bundle *_send_alarm_get_appsvc_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code);
notification_h _send_alarm_get_noti_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code);
bool _send_alarm_set_rtc_time(alarm_context_t context, alarm_date_t *time, int *error_code);
-bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, int *error_code);
-bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, alarm_set_time_cb_t result_cb, void *user_data);
+bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, struct timespec new_time, struct timespec req_time, int *error_code);
+bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, struct timespec new_time, struct timespec req_time, alarm_set_time_cb_t result_cb, void *user_data);
bool _send_alarm_set_timezone(alarm_context_t context, char *tzpath_str, int *error_code);
bool _send_alarm_create_periodic(alarm_context_t context, int interval, int is_ref, int method, alarm_id_t *alarm_id, int *error_code);
-bool _send_alarm_set_time(alarm_context_t context, int new_time, int *error_code);
-bool _send_alarm_set_time_async(alarm_context_t context, int new_time, alarm_set_time_cb_t result_cb, void *user_data);
+bool _send_alarm_set_time(alarm_context_t context, time_t new_time, int *error_code);
+bool _send_alarm_set_time_async(alarm_context_t context, time_t new_time, alarm_set_time_cb_t result_cb, void *user_data);
bool _send_alarm_set_global(alarm_context_t context, int alarm_id, bool global, int *error_code);
bool _send_alarm_get_global(alarm_context_t context, int alarm_id, bool *global, int *error_code);
int alarm_manager_alarm_get_appsvc_info(GVariant *parameters, uid_t uid, gchar **b_data);
int alarm_manager_alarm_get_noti_info(GVariant *parameters, uid_t uid, gchar **noti_data);
int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, alarm_info_t *alarm_info);
-int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, int *duetime);
+int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, time_t *duetime);
int alarm_manager_alarm_get_all_info(uid_t uid, char **db_path);
int alarm_manager_alarm_set_rtc_time(GVariant *parameters);
int alarm_manager_alarm_set_time(GVariant* parameters);
alarm_mode_t mode; /**< mode of alarm */
int msec;
int alarm_type; /**< alarm type*/
- int reserved_info; /** 1st duetime(UTC epochtime) */
+ time_t reserved_info; /** 1st duetime(UTC epochtime) */
} alarm_info_t;
#define alarm_entry_t alarm_info_t
* @retval #ERR_ALARM_SYSTEM_FAIL System failure
*/
int alarmmgr_set_systime(int new_time);
+int alarmmgr_set_systime64(time_t new_time);
/**
* This function asynchronously changes the system time which tranferred by other module
* @retval #ERR_ALARM_SYSTEM_FAIL System failure
*/
int alarmmgr_set_systime_async(int new_time, alarm_set_time_cb_t result_cb, void *user_param);
+int alarmmgr_set_systime64_async(time_t new_time, alarm_set_time_cb_t result_cb, void *user_param);
/**
* This function changes the system time and compensates the time using propagation delay.
g_variant_store(noti_gv, data);
noti_data = g_base64_encode((guchar *)data, datalen);
- param = g_variant_new("(iiiiiiiiiiiiiis)",
+ param = g_variant_new("(iiiiiiiiiixiixs)",
alarm_info->start.year,
alarm_info->start.month,
alarm_info->start.day,
alarm_info->end.month,
alarm_info->end.day,
alarm_info->mode.u_interval.day_of_week,
- alarm_info->mode.u_interval.interval,
+ (gint64)alarm_info->mode.u_interval.interval,
alarm_info->mode.repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
(char *)noti_data);
if (noti_data)
return false;
}
- param = g_variant_new("(iiiiiiiiiiiiiis)",
+ param = g_variant_new("(iiiiiiiiiixiixs)",
alarm_info->start.year,
alarm_info->start.month,
alarm_info->start.day,
alarm_info->end.month,
alarm_info->end.day,
alarm_info->mode.u_interval.day_of_week,
- alarm_info->mode.u_interval.interval,
+ (gint64)alarm_info->mode.u_interval.interval,
alarm_info->mode.repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
(char *)b_data);
if (b_data)
return false;
}
- param = g_variant_new("(ssiiiiiiiiiiiiiissi)",
+ param = g_variant_new("(ssiiiiiiiiiiiiixss)",
context.app_service_name,
context.app_service_name_mod,
alarm_info->start.year,
alarm_info->mode.u_interval.day_of_week,
alarm_info->mode.repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
dst_service_name, dst_service_name_mod);
reply = g_dbus_proxy_call_sync(context.proxy, "alarm_create", param,
int return_code = -1;
GVariant *param = NULL;
GVariant *reply = NULL;
-
+ gint64 tmp_reserved_info;
param = g_variant_new("(i)", alarm_id);
reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_info", param,
return false;
}
- g_variant_get(reply, "(iiiiiiiiiiiiii)",
+ g_variant_get(reply, "(iiiiiiiiiiiixi)",
&alarm_info->start.year,
&alarm_info->start.month,
&alarm_info->start.day,
&alarm_info->mode.u_interval.day_of_week,
&alarm_info->mode.repeat,
&alarm_info->alarm_type,
- &alarm_info->reserved_info,
+ &tmp_reserved_info,
&return_code);
+ alarm_info->reserved_info = (time_t)tmp_reserved_info;
LOGD("alarm_get_info() dbus sync success. return_code[%d].",
return_code);
int return_code = -1;
GVariant *param = NULL;
GVariant *reply = NULL;
- int _duetime = 0;
+ gint64 _duetime = 0;
param = g_variant_new("(i)", alarm_id);
return false;
}
- g_variant_get(reply, "(ii)", &_duetime, &return_code);
+ g_variant_get(reply, "(xi)", &_duetime, &return_code);
LOGD("alarm_get_next_duetime() dbus sync success. return_code[%d].",
return_code);
return true;
}
-bool _send_alarm_set_time(alarm_context_t context, int new_time, int *error_code)
+bool _send_alarm_set_time(alarm_context_t context, time_t new_time, int *error_code)
{
GError *error = NULL;
int return_code = -1;
GVariant *param = NULL;
GVariant *reply = NULL;
- param = g_variant_new("(i)", new_time);
+ param = g_variant_new("(x)", (gint64)new_time);
reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_time", param,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
g_free(func_data);
}
-bool _send_alarm_set_time_async(alarm_context_t context, int new_time, alarm_set_time_cb_t result_cb, void *user_data)
+bool _send_alarm_set_time_async(alarm_context_t context, time_t new_time, alarm_set_time_cb_t result_cb, void *user_data)
{
alarm_set_time_data_t *func_data;
GVariant *param;
func_data->user_data = user_data;
func_data->proxy = context.proxy;
- param = g_variant_new("(i)", new_time);
+ param = g_variant_new("(x)", (gint64)new_time);
g_dbus_proxy_call(context.proxy, "alarm_set_time", param,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, _alarm_set_time_cb, func_data);
return true;
}
-bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, int *error_code)
+bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, struct timespec new_time, struct timespec req_time, int *error_code)
{
GError *error = NULL;
int return_code = -1;
GVariant *param = NULL;
GVariant *reply = NULL;
- param = g_variant_new("(uuuu)", new_sec, new_nsec, req_sec, req_nsec);
+ param = g_variant_new("(xxxx)", (gint64)new_time.tv_sec, (gint64)new_time.tv_nsec,
+ (gint64)req_time.tv_sec, (gint64)req_time.tv_nsec);
reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_time_with_propagation_delay", param,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
g_free(func_data);
}
-bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, alarm_set_time_cb_t result_cb, void *user_data)
+bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, struct timespec new_time, struct timespec req_time, alarm_set_time_cb_t result_cb, void *user_data)
{
alarm_set_time_data_t *func_data;
GVariant *param = NULL;
func_data->user_data = user_data;
func_data->proxy = context.proxy;
- param = g_variant_new("(uuuu)", new_sec, new_nsec, req_sec, req_nsec);
+ param = g_variant_new("(xxxx)", (gint64)new_time.tv_sec, (gint64)new_time.tv_nsec,
+ (gint64)req_time.tv_sec, (gint64)req_time.tv_nsec);
g_dbus_proxy_call(context.proxy, "alarm_set_time_with_propagation_delay", param,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, _alarm_set_time_with_delay_cb, func_data);
GVariant *param = NULL;
GVariant *reply = NULL;
- param = g_variant_new("(iiiiiiiiiiiiiii)",
+ param = g_variant_new("(iiiiiiiiiixiixi)",
alarm_id,
alarm_info->start.year,
alarm_info->start.month,
alarm_info->end.year,
alarm_info->end.month,
alarm_info->end.day,
- alarm_info->mode.u_interval.interval,
+ (gint64)alarm_info->mode.u_interval.interval,
alarm_info->mode.repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
update_flag);
reply = g_dbus_proxy_call_sync(context.proxy, "alarm_update", param,
alarm_info->msec = precision ? (int)current_time.tv_usec / 1000 : 0;
LOGD("trigger_at_time(%ld), start(%d-%d-%d, %02d:%02d:%02d),\
- repeat(%d), interval(%d), type(%d)",
+ repeat(%d), interval(%ld), type(%d)",
trigger_at_time, alarm_info->start.day, alarm_info->start.month,
alarm_info->start.year, alarm_info->start.hour,
alarm_info->start.min, alarm_info->start.sec,
- alarm_info->mode.repeat, (int)alarm_info->mode.u_interval.interval,
+ alarm_info->mode.repeat, alarm_info->mode.u_interval.interval,
alarm_info->alarm_type);
}
g_variant_get(param, "(ii&s)", &alarm_id, &msec, &package_name);
LOGD("[alarm-lib] : Alarm expired for [%s] : Alarm id [%d]", package_name, alarm_id);
+ if (msec > 0) {
+ gettimeofday(¤t_time, NULL);
+ msec = msec - (int)current_time.tv_usec / 1000;
+ }
+
if (alarm_context.alarm_handler != NULL) {
if (msec > 0) {
- gettimeofday(¤t_time, NULL);
- msec = msec - (int)current_time.tv_usec / 1000;
- if (msec > 0) {
- alarm_context.handler_id = alarm_id;
- g_timeout_add_full(G_PRIORITY_HIGH, (guint)msec,
- __handle_millisec_accuracy, NULL, NULL);
- } else {
- alarm_context.alarm_handler(alarm_id,
- alarm_context.user_param);
- }
+ alarm_context.handler_id = alarm_id;
+ g_timeout_add_full(G_PRIORITY_HIGH, (guint)msec,
+ __handle_millisec_accuracy, NULL, NULL);
} else {
alarm_context.alarm_handler(alarm_id,
alarm_context.user_param);
info = __find_resultcb(alarm_id);
if (info && info->cb_func) {
if (msec > 0) {
- gettimeofday(¤t_time, NULL);
- msec = msec - (int)current_time.tv_usec / 1000;
- if (msec > 0) {
- g_timeout_add_full(G_PRIORITY_HIGH, (guint)msec,
- __handle_millisec_accuracy, info, NULL);
- } else {
- info->cb_func(alarm_id, info->priv_data);
- }
+ g_timeout_add_full(G_PRIORITY_HIGH, (guint)msec,
+ __handle_millisec_accuracy, info, NULL);
} else {
LOGW("[alarm-lib] Call expired callback");
info->cb_func(alarm_id, info->priv_data);
if (param->type == SET_SYSTIME_WITH_PROPAGATION_DELAY) {
struct timespec new_time;
struct timespec req_time;
- g_variant_get(param->v, "(uuuu)", &new_time.tv_sec, &new_time.tv_nsec,
- &req_time.tv_sec, &req_time.tv_nsec);
+ gint64 new_sec, new_nsec, req_sec, req_nsec;
+ g_variant_get(param->v, "(xxxx)", &new_sec, &new_nsec,
+ &req_sec, &req_nsec);
+ new_time.tv_sec = (time_t)new_sec;
+ new_time.tv_nsec = (long)new_nsec;
+ req_time.tv_sec = (time_t)req_sec;
+ req_time.tv_nsec = (long)new_nsec;
+
_send_alarm_set_time_with_propagation_delay_async(alarm_context,
- new_time.tv_sec, new_time.tv_nsec,
- req_time.tv_sec, req_time.tv_nsec,
- param->result_cb, param->user_param);
+ new_time, req_time, param->result_cb, param->user_param);
} else if (param->type == SET_SYSTIME) {
- int new_time;
- g_variant_get(param->v, "i", &new_time);
- _send_alarm_set_time_async(alarm_context, new_time,
+ gint64 new_time;
+ g_variant_get(param->v, "x", &new_time);
+ _send_alarm_set_time_async(alarm_context, (time_t)new_time,
param->result_cb, param->user_param);
}
}
alarm_mode_t *mode = &alarm_info->mode;
- LOGW("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
+ LOGW("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%ld), type(%d)",
alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
- alarm_info->mode.repeat, (int)alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ alarm_info->mode.repeat, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX)
if (ret < 0)
return ret;
- LOGD("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
+ LOGD("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%ld), type(%d)",
alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
- alarm_info->mode.repeat, (int)alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ alarm_info->mode.repeat, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX)
alarm_mode_t *mode = &alarm_info->mode;
- LOGW("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
+ LOGW("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%ld), type(%d)",
alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
- alarm_info->mode.repeat, (int)alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ alarm_info->mode.repeat, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX)
}
EXPORT_API int alarmmgr_set_systime(int new_time)
+{
+ return alarmmgr_set_systime64((time_t)new_time);
+}
+
+EXPORT_API int alarmmgr_set_systime64(time_t new_time)
{
int error_code;
- LOGD("[alarm-lib]:alarmmgr_set_systime(%d) is called.", new_time);
+ LOGD("[alarm-lib]:alarmmgr_set_systime(%ld) is called.", new_time);
if (__sub_init() < 0)
return ERR_ALARM_SYSTEM_FAIL;
return error_code;
}
- LOGD("[alarm-lib]: successfully set the time(%d) by pid(%d).", new_time, getpid());
+ LOGD("[alarm-lib]: successfully set the time(%ld) by pid(%d).", new_time, getpid());
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_set_systime_async(int new_time, alarm_set_time_cb_t result_cb, void *user_param)
+{
+ return alarmmgr_set_systime64_async((time_t)new_time, result_cb, user_param);
+}
+
+EXPORT_API int alarmmgr_set_systime64_async(time_t new_time, alarm_set_time_cb_t result_cb, void *user_param)
{
struct alarm_async_param_t *param;
- LOGD("[alarm-lib]:alarmmgr_set_systime(%d) is called.", new_time);
+ LOGD("[alarm-lib]:alarmmgr_set_systime(%ld) is called.", new_time);
if (sub_initialized) {
if (!_send_alarm_set_time_async(alarm_context, new_time,
if (__sub_init() < 0)
return ERR_ALARM_SYSTEM_FAIL;
- if (!_send_alarm_set_time_with_propagation_delay(alarm_context, new_time.tv_sec, new_time.tv_nsec, req_time.tv_sec, req_time.tv_nsec, &error_code)) {
+ if (!_send_alarm_set_time_with_propagation_delay(alarm_context, new_time, req_time, &error_code)) {
LOGE("Failed to set time with propagation delay. error: %d", error_code);
return error_code;
}
if (sub_initialized) {
if (!_send_alarm_set_time_with_propagation_delay_async(alarm_context,
- new_time.tv_sec, new_time.tv_nsec, req_time.tv_sec,
- req_time.tv_nsec, result_cb, user_param))
+ new_time, req_time, result_cb, user_param))
return ERR_ALARM_SYSTEM_FAIL;
} else {
#if !(GLIB_CHECK_VERSION(2, 32, 0))
return ERR_ALARM_SYSTEM_FAIL;
}
param->type = SET_SYSTIME_WITH_PROPAGATION_DELAY;
- param->v = g_variant_new("(uuuu)", new_time.tv_sec, new_time.tv_nsec,
- req_time.tv_sec, req_time.tv_nsec);
+ param->v = g_variant_new("(xxxx)",
+ (gint64)new_time.tv_sec, (gint64)new_time.tv_nsec,
+ (gint64)req_time.tv_sec, (gint64)req_time.tv_nsec);
param->result_cb = result_cb;
param->user_param = user_param;
g_bus_get(G_BUS_TYPE_SYSTEM, NULL, __bus_get_for_async_api, param);
if (ret < 0)
return ret;
- LOGD("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
+ LOGD("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%ld), type(%d)",
alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
- alarm_info->mode.repeat, (int)alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ alarm_info->mode.repeat, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
if (update_flag == ALARM_UPDATE_FLAG_TIME) {
if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
app_service_name, app_service_name_mod, bundle, noti_len, noti, year,\
month, day, hour, min, sec, msec, day_of_week, repeat,\
alarm_type, reserved_info, dst_service_name, dst_service_name_mod)\
- values (%d,%d,%d,%d,%d,0,%Q,%Q,%Q,%Q,%Q,%Q,%d,%Q,%d,%d,%d,%d,%d,%d,%d,%d,%d,\
- %d,%d,%Q,%Q)",\
+ values (%d,%lld,%lld,%d,%d,0,%Q,%Q,%Q,%Q,%Q,%Q,%d,%Q,%d,%d,%d,%d,%d,%d,%d,%d,%d,\
+ %d,%lld,%Q,%Q)",\
__alarm_info->alarm_id,
- (int)__alarm_info->start,
- (int)__alarm_info->end,
+ (gint64)__alarm_info->start,
+ (gint64)__alarm_info->end,
__alarm_info->uid,
__alarm_info->global,
CHECK_NULL_STRING(__alarm_info->caller_pkgid),
mode->u_interval.day_of_week,
mode->repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
CHECK_NULL_STRING(__alarm_info->dst_service_name),
CHECK_NULL_STRING(__alarm_info->dst_service_name_mod));
alarm_date_t *start = &alarm_info->start;
alarm_mode_t *mode = &alarm_info->mode;
- char *query = sqlite3_mprintf("update alarmmgr set start=%d, end=%d,\
+ char *query = sqlite3_mprintf("update alarmmgr set start=%lld, end=%lld,\
uid=%d, global=%d, is_disabled=0, caller_pkgid=%Q, callee_pkgid=%Q, app_unique_name=%Q, app_service_name=%Q, app_service_name_mod=%Q,\
bundle=%Q, noti_len=%d, noti=%Q, year=%d, month=%d, day=%d, hour=%d, min=%d, sec=%d, msec=%d,\
day_of_week=%d, repeat=%d, alarm_type=%d,\
- reserved_info=%d, dst_service_name=%Q, dst_service_name_mod=%Q\
+ reserved_info=%lld, dst_service_name=%Q, dst_service_name_mod=%Q\
where alarm_id=%d",\
- (int)__alarm_info->start,
- (int)__alarm_info->end,
+ (gint64)__alarm_info->start,
+ (gint64)__alarm_info->end,
__alarm_info->uid,
__alarm_info->global,
CHECK_NULL_STRING(__alarm_info->caller_pkgid),
mode->u_interval.day_of_week,
mode->repeat,
alarm_info->alarm_type,
- alarm_info->reserved_info,
+ (gint64)alarm_info->reserved_info,
CHECK_NULL_STRING(__alarm_info->dst_service_name),
CHECK_NULL_STRING(__alarm_info->dst_service_name_mod),
__alarm_info->alarm_id);
char bundle[MAX_BUNDLE_NAME_LEN] = {0,};
int noti_len;
char *noti;
+ gint64 start_64, end_64, reserved_info_64;
if (SQLITE_OK != sqlite3_prepare(alarmmgr_db, query, strlen(query), &stmt, &tail)) {
LOGE("sqlite3_prepare() is failed.");
mode = &alarm_info->mode;
__alarm_info->alarm_id = sqlite3_column_int(stmt, col_idx++);
- __alarm_info->start = sqlite3_column_int(stmt, col_idx++);
- __alarm_info->end = sqlite3_column_int(stmt, col_idx++);
+ start_64 = sqlite3_column_int64(stmt, col_idx++);
+ __alarm_info->start = (time_t)start_64;
+ end_64 = sqlite3_column_int64(stmt, col_idx++);
+ __alarm_info->end = (time_t)end_64;
__alarm_info->uid = sqlite3_column_int(stmt, col_idx++);
__alarm_info->global = sqlite3_column_int(stmt, col_idx++);
is_disabled = sqlite3_column_int(stmt, col_idx++);
mode->u_interval.day_of_week = sqlite3_column_int(stmt, col_idx++);
mode->repeat = (alarm_repeat_mode_t)sqlite3_column_int(stmt, col_idx++);
alarm_info->alarm_type = sqlite3_column_int(stmt, col_idx++);
- alarm_info->reserved_info = sqlite3_column_int(stmt, col_idx++);
+ reserved_info_64 = sqlite3_column_int64(stmt, col_idx++);
+ alarm_info->reserved_info = (time_t)reserved_info_64;
strncpy(dst_service_name, (const char *)sqlite3_column_text(stmt, col_idx++),
MAX_SERVICE_NAME_LEN - 1);
strncpy(dst_service_name_mod, (const char *)sqlite3_column_text(stmt, col_idx++),
" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
-" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='x' name='alarm_info_reserved_info' direction='in' />"
" <arg type='s' name='alarm_info_reserved_service_name' direction='in' />"
" <arg type='s' name='alarm_info_reserved_service_name_mod' direction='in' />"
" <arg type='i' name='alarm_id' direction='out' />"
" <arg type='i' name='alarm_info_end_month' direction='in' />"
" <arg type='i' name='alarm_info_end_day' direction='in' />"
" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
-" <arg type='i' name='alarm_info_mode_interval' direction='in' />"
+" <arg type='x' name='alarm_info_mode_interval' direction='in' />"
" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
-" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='x' name='alarm_info_reserved_info' direction='in' />"
" <arg type='s' name='alarm_info_bundle_data' direction='in' />"
" <arg type='i' name='alarm_id' direction='out' />"
" <arg type='i' name='return_code' direction='out' />"
" <arg type='i' name='alarm_info_end_month' direction='in' />"
" <arg type='i' name='alarm_info_end_day' direction='in' />"
" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
-" <arg type='i' name='alarm_info_mode_interval' direction='in' />"
+" <arg type='x' name='alarm_info_mode_interval' direction='in' />"
" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
-" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='x' name='alarm_info_reserved_info' direction='in' />"
" <arg type='s' name='alarm_info_noti_data' direction='in' />"
" <arg type='i' name='alarm_id' direction='out' />"
" <arg type='i' name='return_code' direction='out' />"
" <arg type='i' name='alarm_info_end_year' direction='in' />"
" <arg type='i' name='alarm_info_end_month' direction='in' />"
" <arg type='i' name='alarm_info_end_day' direction='in' />"
-" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
+" <arg type='x' name='alarm_info_mode_interval' direction='in' />"
" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
-" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='x' name='alarm_info_reserved_info' direction='in' />"
" <arg type='i' name='update_flag' direction='in' />"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <arg type='i' name='alarm_info_mode_day_of_week' direction='out' />"
" <arg type='i' name='alarm_info_mode_repeat' direction='out' />"
" <arg type='i' name='alarm_info_alarm_type' direction='out' />"
-" <arg type='i' name='alarm_info_reserved_info' direction='out' />"
+" <arg type='x' name='alarm_info_reserved_info' direction='out' />"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <method name='alarm_set_rtc_time'>"
" </method>"
" <method name='alarm_get_next_duetime'>"
" <arg type='i' name='alarm_id' direction='in' />"
-" <arg type='i' name='duetime' direction='out' />"
+" <arg type='x' name='duetime' direction='out' />"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <method name='alarm_get_all_info'>"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <method name='alarm_set_time'>"
-" <arg type='i' name='time' direction='in' />"
+" <arg type='x' name='time' direction='in' />"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <method name='alarm_set_time_with_propagation_delay'>"
-" <arg type='u' name='new_sec' direction='in' />"
-" <arg type='u' name='new_nsec' direction='in' />"
-" <arg type='u' name='req_sec' direction='in' />"
-" <arg type='u' name='req_nsec' direction='in' />"
+" <arg type='x' name='new_sec' direction='in' />"
+" <arg type='x' name='new_nsec' direction='in' />"
+" <arg type='x' name='req_sec' direction='in' />"
+" <arg type='x' name='req_nsec' direction='in' />"
" <arg type='i' name='return_code' direction='out' />"
" </method>"
" <method name='alarm_set_timezone'>"
ret = alarm_manager_alarm_get_info(parameters, uid, &alarm_info);
g_dbus_method_invocation_return_value(
- invoc, g_variant_new("(iiiiiiiiiiiiii)",
+ invoc, g_variant_new("(iiiiiiiiiiiixi)",
alarm_info.start.year, alarm_info.start.month,
alarm_info.start.day, alarm_info.start.hour,
alarm_info.start.min, alarm_info.start.sec,
alarm_info.end.year, alarm_info.end.month,
alarm_info.end.day, alarm_info.mode.u_interval.day_of_week,
alarm_info.mode.repeat, alarm_info.alarm_type,
- alarm_info.reserved_info, ret));
+ (gint64)alarm_info.reserved_info, ret));
} else if (g_strcmp0(method_name, "alarm_get_next_duetime") == 0) {
- int duetime;
+ time_t duetime;
ret = alarm_manager_alarm_get_next_duetime(parameters, uid, &duetime);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, ret));
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(xi)", (gint64)duetime, ret));
} else if (g_strcmp0(method_name, "alarm_get_all_info") == 0) {
char *db_path = NULL;
if (g_scheduled_alarm_list == NULL || g_scheduled_alarm_list->data == NULL)
return false;
- int time_sec = (int)(intptr_t)user_data;
+ time_t time_sec = (time_t)(intptr_t)user_data;
__scheduled_alarm_t *alarm = (__scheduled_alarm_t *)g_scheduled_alarm_list->data;
__alarm_info_t *alarm_info = alarm->__alarm_info;
return false;
}
-void __reschedule_alarms_with_newtime(int cur_time, int new_time, double diff_time)
+void __reschedule_alarms_with_newtime(time_t cur_time, time_t new_time, double diff_time)
{
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
char *timebuf = ctime((const time_t *)&new_time);
if (timebuf) {
timebuf[strlen(timebuf) - 1] = '\0'; /* to avoid newline */
- snprintf(log_message, sizeof(log_message), "Current: %d, New: %d, %s, diff: %f", cur_time, new_time, timebuf, diff_time);
+ snprintf(log_message, sizeof(log_message), "Current: %ld, New: %ld, %s, diff: %f", cur_time, new_time, timebuf, diff_time);
}
__save_module_log("CHANGE TIME", log_message);
#endif
}
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
- snprintf(log_message, sizeof(log_message), "wakeup rtc time: %d, %s", (int)rtc_time, ctime(&rtc_time));
+ snprintf(log_message, sizeof(log_message), "wakeup rtc time: %ld, %s", rtc_time, ctime(&rtc_time));
__save_module_log(log_tag, log_message);
#endif
return return_code;
{
double diff_time = 0.0;
struct timeval cur_time = {0,};
- int time_sec;
+ gint64 time_sec;
+ time_t new_time;
- g_variant_get(parameters, "(i)", &time_sec);
+ g_variant_get(parameters, "(x)", &time_sec);
+
+ new_time = (time_t)time_sec;
_alarm_disable_timer(); /* Disable the timer to reschedule the alarm before the time is changed. */
accrue_msec += (cur_time.tv_usec / 1000); /* Accrue the millisecond to compensate the time */
if (accrue_msec > 500) {
- diff_time = difftime(time_sec, cur_time.tv_sec) - 1;
+ diff_time = difftime(new_time, cur_time.tv_sec) - 1;
accrue_msec -= 1000;
} else {
- diff_time = difftime(time_sec, cur_time.tv_sec);
+ diff_time = difftime(new_time, cur_time.tv_sec);
}
- if (!__set_time(time_sec)) { /* Change both OS time and RTC */
+ if (!__set_time(new_time)) { /* Change both OS time and RTC */
LOGE("Failed to change both OS time and RTC");
_clear_scheduled_alarm_list();
_alarm_schedule();
return ERR_ALARM_SYSTEM_FAIL;
}
- LOGD("[TIMESTAMP]Current time(%ld), New time(%d)(%s), diff_time(%f)",
- cur_time.tv_sec, time_sec, ctime((const time_t *)&time_sec), diff_time);
+ LOGD("[TIMESTAMP]Current time(%ld), New time(%ld)(%s), diff_time(%f)",
+ cur_time.tv_sec, new_time, ctime((const time_t *)&new_time), diff_time);
- __reschedule_alarms_with_newtime(cur_time.tv_sec, time_sec, diff_time);
+ __reschedule_alarms_with_newtime(cur_time.tv_sec, new_time, diff_time);
return ALARMMGR_RESULT_SUCCESS;;
}
struct timespec cur_time = {0,};
struct timespec delay = {0,};
struct timespec sleep_time = {0,};
- guint real_newtime = 0;
+ time_t real_newtime = 0;
accrue_msec = 0; /* reset accrued msec */
- guint new_sec, new_nsec, req_sec, req_nsec;
+ time_t new_sec, req_sec;
+ long new_nsec, req_nsec;
+ gint64 tmp_new_sec, tmp_req_sec, tmp_new_nsec, tmp_req_nsec;
- g_variant_get(parameters, "(uuuu)", &new_sec, &new_nsec, &req_sec, &req_nsec);
+ g_variant_get(parameters, "(xxxx)", &tmp_new_sec, &tmp_new_nsec, &tmp_req_sec, &tmp_req_nsec);
+ new_sec = (time_t)tmp_new_sec;
+ new_nsec = (long)tmp_new_nsec;
+ req_sec = (time_t)tmp_req_sec;
+ req_nsec = (long)tmp_req_nsec;
_alarm_disable_timer(); /* Disable the timer to reschedule the alarm before the time is changed. */
/* Check validation of requested time */
if (req_sec > cur_time.tv_sec || (req_sec == cur_time.tv_sec && req_nsec > cur_time.tv_nsec)) {
- LOGE("The requeted time(%d.%09d) must be equal to or less than current time(%ld.%09ld).",
+ LOGE("The requeted time(%ld.%09ld) must be equal to or less than current time(%ld.%09ld).",
req_sec, req_nsec, cur_time.tv_sec, cur_time.tv_nsec);
return ERR_ALARM_INVALID_PARAM;
}
}
diff_time = difftime(real_newtime, cur_time.tv_sec);
- LOGD("[TIMESTAMP]Current time(%ld.%09ld), New time(%d.%09d), Real Newtime(%d), diff_time(%f)",
+ LOGD("[TIMESTAMP]Current time(%ld.%09ld), New time(%ld.%09ld), Real Newtime(%ld), diff_time(%f)",
cur_time.tv_sec, cur_time.tv_nsec, new_sec, new_nsec, real_newtime, diff_time);
- LOGD("Requested(%d.%09d) Delay(%ld.%09ld) Sleep(%09ld)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
+ LOGD("Requested(%ld.%09ld) Delay(%ld.%09ld) Sleep(%09ld)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
__reschedule_alarms_with_newtime(cur_time.tv_sec, real_newtime, diff_time);
return ALARMMGR_RESULT_SUCCESS;
}
const char *callee_appid;
int start_year, start_month, start_day, start_hour, start_min, start_sec;
int end_year, end_month, end_day;
- int mode_day_of_week, mode_interval, mode_repeat, alarm_type, reserved_info;
+ int mode_day_of_week, mode_repeat, alarm_type;
+ time_t mode_interval, reserved_info;
+ gint64 tmp_mode_interval, tmp_reserved_info;
char *bundle_data;
*alarm_id = _alarm_id;
if (uid < 0 || pid < 0)
return ERR_ALARM_SYSTEM_FAIL;
- g_variant_get(parameters, "(iiiiiiiiiiiiii&s)",
+ g_variant_get(parameters, "(iiiiiiiiiixiix&s)",
&start_year, &start_month, &start_day, &start_hour, &start_min,
&start_sec, &end_year, &end_month, &end_day, &mode_day_of_week,
- &mode_interval, &mode_repeat, &alarm_type, &reserved_info, &bundle_data);
+ &tmp_mode_interval, &mode_repeat, &alarm_type, &tmp_reserved_info, &bundle_data);
+
+ mode_interval = (time_t)tmp_mode_interval;
+ reserved_info = (time_t)tmp_reserved_info;
b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
if (b == NULL) {
#endif
int start_year, start_month, start_day, start_hour, start_min, start_sec;
int end_year, end_month, end_day;
- int mode_day_of_week, mode_interval, mode_repeat, alarm_type, reserved_info;
+ int mode_day_of_week, mode_repeat, alarm_type;
+ time_t mode_interval, reserved_info;
+ gint64 tmp_mode_interval, tmp_reserved_info;
char *noti_data;
*alarm_id = _alarm_id;
if (uid < 0 || pid < 0)
return ERR_ALARM_SYSTEM_FAIL;
- g_variant_get(parameters, "(iiiiiiiiiiiiii&s)",
+ g_variant_get(parameters, "(iiiiiiiiiixiix&s)",
&start_year, &start_month, &start_day, &start_hour, &start_min,
&start_sec, &end_year, &end_month, &end_day, &mode_day_of_week,
- &mode_interval, &mode_repeat, &alarm_type, &reserved_info, ¬i_data);
+ &tmp_mode_interval, &mode_repeat, &alarm_type, &tmp_reserved_info, ¬i_data);
+
+ mode_interval = (time_t)tmp_mode_interval;
+ reserved_info = (time_t)tmp_reserved_info;
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
char *app_service_name_mod = NULL;
int start_year, start_month, start_day, start_hour, start_min, start_sec;
int msec, end_year, end_month, end_day;
- int mode_day_of_week, mode_repeat, alarm_type, reserved_info;
+ int mode_day_of_week, mode_repeat, alarm_type;
+ gint64 tmp_reserved_info;
+ time_t reserved_info;
char *reserved_service_name = NULL;
char *reserved_service_name_mod = NULL;
if (uid < 0 || pid < 0)
return ERR_ALARM_SYSTEM_FAIL;
- g_variant_get(parameters, "(&s&siiiiiiiiiiiiii&s&s)",
+ g_variant_get(parameters, "(&s&siiiiiiiiiiiiix&s&s)",
&app_service_name, &app_service_name_mod,
&start_year, &start_month, &start_day, &start_hour, &start_min,
&start_sec, &msec, &end_year, &end_month, &end_day,
- &mode_day_of_week, &mode_repeat, &alarm_type, &reserved_info,
+ &mode_day_of_week, &mode_repeat, &alarm_type, &tmp_reserved_info,
&reserved_service_name, &reserved_service_name_mod);
+ reserved_info = (time_t)tmp_reserved_info;
+
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
alarm_info.start.day = start_day;
int alarm_id;
int start_year, start_month, start_day, start_hour, start_min, start_sec;
int end_year, end_month, end_day;
- int mode_interval, mode_repeat, alarm_type, reserved_info, update_flag;
+ int mode_repeat, alarm_type, update_flag;
+ time_t mode_interval, reserved_info;
+ gint64 tmp_mode_interval, tmp_reserved_info;
if (uid < 0 || pid < 0)
return ERR_ALARM_SYSTEM_FAIL;
- g_variant_get(parameters, "(iiiiiiiiiiiiiii)",
+ g_variant_get(parameters, "(iiiiiiiiiixiixi)",
&alarm_id, &start_year, &start_month, &start_day, &start_hour,
&start_min, &start_sec, &end_year, &end_month, &end_day,
- &mode_interval, &mode_repeat, &alarm_type, &reserved_info,
+ &tmp_mode_interval, &mode_repeat, &alarm_type, &tmp_reserved_info,
&update_flag);
+ mode_interval = (time_t)tmp_mode_interval;
+ reserved_info = (time_t)tmp_reserved_info;
+
return_code = __check_modifiable(uid, pid, alarm_id);
if (return_code != ALARMMGR_RESULT_SUCCESS)
return return_code;
return ALARMMGR_RESULT_SUCCESS;
}
-int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, int *duetime)
+int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, time_t *duetime)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
_alarm_set_next_duetime(find_item);
LOGD("Next duetime : %s", ctime(&(find_item->due_time)));
- *duetime = (int)(find_item->due_time);
+ *duetime = find_item->due_time;
return ALARMMGR_RESULT_SUCCESS;
}
projects / platform / core / appfw / alarm-manager.git / commitdiff