src/DataSync/DataSyncConverter.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 <dpl/log/log.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/JSUtils.h>
  22
  23 #include "DataSyncConverter.h"
  24 #include "JSDataSyncManager.h"
  25 #include "JSSyncServiceInfo.h"
  26 #include "JSSyncProfileInfo.h"
  27 #include "JSSyncStatistics.h"
  28
  29 using namespace WrtDeviceApis::Commons;
  30 using namespace WrtDeviceApis::CommonsJavaScript;
  31
  32 namespace DeviceAPI {
  33 namespace DataSync {
  34
  35 DataSyncConverter::DataSyncConverter(JSContextRef context) : Converter(context)
  36 {
  37 }
  38
  39 DataSyncConverter::~DataSyncConverter()
  40 {
  41 }
  42
  43 SyncInfo::SyncMode DataSyncConverter::toSyncMode(std::string tizenValue) const
  44 {
  45     if(!tizenValue.compare(TIZEN_DATA_SYNC_MODE_MANUAL)) {
  46         return SyncInfo::MANUAL_MODE;
  47         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_MODE_PERIODICL)) {
  48         return SyncInfo::PERIODIC_MODE;
  49         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_MODE_PUSH)) {
  50         return SyncInfo::PUSH_MODE;
  51         } else {
  52         ThrowMsg(ConversionException, "Invalid sync mode.");
  53         }
  54 }
  55
  56 std::string DataSyncConverter::toTizenValue(SyncInfo::SyncMode abstractValue) const
  57 {
  58     switch (abstractValue) {
  59             case SyncInfo::MANUAL_MODE:
  60                 return TIZEN_DATA_SYNC_MODE_MANUAL;
  61             case SyncInfo::PERIODIC_MODE:
  62                 return TIZEN_DATA_SYNC_MODE_PERIODICL;
  63             case SyncInfo::PUSH_MODE:
  64                 return TIZEN_DATA_SYNC_MODE_PUSH;
  65             default:
  66                 {
  67                         LogWarning("Invalid sync mode.");
  68                         return "";
  69         }
  70         }
  71 }
  72
  73 SyncInfo::SyncType DataSyncConverter::toSyncType(std::string tizenValue) const
  74 {
  75     if(!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_TWO_WAY)) {
  76         return SyncInfo::TWO_WAY_TYPE;
  77         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_SLOW)) {
  78         return SyncInfo::SLOW_TYPE;
  79         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_ONE_WAY_FROM_CLIENT)) {
  80         return SyncInfo::ONE_WAY_FROM_CLIENT_TYPE;
  81         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_REFRESH_FROM_CLIENT)) {
  82         return SyncInfo::REFRESH_FROM_CLIENT_TYPE;
  83         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_ONE_WAY_FROM_SERVER)) {
  84                 return SyncInfo::ONE_WAY_FROM_SERVER_TYPE;
  85         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_TYPE_REFRESH_FROM_SERVER)) {
  86                 return SyncInfo::REFRESH_FROM_CLIENT_TYPE;
  87         } else {
  88         ThrowMsg(ConversionException, "Invalid sync type.");
  89         }
  90 }
  91
  92 std::string DataSyncConverter::toTizenValue(SyncInfo::SyncType abstractValue) const
  93 {
  94     switch (abstractValue) {
  95             case SyncInfo::TWO_WAY_TYPE:
  96                 return TIZEN_DATA_SYNC_TYPE_TWO_WAY;
  97             case SyncInfo::SLOW_TYPE:
  98                 return TIZEN_DATA_SYNC_TYPE_SLOW;
  99             case SyncInfo::ONE_WAY_FROM_CLIENT_TYPE:
 100                 return TIZEN_DATA_SYNC_TYPE_ONE_WAY_FROM_CLIENT;
 101                 case SyncInfo::REFRESH_FROM_CLIENT_TYPE:
 102                         return TIZEN_DATA_SYNC_TYPE_REFRESH_FROM_CLIENT;
 103                 case SyncInfo::ONE_WAY_FROM_SERVER_TYPE:
 104                         return TIZEN_DATA_SYNC_TYPE_ONE_WAY_FROM_SERVER;
 105                 case SyncInfo::REFRESH_FROM_SERVER_TYPE:
 106                         return TIZEN_DATA_SYNC_TYPE_REFRESH_FROM_SERVER;
 107             default:
 108                 {
 109                         LogWarning("Invalid sync type.");
 110                         return "";
 111         }
 112         }
 113 }
 114
 115 SyncInfo::SyncInterval DataSyncConverter::toSyncInterval(std::string tizenValue) const
 116 {
 117     if(!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_5_MINUTES)) {
 118         return SyncInfo::INTERVAL_5_MINUTES;
 119         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_15_MINUTES)) {
 120         return SyncInfo::INTERVAL_15_MINUTES;
 121         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_1_HOUR)) {
 122         return SyncInfo::INTERVAL_1_HOUR;
 123         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_4_HOURS)) {
 124         return SyncInfo::INTERVAL_4_HOURS;
 125         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_12_HOURS)) {
 126                 return SyncInfo::INTERVAL_12_HOURS;
 127         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_1_DAY)) {
 128                 return SyncInfo::INTERVAL_1_DAY;
 129         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_1_WEEK)) {
 130                 return SyncInfo::INTERVAL_1_WEEK;
 131         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_INTERVAL_1_MONTH)) {
 132                 return SyncInfo::INTERVAL_1_WEEK;
 133         } else {
 134         ThrowMsg(ConversionException, "Invalid sync interval.");
 135         }
 136 }
 137
 138 std::string DataSyncConverter::toTizenValue(SyncInfo::SyncInterval abstractValue) const
 139 {
 140     switch (abstractValue) {
 141             case SyncInfo::INTERVAL_5_MINUTES:
 142                 return TIZEN_DATA_SYNC_INTERVAL_5_MINUTES;
 143             case SyncInfo::INTERVAL_15_MINUTES:
 144                 return TIZEN_DATA_SYNC_INTERVAL_15_MINUTES;
 145             case SyncInfo::INTERVAL_1_HOUR:
 146                 return TIZEN_DATA_SYNC_INTERVAL_1_HOUR;
 147                 case SyncInfo::INTERVAL_4_HOURS:
 148                         return TIZEN_DATA_SYNC_INTERVAL_4_HOURS;
 149                 case SyncInfo::INTERVAL_12_HOURS:
 150                         return TIZEN_DATA_SYNC_INTERVAL_12_HOURS;
 151                 case SyncInfo::INTERVAL_1_DAY:
 152                         return TIZEN_DATA_SYNC_INTERVAL_1_DAY;
 153                 case SyncInfo::INTERVAL_1_WEEK:
 154                         return TIZEN_DATA_SYNC_INTERVAL_1_WEEK;
 155                 case SyncInfo::INTERVAL_1_MONTH:
 156                         return TIZEN_DATA_SYNC_INTERVAL_1_MONTH;
 157             default:
 158                 {
 159                         LogWarning("Invalid sync interval.");
 160                         return "";
 161         }
 162         }
 163 }
 164
 165 SyncServiceInfo::SyncServiceType DataSyncConverter::toSyncServiceType(std::string tizenValue) const
 166 {
 167     if(!tizenValue.compare(TIZEN_DATA_SYNC_SERVICE_TYPE_CONTACT)) {
 168         return SyncServiceInfo::CONTACT_SERVICE_TYPE;
 169         } else if (!tizenValue.compare(TIZEN_DATA_SYNC_SERVICE_TYPE_EVENT)) {
 170         return SyncServiceInfo::EVENT_SERVICE_TYPE;
 171         } else {
 172         ThrowMsg(ConversionException, "Invalid sync service type.");
 173         }
 174 }
 175
 176 std::string DataSyncConverter::toTizenValue(SyncServiceInfo::SyncServiceType abstractValue) const
 177 {
 178     switch (abstractValue) {
 179             case SyncServiceInfo::CONTACT_SERVICE_TYPE:
 180                 return TIZEN_DATA_SYNC_SERVICE_TYPE_CONTACT;
 181             case SyncServiceInfo::EVENT_SERVICE_TYPE:
 182                 return TIZEN_DATA_SYNC_SERVICE_TYPE_EVENT;
 183             default:
 184                 {
 185                         LogWarning("Invalid sync service type.");
 186                         return "";
 187         }
 188         }
 189 }
 190
 191 std::string DataSyncConverter::toTizenValue(SyncStatistics::SyncStatus abstractValue) const
 192 {
 193     switch (abstractValue) {
 194             case SyncStatistics::SUCCESS_STATUS:
 195                 return TIZEN_DATA_SYNC_STATUS_SUCCESS;
 196             case SyncStatistics::FAIL_STATUS:
 197                 return TIZEN_DATA_SYNC_STATUS_FAIL;
 198                 case SyncStatistics::STOP_STATUS:
 199                         return TIZEN_DATA_SYNC_STATUS_STOP;
 200             case SyncStatistics::NONE_STATUS:
 201                 return TIZEN_DATA_SYNC_STATUS_NONE;
 202             default:
 203                 {
 204                         LogWarning("Invalid sync status type.");
 205                         return "";
 206         }
 207         }
 208 }
 209
 210 SyncServiceInfoPtr DataSyncConverter::toServiceInfo(JSValueRef serviceInfo)
 211 {
 212         return JSSyncServiceInfo::getPrivateObject(toJSObjectRef(serviceInfo));
 213 }
 214
 215 SyncServiceInfoListPtr DataSyncConverter::toServiceInfoList(JSValueRef serviceInfoList)
 216 {
 217     SyncServiceInfoListPtr result(new SyncServiceInfoList());
 218
 219     std::vector<SyncServiceInfoPtr> resultVector;
 220     JSObjectRef objArg = toJSObjectRef(serviceInfoList);
 221     LogDebug("Array length "<<JSGetArrayLength(m_context, objArg));
 222     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 223         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 224                 if (!JSValueIsObjectOfClass(m_context, element, JSSyncServiceInfo::getClassRef())) {
 225                         ThrowMsg(ConversionException, "Wrong array element type.");
 226                 }
 227         SyncServiceInfoPtr serviceInfo = JSSyncServiceInfo::getPrivateObject(toJSObjectRef(element));
 228         resultVector.push_back(serviceInfo);
 229     }
 230
 231     *result = resultVector;
 232     return result;
 233 }
 234
 235 JSValueRef DataSyncConverter::toJSValueRefServiceInfo(const SyncServiceInfoPtr& arg)
 236 {
 237     return JSUtils::makeObject(m_context, JSSyncServiceInfo::getClassRef(), arg);
 238 }
 239
 240 JSValueRef DataSyncConverter::toJSValueRefServiceInfoList(const SyncServiceInfoListPtr &arg)
 241 {
 242     return toJSValueRef_(*arg, &DataSyncConverter::toJSValueRefServiceInfo, this);
 243 }
 244
 245 JSValueRef DataSyncConverter::toJSValueRefProfileInfo(const SyncProfileInfoPtr& arg)
 246 {
 247     return JSUtils::makeObject(m_context, JSSyncProfileInfo::getClassRef(), arg);
 248 }
 249
 250 JSValueRef DataSyncConverter::toJSValueRefProfileInfoList(const SyncProfileInfoListPtr &arg)
 251 {
 252     return toJSValueRef_(*arg, &DataSyncConverter::toJSValueRefProfileInfo, this);
 253 }
 254
 255 JSValueRef DataSyncConverter::toJSValueRefSyncStatistics(const SyncStatisticsPtr& arg)
 256 {
 257     return JSUtils::makeObject(m_context, JSSyncStatistics::getClassRef(), arg);
 258 }
 259
 260 JSValueRef DataSyncConverter::toJSValueRefSyncStatisticsList(const SyncStatisticsListPtr &arg)
 261 {
 262     return toJSValueRef_(*arg, &DataSyncConverter::toJSValueRefSyncStatistics, this);
 263 }
 264
 265 }
 266 }