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