#define ALARM_TYPE_WITHCB 0x40000000 /**< withcb */
#define ALARM_TYPE_PERIOD 0x10000000 /**< periodic */
-bool _send_alarm_create(alarm_context_t context, alarm_info_t *alarm,
+#define base_info_t alarm_info_t
+
+bool _send_alarm_create(alarm_context_t context, base_info_t *base,
alarm_id_t *id, const char *dst_service_name, const char *dst_service_name_mod, int *error_code);
-bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info,
+bool _send_alarm_create_appsvc(alarm_context_t context, base_info_t *base_info,
alarm_id_t *alarm_id, bundle *b, int *error_code);
-bool _send_alarm_create_noti(alarm_context_t context, alarm_info_t *alarm_info,
+bool _send_alarm_create_noti(alarm_context_t context, base_info_t *base_info,
alarm_id_t *alarm_id, notification_h noti, int *error_code);
bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code);
+ base_info_t *base_info, int update_flag, int *error_code);
bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id, int *error_code);
bool _send_alarm_delete_all(alarm_context_t context, int *error_code);
bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,
GVariantIter **iter, int *num_of_ids, int *error_code);
bool _send_alarm_get_number_of_ids(alarm_context_t context, int *num_of_ids, int *error_code);
-bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id, alarm_info_t *alarm_info, int *error_code);
+bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id, base_info_t *base_info, int *error_code);
bool _send_alarm_get_next_duetime(alarm_context_t context, alarm_id_t alarm_id, time_t* duetime, int *error_code);
bool _send_alarm_get_all_info(alarm_context_t context, char ** db_path, int *error_code);
bool _send_alarm_reset(alarm_context_t context, int *error_code);
char *bundle;
char *noti;
- alarm_info_t alarm_info;
+ base_info_t base_info;
periodic_method_e method;
long requested_interval;
int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid, pid_t pid, GVariant **alarm_array, int *num_of_alarm);
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_info(GVariant *parameters, uid_t uid, base_info_t *base_info);
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);
return error_code;
}
-bool _send_alarm_create_noti(alarm_context_t context, alarm_info_t *alarm_info,
+bool _send_alarm_create_noti(alarm_context_t context, base_info_t *base_info,
alarm_id_t *alarm_id, notification_h noti, int *error_code)
{
int return_code = -1;
noti_data = g_base64_encode((guchar *)data, datalen);
param = g_variant_new("(iiiiiiiiiixiixs)",
- 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,
- (gint64)alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- (gint64)alarm_info->reserved_info,
+ base_info->start.year,
+ base_info->start.month,
+ base_info->start.day,
+ base_info->start.hour,
+ base_info->start.min,
+ base_info->start.sec,
+ base_info->end.year,
+ base_info->end.month,
+ base_info->end.day,
+ base_info->mode.u_interval.day_of_week,
+ (gint64)base_info->mode.u_interval.interval,
+ base_info->mode.repeat,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
(char *)noti_data);
if (noti_data)
return true;
}
-bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info,
+bool _send_alarm_create_appsvc(alarm_context_t context, base_info_t *base_info,
alarm_id_t *alarm_id, bundle *b, int *error_code)
{
int return_code = -1;
}
param = g_variant_new("(iiiiiiiiiixiixs)",
- 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,
- (gint64)alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- (gint64)alarm_info->reserved_info,
+ base_info->start.year,
+ base_info->start.month,
+ base_info->start.day,
+ base_info->start.hour,
+ base_info->start.min,
+ base_info->start.sec,
+ base_info->end.year,
+ base_info->end.month,
+ base_info->end.day,
+ base_info->mode.u_interval.day_of_week,
+ (gint64)base_info->mode.u_interval.interval,
+ base_info->mode.repeat,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
(char *)b_data);
if (b_data)
return true;
}
-bool _send_alarm_create(alarm_context_t context, alarm_info_t *alarm_info,
+bool _send_alarm_create(alarm_context_t context, base_info_t *base_info,
alarm_id_t *alarm_id, const char *dst_service_name, const char *dst_service_name_mod,
int *error_code)
{
param = g_variant_new("(ssiiiiiiiiiiiiixss)",
context.app_service_name,
context.app_service_name_mod,
- 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->msec,
- 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,
- (gint64)alarm_info->reserved_info,
+ base_info->start.year,
+ base_info->start.month,
+ base_info->start.day,
+ base_info->start.hour,
+ base_info->start.min,
+ base_info->start.sec,
+ base_info->msec,
+ base_info->end.year,
+ base_info->end.month,
+ base_info->end.day,
+ base_info->mode.u_interval.day_of_week,
+ base_info->mode.repeat,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
dst_service_name, dst_service_name_mod);
return_code = __dbus_call_sync(context.proxy, "alarm_create",
}
bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int *error_code)
+ base_info_t *base_info, int *error_code)
{
int return_code = -1;
GVariant *param = NULL;
}
g_variant_get(reply, "(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,
+ &base_info->start.year,
+ &base_info->start.month,
+ &base_info->start.day,
+ &base_info->start.hour,
+ &base_info->start.min,
+ &base_info->start.sec,
+ &base_info->end.year,
+ &base_info->end.month,
+ &base_info->end.day,
+ &base_info->mode.u_interval.day_of_week,
+ &base_info->mode.repeat,
+ &base_info->alarm_type,
&tmp_reserved_info,
&return_code);
- alarm_info->reserved_info = (time_t)tmp_reserved_info;
+ base_info->reserved_info = (time_t)tmp_reserved_info;
LOGD("alarm_get_info() dbus sync success. return_code[%d].",
return_code);
}
bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code)
+ base_info_t *base_info, int update_flag, int *error_code)
{
int return_code = -1;
GVariant *param = NULL;
param = g_variant_new("(iiiiiiiiiixiixi)",
alarm_id,
- 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,
- (gint64)alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- (gint64)alarm_info->reserved_info,
+ base_info->start.year,
+ base_info->start.month,
+ base_info->start.day,
+ base_info->start.hour,
+ base_info->start.min,
+ base_info->start.sec,
+ base_info->end.year,
+ base_info->end.month,
+ base_info->end.day,
+ (gint64)base_info->mode.u_interval.interval,
+ base_info->mode.repeat,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
update_flag);
return_code = __dbus_call_sync(context.proxy, "alarm_update",
NULL
};
-void _initialize_alarm_info(alarm_info_t *alarm_info, int alarm_type,
+void _initialize_alarm_info(base_info_t *base_info, int alarm_type,
time_t trigger_at_time, time_t interval, bool precision)
{
struct timespec current_time;
clock_gettime(CLOCK_REALTIME, ¤t_time);
- memset(alarm_info, 0, sizeof(alarm_info_t));
+ memset(base_info, 0, sizeof(base_info_t));
- alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
- alarm_info->alarm_type = alarm_type;
+ base_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ base_info->alarm_type = alarm_type;
if (current_time.tv_nsec > (BILLION / 2)) {
/* When the nanosecond part of the current_time is bigger than 500ms,
} else {
current_time.tv_sec += trigger_at_time;
}
- alarm_info->reserved_info = current_time.tv_sec;
+ base_info->reserved_info = current_time.tv_sec;
tzset(); /* Processes the TZ environment variable, and Set timezone, daylight, and tzname. */
localtime_r(¤t_time.tv_sec, &duetime_tm);
- alarm_info->start.year = duetime_tm.tm_year + 1900;
- alarm_info->start.month = duetime_tm.tm_mon + 1;
- alarm_info->start.day = duetime_tm.tm_mday;
+ base_info->start.year = duetime_tm.tm_year + 1900;
+ base_info->start.month = duetime_tm.tm_mon + 1;
+ base_info->start.day = duetime_tm.tm_mday;
- alarm_info->end.year = 0;
- alarm_info->end.month = 0;
- alarm_info->end.day = 0;
+ base_info->end.year = 0;
+ base_info->end.month = 0;
+ base_info->end.day = 0;
- alarm_info->start.hour = duetime_tm.tm_hour;
- alarm_info->start.min = duetime_tm.tm_min;
- alarm_info->start.sec = duetime_tm.tm_sec;
+ base_info->start.hour = duetime_tm.tm_hour;
+ base_info->start.min = duetime_tm.tm_min;
+ base_info->start.sec = duetime_tm.tm_sec;
if (interval <= 0) {
- alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
- alarm_info->mode.u_interval.interval = 0;
+ base_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ base_info->mode.u_interval.interval = 0;
} else {
- alarm_info->mode.repeat = ALARM_REPEAT_MODE_REPEAT;
- alarm_info->mode.u_interval.interval = interval;
+ base_info->mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+ base_info->mode.u_interval.interval = interval;
}
- alarm_info->msec = precision ? (int)current_time.tv_nsec / MILLION : 0;
+ base_info->msec = precision ? (int)current_time.tv_nsec / MILLION : 0;
LOGD("trigger_at_time(%ld), start(%d-%d-%d, %02d:%02d:%02d),\
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, alarm_info->mode.u_interval.interval,
- alarm_info->alarm_type);
+ trigger_at_time, base_info->start.day, base_info->start.month,
+ base_info->start.year, base_info->start.hour,
+ base_info->start.min, base_info->start.sec,
+ base_info->mode.repeat, base_info->mode.u_interval.interval,
+ base_info->alarm_type);
}
static void __add_resultcb(alarm_id_t alarm_id, alarm_cb_t cb_func, void *data)
return true;
}
-static int __check_validation(alarm_info_t *alarm_info, const char *function)
+static int __check_validation(base_info_t *base_info, const char *function)
{
int error_code;
- if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
+ if (!__alarm_validate_date(&base_info->start, &error_code)) {
LOGE("%s : start date error\n", function);
return error_code;
}
- if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
+ if (!__alarm_validate_time(&base_info->start, &error_code)) {
LOGE("%s : start time error\n", function);
return error_code;
}
- if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
+ if (!__alarm_validate_date(&base_info->end, &error_code)) {
LOGE("%s : end date error\n", function);
return error_code;
}
return ret;
}
-static void __adjust_current_milliseconds(alarm_info_t *alarm_info)
+static void __adjust_current_milliseconds(base_info_t *base_info)
{
struct timespec current_time;
struct tm start_tm;
/* When the nanosecond part of the current_time is bigger than 500ms,
* the duetime increases by extra 1sec. */
- start_tm.tm_year = alarm_info->start.year - 1900;
- start_tm.tm_mon = alarm_info->start.month - 1;
- start_tm.tm_mday = alarm_info->start.day;
- start_tm.tm_hour = alarm_info->start.hour;
- start_tm.tm_min = alarm_info->start.min;
- start_tm.tm_sec = alarm_info->start.sec;
+ start_tm.tm_year = base_info->start.year - 1900;
+ start_tm.tm_mon = base_info->start.month - 1;
+ start_tm.tm_mday = base_info->start.day;
+ start_tm.tm_hour = base_info->start.hour;
+ start_tm.tm_min = base_info->start.min;
+ start_tm.tm_sec = base_info->start.sec;
start_tm.tm_isdst = -1;
start = timegm(&start_tm);
start += 1;
localtime_r(&start, &start_tm);
- alarm_info->start.year = start_tm.tm_year + 1900;
- alarm_info->start.month = start_tm.tm_mon + 1;
- alarm_info->start.day = start_tm.tm_mday;
- alarm_info->start.hour = start_tm.tm_hour;
- alarm_info->start.min = start_tm.tm_min;
- alarm_info->start.sec = start_tm.tm_sec;
+ base_info->start.year = start_tm.tm_year + 1900;
+ base_info->start.month = start_tm.tm_mon + 1;
+ base_info->start.day = start_tm.tm_mday;
+ base_info->start.hour = start_tm.tm_hour;
+ base_info->start.min = start_tm.tm_min;
+ base_info->start.sec = start_tm.tm_sec;
LOGW("adjusted start(%d-%d-%d, %02d:%02d:%02d),",
- alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
- alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec);
+ base_info->start.day, base_info->start.month, base_info->start.year,
+ base_info->start.hour, base_info->start.min, base_info->start.sec);
}
}
}
EXPORT_API alarm_entry_t *alarmmgr_create_alarm(void)
{
- alarm_info_t *alarm = (alarm_info_t *)malloc(sizeof(alarm_info_t));
+ base_info_t *base_info = (base_info_t *)malloc(sizeof(base_info_t));
- if (alarm == NULL) {
+ if (base_info == NULL) {
LOGE("alarm is null");
return NULL;
}
- alarm->start.year = 0;
- alarm->start.month = 0;
- alarm->start.day = 0;
- alarm->start.hour = 0;
- alarm->start.min = 0;
- alarm->start.sec = 0;
+ base_info->start.year = 0;
+ base_info->start.month = 0;
+ base_info->start.day = 0;
+ base_info->start.hour = 0;
+ base_info->start.min = 0;
+ base_info->start.sec = 0;
- alarm->msec = 0;
+ base_info->msec = 0;
- alarm->end.year = 0;
- alarm->end.month = 0;
- alarm->end.day = 0;
- alarm->end.hour = 0;
- alarm->end.min = 0;
- alarm->end.sec = 0;
+ base_info->end.year = 0;
+ base_info->end.month = 0;
+ base_info->end.day = 0;
+ base_info->end.hour = 0;
+ base_info->end.min = 0;
+ base_info->end.sec = 0;
- alarm->mode.repeat = ALARM_REPEAT_MODE_ONCE;
- alarm->mode.u_interval.interval = 0;
+ base_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ base_info->mode.u_interval.interval = 0;
- alarm->alarm_type = ALARM_TYPE_DEFAULT;
+ base_info->alarm_type = ALARM_TYPE_DEFAULT;
- alarm->reserved_info = 0;
+ base_info->reserved_info = 0;
- return (alarm_entry_t *) alarm;
+ return (alarm_entry_t *) base_info;
}
EXPORT_API int alarmmgr_free_alarm(alarm_entry_t *alarm)
EXPORT_API int alarmmgr_set_time(alarm_entry_t *alarm, alarm_date_t time)
{
- alarm_info_t *alarm_info;
+ base_info_t *base_info;
int error_code;
if (alarm == NULL) {
return ERR_ALARM_INVALID_PARAM;
}
- alarm_info = (alarm_info_t *)alarm;
+ base_info = (base_info_t *)alarm;
if (!__alarm_validate_date(&time, &error_code)) {
LOGE("start date error\n");
return error_code;
return error_code;
}
- memcpy(&alarm_info->start, &time, sizeof(alarm_date_t));
+ memcpy(&base_info->start, &time, sizeof(alarm_date_t));
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_get_time(const alarm_entry_t *alarm,
alarm_date_t *time)
{
- alarm_info_t *alarm_info = (alarm_info_t *)alarm;
+ base_info_t *base_info = (base_info_t *)alarm;
if (alarm == NULL) {
LOGE("alarm is null");
}
if (time != NULL)
- memcpy(time, &alarm_info->start, sizeof(alarm_date_t));
+ memcpy(time, &base_info->start, sizeof(alarm_date_t));
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_set_repeat_mode(alarm_entry_t *alarm,
alarm_repeat_mode_t repeat, int interval)
{
- alarm_info_t *alarm_info = (alarm_info_t *)alarm;
+ base_info_t *base_info = (base_info_t *)alarm;
if (repeat >= ALARM_REPEAT_MODE_MAX) {
LOGE("repeat value is invalid");
return ERR_ALARM_INVALID_PARAM;
}
- alarm_info->mode.repeat = repeat;
+ base_info->mode.repeat = repeat;
if (repeat == ALARM_REPEAT_MODE_REPEAT
|| repeat == ALARM_REPEAT_MODE_WEEKLY) {
if (interval <= 0)
return ERR_ALARM_INVALID_PARAM;
- alarm_info->mode.u_interval.interval = interval;
+ base_info->mode.u_interval.interval = interval;
}
return ALARMMGR_RESULT_SUCCESS;
EXPORT_API int alarmmgr_get_repeat_mode(const alarm_entry_t *alarm,
alarm_repeat_mode_t *repeat, int *interval)
{
- alarm_info_t *alarm_info = (alarm_info_t *)alarm;
+ base_info_t *base_info = (base_info_t *)alarm;
if (alarm == NULL) {
LOGE("alarm is null");
}
if (repeat != NULL)
- *repeat = alarm_info->mode.repeat;
+ *repeat = base_info->mode.repeat;
if (interval != NULL)
- *interval = alarm_info->mode.u_interval.interval;
+ *interval = base_info->mode.u_interval.interval;
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_set_type(alarm_entry_t *alarm, int alarm_type)
{
- alarm_info_t *alarm_info;
+ base_info_t *base_info;
if (alarm == NULL) {
LOGE("alarm is null");
return ERR_ALARM_INVALID_PARAM;
}
- alarm_info = (alarm_info_t *)alarm;
- alarm_info->alarm_type = alarm_type;
- alarm_info->alarm_type &= (~ALARM_TYPE_RELATIVE);
+ base_info = (base_info_t *)alarm;
+ base_info->alarm_type = alarm_type;
+ base_info->alarm_type &= (~ALARM_TYPE_RELATIVE);
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_get_type(const alarm_entry_t *alarm, int *alarm_type)
{
- alarm_info_t *alarm_info = (alarm_info_t *)alarm;
+ base_info_t *base_info = (base_info_t *)alarm;
if (alarm == NULL) {
LOGE("alarm is null");
}
if (alarm_type != NULL)
- *alarm_type = alarm_info->alarm_type;
+ *alarm_type = base_info->alarm_type;
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_add_alarm_appsvc_with_localtime(alarm_entry_t *alarm, void *bundle_data, alarm_id_t *alarm_id)
{
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
alarm_mode_t *mode;
const char *operation = NULL;
int error_code = 0;
LOGD("[alarm-lib]:alarm_create() is called\n");
- alarm_info = (alarm_info_t *)alarm;
- if (alarm_info == NULL || alarm_id == NULL) {
+ base_info = (base_info_t *)alarm;
+ if (base_info == NULL || alarm_id == NULL) {
LOGE("Invalid parameter\n");
return ERR_ALARM_INVALID_PARAM;
}
- __adjust_current_milliseconds(alarm_info);
+ __adjust_current_milliseconds(base_info);
b = (bundle *)bundle_data;
if (b == NULL) {
appid = appsvc_get_appid(b);
if (appid == NULL) {
- if ((alarm_info->alarm_type & ALARM_TYPE_NOLAUNCH) ||
+ if ((base_info->alarm_type & ALARM_TYPE_NOLAUNCH) ||
(operation && !strcmp(operation, APPSVC_OPERATION_DEFAULT))) {
LOGE("appid is invalid");
return ERR_ALARM_INVALID_PARAM;
}
}
- mode = &alarm_info->mode;
+ mode = &base_info->mode;
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, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ base_info->start.day, base_info->start.month, base_info->start.year,
+ base_info->start.hour, base_info->start.min, base_info->start.sec,
+ base_info->end.year, base_info->end.month, base_info->end.day,
+ base_info->mode.repeat, base_info->mode.u_interval.interval, base_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX)
return ERR_ALARM_INVALID_PARAM;
- error_code = __check_validation(alarm_info, __FUNCTION__);
+ error_code = __check_validation(base_info, __FUNCTION__);
if (error_code != ALARMMGR_RESULT_SUCCESS)
return error_code;
- if (!_send_alarm_create_appsvc(alarm_context, alarm_info, alarm_id, b, &error_code))
+ if (!_send_alarm_create_appsvc(alarm_context, base_info, alarm_id, b, &error_code))
return error_code;
return ALARMMGR_RESULT_SUCCESS;
{
char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
alarm_mode_t *mode;
int ret;
int error_code;
return ERR_ALARM_INVALID_PARAM;
}
- alarm_info = (alarm_info_t *) alarm;
- if (alarm_info == NULL || alarm_id == NULL) {
+ base_info = (base_info_t *) alarm;
+ if (base_info == NULL || alarm_id == NULL) {
LOGE("Invalid parameter bundle\n");
return ERR_ALARM_INVALID_PARAM;
}
- __adjust_current_milliseconds(alarm_info);
+ __adjust_current_milliseconds(base_info);
- mode = &alarm_info->mode;
+ mode = &base_info->mode;
ret = __sub_init();
if (ret < 0)
return ret;
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, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ base_info->start.day, base_info->start.month, base_info->start.year,
+ base_info->start.hour, base_info->start.min, base_info->start.sec,
+ base_info->end.year, base_info->end.month, base_info->end.day,
+ base_info->mode.repeat, base_info->mode.u_interval.interval, base_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
return ERR_ALARM_INVALID_PARAM;
}
- error_code = __check_validation(alarm_info, __FUNCTION__);
+ error_code = __check_validation(base_info, __FUNCTION__);
if (error_code != ALARMMGR_RESULT_SUCCESS)
return error_code;
j++;
}
- if (!_send_alarm_create(alarm_context, alarm_info, alarm_id, dst_service_name, dst_service_name_mod, &error_code))
+ if (!_send_alarm_create(alarm_context, base_info, alarm_id, dst_service_name, dst_service_name_mod, &error_code))
return error_code;
} else {
- if (!_send_alarm_create(alarm_context, alarm_info, alarm_id, "null", "null", &error_code))
+ if (!_send_alarm_create(alarm_context, base_info, alarm_id, "null", "null", &error_code))
return error_code;
}
EXPORT_API int alarmmgr_add_alarm_noti_with_localtime(alarm_entry_t *alarm, notification_h noti, alarm_id_t *alarm_id)
{
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
int error_code = 0;
- alarm_info = (alarm_info_t *)alarm;
+ base_info = (base_info_t *)alarm;
alarm_mode_t *mode;
- if (alarm_info == NULL || alarm_id == NULL) {
+ if (base_info == NULL || alarm_id == NULL) {
LOGE("Invalid parameter\n");
return ERR_ALARM_INVALID_PARAM;
}
- __adjust_current_milliseconds(alarm_info);
+ __adjust_current_milliseconds(base_info);
if (__alarmmgr_init_appsvc() < 0) {
LOGE("Unable to initialize dbus!!!\n");
return ERR_ALARM_SYSTEM_FAIL;
}
- mode = &alarm_info->mode;
+ mode = &base_info->mode;
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, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ base_info->start.day, base_info->start.month, base_info->start.year,
+ base_info->start.hour, base_info->start.min, base_info->start.sec,
+ base_info->end.year, base_info->end.month, base_info->end.day,
+ base_info->mode.repeat, base_info->mode.u_interval.interval, base_info->alarm_type);
/* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
if (mode->repeat >= ALARM_REPEAT_MODE_MAX)
return ERR_ALARM_INVALID_PARAM;
- error_code = __check_validation(alarm_info, __FUNCTION__);
+ error_code = __check_validation(base_info, __FUNCTION__);
if (error_code != ALARMMGR_RESULT_SUCCESS)
return error_code;
- if (!_send_alarm_create_noti(alarm_context, alarm_info, alarm_id, noti, &error_code))
+ if (!_send_alarm_create_noti(alarm_context, base_info, alarm_id, noti, &error_code))
return error_code;
return ALARMMGR_RESULT_SUCCESS;
int error_code = 0;
int result = 0;
int modified_alarm_type = 0;
- alarm_info_t alarm_info;
+ base_info_t base_info;
const char *operation = NULL;
const char *appid = NULL;
bundle *b;
modified_alarm_type ^= ALARM_TYPE_INEXACT;
}
- _initialize_alarm_info(&alarm_info, modified_alarm_type | ALARM_TYPE_RELATIVE,
+ _initialize_alarm_info(&base_info, modified_alarm_type | ALARM_TYPE_RELATIVE,
trigger_at_time, interval, false);
- if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT) &&
- alarm_info.mode.u_interval.interval < MIN_INEXACT_INTERVAL) {
- alarm_info.mode.u_interval.interval = MIN_INEXACT_INTERVAL;
- alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+ if ((base_info.alarm_type & ALARM_TYPE_INEXACT) &&
+ base_info.mode.u_interval.interval < MIN_INEXACT_INTERVAL) {
+ base_info.mode.u_interval.interval = MIN_INEXACT_INTERVAL;
+ base_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
}
- if (!_send_alarm_create_appsvc(alarm_context, &alarm_info, alarm_id, b, &error_code))
+ if (!_send_alarm_create_appsvc(alarm_context, &base_info, alarm_id, b, &error_code))
return error_code;
alarm_id_t *alarm_id)
{
int error_code = 0;
- alarm_info_t alarm_info;
+ base_info_t base_info;
if (__alarmmgr_init_appsvc() < 0) {
LOGE("Unable to initialize dbus!!!\n");
return ERR_ALARM_INVALID_PARAM;
}
- _initialize_alarm_info(&alarm_info, alarm_type | ALARM_TYPE_RELATIVE,
+ _initialize_alarm_info(&base_info, alarm_type | ALARM_TYPE_RELATIVE,
trigger_at_time, interval, false);
- if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT) &&
- alarm_info.mode.u_interval.interval < MIN_INEXACT_INTERVAL) {
- alarm_info.mode.u_interval.interval = MIN_INEXACT_INTERVAL;
- alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+ if ((base_info.alarm_type & ALARM_TYPE_INEXACT) &&
+ base_info.mode.u_interval.interval < MIN_INEXACT_INTERVAL) {
+ base_info.mode.u_interval.interval = MIN_INEXACT_INTERVAL;
+ base_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
}
- if (!_send_alarm_create_noti(alarm_context, &alarm_info, alarm_id, noti, &error_code))
+ if (!_send_alarm_create_noti(alarm_context, &base_info, alarm_id, noti, &error_code))
return error_code;
return ALARMMGR_RESULT_SUCCESS;
int i = 0;
int j = 0;
int error_code;
- alarm_info_t alarm_info;
+ base_info_t base_info;
int ret;
ret = __sub_init();
return ERR_ALARM_INVALID_PARAM;
}
- _initialize_alarm_info(&alarm_info, alarm_type | ALARM_TYPE_RELATIVE,
+ _initialize_alarm_info(&base_info, alarm_type | ALARM_TYPE_RELATIVE,
trigger_at_time, interval, precision);
if (destination != NULL) {
j++;
}
- if (!_send_alarm_create(alarm_context, &alarm_info,
+ if (!_send_alarm_create(alarm_context, &base_info,
alarm_id, dst_service_name,
dst_service_name_mod,
&error_code))
return error_code;
} else {
- if (!_send_alarm_create(alarm_context, &alarm_info, alarm_id,
+ if (!_send_alarm_create(alarm_context, &base_info, alarm_id,
"null", "null", &error_code))
return error_code;
}
alarm_id_t *alarm_id, bool precision)
{
int error_code = 0;
- alarm_info_t alarm_info;
+ base_info_t base_info;
int ret = 0;
__check_appid();
return ERR_ALARM_INVALID_PARAM;
}
- _initialize_alarm_info(&alarm_info,
+ _initialize_alarm_info(&base_info,
alarm_type | ALARM_TYPE_RELATIVE | ALARM_TYPE_WITHCB,
trigger_at_time, interval, precision);
- if (!_send_alarm_create(alarm_context, &alarm_info, alarm_id, "null", "null", &error_code))
+ if (!_send_alarm_create(alarm_context, &base_info, alarm_id, "null", "null", &error_code))
return error_code;
__add_resultcb(*alarm_id, handler, user_param);
EXPORT_API int alarmmgr_get_info(alarm_id_t alarm_id, alarm_entry_t *alarm)
{
int error_code;
- alarm_info_t *alarm_info = (alarm_info_t *) alarm;
+ base_info_t *base_info = (base_info_t *) alarm;
int ret;
ret = __sub_init();
LOGD("[alarm-lib]:alarm_get_info() is called\n");
- if (alarm_id < 0 || alarm_info == NULL) {
- LOGE("[alarm-lib]:alarm_info is null or alar_id is invalid[%d].", alarm_id);
+ if (alarm_id < 0 || base_info == NULL) {
+ LOGE("[alarm-lib]:base_info is null or alar_id is invalid[%d].", alarm_id);
return ERR_ALARM_INVALID_PARAM;
}
- if (!_send_alarm_get_info(alarm_context, alarm_id, alarm_info, &error_code))
+ if (!_send_alarm_get_info(alarm_context, alarm_id, base_info, &error_code))
return error_code;
return ALARMMGR_RESULT_SUCCESS;
EXPORT_API int alarmmgr_update_alarm(alarm_id_t alarm_id,
alarm_entry_t *alarm, int update_flag)
{
- alarm_info_t *alarm_info;
+ base_info_t *base_info;
int ret;
LOGD("[alarm-lib]:alarmmgr_update_alarm() is called\n");
return ERR_ALARM_INVALID_PARAM;
}
- alarm_info = (alarm_info_t *) alarm;
- if (alarm_info == NULL || alarm_id <= 0) {
+ base_info = (base_info_t *) alarm;
+ if (base_info == NULL || alarm_id <= 0) {
LOGE("[alarm-lib]:alarm is NULL or invalid alarm_id[%d]\n", alarm_id);
return ERR_ALARM_INVALID_PARAM;
}
return ret;
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, alarm_info->mode.u_interval.interval, alarm_info->alarm_type);
+ base_info->start.day, base_info->start.month, base_info->start.year,
+ base_info->start.hour, base_info->start.min, base_info->start.sec,
+ base_info->end.year, base_info->end.month, base_info->end.day,
+ base_info->mode.repeat, base_info->mode.u_interval.interval, base_info->alarm_type);
if (update_flag == ALARM_UPDATE_FLAG_TIME) {
- error_code = __check_validation(alarm_info, __FUNCTION__);
+ error_code = __check_validation(base_info, __FUNCTION__);
if (error_code != ALARMMGR_RESULT_SUCCESS)
return error_code;
}
- if (!_send_alarm_update(alarm_context, alarm_id, alarm_info, update_flag, &error_code))
+ if (!_send_alarm_update(alarm_context, alarm_id, base_info, update_flag, &error_code))
return error_code;
return ALARMMGR_RESULT_SUCCESS;
bool _save_alarms(__alarm_info_t *__alarm_info)
{
char *error_message = NULL;
- alarm_info_t *alarm_info =
- (alarm_info_t *) &(__alarm_info->alarm_info);
- alarm_date_t *start = &alarm_info->start;
- alarm_mode_t *mode = &alarm_info->mode;
+ base_info_t *base_info =
+ (base_info_t *) &(__alarm_info->base_info);
+ alarm_date_t *start = &base_info->start;
+ alarm_mode_t *mode = &base_info->mode;
char *query = sqlite3_mprintf("insert into alarmmgr( alarm_id, start,\
end, uid, global, is_disabled, caller_pkgid, callee_pkgid, app_unique_name,\
start->hour,
start->min,
start->sec,
- alarm_info->msec,
+ base_info->msec,
mode->u_interval.day_of_week,
mode->repeat,
- alarm_info->alarm_type,
- (gint64)alarm_info->reserved_info,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
CHECK_NULL_STRING(__alarm_info->dst_service_name),
CHECK_NULL_STRING(__alarm_info->dst_service_name_mod));
bool _update_alarms(__alarm_info_t *__alarm_info)
{
char *error_message = NULL;
- alarm_info_t *alarm_info =
- (alarm_info_t *) &(__alarm_info->alarm_info);
- alarm_date_t *start = &alarm_info->start;
- alarm_mode_t *mode = &alarm_info->mode;
+ base_info_t *base_info =
+ (base_info_t *) &(__alarm_info->base_info);
+ alarm_date_t *start = &base_info->start;
+ alarm_mode_t *mode = &base_info->mode;
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,\
start->hour,
start->min,
start->sec,
- alarm_info->msec,
+ base_info->msec,
mode->u_interval.day_of_week,
mode->repeat,
- alarm_info->alarm_type,
- (gint64)alarm_info->reserved_info,
+ base_info->alarm_type,
+ (gint64)base_info->reserved_info,
CHECK_NULL_STRING(__alarm_info->dst_service_name),
CHECK_NULL_STRING(__alarm_info->dst_service_name_mod),
__alarm_info->alarm_id);
const char *null_str = "null";
sqlite3_stmt *stmt = NULL;
const char *tail = NULL;
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
__alarm_info_t *__alarm_info = NULL;
alarm_date_t *start = NULL;
alarm_mode_t *mode = NULL;
LOGE("Memory allocation failed.");
goto done;
}
- alarm_info = (alarm_info_t *) &(__alarm_info->alarm_info);
- start = &alarm_info->start;
- mode = &alarm_info->mode;
+ base_info = (base_info_t *) &(__alarm_info->base_info);
+ start = &base_info->start;
+ mode = &base_info->mode;
__alarm_info->alarm_id = sqlite3_column_int(stmt, col_idx++);
start_64 = sqlite3_column_int64(stmt, col_idx++);
start->hour = sqlite3_column_int(stmt, col_idx++);
start->min = sqlite3_column_int(stmt, col_idx++);
start->sec = sqlite3_column_int(stmt, col_idx++);
- alarm_info->msec = sqlite3_column_int(stmt, col_idx++);
+ base_info->msec = 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++);
+ base_info->alarm_type = sqlite3_column_int(stmt, col_idx++);
reserved_info_64 = sqlite3_column_int64(stmt, col_idx++);
- alarm_info->reserved_info = (time_t)reserved_info_64;
+ base_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++),
SECURE_LOGD("#%d alarm id[%d] app_name[%s] duetime[%ld]",
index, entry->alarm_id, entry->app_unique_name, entry->start);
- alarm_info_t *alarm_info = (alarm_info_t *) &(entry->alarm_info);
- alarm_mode_t *mode = &alarm_info->mode;
+ base_info_t *base_info = (base_info_t *) &(entry->base_info);
+ alarm_mode_t *mode = &base_info->mode;
char *query = sqlite3_mprintf("insert into alarmmgr_tool( alarm_id, duetime_epoch, duetime, start_epoch,\
end_epoch, global, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, dst_service_name, day_of_week, repeat, alarm_type)\
CHECK_NULL_STRING(entry->dst_service_name),
mode->u_interval.day_of_week,
mode->repeat,
- entry->alarm_info.alarm_type);
+ entry->base_info.alarm_type);
if (sqlite3_exec(alarmmgr_tool_db, query, NULL, NULL, &error_message) != SQLITE_OK) {
SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
entry = (__alarm_info_t *)iter->data;
- alarm_info_t *alarm_info = &(entry->alarm_info);
- if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE)
+ base_info_t *base_info = &(entry->base_info);
+ if (base_info->alarm_type & ALARM_TYPE_RELATIVE)
_update_alarms(entry);
}
if (noti_data)
free(noti_data);
} else if (g_strcmp0(method_name, "alarm_get_info") == 0) {
- alarm_info_t alarm_info = { 0, };
+ base_info_t base_info = { 0, };
- ret = alarm_manager_alarm_get_info(parameters, uid, &alarm_info);
+ ret = alarm_manager_alarm_get_info(parameters, uid, &base_info);
g_dbus_method_invocation_return_value(
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,
- (gint64)alarm_info.reserved_info, ret));
+ base_info.start.year, base_info.start.month,
+ base_info.start.day, base_info.start.hour,
+ base_info.start.min, base_info.start.sec,
+ base_info.end.year, base_info.end.month,
+ base_info.end.day, base_info.mode.u_interval.day_of_week,
+ base_info.mode.repeat, base_info.alarm_type,
+ (gint64)base_info.reserved_info, ret));
} else if (g_strcmp0(method_name, "alarm_get_next_duetime") == 0) {
time_t duetime;
ret = alarm_manager_alarm_get_next_duetime(parameters, uid, &duetime);
struct tm tmp_tm;
int current_dst = 0;
- if ((__alarm_info->alarm_info.alarm_type & ALARM_TYPE_RELATIVE) && __alarm_info->start != 0) {
+ if ((__alarm_info->base_info.alarm_type & ALARM_TYPE_RELATIVE) && __alarm_info->start != 0) {
LOGE("Final due_time = %ld, %s",
__alarm_info->start, ctime(&__alarm_info->start));
return __alarm_info->start;
}
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_date_t *start = &alarm_info->start;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_date_t *start = &base_info->start;
tzset();
time(¤t_time);
time_t current_time = 0;
struct tm duetime_tm;
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_date_t *start = &alarm_info->start;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_date_t *start = &base_info->start;
time(¤t_time);
duetime_tm.tm_mday = start->day;
duetime_tm.tm_isdst = -1;
- if (alarm_info->alarm_type & ALARM_TYPE_PERIOD &&
- alarm_info->mode.u_interval.interval > 0) {
+ if (base_info->alarm_type & ALARM_TYPE_PERIOD &&
+ base_info->mode.u_interval.interval > 0) {
/* For minimize 'while loop'
* Duetime should be "periodic_standard_time + (interval * x) >= current" */
time_t periodic_standard_time = _get_periodic_alarm_standard_time();
time_t temp;
- temp = (current_time - periodic_standard_time) / alarm_info->mode.u_interval.interval;
- due_time = periodic_standard_time + (temp * alarm_info->mode.u_interval.interval);
+ temp = (current_time - periodic_standard_time) / base_info->mode.u_interval.interval;
+ due_time = periodic_standard_time + (temp * base_info->mode.u_interval.interval);
} else {
due_time = mktime(&duetime_tm);
}
while (__alarm_info->start > due_time || current_time > due_time || ((!is_time_changed) && (current_time == due_time))) {
- if (due_time + alarm_info->mode.u_interval.interval < due_time) {
+ if (due_time + base_info->mode.u_interval.interval < due_time) {
LOGD("time_t OVERFLOW!! duetime = %ld", due_time);
due_time = -1;
break;
}
- due_time += alarm_info->mode.u_interval.interval;
+ due_time += base_info->mode.u_interval.interval;
}
localtime_r(&due_time, &duetime_tm);
time_t current_time = 0;
struct tm duetime_tm;
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_date_t *start = &alarm_info->start;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_date_t *start = &base_info->start;
time(¤t_time);
localtime_r(¤t_time, &duetime_tm);
time_t current_time = 0;
struct tm duetime_tm;
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_date_t *start = &alarm_info->start;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_date_t *start = &base_info->start;
time(¤t_time);
localtime_r(¤t_time, &duetime_tm);
struct tm before_tm;
struct tm after_tm;
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_date_t *start = &alarm_info->start;
- alarm_mode_t *mode = &alarm_info->mode;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_date_t *start = &base_info->start;
+ alarm_mode_t *mode = &base_info->mode;
tzset();
time(¤t_time);
struct tm tm, *cur_tm = NULL;
struct tm *due_tm = NULL;
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
- alarm_mode_t *mode = &alarm_info->mode;
+ base_info_t *base_info = &__alarm_info->base_info;
+ alarm_mode_t *mode = &base_info->mode;
time(¤t_time);
cur_tm = localtime_r(¤t_time, &tm);
LOGW("The alarm(%d) is removed [unique_name : %s, dst : %s",
entry->alarm_id, entry->app_unique_name, dst);
- if (!(entry->alarm_info.alarm_type & ALARM_TYPE_VOLATILE))
+ if (!(entry->base_info.alarm_type & ALARM_TYPE_VOLATILE))
_delete_alarms(entry->alarm_id);
_save_alarm_info_log("AUTO_DELETE", entry);
"interval:%ld, duetime: %ld %s",
info->alarm_id, info->uid, info->app_unique_name, info->callee_pkgid,
info->dst_service_name, info->dst_service_name_mod,
- info->alarm_info.alarm_type, info->alarm_info.mode.repeat,
- info->alarm_info.mode.u_interval.interval, info->due_time, due_time_str);
+ info->base_info.alarm_type, info->base_info.mode.repeat,
+ info->base_info.mode.u_interval.interval, info->due_time, due_time_str);
_save_module_log(tag, log_message);
#endif /* _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG */
static void __alarm_add_to_list(__alarm_info_t *__alarm_info);
static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
static __alarm_info_t *__alarm_update_in_list(uid_t uid, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code);
+ base_info_t *base_info, int update_flag, int *error_code);
static bool __alarm_remove_from_list(uid_t uid, alarm_id_t alarm_id,
int *error_code);
-static void __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
+static void __alarm_set_start_and_end_time(base_info_t *base_info,
__alarm_info_t *__alarm_info);
static void __alarm_update_due_time_of_all_items_in_list(time_t new_time,double diff_time);
-static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id, uid_t uid,
+static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
int pid, periodic_method_e method, long requested_interval, int is_ref,
char *app_service_name, char *app_service_name_mod,
const char *dst_service_name, const char *dst_service_name_mod,
int *error_code);
-static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
+static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code);
static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code);
static bool __alarm_update(uid_t uid, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code);
+ base_info_t *base_info, int update_flag, int *error_code);
static void __on_system_time_external_changed(keynode_t *node, void *data);
static void __initialize_alarm_list();
static void __initialize_scheduled_alarm_list();
static void __alarm_add_to_list(__alarm_info_t *__alarm_info)
{
- alarm_info_t *alarm_info = &__alarm_info->alarm_info;
+ base_info_t *base_info = &__alarm_info->base_info;
__alarm_info_t *entry = NULL;
GSList *iter = NULL;
LOGD("[alarm-server]: alarm_id(%d).", entry->alarm_id);
}
- if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
+ if (!(base_info->alarm_type & ALARM_TYPE_VOLATILE)) {
if (!_save_alarms(__alarm_info))
LOGE("Saving alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
}
}
static __alarm_info_t *__alarm_update_in_list(uid_t uid, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code)
+ base_info_t *base_info, int update_flag, int *error_code)
{
bool found = false;
GSList *iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *_alarm_info = NULL;
+ base_info_t *found_base_info = NULL;
time_t current_time;
for (iter = alarm_context.alarms; iter != NULL;
if (entry->uid == uid &&
entry->alarm_id == alarm_id) {
found = true;
- _alarm_info = &entry->alarm_info;
+ found_base_info = &entry->base_info;
if (update_flag == ALARM_UPDATE_FLAG_TIME ||
ALARM_UPDATE_FLAG_WEEK) {
}
if (update_flag == ALARM_UPDATE_FLAG_TIME) {
- __alarm_set_start_and_end_time(alarm_info, entry);
- memcpy(_alarm_info, alarm_info, sizeof(alarm_info_t));
+ __alarm_set_start_and_end_time(base_info, entry);
+ memcpy(found_base_info, base_info, sizeof(base_info_t));
- if (_alarm_info->mode.repeat == ALARM_REPEAT_MODE_ONCE) {
+ if (found_base_info->mode.repeat == ALARM_REPEAT_MODE_ONCE) {
time(¤t_time);
- _alarm_info->reserved_info = current_time;
+ found_base_info->reserved_info = current_time;
}
} else if (update_flag == ALARM_UPDATE_FLAG_PERIOD) {
- _alarm_info->alarm_type |= ALARM_TYPE_INEXACT;
- _alarm_info->alarm_type |= ALARM_TYPE_PERIOD;
- _alarm_info->mode.repeat = ALARM_REPEAT_MODE_REPEAT;
- _alarm_info->mode.u_interval.interval =
- __get_proper_interval(alarm_info->mode.u_interval.interval,
- _alarm_info->alarm_type);
+ found_base_info->alarm_type |= ALARM_TYPE_INEXACT;
+ found_base_info->alarm_type |= ALARM_TYPE_PERIOD;
+ found_base_info->mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+ found_base_info->mode.u_interval.interval =
+ __get_proper_interval(base_info->mode.u_interval.interval,
+ found_base_info->alarm_type);
} else if (update_flag == ALARM_UPDATE_FLAG_WEEK) {
- _alarm_info->alarm_type &= ~ALARM_TYPE_INEXACT;
- _alarm_info->mode = alarm_info->mode;
+ found_base_info->alarm_type &= ~ALARM_TYPE_INEXACT;
+ found_base_info->mode = base_info->mode;
} else if (update_flag == ALARM_UPDATE_FLAG_CLEAR_PERIOD) {
- if (_alarm_info->mode.repeat == ALARM_REPEAT_MODE_REPEAT) {
- _alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
- _alarm_info->mode.u_interval.interval = 0;
+ if (found_base_info->mode.repeat == ALARM_REPEAT_MODE_REPEAT) {
+ found_base_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ found_base_info->mode.u_interval.interval = 0;
}
} else if (update_flag == ALARM_UPDATE_FLAG_CLEAR_WEEK_FLAG) {
- if (_alarm_info->mode.repeat == ALARM_REPEAT_MODE_WEEKLY) {
- _alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
- _alarm_info->mode.u_interval.interval = 0;
+ if (found_base_info->mode.repeat == ALARM_REPEAT_MODE_WEEKLY) {
+ found_base_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ found_base_info->mode.u_interval.interval = 0;
}
}
break;
return NULL;
}
- if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
+ if (!(base_info->alarm_type & ALARM_TYPE_VOLATILE)) {
if (!_update_alarms(entry))
LOGE("Updating alarm_id(%d) in DB is failed.", alarm_id);
}
{
bool found = false;
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
GSList *iter = NULL;
__alarm_info_t *entry = NULL;
for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
entry = (__alarm_info_t *)iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
- alarm_info = &entry->alarm_info;
+ base_info = &entry->base_info;
LOGD("[alarm-server]:Remove alarm id(%d)", entry->alarm_id);
- if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
+ if (!(base_info->alarm_type & ALARM_TYPE_VOLATILE)) {
if (!_delete_alarms(alarm_id))
break;
}
return true;
}
-static void __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
+static void __alarm_set_start_and_end_time(base_info_t *base_info,
__alarm_info_t *__alarm_info)
{
- alarm_date_t *start = &alarm_info->start;
- alarm_date_t *end = &alarm_info->end;
+ alarm_date_t *start = &base_info->start;
+ alarm_date_t *end = &base_info->end;
struct tm alarm_tm = { 0, };
if (start->year != 0) {
- if ((alarm_info->alarm_type & ALARM_TYPE_RELATIVE) && alarm_info->reserved_info != 0) {
- __alarm_info->start = alarm_info->reserved_info;
+ if ((base_info->alarm_type & ALARM_TYPE_RELATIVE) && base_info->reserved_info != 0) {
+ __alarm_info->start = base_info->reserved_info;
} else {
alarm_tm.tm_year = start->year - 1900;
alarm_tm.tm_mon = start->month - 1;
tzset();
for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
entry = (__alarm_info_t *)iter->data;
- alarm_info_t *alarm_info = &(entry->alarm_info);
- if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
+ base_info_t *base_info = &(entry->base_info);
+ if (base_info->alarm_type & ALARM_TYPE_RELATIVE) {
/* case of RTC reset */
- if (entry->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
+ if (entry->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
if ((entry->due_time + diff_time - new_time) >
- (entry->due_time - entry->alarm_info.reserved_info)) {
+ (entry->due_time - entry->base_info.reserved_info)) {
LOGE("[ RTC reset]: new time %s %ld, diff %f, id %d duetime %s %ld %ld",
ctime(&new_time), new_time, diff_time, entry->alarm_id,
ctime(&entry->due_time), entry->due_time,
- entry->alarm_info.reserved_info);
+ entry->base_info.reserved_info);
continue;
}
entry->due_time += diff_time;
- entry->alarm_info.reserved_info = new_time;
+ entry->base_info.reserved_info = new_time;
} else {
entry->due_time += diff_time;
is_rtc_reset = false;
- if ((entry->due_time - new_time) > alarm_info->mode.u_interval.interval) {
+ if ((entry->due_time - new_time) > base_info->mode.u_interval.interval) {
is_rtc_reset = true;
entry->due_time = new_time +
- ((entry->due_time - new_time) % alarm_info->mode.u_interval.interval);
+ ((entry->due_time - new_time) % base_info->mode.u_interval.interval);
LOGE("[ RTC reset]: new time %s %ld, diff %f, id %d duetime %s %ld %ld",
ctime(&new_time), new_time, diff_time, entry->alarm_id,
ctime(&entry->due_time), entry->due_time,
- alarm_info->mode.u_interval.interval);
+ base_info->mode.u_interval.interval);
}
}
- alarm_date_t *start = &alarm_info->start; /**< start time of the alarm */
- alarm_date_t *end = &alarm_info->end; /**< end time of the alarm */
+ alarm_date_t *start = &base_info->start; /**< start time of the alarm */
+ alarm_date_t *end = &base_info->end; /**< end time of the alarm */
p_time = localtime_r(&entry->due_time, &due_time_result);
if (p_time != NULL) {
LOGW("The alarm(%d) is removed [unique_name : %s, dst : %s",
entry->alarm_id, entry->app_unique_name, dst);
- if (!(entry->alarm_info.alarm_type & ALARM_TYPE_VOLATILE))
+ if (!(entry->base_info.alarm_type & ALARM_TYPE_VOLATILE))
_delete_alarms(entry->alarm_id);
_save_alarm_info_log("AUTO_DELETE", entry);
alarm_info->dst_service_name,
alarm_context.c_due_time);
- if (alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
- alarm_info->alarm_info.reserved_info = current_time;
+ if (alarm_info->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
+ alarm_info->base_info.reserved_info = current_time;
if (alarm_context.c_due_time < current_time) {
LOGW("Caution!! alarm_context.c_due_time (%ld) is less than current time(%ld)",
if (alarm_info->due_time == 0) {
LOGW("[alarm-server]:Create a new alarm: due_time is 0. [alarm(%d):repeat_type(%d)]",
- alarm_info->alarm_id, alarm_info->alarm_info.mode.repeat);
+ alarm_info->alarm_id, alarm_info->base_info.mode.repeat);
- if (alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
+ if (alarm_info->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
return false;
__alarm_add_to_list(alarm_info);
return true;
} else if (current_time == alarm_info->due_time) {
LOGW("[alarm-server]:Create alarm: current_time(%ld) is same as due_time(%ld) [alarm(%d):repeat_type(%d)]",
- current_time, alarm_info->due_time, alarm_info->alarm_id, alarm_info->alarm_info.mode.repeat);
+ current_time, alarm_info->due_time, alarm_info->alarm_id, alarm_info->base_info.mode.repeat);
__alarm_add_to_list(alarm_info);
_clear_scheduled_alarm_list();
LOGW("[alarm-server]: Expired Due Time. \
[Due time=%ld, Current Time=%ld]!!!Do not add to schedule list. \
[alarm(%d):repeat_type(%d)]",
- alarm_info->due_time, current_time, alarm_info->alarm_id, alarm_info->alarm_info.mode.repeat);
+ alarm_info->due_time, current_time, alarm_info->alarm_id, alarm_info->base_info.mode.repeat);
- if (alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
+ if (alarm_info->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
return false;
__alarm_add_to_list(alarm_info);
return true;
}
-static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
+static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code)
{
char app_name[MAX_APP_ID_LEN] = { 0 };
b_data = NULL;
}
- __alarm_set_start_and_end_time(alarm_info, __alarm_info);
- memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
+ __alarm_set_start_and_end_time(base_info, __alarm_info);
+ memcpy(&(__alarm_info->base_info), base_info, sizeof(base_info_t));
__alarm_generate_alarm_id(__alarm_info, alarm_id);
if (__alarm_add_and_set(__alarm_info, pid) == false) {
return true;
}
-static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id, uid_t uid,
+static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
int pid, periodic_method_e method, long requested_interval, int is_ref,
char *app_service_name, char *app_service_name_mod,
const char *dst_service_name, const char *dst_service_name_mod,
if (dst_service_name_mod)
__alarm_info->dst_service_name_mod = strdup(dst_service_name_mod);
- __alarm_set_start_and_end_time(alarm_info, __alarm_info);
- memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
+ __alarm_set_start_and_end_time(base_info, __alarm_info);
+ memcpy(&(__alarm_info->base_info), base_info, sizeof(base_info_t));
__alarm_generate_alarm_id(__alarm_info, alarm_id);
if (__alarm_add_and_set(__alarm_info, pid) == false) {
return new_noti_data;
}
-static bool __alarm_create_noti(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
+static bool __alarm_create_noti(base_info_t *base_info, alarm_id_t *alarm_id,
long requested_interval, uid_t uid, int pid, char *noti_data, int *error_code)
{
char app_name[MAX_APP_ID_LEN] = { 0 };
__alarm_info->noti = strdup(noti_data);
}
- __alarm_set_start_and_end_time(alarm_info, __alarm_info);
- memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
+ __alarm_set_start_and_end_time(base_info, __alarm_info);
+ memcpy(&(__alarm_info->base_info), base_info, sizeof(base_info_t));
__alarm_generate_alarm_id(__alarm_info, alarm_id);
if (__alarm_add_and_set(__alarm_info, pid) == false) {
}
static bool __alarm_update(uid_t uid, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code)
+ base_info_t *base_info, int update_flag, int *error_code)
{
time_t current_time;
char due_time_r[100] = { 0 };
alarm_context.c_due_time = -1;
}
- __alarm_info = __alarm_update_in_list(uid, alarm_id, alarm_info,
+ __alarm_info = __alarm_update_in_list(uid, alarm_id, base_info,
update_flag, error_code);
if (!__alarm_info) {
LOGE("[alarm-server]: requested alarm_id "
return false;
}
- if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
- __alarm_info->alarm_info.reserved_info = current_time;
+ if (__alarm_info->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE)
+ __alarm_info->base_info.reserved_info = current_time;
_alarm_set_next_duetime(__alarm_info);
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *alarm = NULL;
+ base_info_t *base_info = NULL;
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t *)gs_iter->data;
if (entry->alarm_id == alarm_id) {
- alarm = &(entry->alarm_info);
+ base_info = &(entry->base_info);
time_t ts = 0;
struct tm ts_tm;
int dur = entry->requested_interval;
int from, to;
- if (dur == 0 || !(alarm->alarm_type & ALARM_TYPE_PERIOD) || entry->method == CUT_OFF)
+ if (dur == 0 || !(base_info->alarm_type & ALARM_TYPE_PERIOD) || entry->method == CUT_OFF)
return false;
- ts_tm.tm_hour = alarm->start.hour;
- ts_tm.tm_min = alarm->start.min;
- ts_tm.tm_sec = alarm->start.sec;
+ ts_tm.tm_hour = base_info->start.hour;
+ ts_tm.tm_min = base_info->start.min;
+ ts_tm.tm_sec = base_info->start.sec;
- ts_tm.tm_year = alarm->start.year - 1900;
- ts_tm.tm_mon = alarm->start.month - 1;
- ts_tm.tm_mday = alarm->start.day;
+ ts_tm.tm_year = base_info->start.year - 1900;
+ ts_tm.tm_mon = base_info->start.month - 1;
+ ts_tm.tm_mday = base_info->start.day;
ts_tm.tm_isdst = -1;
ts = mktime(&ts_tm);
from = (ts / dur) * dur;
to = from + dur;
- if (ts >= from && ts < to && from > ts - alarm->mode.u_interval.interval)
+ if (ts >= from && ts < to && from > ts - base_info->mode.u_interval.interval)
return false;
return true;
} else {
/* since 2.4 */
appid = (char *)appsvc_get_appid(b);
- if ((alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid)) {
+ if ((alarm_info->base_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid)) {
LOGE("This alarm is ignored\n");
- } else if (!(alarm_info->alarm_info.alarm_type & ALARM_TYPE_INEXACT) ||
+ } else if (!(alarm_info->base_info.alarm_type & ALARM_TYPE_INEXACT) ||
!_can_skip_expired_cb(alarm_info->alarm_id)) {
if (alarm_info->global) {
if (__find_login_user(&target_uid) < 0) {
LOGD("before alarm_send_noti_to_application");
_alarm_send_noti_to_application_by_dbus(destination_app_service_name,
- alarm_info->alarm_id, alarm_info->alarm_info.msec, alarm_info->uid); /* dbus auto activation */
+ alarm_info->alarm_id, alarm_info->base_info.msec, alarm_info->uid); /* dbus auto activation */
LOGD("after _alarm_send_noti_to_application_by_dbus");
} else {
/* Case #3-2. The process was killed && App type
__expired_alarm_t *expire_info;
char alarm_id_str[32] = { 0, };
- if (alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
+ if (alarm_info->base_info.alarm_type & ALARM_TYPE_WITHCB) {
__alarm_remove_from_list(alarm_info->uid, alarm_info->alarm_id, NULL);
LOGW("[alarm-server]:This alarm_type is WITHCB");
return -2;
} else {
/* Case #3-3. The process was killed && non-app type(daemon)
* Expiration noti is sent by DBus. it makes the process alive. (dbus auto activation) */
- if (alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
+ if (alarm_info->base_info.alarm_type & ALARM_TYPE_WITHCB) {
char *cmdline = _get_cmdline_from_pid(alarm_info->pid);
if (!cmdline || strcmp(cmdline, alarm_info->app_unique_name) != 0) {
__alarm_remove_from_list(alarm_info->uid, alarm_info->alarm_id, NULL);
LOGD("before alarm_send_noti_to_application for daemon");
_alarm_send_noti_to_application_by_dbus(destination_app_service_name,
- alarm_info->alarm_id, alarm_info->alarm_info.msec, alarm_info->uid); /* dbus auto activation */
+ alarm_info->alarm_id, alarm_info->base_info.msec, alarm_info->uid); /* dbus auto activation */
LOGD("after _alarm_send_noti_to_application_by_dbus for daemon");
}
if (using_rtc)
DO_AFTER_ALARM_EXPIRE(__alarm_info->pid, __alarm_info->app_unique_name);
- if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
+ if (__alarm_info->base_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
__alarm_remove_from_list(__alarm_info->uid, __alarm_info->alarm_id, NULL);
} else {
_alarm_set_next_duetime(__alarm_info);
alarm_context.alarms = g_slist_append(alarm_context.alarms, entry);
g_disabled_alarm_list = g_slist_remove(g_disabled_alarm_list, entry);
- if (!(entry->alarm_info.alarm_type & ALARM_TYPE_VOLATILE))
+ if (!(entry->base_info.alarm_type & ALARM_TYPE_VOLATILE))
_update_db_for_disabled_alarm(entry->alarm_id, false);
is_restored = true;
}
gs_iter = g_slist_next(gs_iter);
if (strncmp(appid, entry->app_unique_name, strlen(appid)) == 0) {
- if (!(entry->alarm_info.alarm_type & ALARM_TYPE_VOLATILE))
+ if (!(entry->base_info.alarm_type & ALARM_TYPE_VOLATILE))
_update_db_for_disabled_alarm(entry->alarm_id, true);
g_disabled_alarm_list = g_slist_append(g_disabled_alarm_list, entry);
alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
alarm_context.alarms = g_slist_append(alarm_context.alarms, entry);
g_disabled_alarm_list = g_slist_remove(g_disabled_alarm_list, entry);
- if (!(entry->alarm_info.alarm_type & ALARM_TYPE_VOLATILE))
+ if (!(entry->base_info.alarm_type & ALARM_TYPE_VOLATILE))
_update_db_for_disabled_alarm(entry->alarm_id, false);
is_restored = true;
}
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
bool is_deleted = false;
int is_power_saving_mode = 0;
if (_remove_from_scheduled_alarm_list(entry->uid, entry->alarm_id))
is_deleted = true;
- alarm_info = &entry->alarm_info;
- if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
+ base_info = &entry->base_info;
+ if (!(base_info->alarm_type & ALARM_TYPE_VOLATILE)) {
if (is_power_saving_mode == 1)
_update_db_for_disabled_alarm(entry->alarm_id, true);
else
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t *)gs_iter->data;
- if (entry->alarm_info.alarm_type & ALARM_TYPE_PERIOD) {
- if (entry->alarm_info.mode.u_interval.interval <= interval &&
- entry->alarm_info.mode.u_interval.interval > maxInterval)
- maxInterval = entry->alarm_info.mode.u_interval.interval;
+ if (entry->base_info.alarm_type & ALARM_TYPE_PERIOD) {
+ if (entry->base_info.mode.u_interval.interval <= interval &&
+ entry->base_info.mode.u_interval.interval > maxInterval)
+ maxInterval = entry->base_info.mode.u_interval.interval;
}
}
int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
{
- alarm_info_t alarm_info;
+ base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
int _alarm_id = 0;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
bundle_free(b);
}
- alarm_info.start.year = start_year;
- alarm_info.start.month = start_month;
- alarm_info.start.day = start_day;
- alarm_info.start.hour = start_hour;
- alarm_info.start.min = start_min;
- alarm_info.start.sec = start_sec;
+ base_info.start.year = start_year;
+ base_info.start.month = start_month;
+ base_info.start.day = start_day;
+ base_info.start.hour = start_hour;
+ base_info.start.min = start_min;
+ base_info.start.sec = start_sec;
- alarm_info.end.year = end_year;
- alarm_info.end.month = end_month;
- alarm_info.end.day = end_day;
+ base_info.end.year = end_year;
+ base_info.end.month = end_month;
+ base_info.end.day = end_day;
- alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
- alarm_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
+ base_info.mode.u_interval.day_of_week = mode_day_of_week;
+ base_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
- alarm_info.alarm_type = alarm_type;
- alarm_info.reserved_info = reserved_info;
+ base_info.alarm_type = alarm_type;
+ base_info.reserved_info = reserved_info;
- if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT)) {
- alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
- alarm_info.mode.u_interval.interval =
- __get_proper_interval(mode_interval, alarm_info.alarm_type);
+ if ((base_info.alarm_type & ALARM_TYPE_INEXACT)) {
+ base_info.alarm_type |= ALARM_TYPE_PERIOD;
+ base_info.mode.u_interval.interval =
+ __get_proper_interval(mode_interval, base_info.alarm_type);
} else if (mode_interval <= 0) {
- alarm_info.mode.u_interval.interval = 0;
+ base_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_appsvc(&alarm_info, &_alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
+ if (!__alarm_create_appsvc(&base_info, &_alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE SVC", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message),
int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
int *alarm_id)
{
- alarm_info_t alarm_info;
+ base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
int _alarm_id = 0;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
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;
- alarm_info.start.day = start_day;
- alarm_info.start.hour = start_hour;
- alarm_info.start.min = start_min;
- alarm_info.start.sec = start_sec;
+ base_info.start.year = start_year;
+ base_info.start.month = start_month;
+ base_info.start.day = start_day;
+ base_info.start.hour = start_hour;
+ base_info.start.min = start_min;
+ base_info.start.sec = start_sec;
- alarm_info.end.year = end_year;
- alarm_info.end.month = end_month;
- alarm_info.end.day = end_day;
+ base_info.end.year = end_year;
+ base_info.end.month = end_month;
+ base_info.end.day = end_day;
- alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
- alarm_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
+ base_info.mode.u_interval.day_of_week = mode_day_of_week;
+ base_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
- alarm_info.alarm_type = alarm_type;
- alarm_info.reserved_info = reserved_info;
+ base_info.alarm_type = alarm_type;
+ base_info.reserved_info = reserved_info;
- if ((alarm_info.alarm_type & ALARM_TYPE_INEXACT)) {
- alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
- alarm_info.mode.u_interval.interval =
- __get_proper_interval(mode_interval, alarm_info.alarm_type);
+ if ((base_info.alarm_type & ALARM_TYPE_INEXACT)) {
+ base_info.alarm_type |= ALARM_TYPE_PERIOD;
+ base_info.mode.u_interval.interval =
+ __get_proper_interval(mode_interval, base_info.alarm_type);
} else if (mode_interval <= 0) {
- alarm_info.mode.u_interval.interval = 0;
+ base_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_noti(&alarm_info, &_alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
+ if (!__alarm_create_noti(&base_info, &_alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE NOTI", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
{
- alarm_info_t alarm_info;
+ base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
int _alarm_id = 0;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
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;
- alarm_info.start.hour = start_hour;
- alarm_info.start.min = start_min;
- alarm_info.start.sec = start_sec;
+ base_info.start.year = start_year;
+ base_info.start.month = start_month;
+ base_info.start.day = start_day;
+ base_info.start.hour = start_hour;
+ base_info.start.min = start_min;
+ base_info.start.sec = start_sec;
- alarm_info.msec = msec;
+ base_info.msec = msec;
- alarm_info.end.year = end_year;
- alarm_info.end.month = end_month;
- alarm_info.end.day = end_day;
+ base_info.end.year = end_year;
+ base_info.end.month = end_month;
+ base_info.end.day = end_day;
- alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
- alarm_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
+ base_info.mode.u_interval.day_of_week = mode_day_of_week;
+ base_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
- alarm_info.alarm_type = alarm_type;
- alarm_info.reserved_info = reserved_info;
+ base_info.alarm_type = alarm_type;
+ base_info.reserved_info = reserved_info;
if (strcmp(reserved_service_name, "null") == 0)
_reserved_service_name = NULL;
if (strcmp(reserved_service_name_mod, "null") == 0)
_reserved_service_name_mod = NULL;
- if (!__alarm_create(&alarm_info, &_alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
+ if (!__alarm_create(&base_info, &_alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
_reserved_service_name, _reserved_service_name_mod, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
pid_t pid, int *alarm_id)
{
- alarm_info_t alarm_info;
+ base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
int _alarm_id = 0;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
time_t standard_time = _get_periodic_alarm_standard_time();
localtime_r(&standard_time, &standard_tm);
- alarm_info.reserved_info = standard_time;
+ base_info.reserved_info = standard_time;
- alarm_info.start.year = standard_tm.tm_year + 1900;
- alarm_info.start.month = standard_tm.tm_mon + 1;
- alarm_info.start.day = standard_tm.tm_mday;
- alarm_info.start.hour = standard_tm.tm_hour;
- alarm_info.start.min = standard_tm.tm_min;
- alarm_info.start.sec = standard_tm.tm_sec;
+ base_info.start.year = standard_tm.tm_year + 1900;
+ base_info.start.month = standard_tm.tm_mon + 1;
+ base_info.start.day = standard_tm.tm_mday;
+ base_info.start.hour = standard_tm.tm_hour;
+ base_info.start.min = standard_tm.tm_min;
+ base_info.start.sec = standard_tm.tm_sec;
- alarm_info.msec = 0;
+ base_info.msec = 0;
- alarm_info.end.year = 0;
- alarm_info.end.month = 0;
- alarm_info.end.day = 0;
+ base_info.end.year = 0;
+ base_info.end.month = 0;
+ base_info.end.day = 0;
- alarm_info.alarm_type = ALARM_TYPE_VOLATILE;
- alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
- alarm_info.alarm_type |= ALARM_TYPE_WITHCB;
- alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
+ base_info.alarm_type = ALARM_TYPE_VOLATILE;
+ base_info.alarm_type |= ALARM_TYPE_RELATIVE;
+ base_info.alarm_type |= ALARM_TYPE_WITHCB;
+ base_info.alarm_type |= ALARM_TYPE_PERIOD;
if (interval <= 0) {
- alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
- alarm_info.mode.u_interval.interval = 0;
+ base_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
+ base_info.mode.u_interval.interval = 0;
} else {
- alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+ base_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
if (is_ref)
- alarm_info.mode.u_interval.interval = interval * 60;
+ base_info.mode.u_interval.interval = interval * 60;
else
- alarm_info.mode.u_interval.interval = __get_proper_interval(interval * 60, alarm_info.alarm_type);
+ base_info.mode.u_interval.interval = __get_proper_interval(interval * 60, base_info.alarm_type);
}
- if (!__alarm_create(&alarm_info, &_alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
+ if (!__alarm_create(&base_info, &_alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
app_service_name, app_service_name_mod,
NULL, NULL, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREAT PERIOD", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
- _alarm_id, uid, pid, 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_id, uid, pid, base_info.start.year, base_info.start.month,
+ base_info.start.day, base_info.start.hour,
+ base_info.start.min, base_info.start.sec);
_save_module_log(log_tag, log_message);
return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
{
GSList *gs_iter = NULL;
char app_name[MAX_APP_ID_LEN] = { 0 };
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
__alarm_info_t *entry = NULL;
bool is_deleted = false;
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
if (_remove_from_scheduled_alarm_list(uid, entry->alarm_id))
is_deleted = true;
- alarm_info = &entry->alarm_info;
- if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
+ base_info = &entry->base_info;
+ if (!(base_info->alarm_type & ALARM_TYPE_VOLATILE)) {
if (!_delete_alarms(entry->alarm_id))
SECURE_LOGE("_delete_alarms() is failed. pid[%d], alarm_id[%d]", pid, entry->alarm_id);
}
int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
{
int return_code = ALARMMGR_RESULT_SUCCESS;
- alarm_info_t alarm_info;
+ base_info_t base_info;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
int alarm_id;
if (return_code != ALARMMGR_RESULT_SUCCESS)
return return_code;
- alarm_info.start.year = start_year;
- alarm_info.start.month = start_month;
- alarm_info.start.day = start_day;
- alarm_info.start.hour = start_hour;
- alarm_info.start.min = start_min;
- alarm_info.start.sec = start_sec;
+ base_info.start.year = start_year;
+ base_info.start.month = start_month;
+ base_info.start.day = start_day;
+ base_info.start.hour = start_hour;
+ base_info.start.min = start_min;
+ base_info.start.sec = start_sec;
- alarm_info.end.year = end_year;
- alarm_info.end.month = end_month;
- alarm_info.end.day = end_day;
+ base_info.end.year = end_year;
+ base_info.end.month = end_month;
+ base_info.end.day = end_day;
- alarm_info.mode.u_interval.interval = mode_interval;
- alarm_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
+ base_info.mode.u_interval.interval = mode_interval;
+ base_info.mode.repeat = (alarm_repeat_mode_t)mode_repeat;
- alarm_info.alarm_type = alarm_type;
- alarm_info.reserved_info = reserved_info;
+ base_info.alarm_type = alarm_type;
+ base_info.reserved_info = reserved_info;
- if (!__alarm_update(uid, alarm_id, &alarm_info,
+ if (!__alarm_update(uid, alarm_id, &base_info,
update_flag, &return_code)) {
LOGE("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
strncpy(log_tag, "FAIL: UPDATE", sizeof(log_tag) - 1);
return return_code;
}
-int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, alarm_info_t *alarm_info)
+int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, base_info_t *base_info)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *_alarm_info = NULL;
+ base_info_t *found_base_info = NULL;
int alarm_id;
g_variant_get(parameters, "(i)", &alarm_id);
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
- _alarm_info = &(entry->alarm_info);
+ found_base_info = &(entry->base_info);
break;
}
}
- if (_alarm_info == NULL) {
+ if (found_base_info == NULL) {
LOGE("The alarm(%d) is not found.", alarm_id);
return ERR_ALARM_INVALID_ID;
} else {
LOGD("The alarm(%d) is found.", alarm_id);
- alarm_info->start.year = _alarm_info->start.year;
- alarm_info->start.month = _alarm_info->start.month;
- alarm_info->start.day = _alarm_info->start.day;
- alarm_info->start.hour = _alarm_info->start.hour;
- alarm_info->start.min = _alarm_info->start.min;
- alarm_info->start.sec = _alarm_info->start.sec;
- alarm_info->end.year = _alarm_info->end.year;
- alarm_info->end.month = _alarm_info->end.month;
- alarm_info->end.day = _alarm_info->end.day;
- alarm_info->mode.u_interval.day_of_week =
- _alarm_info->mode.u_interval.day_of_week;
- alarm_info->mode.repeat = _alarm_info->mode.repeat;
- alarm_info->alarm_type = _alarm_info->alarm_type;
- alarm_info->reserved_info = _alarm_info->reserved_info;
+ base_info->start.year = found_base_info->start.year;
+ base_info->start.month = found_base_info->start.month;
+ base_info->start.day = found_base_info->start.day;
+ base_info->start.hour = found_base_info->start.hour;
+ base_info->start.min = found_base_info->start.min;
+ base_info->start.sec = found_base_info->start.sec;
+ base_info->end.year = found_base_info->end.year;
+ base_info->end.month = found_base_info->end.month;
+ base_info->end.day = found_base_info->end.day;
+ base_info->mode.u_interval.day_of_week =
+ found_base_info->mode.u_interval.day_of_week;
+ base_info->mode.repeat = found_base_info->mode.repeat;
+ base_info->alarm_type = found_base_info->alarm_type;
+ base_info->reserved_info = found_base_info->reserved_info;
}
return ALARMMGR_RESULT_SUCCESS;
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *alarm_info = NULL;
+ base_info_t *base_info = NULL;
int retval = 0;
int return_code = ALARMMGR_RESULT_SUCCESS;
char *callee_pkgid;
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
- alarm_info = &(entry->alarm_info);
+ base_info = &(entry->base_info);
break;
}
}
- if (alarm_info == NULL) {
+ if (base_info == NULL) {
LOGE("The alarm(%d) is not found.", alarm_id);
return ERR_ALARM_INVALID_ID;
} else {
TEST_F(AlarmServerTest, alarm_manager_alarm_get_info_n)
{
int ret;
- alarm_info_t info;
+ base_info_t info;
GVariant *param = NULL;
param = g_variant_new("(i)", 10);
projects / platform / core / appfw / alarm-manager.git / commitdiff