src/Alarm/JSAlarmAbsolute.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/JSUtils.h>
  19 #include <CommonsJavaScript/Converter.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/JSDOMExceptionFactory.h>
  22
  23 #include <ArgumentValidator.h>
  24
  25 #include <Commons/Exception.h>
  26 #include <JSWebAPIErrorFactory.h>
  27 #include <SecurityExceptions.h>
  28
  29 #include "AlarmAbsolute.h"
  30 #include "AlarmConverter.h"
  31 #include <app.h>
  32 #include <time.h>
  33 #include <JSUtil.h>
  34
  35 #include <TimeTracer.h>
  36 #include "JSAlarmAbsolute.h"
  37 #include "JSAlarmManager.h"
  38 #include <Export.h>
  39 #include <Logger.h>
  40
  41 #define ALARM_FUNCTION_API_GET_NEXT_SCHEDULED_DATE "getNextScheduledDate"
  42
  43 namespace DeviceAPI {
  44 namespace Alarm {
  45
  46 using namespace WrtDeviceApis::Commons;
  47 using namespace WrtDeviceApis::CommonsJavaScript;
  48 using namespace DeviceAPI::Common;
  49
  50 JSClassRef JSAlarmAbsolute::m_jsClassRef = NULL;
  51
  52 JSClassDefinition JSAlarmAbsolute::m_jsClassInfo = {
  53         0,
  54         kJSClassAttributeNone,
  55         TIZEN_ALARM_ABSOLUTE_INTERFACE,
  56         NULL,
  57         m_property,
  58         m_function,
  59         initialize,
  60         finalize,
  61         NULL, //hasProperty,
  62         NULL, //getProperty,
  63         NULL, //setProperty,
  64         NULL, //deleteProperty,Geolocation
  65         NULL, //getPropertyNames,
  66         NULL,
  67         NULL, // constructor
  68         NULL,
  69         NULL
  70 };
  71
  72 JSStaticFunction JSAlarmAbsolute::m_function[] = {
  73     { ALARM_FUNCTION_API_GET_NEXT_SCHEDULED_DATE, JSAlarmAbsolute::getNextScheduledDate, kJSPropertyAttributeNone },
  74     { 0, 0, 0 }
  75 };
  76
  77 JSStaticValue JSAlarmAbsolute::m_property[] = {
  78     { TIZEN_ALARM_ABSOLUTE_ATTRIBUTE_ID, getId, NULL, kJSPropertyAttributeReadOnly },
  79     { TIZEN_ALARM_ABSOLUTE_ATTRIBUTE_DATE, getDate, NULL, kJSPropertyAttributeReadOnly },
  80     { TIZEN_ALARM_ABSOLUTE_ATTRIBUTE_PERIOD, getInterval, NULL, kJSPropertyAttributeReadOnly },
  81     { TIZEN_ALARM_ABSOLUTE_ATTRIBUTE_DAYSOFTHEWEEK, getDaysOfTheWeek, NULL, kJSPropertyAttributeReadOnly },
  82     { 0, 0, 0, 0 }
  83 };
  84
  85 const JSClassRef DLL_EXPORT JSAlarmAbsolute::getClassRef()
  86 {
  87     if (!m_jsClassRef) {
  88         m_jsClassRef = JSClassCreate(&m_jsClassInfo);
  89     }
  90     return m_jsClassRef;
  91 }
  92
  93 const JSClassDefinition* JSAlarmAbsolute::getClassInfo()
  94 {
  95     return &m_jsClassInfo;
  96 }
  97
  98 void JSAlarmAbsolute::initialize(JSContextRef context, JSObjectRef object)
  99 {
 100 }
 101 void JSAlarmAbsolute::finalize(JSObjectRef object)
 102 {
 103     JSAlarmAbsolutePriv *priv = static_cast<JSAlarmAbsolutePriv*>(JSObjectGetPrivate(object));
 104     if (!priv) {
 105         LoggerE("Private object is null");
 106     }
 107     delete priv;
 108
 109 }
 110
 111
 112 JSObjectRef DLL_EXPORT JSAlarmAbsolute::constructor(JSContextRef ctx, JSObjectRef constructor, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
 113 {
 114         ArgumentValidator validator(ctx, argumentCount, arguments);
 115
 116         AlarmAbsolutePtr priv = AlarmAbsolutePtr(new AlarmAbsolute());
 117
 118     try {
 119         time_t date = validator.toTimeT(0);
 120         struct tm *startDate = localtime(&date);
 121         mktime(startDate);
 122
 123         priv->setDate(*startDate);
 124
 125         if (argumentCount >= 2) {
 126             if (JSIsArrayValue(ctx, arguments[1])) {
 127                 std::vector<std::string> daysOfTheWeek =  validator.toStringVector(1);
 128
 129                 for (size_t i = 0; i < daysOfTheWeek.size(); i++ ) {
 130                     if ( (daysOfTheWeek[i]!="SU") && (daysOfTheWeek[i]!="MO") &&
 131                          (daysOfTheWeek[i]!="TU") && (daysOfTheWeek[i]!="WE") &&
 132                          (daysOfTheWeek[i]!="TH") && (daysOfTheWeek[i]!="FR") &&
 133                          (daysOfTheWeek[i]!="SA") ) {
 134                         // remove unacceptable data from vector
 135                         daysOfTheWeek.erase(std::remove(daysOfTheWeek.begin(), daysOfTheWeek.end(), daysOfTheWeek[i]), daysOfTheWeek.end());
 136                     }
 137                 }
 138
 139                 if(daysOfTheWeek.size() > 0) {
 140                     priv->setByDayRecurrence(daysOfTheWeek);
 141                 }
 142             } else {
 143                 long interval = validator.toLong(1);
 144                 if (interval < 0) {
 145                     throw InvalidValuesException("period can not be negative value");
 146                 }
 147
 148                 priv->setInterval(interval);
 149             }
 150         }
 151         } catch (const BasePlatformException& err) {
 152                 LoggerE("Exception occured while creating constructor : " << err.getMessage());
 153         }
 154
 155         JSAlarmAbsolutePriv *jspriv = new JSAlarmAbsolutePriv(ctx, priv);
 156         JSObjectRef obj = JSObjectMake(ctx, getClassRef(), jspriv);
 157
 158     JSStringRef ctorName = JSStringCreateWithUTF8CString("constructor");
 159     JSObjectSetProperty(ctx, obj, ctorName, constructor,
 160         kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete | kJSPropertyAttributeDontEnum, NULL);
 161     JSStringRelease(ctorName);
 162
 163         return obj;
 164 }
 165
 166 AlarmAbsolutePtr JSAlarmAbsolute::getPrivData(JSObjectRef object)
 167 {
 168     JSAlarmAbsolutePriv *priv = static_cast<JSAlarmAbsolutePriv*>(JSObjectGetPrivate(object));
 169     if (!priv) {
 170         throw TypeMismatchException("Private object is null");
 171     }
 172     AlarmAbsolutePtr result = priv->getObject();
 173     if (!result) {
 174         throw TypeMismatchException("Private object is null");
 175     }
 176     return result;
 177 }
 178
 179
 180 JSValueRef JSAlarmAbsolute::createJSObject(JSContextRef context, AlarmAbsolutePtr privateData)
 181 {
 182     JSAlarmAbsolutePriv *priv = new JSAlarmAbsolutePriv(context, privateData);
 183     if (!priv) {
 184         throw TypeMismatchException("Private object is null");
 185     }
 186     return JSObjectMake(context, getClassRef(), static_cast<void*>(priv));
 187 }
 188
 189 JSValueRef JSAlarmAbsolute::getNextScheduledDate( JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef * exception)
 190 {
 191     TIME_TRACER_ITEM_BEGIN(__FUNCTION__, 0);
 192     try {
 193         struct tm date;
 194         Converter converter(ctx);
 195
 196         AlarmAbsolutePtr privateData = getPrivData(thisObject);
 197         if (!privateData) {
 198             throw TypeMismatchException("Private object is null");
 199         }
 200
 201         if(!privateData->is_registered) {
 202             return JSValueMakeNull(ctx);
 203         }
 204
 205         int id = privateData->getId();
 206         TIME_TRACER_ITEM_BEGIN("(getNextScheduledDate)alarm_get_scheduled_date", 0);
 207         int err = alarm_get_scheduled_date(id, &date);
 208         TIME_TRACER_ITEM_END("(getNextScheduledDate)alarm_get_scheduled_date", 0);
 209         if(err != ALARM_ERROR_NONE) {
 210             return JSValueMakeNull(ctx);
 211         }
 212
 213         // check wheter the alarm is expired or not
 214         struct tm curr_date;
 215         TIME_TRACER_ITEM_BEGIN("(getNextScheduledDate)alarm_get_current_time", 0);
 216         err = alarm_get_current_time(&curr_date);
 217         TIME_TRACER_ITEM_END("(getNextScheduledDate)alarm_get_current_time", 0);
 218         if(err != ALARM_ERROR_NONE) {
 219             return JSValueMakeNull(ctx);
 220         }
 221
 222         if (mktime(&date) < mktime(&curr_date)) {
 223             return JSValueMakeNull(ctx);
 224         }
 225         TIME_TRACER_ITEM_END(__FUNCTION__, 0);
 226
 227         return converter.toJSValueRef(date);
 228
 229     } catch (const BasePlatformException &err) {
 230         return JSWebAPIErrorFactory::postException(ctx, exception, err);
 231     } catch (...) {
 232         DeviceAPI::Common::UnknownException err("Unknown Error in ApplicationManager.getAppSharedURI().");
 233         return JSWebAPIErrorFactory::postException(ctx, exception, err);
 234     }
 235 }
 236
 237 JSValueRef JSAlarmAbsolute::getDate(JSContextRef ctx,
 238         JSObjectRef object,
 239         JSStringRef propertyName,
 240         JSValueRef* exception)
 241 {
 242     Converter converter(ctx);
 243     struct tm date;
 244
 245     try {
 246         AlarmAbsolutePtr privateData = getPrivData(object);
 247         if (!privateData) {
 248             throw TypeMismatchException("Private object is null");
 249         }
 250
 251         date = privateData->getDate();
 252         LoggerI("JSAlarmAbsolute Date  = " << "  Sec : " << date.tm_sec << "  Min : "<< date.tm_min
 253         << "  Hour" << date.tm_hour << "Day : " << date.tm_mday << "  MON : " << date.tm_mon
 254         << "  Year : " <<  date.tm_year);
 255
 256         JSValueRef args[6];
 257         args[0] = JSValueMakeNumber(ctx, date.tm_year + 1900);
 258         args[1] = JSValueMakeNumber(ctx, date.tm_mon);
 259         args[2] = JSValueMakeNumber(ctx, date.tm_mday);
 260         args[3] = JSValueMakeNumber(ctx, date.tm_hour);
 261         args[4] = JSValueMakeNumber(ctx, date.tm_min);
 262         args[5] = JSValueMakeNumber(ctx, date.tm_sec);
 263
 264         JSObjectRef result = JSObjectMakeDate(ctx, 6, args, exception);
 265         return result;
 266     } catch (...) {
 267         LoggerE("Exception: occured");
 268     }
 269
 270     return JSValueMakeUndefined(ctx);
 271 }
 272
 273 JSValueRef JSAlarmAbsolute::getId(JSContextRef ctx,
 274         JSObjectRef object,
 275         JSStringRef propertyName,
 276         JSValueRef* exception)
 277 {
 278     try {
 279         AlarmAbsolutePtr privateData = getPrivData(object);
 280         if (!privateData) {
 281             throw TypeMismatchException("Private object is null");
 282         }
 283
 284         Converter converter(ctx);
 285         if (privateData->is_registered) {
 286             std::string strId = converter.toString(privateData->getId());
 287             return converter.toJSValueRef(strId);
 288         } else {
 289             return JSValueMakeNull(ctx);
 290         }
 291     } catch (...) {
 292         LoggerE("Exception: occured");
 293     }
 294
 295     return JSValueMakeUndefined(ctx);
 296 }
 297
 298 JSValueRef JSAlarmAbsolute::getInterval(JSContextRef ctx,
 299         JSObjectRef object,
 300         JSStringRef propertyName,
 301         JSValueRef* exception)
 302 {
 303     try {
 304         AlarmAbsolutePtr privateData = getPrivData(object);
 305         AbsoluteRecurrence::Type alarmType = privateData->getRecurrenceType();
 306
 307         if(alarmType == AbsoluteRecurrence::Interval) {
 308             long interval = privateData->getInterval();
 309             if (interval == -1 ) {
 310                 return JSValueMakeNull(ctx);
 311             } else {
 312                 return DeviceAPI::Common::JSUtil::toJSValueRef(ctx, interval);
 313             }
 314         } else {
 315             return JSValueMakeNull(ctx);
 316         }
 317     } catch (...) {
 318         LoggerI("Exception: occured");
 319     }
 320
 321     return JSValueMakeUndefined(ctx);
 322 }
 323
 324 JSValueRef JSAlarmAbsolute::getDaysOfTheWeek(JSContextRef ctx,
 325         JSObjectRef object,
 326         JSStringRef propertyName,
 327         JSValueRef* exception)
 328 {
 329     Converter converter(ctx);
 330
 331     try {
 332         AlarmAbsolutePtr privateData = getPrivData(object);
 333         if (!privateData) {
 334             throw TypeMismatchException("Private object is null");
 335         }
 336
 337         JSObjectRef jsResult = JSCreateArrayObject(ctx, 0, NULL);
 338         if (jsResult == NULL) {
 339             throw UnknownException("Could not create js array object");
 340         }
 341
 342         std::vector<std::string> daysOfTheWeek = privateData->getByDayRecurrence();
 343
 344         if(daysOfTheWeek.size() > 0) {
 345             for(size_t i = 0; i<daysOfTheWeek.size(); i++) {
 346                 JSValueRef val = converter.toJSValueRef(daysOfTheWeek.at(i));
 347                 if(!JSSetArrayElement(ctx, jsResult, i, val)) {
 348                     throw UnknownException("Could not insert value into js array");
 349                 }
 350             }
 351         }
 352
 353         return jsResult;
 354     } catch (...) {
 355         LoggerI("Exception: occured");
 356     }
 357
 358     return JSValueMakeUndefined(ctx);
 359 }
 360
 361 } // Alarm
 362 } // TizenApis
 363
 364