src/DataSync/JSSyncInfo.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
  19 #include "JSSyncInfo.h"
  20 #include "DataSyncConverter.h"
  21
  22 #include <JSWebAPIErrorFactory.h>
  23 #include <CommonsJavaScript/Converter.h>
  24 #include <Logger.h>
  25
  26 using namespace WrtDeviceApis::Commons;
  27 using namespace WrtDeviceApis::CommonsJavaScript;
  28 using namespace DeviceAPI::Common;
  29
  30 namespace DeviceAPI {
  31 namespace DataSync {
  32
  33 JSClassDefinition JSSyncInfo::m_classInfo = {
  34     0,
  35     kJSClassAttributeNone,
  36     TIZEN_SYNC_INFO_INTERFACE,
  37     NULL, //parentClass
  38     m_property,
  39     NULL, //staticValues,
  40     initialize,
  41     finalize,
  42     NULL, //hasProperty,
  43     NULL, //getProperty,
  44     NULL, //setProperty,
  45     NULL, //deleteProperty,
  46     NULL, //getPropertyNames,
  47     NULL, //callAsFunction,
  48     NULL, //constructor,
  49     NULL, //hasInstance,
  50     NULL, //convertToType,
  51 };
  52
  53 JSStaticValue JSSyncInfo::m_property[] = {
  54     { TIZEN_SYNC_INFO_URL, getProperty, setProperty, kJSPropertyAttributeNone },
  55     { TIZEN_SYNC_INFO_ID, getProperty, setProperty, kJSPropertyAttributeNone },
  56     { TIZEN_SYNC_INFO_PASSWORD, getProperty, setProperty, kJSPropertyAttributeNone },
  57         { TIZEN_SYNC_INFO_MODE, getProperty, setProperty, kJSPropertyAttributeNone },
  58         { TIZEN_SYNC_INFO_TYPE, getProperty, setProperty, kJSPropertyAttributeNone },
  59         { TIZEN_SYNC_INFO_INTERVAL, getProperty, setProperty, kJSPropertyAttributeNone },
  60
  61     { 0, 0, 0, 0 }
  62 };
  63
  64 JSClassRef JSSyncInfo::m_jsClassRef = JSClassCreate(
  65         JSSyncInfo::getClassInfo());
  66
  67 const JSClassDefinition* JSSyncInfo::getClassInfo()
  68 {
  69     return &(m_classInfo);
  70 }
  71
  72 JSClassRef JSSyncInfo::getClassRef()
  73 {
  74     if (!m_jsClassRef) {
  75         m_jsClassRef = JSClassCreate(&m_classInfo);
  76     }
  77     return m_jsClassRef;
  78 }
  79
  80 JSObjectRef JSSyncInfo::createJSSyncInfo(JSContextRef context, SyncInfoPtr syncInfo)
  81 {
  82     SyncInfoPrivateObject *priv = new SyncInfoPrivateObject(context, syncInfo);
  83     return JSObjectMake(context, getClassRef(), priv);
  84 }
  85
  86 void JSSyncInfo::initialize(JSContextRef context,
  87         JSObjectRef object)
  88 {
  89     if (!JSObjectGetPrivate(object)) {
  90         LoggerD("Create JSSyncInfo private object.");
  91         SyncInfoPtr syncInfo( new SyncInfo() );
  92         SyncInfoPrivateObject *priv = new SyncInfoPrivateObject(context, syncInfo);
  93         if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
  94             delete priv;
  95         }
  96     } else {
  97         LoggerD("Private object already set.");
  98     }
  99 }
 100
 101 void JSSyncInfo::finalize(JSObjectRef object)
 102 {
 103     SyncInfoPrivateObject* priv = static_cast<SyncInfoPrivateObject*>(JSObjectGetPrivate(object));
 104     if (priv) {
 105         LoggerD("Deleting JSSyncInfo private object.");
 106         delete priv;
 107         JSObjectSetPrivate(object, NULL);
 108     }
 109 }
 110
 111 SyncInfoPtr JSSyncInfo::getPrivateObject(JSObjectRef object)
 112 {
 113     SyncInfoPrivateObject *priv = static_cast<SyncInfoPrivateObject*>(JSObjectGetPrivate(object));
 114     if (!priv) {
 115         ThrowMsg(NullPointerException, "Private object is null.");
 116     }
 117
 118     SyncInfoPtr syncInfo = priv->getObject();
 119     if (!syncInfo) {
 120         ThrowMsg(NullPointerException, "JSSyncInfo object is null.");
 121     }
 122     return syncInfo;
 123 }
 124
 125 void JSSyncInfo::setPrivateObject(const SyncInfoPtr &syncInfo,
 126         JSContextRef ctx,
 127         const JSObjectRef object)
 128 {
 129     Try
 130     {
 131         SyncInfoPrivateObject *priv = static_cast<SyncInfoPrivateObject*>(JSObjectGetPrivate(object));
 132         delete priv;
 133         priv = new SyncInfoPrivateObject(ctx, syncInfo);
 134         if (!JSObjectSetPrivate(object, static_cast<void*>(priv))) {
 135             delete priv;
 136         }
 137     }
 138     Catch(Exception)
 139     {
 140         LoggerE("Error during setting JSSyncInfo object.");
 141     }
 142 }
 143
 144 JSObjectRef JSSyncInfo::constructor(JSContextRef context,
 145     JSObjectRef constructor,
 146     size_t argumentCount,
 147     const JSValueRef arguments[],
 148     JSValueRef* exception)
 149 {
 150     Try
 151     {
 152         DataSyncConverter converter(context);
 153
 154         SyncInfoPtr syncInfo( new SyncInfo() );
 155
 156         if (argumentCount>=1) {
 157                         syncInfo->setUrl(converter.toString(arguments[0]));
 158         }
 159         if (argumentCount>=2) {
 160                         syncInfo->setId(converter.toString(arguments[1]));
 161         }
 162         if (argumentCount>=3) {
 163                         syncInfo->setPassword(converter.toString(arguments[2]));
 164         }
 165         if (argumentCount>=4) {
 166                         syncInfo->setSyncMode(converter.toSyncMode(converter.toString(arguments[3])));
 167         }
 168
 169         LoggerD("mode: "<<syncInfo->getSyncMode());
 170
 171                 if (SyncInfo::MANUAL_MODE==syncInfo->getSyncMode()) {
 172                         if (argumentCount>=5) {
 173                                 syncInfo->setSyncType(converter.toSyncType(converter.toString(arguments[4])));
 174                         }
 175                 } else if (SyncInfo::PERIODIC_MODE==syncInfo->getSyncMode()) {
 176                         if (argumentCount>=5) {
 177                                 syncInfo->setSyncInterval(converter.toSyncInterval(converter.toString(arguments[4])));
 178                         }
 179                 } else {
 180                         LoggerD("The sync mode should be push.");
 181                 }
 182
 183         return createJSSyncInfo(context, syncInfo);
 184     }
 185     Catch(UnsupportedException)
 186     {
 187         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 188         return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::NOT_SUPPORTED_ERROR, _rethrown_exception.GetMessage());
 189     }
 190     Catch(InvalidArgumentException)
 191     {
 192         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 193         return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, _rethrown_exception.GetMessage());
 194     }
 195     Catch(ConversionException)
 196     {
 197         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 198         return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::TYPE_MISMATCH_ERROR, _rethrown_exception.GetMessage());
 199     }
 200     Catch(Exception)
 201     {
 202         LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 203         return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::UNKNOWN_ERROR, _rethrown_exception.GetMessage());
 204     }
 205 }
 206
 207 JSValueRef JSSyncInfo::getProperty(JSContextRef context,
 208         JSObjectRef object,
 209         JSStringRef propertyName,
 210         JSValueRef* exception)
 211 {
 212     Try
 213     {
 214         SyncInfoPrivateObject* priv = static_cast<SyncInfoPrivateObject*>(JSObjectGetPrivate(object));
 215         if (!priv) {
 216             ThrowMsg(NullPointerException, "Private object is NULL.");
 217         }
 218
 219         SyncInfoPtr syncInfo = priv->getObject();
 220
 221         DataSyncConverter converter(context);
 222
 223         if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_URL)) {
 224             return converter.toJSValueRef(syncInfo->getUrl());
 225         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_ID)) {
 226                 // For a privacy reason.
 227             return JSValueMakeNull(context);
 228         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_PASSWORD)) {
 229                 // For a privacy reason.
 230             return JSValueMakeNull(context);
 231         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_MODE)) {
 232             return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncMode()));
 233         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_TYPE)) {
 234             return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncType()));
 235         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_INTERVAL)) {
 236                 if( SyncInfo::INTERVAL_UNDEFINED==syncInfo->getSyncInterval() ) {
 237                             return JSValueMakeUndefined(context);
 238                         } else {
 239                     return converter.toJSValueRef(converter.toTizenValue(syncInfo->getSyncInterval()));
 240                         }
 241         } else {
 242                 LoggerD("Wrong property name.");
 243                 }
 244     }
 245     Catch(Exception)
 246     {
 247                 LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 248     }
 249
 250     return JSValueMakeUndefined(context);
 251 }
 252
 253 bool JSSyncInfo::setProperty(JSContextRef context,
 254         JSObjectRef object,
 255         JSStringRef propertyName,
 256         JSValueRef value,
 257         JSValueRef* exception)
 258 {
 259     Try
 260     {
 261         SyncInfoPrivateObject* priv = static_cast<SyncInfoPrivateObject*>(JSObjectGetPrivate(object));
 262         if (!priv) {
 263             ThrowMsg(NullPointerException, "Private object is NULL.");
 264         }
 265
 266         SyncInfoPtr syncInfo = priv->getObject();
 267
 268         DataSyncConverter converter(context);
 269
 270         if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_URL)) {
 271             syncInfo->setUrl(converter.toString(value));
 272             return true;
 273         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_ID)) {
 274             syncInfo->setId(converter.toString(value));
 275             return true;
 276         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_PASSWORD)) {
 277             syncInfo->setPassword(converter.toString(value));
 278             return true;
 279         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_MODE)) {
 280             syncInfo->setSyncMode(converter.toSyncMode(converter.toString(value)));
 281             return true;
 282         } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_TYPE)) {
 283             syncInfo->setSyncType(converter.toSyncType(converter.toString(value)));
 284             return true;
 285                 } else if (JSStringIsEqualToUTF8CString(propertyName, TIZEN_SYNC_INFO_INTERVAL)) {
 286                         syncInfo->setSyncInterval(converter.toSyncInterval(converter.toString(value)));
 287                         return true;
 288         } else {
 289                 LoggerD("Wrong property name.");
 290         }
 291     }
 292     Catch(Exception)
 293     {
 294                 LoggerW("Exception: "<<_rethrown_exception.GetMessage());
 295     }
 296
 297     return true;
 298 }
 299
 300 }
 301 }