4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Venkatesha Sarpangala <sarpangala.v@samsung.com>, Jayoun Lee <airjany@samsung.com>,
7 * Sewook Park <sewook7.park@samsung.com>, Jaeho Lee <jaeho81.lee@samsung.com>
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
25 #define _BSD_SOURCE /*for localtime_r*/
31 #include <sys/types.h>
34 #include <sys/timerfd.h>
39 #if !GLIB_CHECK_VERSION (2, 31, 0)
40 #include <glib/gmacros.h>
45 #include "alarm-internal.h"
46 #include "alarm-mgr-stub.h"
50 #include <security-server.h>
53 #include <vconf-keys.h>
55 #include <pkgmgr-info.h>
56 #include <device/display.h>
58 #define SIG_TIMER 0x32
59 #define WAKEUP_ALARM_APP_ID "org.tizen.alarm.ALARM"
60 /* alarm ui application's alarm's dbus_service name instead of 21
61 (alarm application's app_id) value */
63 __alarm_server_context_t alarm_context;
64 bool g_dummy_timer_is_set = FALSE;
66 GSList *g_scheduled_alarm_list = NULL;
67 GSList *g_expired_alarm_list = NULL;
69 #ifndef RTC_WKALM_BOOT_SET
70 #define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
73 /* 2008. 6. 3 sewook7.park
74 When the alarm becoms sleeping mode, alarm timer is not expired.
75 So using RTC, phone is awaken before alarm rings.
77 #define __WAKEUP_USING_RTC__
78 #ifdef __WAKEUP_USING_RTC__
80 #include <linux/rtc.h>
81 #include <sys/ioctl.h>
84 #define ALARM_RTC_WAKEUP 0
86 #define ALARM_IOW(c, type, size) _IOW('a', (c) | ((type) << 4), size)
87 #define ALARM_SET(type) ALARM_IOW(2, type, struct timespec)
88 #define ALARM_SET_RTC _IOW('a', 5, struct timespec)
89 #define ALARM_CLEAR(type) _IO('a', 0 | ((type) << 4))
92 #define ALARMMGR_LOG_BUFFER_SIZE 10000
93 #define ALARMMGR_LOG_BUFFER_STRING_SIZE 200
94 #define ALARMMGR_LOG_TAG_SIZE 20
95 #define ALARMMGR_LOG_MESSAGE_SIZE 120
96 #define ALARMMGR_LOG_FILE_PATH "/var/log/alarmmgr.log"
97 static int log_index = 0;
98 static int log_fd = 0;
100 // display lock and unlock
101 #define DEVICED_BUS_NAME "org.tizen.system.deviced"
102 #define DEVICED_PATH_DISPLAY "/Org/Tizen/System/DeviceD/Display"
103 #define DEVICED_INTERFACE_DISPLAY "org.tizen.system.deviced.display"
104 #define DEVICED_LOCK_STATE "lockstate"
105 #define DEVICED_UNLOCK_STATE "unlockstate"
106 #define DEVICED_DBUS_REPLY_TIMEOUT (120*1000)
107 #define DEVICED_LCD_OFF "lcdoff"
108 #define DEVICED_STAY_CUR_STATE "staycurstate"
109 #define DEVICED_SLEEP_MARGIN "sleepmargin"
111 // link path for timezone info
112 #define TIMEZONE_INFO_LINK_PATH "/opt/etc/localtime"
114 static const char default_rtc[] = "/dev/alarm";
118 #endif /*__WAKEUP_USING_RTC__*/
120 /* GDBus Declaration */
121 #define ALARM_MGR_DBUS_PATH "/org/tizen/alarm/manager"
122 #define ALARM_MGR_DBUS_NAME "org.tizen.alarm.manager"
123 GDBusObjectManagerServer *alarmmgr_server = NULL;
124 static AlarmManager* interface = NULL;
126 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info);
127 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
128 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
129 __alarm_info_t *__alarm_info,
131 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
133 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
134 __alarm_info_t *__alarm_info);
135 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time);
136 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
137 int pid, periodic_method_e method, long requested_interval, int is_ref,
138 char *app_service_name, char *app_service_name_mod,
139 const char *dst_service_name, const char *dst_service_name_mod,
141 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
142 int pid, char *bundle_data, int *error_code);
144 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code);
145 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
146 alarm_info_t *alarm_info, int *error_code);
147 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id);
148 static void __alarm_expired();
149 static gboolean __alarm_handler_idle(gpointer user_data);
150 static void __clean_registry();
151 static bool __alarm_manager_reset();
152 static void __on_system_time_external_changed(keynode_t *node, void *data);
153 static void __initialize_timer();
154 static void __initialize_alarm_list();
155 static void __initialize_scheduled_alarm_list();
156 static bool __initialize_noti();
158 static bool __initialize_dbus();
159 static bool __initialize_db();
160 static void __initialize();
161 void on_bus_name_owner_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
162 const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data);
163 bool __get_caller_unique_name(int pid, char *unique_name);
165 static void __initialize_module_log(void);
166 static bool __save_module_log(const char *tag, const char *messgae);
168 int __display_lock_state(char *state, char *flag, unsigned int timeout);
169 int __display_unlock_state(char *state, char *flag);
171 static void __rtc_set()
173 #ifdef __WAKEUP_USING_RTC__
174 const char *rtc = default_rtc;
175 struct rtc_wkalrm rtc_wk;
177 struct timespec alarm_time;
178 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
179 #ifdef _SIMUL /*if build is simulator, we don't need to set
180 RTC because RTC does not work in simulator.*/
181 ALARM_MGR_EXCEPTION_PRINT("because it is simulator's mode, we don't set RTC.");
186 gfd = open(rtc, O_RDWR);
188 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
193 /* Read the RTC time/date */
195 char *timebuf = ctime(&alarm_context.c_due_time);
196 if (timebuf == NULL) {
197 ALARM_MGR_EXCEPTION_PRINT("timebuf is NULL.");
201 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid new line
202 sprintf(log_message, "wakeup time: %d, %s", alarm_context.c_due_time, timebuf);
204 ALARM_MGR_LOG_PRINT("alarm_context.c_due_time is %d.", alarm_context.c_due_time);
206 if (alarm_context.c_due_time != -1) {
207 retval = ioctl(gfd, ALARM_CLEAR(ALARM_RTC_WAKEUP));
209 if (errno == ENOTTY) {
210 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
212 ALARM_MGR_EXCEPTION_PRINT("ALARM_CLEAR ioctl is failed. errno = %s", strerror(errno));
215 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]ALARM_CLEAR ioctl is successfully done.");
217 time_t due_time = alarm_context.c_due_time;
218 gmtime_r(&due_time, &due_tm);
220 ALARM_MGR_EXCEPTION_PRINT("Setted RTC Alarm date/time is %d-%d-%d, %02d:%02d:%02d (UTC).",
221 due_tm.tm_mday, due_tm.tm_mon + 1, due_tm.tm_year + 1900,
222 due_tm.tm_hour, due_tm.tm_min, due_tm.tm_sec);
224 alarm_time.tv_sec = due_time - 1;
225 alarm_time.tv_nsec = 500000000; // Wakeup is 500ms faster than expiring time to correct RTC error.
226 retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
228 if (errno == ENOTTY) {
229 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
231 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
232 __save_module_log("FAIL: SET RTC", log_message);
235 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]RTC ALARM_SET ioctl is successfully done.");
236 __save_module_log("SET RTC", log_message);
239 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]alarm_context.c_due_time is"
240 "less than 10 sec. RTC alarm does not need to be set");
242 #endif /* __WAKEUP_USING_RTC__ */
246 int _set_rtc_time(time_t _time)
249 const char *rtc0 = default_rtc;
250 struct timespec rtc_time;
251 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
252 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
255 gfd = open(rtc0, O_RDWR);
258 ALARM_MGR_LOG_PRINT("error to open /dev/alarm.");
263 rtc_time.tv_sec = _time;
264 rtc_time.tv_nsec = 0;
266 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
267 char *timebuf = ctime(&_time);
269 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid new line
270 sprintf(log_message, "rtc time = %d, %s", _time, timebuf);
273 ret = ioctl(gfd, ALARM_SET_RTC, &rtc_time);
275 ALARM_MGR_LOG_PRINT("ALARM_SET_RTC ioctl is failed. errno = %s", strerror(errno));
276 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
281 __save_module_log(log_tag, log_message);
286 bool __alarm_clean_list()
288 g_slist_free_full(alarm_context.alarms, g_free);
292 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id)
294 bool unique_id = false;
295 __alarm_info_t *entry = NULL;
298 srand((unsigned int)time(NULL));
299 __alarm_info->alarm_id = (rand() % INT_MAX) + 1;
300 ALARM_MGR_LOG_PRINT("__alarm_info->alarm_id is %d", __alarm_info->alarm_id);
302 while (unique_id == false) {
305 for (iter = alarm_context.alarms; iter != NULL;
306 iter = g_slist_next(iter)) {
308 if (entry->alarm_id == __alarm_info->alarm_id) {
309 __alarm_info->alarm_id++;
315 *alarm_id = __alarm_info->alarm_id;
320 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info)
322 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
323 __alarm_info_t *entry = NULL;
326 ALARM_MGR_LOG_PRINT("[alarm-server]: Before add alarm_id(%d)", __alarm_info->alarm_id);
328 alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
329 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: After add alarm_id(%d)", __alarm_info->alarm_id);
332 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
334 ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d).", entry->alarm_id);
337 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
338 if (!_save_alarms(__alarm_info)) {
339 ALARM_MGR_EXCEPTION_PRINT("Saving alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
346 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
347 __alarm_info_t *__alarm_info,
351 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
353 __alarm_info_t *entry = NULL;
355 for (iter = alarm_context.alarms; iter != NULL;
356 iter = g_slist_next(iter)) {
358 if (entry->alarm_id == alarm_id) {
361 __alarm_info->quark_app_unique_name =
362 entry->quark_app_unique_name;
363 __alarm_info->quark_dst_service_name =
364 entry->quark_dst_service_name;
365 memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
373 *error_code = ERR_ALARM_INVALID_ID;
377 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
378 if (!_update_alarms(__alarm_info)) {
379 ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
386 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
391 alarm_info_t *alarm_info = NULL;
394 __alarm_info_t *entry = NULL;
397 ALARM_MGR_LOG_PRINT("[alarm-server]: before del : alarm id(%d)", alarm_id);
399 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
401 if (entry->alarm_id == alarm_id) {
402 alarm_info = &entry->alarm_info;
404 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Remove alarm id(%d)", entry->alarm_id);
406 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
407 _delete_alarms(alarm_id);
410 alarm_context.alarms = g_slist_remove(alarm_context.alarms, iter->data);
418 ALARM_MGR_LOG_PRINT("[alarm-server]: after del\n");
422 *error_code = ERR_ALARM_INVALID_ID;
429 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
430 __alarm_info_t *__alarm_info)
432 alarm_date_t *start = &alarm_info->start;
433 alarm_date_t *end = &alarm_info->end;
435 struct tm alarm_tm = { 0, };
437 if (start->year != 0) {
438 alarm_tm.tm_year = start->year - 1900;
439 alarm_tm.tm_mon = start->month - 1;
440 alarm_tm.tm_mday = start->day;
442 alarm_tm.tm_hour = start->hour;
443 alarm_tm.tm_min = start->min;
444 alarm_tm.tm_sec = start->sec;
445 alarm_tm.tm_isdst = -1;
447 __alarm_info->start = mktime(&alarm_tm);
449 __alarm_info->start = 0;
452 if (end->year != 0) {
453 alarm_tm.tm_year = end->year - 1900;
454 alarm_tm.tm_mon = end->month - 1;
455 alarm_tm.tm_mday = end->day;
457 alarm_tm.tm_hour = end->hour;
458 alarm_tm.tm_min = end->min;
459 alarm_tm.tm_sec = end->sec;
461 __alarm_info->end = mktime(&alarm_tm);
463 __alarm_info->end = 0;
470 static bool alarm_get_tz_info(int *gmt_idx, int *dst)
472 GConfValue *value1 = NULL;
473 GConfValue *value2 = NULL;
474 GConfClient* gConfClient = NULL;
477 gConfClient = gconf_client_get_default();
480 value1 = gconf_client_get(gConfClient, SETTINGS_CLOCKTIMEZONE,
483 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
484 gconf_client_get() failed:
485 error:[%s]\n", err->message);
489 *gmt_idx = gconf_value_get_int(value1);
490 ALARM_MGR_LOG_PRINT("gconf return gmt_idx =%d\n ", *gmt_idx);
492 value2 = gconf_client_get(gConfClient,
493 SETTINGS_DAYLIGHTSTATUS, &err);
495 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
496 gconf_client_get() failed: error:[%s]\n", err->message);
501 *dst = gconf_value_get_int(value2);
502 ALARM_MGR_LOG_PRINT("gconf return dst =%d\n ", *dst);
504 if(gConfClient != NULL) {
505 g_object_unref(gConfClient);
510 ALARM_MGR_LOG_PRINT("check the gconf setting failed!!!!! \n ");
513 gconf_value_free(value1);
517 gconf_value_free(value2);
525 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time)
528 time_t min_time = -1;
531 __alarm_info_t *entry = NULL;
532 struct tm *p_time = NULL ;
533 struct tm due_time_result ;
534 struct tm fixed_time = { 0, };
536 for (iter = alarm_context.alarms; iter != NULL;
537 iter = g_slist_next(iter)) {
539 alarm_info_t *alarm_info = &(entry->alarm_info);
540 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
541 /*diff_time ó\B8\AE */
543 entry->due_time += diff_time;
545 alarm_date_t *start = &alarm_info->start; /**< start
547 alarm_date_t *end = &alarm_info->end;;
548 /**< end time of the alarm */
551 p_time = localtime_r(&entry->due_time, &due_time_result);
552 if (p_time != NULL) {
553 start->year = p_time->tm_year + 1900;
554 start->month = p_time->tm_mon + 1;
555 start->day = p_time->tm_mday;
556 start->hour = p_time->tm_hour;
557 start->min = p_time->tm_min;
558 start->sec = p_time->tm_sec;
560 end->year = p_time->tm_year + 1900;
561 end->month = p_time->tm_mon + 1;
562 end->day = p_time->tm_mday;
565 memset(&fixed_time, 0, sizeof(fixed_time));
566 fixed_time.tm_year = p_time->tm_year;
567 fixed_time.tm_mon = p_time->tm_mon;
568 fixed_time.tm_mday = p_time->tm_mday;
569 fixed_time.tm_hour = 0;
570 fixed_time.tm_min = 0;
571 fixed_time.tm_sec = 0;
573 entry->start = mktime(&fixed_time);
575 fixed_time.tm_hour = 23;
576 fixed_time.tm_min = 59;
577 fixed_time.tm_sec = 59;
579 entry->end = mktime(&fixed_time);
581 ALARM_MGR_LOG_PRINT("alarm_info->alarm_type is "
582 "ALARM_TYPE_RELATIVE\n");
584 _update_alarms(entry);
587 _alarm_next_duetime(entry);
588 ALARM_MGR_LOG_PRINT("entry->due_time is %d\n", entry->due_time);
593 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
595 due_time = entry->due_time;
599 ALARM_MGR_LOG_PRINT("alarm[%d] with duetime(%u) at "
600 "current(%u)\n", entry->alarm_id, due_time, current_time);
601 if (due_time == 0) { /* 0 means this alarm has been disabled */
605 interval = difftime(due_time, current_time);
608 ALARM_MGR_EXCEPTION_PRINT("The duetime of alarm(%d) is OVER.", entry->alarm_id);
612 interval = difftime(due_time, min_time);
614 if ((interval < 0) || min_time == -1) {
620 alarm_context.c_due_time = min_time;
625 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
626 int pid, char *bundle_data, int *error_code)
631 char due_time_r[100] = { 0 };
632 char app_name[512] = { 0 };
634 char caller_appid[256] = { 0 };
635 char* callee_appid = NULL;
636 char* caller_pkgid = NULL;
637 char* callee_pkgid = NULL;
638 pkgmgrinfo_pkginfo_h caller_handle;
639 pkgmgrinfo_pkginfo_h callee_handle;
640 bundle_raw *b_data = NULL;
643 __alarm_info_t *__alarm_info = NULL;
645 __alarm_info = malloc(sizeof(__alarm_info_t));
646 if (__alarm_info == NULL) {
647 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
648 *error_code = ERR_ALARM_SYSTEM_FAIL;
652 __alarm_info->pid = pid;
653 __alarm_info->alarm_id = -1;
655 if (!__get_caller_unique_name(pid, app_name)) {
656 *error_code = ERR_ALARM_SYSTEM_FAIL;
660 __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
662 // Get caller_appid and callee_appid to get each package id
664 __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
666 if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
667 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
668 if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
670 __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
673 pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
678 __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
680 b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
681 callee_appid = appsvc_get_appid(b);
682 if (pkgmgrinfo_appinfo_get_appinfo(callee_appid, &callee_handle) == PMINFO_R_OK) {
683 if (pkgmgrinfo_appinfo_get_pkgid(callee_handle, &callee_pkgid) == PMINFO_R_OK) {
685 __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
688 pkgmgrinfo_appinfo_destroy_appinfo(callee_handle);
691 SECURE_LOGD("caller_pkgid = %s, callee_pkgid = %s",
692 g_quark_to_string(__alarm_info->quark_caller_pkgid), g_quark_to_string(__alarm_info->quark_callee_pkgid));
694 bundle_encode(b, &b_data, &datalen);
695 __alarm_info->quark_bundle=g_quark_from_string(b_data);
696 __alarm_info->quark_app_service_name = g_quark_from_string("null");
697 __alarm_info->quark_dst_service_name = g_quark_from_string("null");
698 __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
699 __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
707 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
708 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
709 __alarm_generate_alarm_id(__alarm_info, alarm_id);
713 if (alarm_context.c_due_time < current_time) {
714 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
715 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
716 alarm_context.c_due_time = -1;
719 due_time = _alarm_next_duetime(__alarm_info);
720 if (__alarm_add_to_list(__alarm_info) == false) {
722 *error_code = ERR_ALARM_SYSTEM_FAIL;
727 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
728 "due_time is 0, alarm(%d) \n", *alarm_id);
730 } else if (current_time == due_time) {
731 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
732 "current_time(%d) is same as due_time(%d)", current_time,
735 } else if (difftime(due_time, current_time) < 0) {
736 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list\n", due_time, current_time);
739 localtime_r(&due_time, &ts_ret);
740 strftime(due_time_r, 30, "%c", &ts_ret);
741 SECURE_LOGD("[alarm-server]:Create a new alarm: "
742 "alarm(%d) due_time(%s)", *alarm_id,
746 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
748 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
749 _clear_scheduled_alarm_list();
750 _add_to_scheduled_alarm_list(__alarm_info);
751 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
752 alarm_context.c_due_time = due_time;
753 } else if (due_time == alarm_context.c_due_time) {
754 _add_to_scheduled_alarm_list(__alarm_info);
762 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
763 int pid, periodic_method_e method, long requested_interval, int is_ref,
764 char *app_service_name, char *app_service_name_mod,
765 const char *dst_service_name, const char *dst_service_name_mod,
770 char app_name[512] = { 0 };
771 char caller_appid[256] = { 0 };
772 char* caller_pkgid = NULL;
773 pkgmgrinfo_pkginfo_h caller_handle;
775 __alarm_info_t *__alarm_info = NULL;
777 __alarm_info = malloc(sizeof(__alarm_info_t));
778 if (__alarm_info == NULL) {
779 SECURE_LOGE("Caution!! app_pid=%d, malloc "
780 "failed. it seems to be OOM\n", pid);
781 *error_code = ERR_ALARM_SYSTEM_FAIL;
784 __alarm_info->pid = pid;
785 __alarm_info->alarm_id = -1;
786 __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
787 __alarm_info->method = method;
788 __alarm_info->requested_interval = requested_interval;
789 __alarm_info->is_ref = is_ref;
791 // Get caller_appid to get caller's package id. There is no callee.
792 if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
793 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
794 if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
796 __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
799 pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
803 __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
804 SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null", g_quark_to_string(__alarm_info->quark_caller_pkgid));
806 if (!__get_caller_unique_name(pid, app_name)) {
807 *error_code = ERR_ALARM_SYSTEM_FAIL;
812 __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
813 __alarm_info->quark_app_service_name = g_quark_from_string(app_service_name);
814 __alarm_info->quark_app_service_name_mod = g_quark_from_string(app_service_name_mod);
815 __alarm_info->quark_dst_service_name = g_quark_from_string(dst_service_name);
816 __alarm_info->quark_dst_service_name_mod = g_quark_from_string(dst_service_name_mod);
817 __alarm_info->quark_bundle = g_quark_from_string("null");
819 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
820 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
821 __alarm_generate_alarm_id(__alarm_info, alarm_id);
825 SECURE_LOGD("[alarm-server]:pid=%d, app_unique_name=%s, "
826 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
827 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
828 g_quark_to_string(__alarm_info->quark_app_service_name), \
829 g_quark_to_string(__alarm_info->quark_dst_service_name), \
830 alarm_context.c_due_time);
832 if (alarm_context.c_due_time < current_time) {
833 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
834 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
835 alarm_context.c_due_time = -1;
838 due_time = _alarm_next_duetime(__alarm_info);
839 if (__alarm_add_to_list(__alarm_info) == false) {
845 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: due_time is 0, alarm(%d).", *alarm_id);
847 } else if (current_time == due_time) {
848 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: current_time(%d) is same as due_time(%d).",
849 current_time, due_time);
851 } else if (difftime(due_time, current_time) < 0) {
852 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list.",
853 due_time, current_time);
856 char due_time_r[100] = { 0 };
858 localtime_r(&due_time, &ts_ret);
859 strftime(due_time_r, 30, "%c", &ts_ret);
860 SECURE_LOGD("[alarm-server]:Create a new alarm: alarm(%d) due_time(%s)", *alarm_id, due_time_r);
863 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
865 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
866 _clear_scheduled_alarm_list();
867 _add_to_scheduled_alarm_list(__alarm_info);
868 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
869 alarm_context.c_due_time = due_time;
870 } else if (due_time == alarm_context.c_due_time) {
871 _add_to_scheduled_alarm_list(__alarm_info);
879 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
880 alarm_info_t *alarm_info, int *error_code)
885 __alarm_info_t *__alarm_info = NULL;
888 __alarm_info = malloc(sizeof(__alarm_info_t));
889 if (__alarm_info == NULL) {
890 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
891 *error_code = ERR_ALARM_SYSTEM_FAIL;
895 __alarm_info->pid = pid;
896 __alarm_info->alarm_id = alarm_id;
898 /* we should consider to check whether pid is running or Not
901 __alarm_info->quark_app_service_name =
902 g_quark_from_string(app_service_name);
903 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
904 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
908 if (alarm_context.c_due_time < current_time) {
909 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
910 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
911 alarm_context.c_due_time = -1;
914 due_time = _alarm_next_duetime(__alarm_info);
915 if (!__alarm_update_in_list(pid, alarm_id, __alarm_info, error_code)) {
917 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
918 "(%d) does not exist. so this value is invalid id.", alarm_id);
922 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
924 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
925 /*there is no scheduled alarm */
926 _alarm_disable_timer(alarm_context);
929 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d).", alarm_id);
934 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: due_time is 0.");
941 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
942 "due_time is 0, alarm(%d)\n", alarm_id);
945 } else if (current_time == due_time) {
946 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
947 "current_time(%d) is same as due_time(%d)", current_time,
951 } else if (difftime(due_time, current_time)< 0) {
952 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list\n", due_time, current_time);
956 char due_time_r[100] = { 0 };
958 localtime_r(&due_time, &ts_ret);
959 strftime(due_time_r, 30, "%c", &ts_ret);
960 SECURE_LOGD("[alarm-server]:Update alarm: alarm(%d) "
961 "due_time(%s)\n", alarm_id, due_time_r);
964 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
966 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
967 _clear_scheduled_alarm_list();
968 _add_to_scheduled_alarm_list(__alarm_info);
969 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
970 alarm_context.c_due_time = due_time;
971 ALARM_MGR_LOG_PRINT("[alarm-server1]:alarm_context.c_due_time "
972 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
973 } else if (due_time == alarm_context.c_due_time) {
974 _add_to_scheduled_alarm_list(__alarm_info);
975 ALARM_MGR_LOG_PRINT("[alarm-server2]:alarm_context.c_due_time "
976 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
986 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code)
990 SECURE_LOGD("[alarm-server]:delete alarm: alarm(%d) pid(%d)\n", alarm_id, pid);
991 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
993 if (!__alarm_remove_from_list(pid, alarm_id, error_code)) {
995 SECURE_LOGE("[alarm-server]:delete alarm: "
996 "alarm(%d) pid(%d) has failed with error_code(%d)\n",
997 alarm_id, pid, *error_code);
1001 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
1002 _alarm_disable_timer(alarm_context);
1011 static bool __can_skip_expired_cb(alarm_id_t alarm_id)
1013 GSList *gs_iter = NULL;
1014 __alarm_info_t *entry = NULL;
1015 alarm_info_t *alarm = NULL;
1017 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
1018 entry = gs_iter->data;
1019 if (entry->alarm_id == alarm_id) {
1020 alarm = &(entry->alarm_info);
1023 int dur = entry->requested_interval;
1026 if (!(alarm->alarm_type & ALARM_TYPE_PERIOD) || entry->method == CUT_OFF)
1029 ts_tm.tm_hour = alarm->start.hour;
1030 ts_tm.tm_min = alarm->start.min;
1031 ts_tm.tm_sec = alarm->start.sec;
1033 ts_tm.tm_year = alarm->start.year - 1900;
1034 ts_tm.tm_mon = alarm->start.month - 1;
1035 ts_tm.tm_mday = alarm->start.day;
1036 ts_tm.tm_isdst = -1;
1038 ts = mktime(&ts_tm);
1040 from = (ts / dur) * dur;
1043 if ( ts >= from && ts < to && from > ts - alarm->mode.u_interval.interval) {
1054 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id)
1056 char service_name[MAX_SERVICE_NAME_LEN] = {0,};
1058 if (app_service_name == NULL || strlen(app_service_name) == 0) {
1059 ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
1063 if (__can_skip_expired_cb(alarm_id))
1066 memcpy(service_name, app_service_name, strlen(app_service_name));
1067 SECURE_LOGI("[alarm server][send expired_alarm(alarm_id=%d) to app_service_name(%s)]", alarm_id, service_name);
1069 g_dbus_connection_call(alarm_context.connection,
1071 "/org/tizen/alarm/client",
1072 "org.tizen.alarm.client",
1074 g_variant_new("(is)", alarm_id, service_name),
1076 G_DBUS_CALL_FLAGS_NONE,
1083 static int __get_caller_pid(const char *name)
1087 GError *error = NULL;
1089 ret = g_dbus_connection_call_sync (alarm_context.connection,
1090 "org.freedesktop.DBus",
1091 "/org/freedesktop/DBus",
1092 "org.freedesktop.DBus",
1093 "GetConnectionUnixProcessID",
1094 g_variant_new ("(s)", name),
1096 G_DBUS_CALL_FLAGS_NONE,
1100 g_variant_get (ret, "(u)", &pid);
1101 g_variant_unref (ret);
1106 static void __alarm_expired()
1108 const char *destination_app_service_name = NULL;
1109 alarm_id_t alarm_id = -1;
1111 __alarm_info_t *__alarm_info = NULL;
1112 char alarm_id_val[32]={0,};
1116 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1117 GError *error = NULL;
1118 GVariant *result = NULL;
1119 gboolean name_has_owner_reply = false;
1121 ALARM_MGR_LOG_PRINT("[alarm-server]: Enter");
1123 time_t current_time;
1126 time(¤t_time);
1128 interval = difftime(alarm_context.c_due_time, current_time);
1129 ALARM_MGR_LOG_PRINT("[alarm-server]: c_due_time(%d), current_time(%d), interval(%d)",
1130 alarm_context.c_due_time, current_time, interval);
1132 if (alarm_context.c_due_time > current_time + 1) {
1133 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds future",
1134 alarm_context.c_due_time - current_time);
1137 // 10 seconds is maximum permitted delay from timer expire to this function
1138 if (alarm_context.c_due_time + 10 < current_time) {
1139 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds past\n",
1140 current_time - alarm_context.c_due_time);
1144 GSList *iter = NULL;
1145 __scheduled_alarm_t *alarm = NULL;
1147 for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
1148 const gchar *quark_bundle = NULL;
1150 alarm_id = alarm->alarm_id;
1152 __alarm_info = alarm->__alarm_info;
1154 app_pid = __alarm_info->pid;
1156 quark_bundle = g_quark_to_string(__alarm_info->quark_bundle);
1157 if (quark_bundle && strncmp(quark_bundle, "null", 4) != 0) {
1158 b_len = strlen(quark_bundle);
1160 b = bundle_decode((bundle_raw *)quark_bundle, b_len);
1164 ALARM_MGR_EXCEPTION_PRINT("Error!!!..Unable to decode the bundle!!\n");
1168 snprintf(alarm_id_val,31,"%d",alarm_id);
1170 if (bundle_add_str(b,"http://tizen.org/appcontrol/data/alarm_id", alarm_id_val)){
1171 ALARM_MGR_EXCEPTION_PRINT("Unable to add alarm id to the bundle\n");
1175 appid = (char *)appsvc_get_appid(b);
1176 if( (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid))
1178 ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
1182 if ( appsvc_run_service(b, 0, NULL, NULL) < 0)
1184 ALARM_MGR_EXCEPTION_PRINT("Unable to run app svc\n");
1188 ALARM_MGR_LOG_PRINT("Successfuly ran app svc\n");
1198 const gchar *dst_service_name = g_quark_to_string(__alarm_info->quark_dst_service_name);
1199 if (dst_service_name && strncmp(dst_service_name, "null", 4) == 0) {
1200 SECURE_LOGD("[alarm-server]:destination is null, so we send expired alarm to %s(%u).",
1201 g_quark_to_string(__alarm_info->quark_app_service_name), __alarm_info->quark_app_service_name);
1202 destination_app_service_name = g_quark_to_string(__alarm_info->quark_app_service_name_mod);
1204 SECURE_LOGD("[alarm-server]:destination :%s(%u)",
1205 g_quark_to_string(__alarm_info->quark_dst_service_name), __alarm_info->quark_dst_service_name);
1206 destination_app_service_name = g_quark_to_string(__alarm_info->quark_dst_service_name_mod);
1210 * we should consider a situation that
1211 * destination_app_service_name is owner_name like (:xxxx) and
1212 * application's pid which registered this alarm was killed.In that case,
1213 * we don't need to send the expire event because the process was killed.
1214 * this causes needless message to be sent.
1216 SECURE_LOGD("[alarm-server]: destination_app_service_name :%s, app_pid=%d", destination_app_service_name, app_pid);
1218 result = g_dbus_connection_call_sync(alarm_context.connection,
1219 "org.freedesktop.DBus",
1220 "/org/freedesktop/DBus",
1221 "org.freedesktop.DBus",
1223 g_variant_new ("(s)", destination_app_service_name),
1224 G_VARIANT_TYPE ("(b)"),
1225 G_DBUS_CALL_FLAGS_NONE,
1229 if (result == NULL) {
1230 ALARM_MGR_EXCEPTION_PRINT("g_dbus_connection_call_sync() is failed. err: %s", error->message);
1231 g_error_free(error);
1233 g_variant_get (result, "(b)", &name_has_owner_reply);
1236 if (name_has_owner_reply == false) {
1237 __expired_alarm_t *expire_info;
1238 char appid[MAX_SERVICE_NAME_LEN] = { 0, };
1239 char alarm_id_str[32] = { 0, };
1241 if (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
1242 __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1246 expire_info = malloc(sizeof(__expired_alarm_t));
1247 if (G_UNLIKELY(NULL == expire_info)) {
1248 ALARM_MGR_ASSERT_PRINT("[alarm-server]:Malloc failed!Can't notify alarm expiry info\n");
1251 memset(expire_info, '\0', sizeof(__expired_alarm_t));
1252 strncpy(expire_info->service_name, destination_app_service_name, MAX_SERVICE_NAME_LEN-1);
1253 expire_info->alarm_id = alarm_id;
1254 g_expired_alarm_list = g_slist_append(g_expired_alarm_list, expire_info);
1256 if (strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null",4) == 0) {
1257 strncpy(appid,g_quark_to_string(__alarm_info->quark_app_service_name)+6,strlen(g_quark_to_string(__alarm_info->quark_app_service_name))-6);
1260 strncpy(appid,g_quark_to_string(__alarm_info->quark_dst_service_name)+6,strlen(g_quark_to_string(__alarm_info->quark_dst_service_name))-6);
1263 snprintf(alarm_id_str, 31, "%d", alarm_id);
1265 SECURE_LOGD("before aul_launch appid(%s) alarm_id_str(%s)", appid, alarm_id_str);
1268 kb = bundle_create();
1269 bundle_add_str(kb, "__ALARM_MGR_ID", alarm_id_str);
1270 aul_launch_app(appid, kb);
1273 ALARM_MGR_LOG_PRINT("before alarm_send_noti_to_application");
1274 ALARM_MGR_LOG_PRINT("WAKEUP pid: %d", __alarm_info->pid);
1276 aul_update_freezer_status(__alarm_info->pid, "wakeup");
1277 __alarm_send_noti_to_application(destination_app_service_name, alarm_id);
1278 ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application");
1282 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is expired.", alarm_id);
1284 sprintf(log_message, "alarmID: %d, pid: %d, unique_name: %s, duetime: %d",
1285 alarm_id, app_pid, g_quark_to_string(__alarm_info->quark_app_unique_name), __alarm_info->due_time);
1286 __save_module_log("EXPIRED", log_message);
1287 memset(log_message, '\0', sizeof(log_message));
1289 if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
1290 __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1292 _alarm_next_duetime(__alarm_info);
1297 _clear_scheduled_alarm_list();
1298 alarm_context.c_due_time = -1;
1300 ALARM_MGR_LOG_PRINT("[alarm-server]: Leave");
1303 static gboolean __alarm_handler_idle(gpointer user_data)
1305 GPollFD *gpollfd = (GPollFD *) user_data;
1307 if (gpollfd == NULL) {
1308 ALARM_MGR_EXCEPTION_PRINT("gpollfd is NULL");
1311 if (read(gpollfd->fd, &exp, sizeof(uint64_t)) < 0) {
1312 ALARM_MGR_EXCEPTION_PRINT("Reading the fd is failed.");
1316 ALARM_MGR_EXCEPTION_PRINT("Lock the display not to enter LCD OFF");
1317 if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS) {
1318 ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
1321 if (g_dummy_timer_is_set == true) {
1322 ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
1325 ALARM_MGR_LOG_PRINT("__alarm_handler_idle");
1333 ALARM_MGR_EXCEPTION_PRINT("Unlock the display from LCD OFF");
1334 if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS) {
1335 ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
1341 static void __clean_registry()
1344 /*TODO:remove all db entries */
1347 static bool __alarm_manager_reset()
1349 _alarm_disable_timer(alarm_context);
1351 __alarm_clean_list();
1353 _clear_scheduled_alarm_list();
1359 static void __on_system_time_external_changed(keynode_t *node, void *data)
1361 double diff_time = 0.0;
1362 time_t cur_time = 0;
1364 _alarm_disable_timer(alarm_context);
1367 diff_time = vconf_keynode_get_dbl(node);
1369 if (vconf_get_dbl(VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, &diff_time) != VCONF_OK) {
1370 ALARM_MGR_EXCEPTION_PRINT("Failed to get value of VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL.");
1378 ALARM_MGR_EXCEPTION_PRINT("diff_time is %f, New time is %s\n", diff_time, ctime(&cur_time));
1380 ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed externally\n");
1381 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n",
1382 alarm_context.c_due_time);
1384 // set rtc time only because the linux time is set externally
1385 _set_rtc_time(cur_time);
1387 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1389 __alarm_update_due_time_of_all_items_in_list(diff_time);
1391 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n",
1392 alarm_context.c_due_time);
1393 _clear_scheduled_alarm_list();
1400 static void __on_time_zone_changed(keynode_t *node, void *data)
1402 double diff_time = 0;
1404 _alarm_disable_timer(alarm_context);
1408 ALARM_MGR_LOG_PRINT("[alarm-server] time zone has been changed\n");
1409 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1411 __alarm_update_due_time_of_all_items_in_list(diff_time);
1413 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1414 _clear_scheduled_alarm_list();
1421 static int __on_app_uninstalled(int req_id, const char *pkg_type,
1422 const char *pkgid, const char *key, const char *val,
1423 const void *pmsg, void *user_data)
1425 GSList* gs_iter = NULL;
1426 __alarm_info_t* entry = NULL;
1427 alarm_info_t* alarm_info = NULL;
1428 bool is_deleted = false;
1430 SECURE_LOGD("pkg_type(%s), pkgid(%s), key(%s), value(%s)", pkg_type, pkgid, key, val);
1432 if (strncmp(key, "end", 3) == 0 && strncmp(val, "ok", 2) == 0)
1434 for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
1436 bool is_found = false;
1437 entry = gs_iter->data;
1439 char* caller_pkgid = g_quark_to_string(entry->quark_caller_pkgid);
1440 char* callee_pkgid = g_quark_to_string(entry->quark_callee_pkgid);
1442 if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
1443 (callee_pkgid && strncmp(pkgid, callee_pkgid, strlen(pkgid)) == 0))
1445 if (_remove_from_scheduled_alarm_list(pkgid, entry->alarm_id))
1450 alarm_info = &entry->alarm_info;
1451 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
1453 if(!_delete_alarms(entry->alarm_id))
1455 SECURE_LOGE("_delete_alarms() is failed. pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1461 gs_iter = g_slist_next(gs_iter);
1465 SECURE_LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1466 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1471 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
1473 _alarm_disable_timer(alarm_context);
1480 return ALARMMGR_RESULT_SUCCESS;
1483 int __check_privilege_by_cookie(char *e_cookie, const char *label, const char *access, bool check_root, int pid) {
1484 guchar *cookie = NULL;
1487 char buf[128] = {0,};
1489 char title[128] = {0,};
1493 // Gets the userID from /proc/pid/status to check if the process is the root or not.
1494 snprintf(buf, sizeof(buf), "/proc/%d/status", pid);
1495 fp = fopen(buf, "r");
1497 while (fgets(buf, sizeof(buf), fp) != NULL) {
1498 if(strncmp(buf, "Uid:", 4) == 0) {
1499 sscanf(buf, "%s %d", title, &uid);
1506 ALARM_MGR_LOG_PRINT("uid : %d", uid);
1509 if (uid != 0) { // Checks the cookie only when the process is not the root
1510 cookie = g_base64_decode(e_cookie, &size);
1511 if (cookie == NULL) {
1512 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!");
1513 return ERR_ALARM_SYSTEM_FAIL;
1516 retval = security_server_check_privilege_by_cookie((const char *)cookie, label, access);
1520 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1521 ALARM_MGR_EXCEPTION_PRINT("Access to alarm-server has been denied by smack.");
1523 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege_by_cookie() : %d.", retval);
1524 return ERR_ALARM_NO_PERMISSION;
1528 ALARM_MGR_LOG_PRINT("The process(%d) was authenticated successfully.", pid);
1529 return ALARMMGR_RESULT_SUCCESS;
1532 bool __get_caller_unique_name(int pid, char *unique_name)
1534 char caller_appid[256] = {0,};
1536 if (unique_name == NULL)
1538 ALARM_MGR_EXCEPTION_PRINT("unique_name should not be NULL.");
1542 if (aul_app_get_appid_bypid(pid, caller_appid, sizeof(caller_appid)) == AUL_R_OK)
1544 // When a caller is an application, the unique name is appID.
1545 strncpy(unique_name, caller_appid, strlen(caller_appid));
1549 // Otherwise, the unique name is /proc/pid/cmdline.
1550 char proc_file[512] = {0,};
1551 char process_name[512] = {0,};
1555 snprintf(proc_file, 512, "/proc/%d/cmdline", pid);
1557 fd = open(proc_file, O_RDONLY);
1559 SECURE_LOGE("Caution!! pid(%d) seems to be killed, so we failed to get proc file(%s) and do not create alarm_info.", pid, proc_file);
1563 if (read(fd, process_name, 512) <= 0)
1565 ALARM_MGR_EXCEPTION_PRINT("Unable to get the process name.");
1571 while (process_name[i] != '\0') {
1572 if (process_name[i] == ' ') {
1573 process_name[i] = '\0';
1578 strncpy(unique_name, process_name, strlen(process_name));
1582 SECURE_LOGD("unique_name= %s", unique_name);
1586 static void __initialize_module_log(void)
1588 log_fd = open(ALARMMGR_LOG_FILE_PATH, O_CREAT | O_WRONLY, 0644);
1590 ALARM_MGR_EXCEPTION_PRINT("Opening the file for alarmmgr log is failed.");
1594 int offset = lseek(log_fd, 0, SEEK_END);
1596 log_index = (int)(offset / ALARMMGR_LOG_BUFFER_STRING_SIZE);
1597 if (log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1599 lseek(log_fd, 0, SEEK_SET);
1605 static bool __save_module_log(const char *tag, const char *message)
1607 char buffer[ALARMMGR_LOG_BUFFER_STRING_SIZE] = {0,};
1612 ALARM_MGR_EXCEPTION_PRINT("The file is not ready.");
1616 if (log_index != 0) {
1617 offset = lseek(log_fd, 0, SEEK_CUR);
1619 offset = lseek(log_fd, 0, SEEK_SET);
1623 snprintf(buffer, ALARMMGR_LOG_BUFFER_STRING_SIZE, "[%-6d] %-20s %-120s %d-%s", log_index, tag, message, (int)now, ctime(&now));
1625 int ret = write(log_fd, buffer, strlen(buffer));
1627 ALARM_MGR_EXCEPTION_PRINT("Writing the alarmmgr log is failed.");
1631 if (++log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1637 int __display_lock_state(char *state, char *flag, unsigned int timeout)
1639 GDBusMessage *msg = NULL;
1640 GDBusMessage *reply = NULL;
1641 GVariant *body = NULL;
1642 GError *error = NULL;
1643 int ret = ALARMMGR_RESULT_SUCCESS;
1646 msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1648 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1649 return ERR_ALARM_SYSTEM_FAIL;
1652 g_dbus_message_set_body(msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
1654 reply = g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, &error);
1656 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1657 g_error_free(error);
1658 ret = ERR_ALARM_SYSTEM_FAIL;
1660 body = g_dbus_message_get_body(reply);
1662 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1663 ret = ERR_ALARM_SYSTEM_FAIL;
1665 g_variant_get(body, "(i)", &val);
1667 ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
1668 ret = ERR_ALARM_SYSTEM_FAIL;
1670 ALARM_MGR_EXCEPTION_PRINT("Lock LCD OFF is successfully done");
1675 g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1676 g_object_unref(msg);
1677 g_object_unref(reply);
1682 int __display_unlock_state(char *state, char *flag)
1684 GDBusMessage *msg = NULL;
1685 GDBusMessage *reply = NULL;
1686 GVariant *body = NULL;
1687 GError *error = NULL;
1688 int ret = ALARMMGR_RESULT_SUCCESS;
1691 msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1693 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1694 return ERR_ALARM_SYSTEM_FAIL;
1697 g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag ));
1699 reply = g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, &error);
1701 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1702 g_error_free(error);
1703 ret = ERR_ALARM_SYSTEM_FAIL;
1705 body = g_dbus_message_get_body(reply);
1707 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1708 ret = ERR_ALARM_SYSTEM_FAIL;
1710 g_variant_get(body, "(i)", &val);
1712 ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
1713 ret = ERR_ALARM_SYSTEM_FAIL;
1715 ALARM_MGR_EXCEPTION_PRINT("Unlock LCD OFF is successfully done");
1720 g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1721 g_object_unref(msg);
1722 g_object_unref(reply);
1727 static long __get_proper_interval(long interval)
1729 GSList *gs_iter = NULL;
1730 __alarm_info_t *entry = NULL;
1731 long maxInterval = 60;
1733 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
1734 entry = gs_iter->data;
1735 if (entry->alarm_info.alarm_type & ALARM_TYPE_PERIOD) {
1736 if (entry->alarm_info.mode.u_interval.interval <= interval &&
1737 entry->alarm_info.mode.u_interval.interval > maxInterval) {
1738 maxInterval = entry->alarm_info.mode.u_interval.interval;
1743 while (maxInterval * 2 <= interval) {
1750 gboolean alarm_manager_alarm_set_rtc_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
1751 int year, int mon, int day,
1752 int hour, int min, int sec, char *e_cookie,
1753 gpointer user_data) {
1754 const char *rtc = default_rtc;
1755 struct timespec alarm_time;
1757 int return_code = ALARMMGR_RESULT_SUCCESS;
1759 struct rtc_time rtc_tm = {0,};
1760 struct rtc_wkalrm rtc_wk;
1761 struct tm *alarm_tm = NULL;
1763 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1764 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1766 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1767 if (retval != ALARMMGR_RESULT_SUCCESS) {
1768 return_code = retval;
1769 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1773 /*extract day of the week, day in the year & daylight saving time from system*/
1774 time_t current_time;
1775 current_time = time(NULL);
1776 alarm_tm = localtime(¤t_time);
1777 if (alarm_tm == NULL) {
1778 ALARM_MGR_EXCEPTION_PRINT("alarm_tm is NULL");
1782 alarm_tm->tm_year = year;
1783 alarm_tm->tm_mon = mon;
1784 alarm_tm->tm_mday = day;
1785 alarm_tm->tm_hour = hour;
1786 alarm_tm->tm_min = min;
1787 alarm_tm->tm_sec = sec;
1789 /*convert to calendar time representation*/
1790 time_t rtc_time = mktime(alarm_tm);
1793 gfd = open(rtc, O_RDWR);
1795 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
1796 return_code = ERR_ALARM_SYSTEM_FAIL;
1797 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1802 alarm_time.tv_sec = rtc_time;
1803 alarm_time.tv_nsec = 0;
1805 retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
1807 if (errno == ENOTTY) {
1808 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
1810 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
1811 return_code = ERR_ALARM_SYSTEM_FAIL;
1812 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
1815 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
1816 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
1819 sprintf(log_message, "wakeup rtc time: %d, %s", rtc_time, ctime(&rtc_time));
1820 __save_module_log(log_tag, log_message);
1822 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1826 gboolean alarm_manager_alarm_set_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int _time, gpointer user_data)
1828 static int diff_msec = 0; // To check a millisecond part of current time at changing the system time
1829 double diff_time = 0.0;
1830 struct timeval before;
1831 int return_code = ALARMMGR_RESULT_SUCCESS;
1832 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1834 _alarm_disable_timer(alarm_context);
1836 gettimeofday(&before, NULL);
1837 diff_msec += (before.tv_usec / 1000); // Accrue the millisecond to compensate the time
1838 ALARM_MGR_LOG_PRINT("Current time = %s. usec = %ld. diff_msec = %d.\n", ctime(&before.tv_sec), before.tv_usec, diff_msec);
1840 if (diff_msec > 500) {
1841 diff_time = difftime(_time, before.tv_sec) - 1;
1845 diff_time = difftime(_time, before.tv_sec);
1850 char *timebuf = ctime(&_time);
1852 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid newline
1853 sprintf(log_message, "Current: %d, New: %d, %s, diff: %f", before.tv_sec, _time, timebuf, diff_time);
1854 __save_module_log("CHANGE TIME", log_message);
1857 ALARM_MGR_EXCEPTION_PRINT("[TIMESTAMP]Current time(%d), New time(%d)(%s), diff_time(%f)", before.tv_sec, _time, ctime(&_time), diff_time);
1859 ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed\n");
1860 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1862 _set_time(_time - 1);
1863 __alarm_update_due_time_of_all_items_in_list(diff_time);
1865 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d", alarm_context.c_due_time);
1866 _clear_scheduled_alarm_list();
1871 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1873 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1877 gboolean alarm_manager_alarm_set_timezone(AlarmManager *pObject, GDBusMethodInvocation *invoc, char *tzpath_str, gpointer user_data)
1880 int return_code = ALARMMGR_RESULT_SUCCESS;
1881 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1882 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1883 struct stat statbuf;
1885 ALARM_MGR_EXCEPTION_PRINT("[TIMESTAMP]Set the timezone to %s.", tzpath_str);
1887 if (stat(tzpath_str, &statbuf) == -1 && errno == ENOENT) {
1888 ALARM_MGR_EXCEPTION_PRINT("Invalid tzpath, %s", tzpath_str);
1889 return_code = ERR_ALARM_INVALID_PARAM;
1893 retval = stat(TIMEZONE_INFO_LINK_PATH, &statbuf);
1894 if (retval == 0 || (retval == -1 && errno != ENOENT)) {
1895 // unlink the current link
1896 if (unlink(TIMEZONE_INFO_LINK_PATH) < 0) {
1897 ALARM_MGR_EXCEPTION_PRINT("unlink() is failed.");
1898 return_code = ERR_ALARM_SYSTEM_FAIL;
1903 // create a new symlink when the /opt/etc/localtime is empty.
1904 if (symlink(tzpath_str, TIMEZONE_INFO_LINK_PATH) < 0) {
1905 ALARM_MGR_EXCEPTION_PRINT("Failed to create an symlink of %s.", tzpath_str);
1906 return_code = ERR_ALARM_SYSTEM_FAIL;
1912 // Rescheduling alarms
1913 _alarm_disable_timer(alarm_context);
1914 __alarm_update_due_time_of_all_items_in_list(0);
1915 ALARM_MGR_LOG_PRINT("next expiring due_time is %d", alarm_context.c_due_time);
1917 _clear_scheduled_alarm_list();
1921 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, 0);
1924 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1925 if (return_code == ALARMMGR_RESULT_SUCCESS) {
1926 strncpy(log_tag, "SET TIMEZONE", strlen("SET TIMEZONE"));
1928 strncpy(log_tag, "FAIL: SET TIMEZONE", strlen("FAIL: SET TIMEZONE"));
1930 sprintf(log_message, "Set the timezone to %s.", tzpath_str);
1931 __save_module_log(log_tag, log_message);
1936 gboolean alarm_manager_alarm_create_appsvc(AlarmManager *pObject, GDBusMethodInvocation *invoc,
1939 int start_month, int start_day,
1940 int start_hour, int start_min,
1941 int start_sec, int end_year, int end_month,
1942 int end_day, int mode_day_of_week,
1943 int mode_repeat, int alarm_type,
1945 char *bundle_data, char *e_cookie,
1948 alarm_info_t alarm_info;
1950 int return_code = ALARMMGR_RESULT_SUCCESS;
1952 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1953 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1956 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1957 if (retval != ALARMMGR_RESULT_SUCCESS) {
1958 return_code = retval;
1959 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1960 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1961 __save_module_log("FAIL: CREATE", log_message);
1965 alarm_info.start.year = start_year;
1966 alarm_info.start.month = start_month;
1967 alarm_info.start.day = start_day;
1968 alarm_info.start.hour = start_hour;
1969 alarm_info.start.min = start_min;
1970 alarm_info.start.sec = start_sec;
1972 alarm_info.end.year = end_year;
1973 alarm_info.end.month = end_month;
1974 alarm_info.end.day = end_day;
1976 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1977 alarm_info.mode.repeat = mode_repeat;
1979 alarm_info.alarm_type = alarm_type;
1980 alarm_info.reserved_info = reserved_info;
1982 if (!__alarm_create_appsvc(&alarm_info, &alarm_id, pid, bundle_data, &return_code)) {
1983 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
1984 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
1987 strncpy(log_tag, "CREATE", strlen("CREATE"));
1991 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1993 sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
1994 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
1995 __save_module_log(log_tag, log_message);
2000 gboolean alarm_manager_alarm_create(AlarmManager *obj, GDBusMethodInvocation *invoc, int pid,
2001 char *app_service_name, char *app_service_name_mod, int start_year,
2002 int start_month, int start_day,
2003 int start_hour, int start_min,
2004 int start_sec, int end_year, int end_month,
2005 int end_day, int mode_day_of_week,
2006 int mode_repeat, int alarm_type,
2008 char *reserved_service_name, char *reserved_service_name_mod, char *e_cookie,
2011 alarm_info_t alarm_info;
2013 int return_code = ALARMMGR_RESULT_SUCCESS;
2015 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2016 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2019 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
2020 if (retval != ALARMMGR_RESULT_SUCCESS) {
2021 return_code = retval;
2022 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2023 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
2024 __save_module_log("FAIL: CREATE", log_message);
2028 alarm_info.start.year = start_year;
2029 alarm_info.start.month = start_month;
2030 alarm_info.start.day = start_day;
2031 alarm_info.start.hour = start_hour;
2032 alarm_info.start.min = start_min;
2033 alarm_info.start.sec = start_sec;
2035 alarm_info.end.year = end_year;
2036 alarm_info.end.month = end_month;
2037 alarm_info.end.day = end_day;
2039 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2040 alarm_info.mode.repeat = mode_repeat;
2042 alarm_info.alarm_type = alarm_type;
2043 alarm_info.reserved_info = reserved_info;
2045 if (!__alarm_create(&alarm_info, &alarm_id, pid, 0, 0, 0, app_service_name,app_service_name_mod,
2046 reserved_service_name, reserved_service_name_mod, &return_code)) {
2047 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2048 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2051 strncpy(log_tag, "CREATE", strlen("CREATE"));
2055 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
2057 sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2058 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2059 __save_module_log(log_tag, log_message);
2064 gboolean alarm_manager_alarm_create_periodic(AlarmManager *obj, GDBusMethodInvocation *invoc,
2065 char *app_service_name, char *app_service_name_mod, int interval,
2066 int is_ref, int method, char *e_cookie, gpointer user_data)
2068 alarm_info_t alarm_info;
2070 int return_code = ALARMMGR_RESULT_SUCCESS;
2072 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2073 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2076 const char *name = g_dbus_method_invocation_get_sender(invoc);
2078 pid = __get_caller_pid(name);
2081 retval = __check_privilege_by_cookie(e_cookie,
2082 "alarm-server::alarm-ref-periodic", "w", true, pid);
2084 retval = __check_privilege_by_cookie(e_cookie,
2085 "alarm-server::alarm-periodic", "w", true, pid);
2087 if (retval != ALARMMGR_RESULT_SUCCESS) {
2088 return_code = retval;
2089 g_dbus_method_invocation_return_value(invoc,
2090 g_variant_new("(ii)", alarm_id, return_code));
2092 sprintf(log_message,
2093 "pid: %d, Smack denied (alarm-server::alarm-ref-periodic, w)", pid);
2095 sprintf(log_message,
2096 "pid: %d, Smack denied (alarm-server::alarm-periodic, w)", pid);
2098 __save_module_log("FAIL: CREATE", log_message);
2102 alarm_info.start.year = 1900;
2103 alarm_info.start.month = 1;
2104 alarm_info.start.day = 0;
2105 alarm_info.start.hour = 0;
2106 alarm_info.start.min = 0;
2107 alarm_info.start.sec = 0;
2109 alarm_info.end.year = 0;
2110 alarm_info.end.month = 0;
2111 alarm_info.end.day = 0;
2113 alarm_info.alarm_type = ALARM_TYPE_VOLATILE;
2114 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
2115 alarm_info.alarm_type |= ALARM_TYPE_WITHCB;
2116 alarm_info.alarm_type |= ALARM_TYPE_PERIOD;
2117 alarm_info.reserved_info = 0;
2119 if (interval <= 0) {
2120 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
2121 alarm_info.mode.u_interval.interval = 0;
2123 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
2125 alarm_info.mode.u_interval.interval = interval * 60;
2127 alarm_info.mode.u_interval.interval = __get_proper_interval(interval * 60);
2130 if (!__alarm_create(&alarm_info, &alarm_id, pid, method, interval * 60, is_ref,
2131 app_service_name, app_service_name_mod,
2132 "null", "null", &return_code)) {
2133 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
2134 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
2137 strncpy(log_tag, "CREATE", strlen("CREATE"));
2141 g_dbus_method_invocation_return_value(invoc,
2142 g_variant_new("(ii)", alarm_id, return_code));
2144 sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2145 alarm_id, pid, alarm_info.start.year, alarm_info.start.month,
2146 alarm_info.start.day, alarm_info.start.hour,
2147 alarm_info.start.min, alarm_info.start.sec);
2148 __save_module_log(log_tag, log_message);
2153 gboolean alarm_manager_alarm_delete(AlarmManager *obj, GDBusMethodInvocation *invoc,
2154 int pid, alarm_id_t alarm_id,
2155 char *e_cookie, gpointer user_data)
2158 int return_code = ALARMMGR_RESULT_SUCCESS;
2159 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2160 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2163 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
2164 if (retval != ALARMMGR_RESULT_SUCCESS) {
2165 return_code = retval;
2166 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2167 sprintf(log_message, "alarmID: %d, pid: %d, Smack denied (alarm-server::alarm, w)", alarm_id, pid);
2168 __save_module_log("FAIL: DELETE", log_message);
2172 if (!__alarm_delete(pid, alarm_id, &return_code)) {
2173 ALARM_MGR_EXCEPTION_PRINT("Unable to delete the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2174 strncpy(log_tag, "FAIL: DELETE", strlen("FAIL: DELETE"));
2177 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", alarm_id);
2178 strncpy(log_tag, "DELETE", strlen("DELETE"));
2182 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2184 sprintf(log_message, "alarmID: %d, pid: %d", alarm_id, pid);
2185 __save_module_log(log_tag, log_message);
2190 gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation *invoc,
2191 int pid, char *e_cookie, gpointer user_data)
2193 GSList* gs_iter = NULL;
2194 char app_name[512] = { 0 };
2195 alarm_info_t* alarm_info = NULL;
2196 __alarm_info_t* entry = NULL;
2197 bool is_deleted = false;
2199 int return_code = ALARMMGR_RESULT_SUCCESS;
2200 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2202 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
2203 if (retval != ALARMMGR_RESULT_SUCCESS) {
2204 return_code = retval;
2205 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2206 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
2207 __save_module_log("FAIL: DELETE ALL", log_message);
2211 if (!__get_caller_unique_name(pid, app_name)) {
2212 return_code = ERR_ALARM_SYSTEM_FAIL;
2213 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2214 sprintf(log_message, "pid: %d. Can not get the unique_name.", pid);
2215 __save_module_log("FAIL: DELETE ALL", log_message);
2219 SECURE_LOGD("Called by process (pid:%d, unique_name=%s)", pid, app_name);
2221 for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
2223 bool is_found = false;
2224 entry = gs_iter->data;
2225 char* tmp_appname = g_quark_to_string(entry->quark_app_unique_name);
2226 SECURE_LOGD("Try to remove app_name[%s], alarm_id[%d]\n", tmp_appname, entry->alarm_id);
2227 if (tmp_appname && strncmp(app_name, tmp_appname, strlen(tmp_appname)) == 0)
2229 if (_remove_from_scheduled_alarm_list(pid, entry->alarm_id))
2234 alarm_info = &entry->alarm_info;
2235 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
2237 if(!_delete_alarms(entry->alarm_id))
2239 SECURE_LOGE("_delete_alarms() is failed. pid[%d], alarm_id[%d]", pid, entry->alarm_id);
2245 gs_iter = g_slist_next(gs_iter);
2249 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", entry->alarm_id);
2250 SECURE_LOGD("Removing is done. app_name[%s], alarm_id [%d]\n", tmp_appname, entry->alarm_id);
2251 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
2256 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
2258 _alarm_disable_timer(alarm_context);
2263 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2267 gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
2268 char *app_service_name, alarm_id_t alarm_id,
2269 int start_year, int start_month,
2270 int start_day, int start_hour,
2271 int start_min, int start_sec, int end_year,
2272 int end_month, int end_day,
2273 int mode_day_of_week, int mode_repeat,
2274 int alarm_type, int reserved_info,
2277 int return_code = ALARMMGR_RESULT_SUCCESS;
2278 alarm_info_t alarm_info;
2280 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2281 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2283 alarm_info.start.year = start_year;
2284 alarm_info.start.month = start_month;
2285 alarm_info.start.day = start_day;
2286 alarm_info.start.hour = start_hour;
2287 alarm_info.start.min = start_min;
2288 alarm_info.start.sec = start_sec;
2290 alarm_info.end.year = end_year;
2291 alarm_info.end.month = end_month;
2292 alarm_info.end.day = end_day;
2294 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2295 alarm_info.mode.repeat = mode_repeat;
2297 alarm_info.alarm_type = alarm_type;
2298 alarm_info.reserved_info = reserved_info;
2300 if (!__alarm_update(pid, app_service_name, alarm_id, &alarm_info, &return_code)) {
2301 ALARM_MGR_EXCEPTION_PRINT("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2302 strncpy(log_tag, "FAIL: UPDATE", strlen("FAIL: UPDATE"));
2305 strncpy(log_tag, "UPDATE", strlen("UPDATE"));
2309 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2311 sprintf(log_message, "alarmID: %d, appname: %s, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2312 alarm_id, app_service_name, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2313 __save_module_log(log_tag, log_message);
2318 gboolean alarm_manager_alarm_get_number_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie,
2321 GSList *gs_iter = NULL;
2322 char app_name[256] = { 0 };
2323 __alarm_info_t *entry = NULL;
2326 int return_code = ALARMMGR_RESULT_SUCCESS;
2328 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2329 if (retval != ALARMMGR_RESULT_SUCCESS) {
2330 return_code = retval;
2331 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2335 if (!__get_caller_unique_name(pid, app_name)) {
2336 return_code = ERR_ALARM_SYSTEM_FAIL;
2337 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2341 SECURE_LOGD("Called by process (pid:%d, unique_name:%s)", pid, app_name);
2343 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2344 entry = gs_iter->data;
2345 const gchar *app_unique_name = g_quark_to_string(entry->quark_app_unique_name);
2346 SECURE_LOGD("app_name=%s, quark_app_unique_name=%s", app_name, g_quark_to_string(entry->quark_app_unique_name));
2347 if (app_unique_name && strncmp(app_name, app_unique_name, strlen(app_name)) == 0) {
2349 SECURE_LOGD("inc number of alarms of app (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2353 SECURE_LOGD("number of alarms of the process (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2354 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2358 gboolean alarm_manager_alarm_get_list_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2359 int max_number_of_ids, gpointer user_data)
2361 GSList *gs_iter = NULL;
2362 char app_name[512] = { 0 };
2363 __alarm_info_t *entry = NULL;
2365 GVariant* arr = NULL;
2366 GVariantBuilder* builder = NULL;
2368 int return_code = ALARMMGR_RESULT_SUCCESS;
2370 if (max_number_of_ids <= 0) {
2371 SECURE_LOGE("called for pid(%d), but max_number_of_ids(%d) is less than 0.", pid, max_number_of_ids);
2372 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2376 if (!__get_caller_unique_name(pid, app_name)) {
2377 return_code = ERR_ALARM_SYSTEM_FAIL;
2378 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2382 SECURE_LOGD("Called by process (pid:%d, unique_name=%s).", pid, app_name);
2384 builder = g_variant_builder_new(G_VARIANT_TYPE ("ai"));
2385 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2386 entry = gs_iter->data;
2388 const gchar *app_unique_name = g_quark_to_string(entry->quark_app_unique_name);
2389 if (app_unique_name && strncmp(app_name, app_unique_name, strlen(app_name)) == 0) {
2390 g_variant_builder_add (builder, "i", entry->alarm_id);
2392 SECURE_LOGE("called for alarmid(%d), but max_number_of_ids(%d) index %d.", entry->alarm_id, max_number_of_ids, index);
2396 arr = g_variant_new("ai", builder);
2399 SECURE_LOGE("Called by pid (%d), but max_number_of_ids(%d) return code %d.", pid, num_of_ids, return_code);
2400 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_ids, return_code));
2402 g_variant_builder_unref(builder);
2406 gboolean alarm_manager_alarm_get_appsvc_info(AlarmManager *pObject, GDBusMethodInvocation *invoc ,
2407 int pid, alarm_id_t alarm_id,
2408 char *e_cookie, gpointer user_data)
2411 GSList *gs_iter = NULL;
2412 __alarm_info_t *entry = NULL;
2414 int return_code = ALARMMGR_RESULT_SUCCESS;
2415 gchar *b_data = NULL;
2417 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2419 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", false, pid);
2420 if (retval != ALARMMGR_RESULT_SUCCESS) {
2421 return_code = retval;
2422 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2426 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2427 entry = gs_iter->data;
2428 if (entry->alarm_id == alarm_id) {
2430 b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
2436 if (b_data && strlen(b_data) == 4 && strncmp(b_data, "null", 4) == 0) {
2437 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
2438 return_code = ERR_ALARM_INVALID_TYPE;
2441 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2442 return_code = ERR_ALARM_INVALID_ID;
2445 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2450 gboolean alarm_manager_alarm_get_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2451 alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2453 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2455 GSList *gs_iter = NULL;
2456 __alarm_info_t *entry = NULL;
2457 alarm_info_t *alarm_info = NULL;
2459 int return_code = ALARMMGR_RESULT_SUCCESS;
2461 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2462 if (retval != ALARMMGR_RESULT_SUCCESS) {
2463 return_code = retval;
2464 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
2468 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2469 entry = gs_iter->data;
2470 if (entry->alarm_id == alarm_id) {
2471 alarm_info = &(entry->alarm_info);
2476 if (alarm_info == NULL) {
2477 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2478 return_code = ERR_ALARM_INVALID_ID;
2479 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
2481 ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
2482 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", alarm_info->start.year, alarm_info->start.month,
2483 alarm_info->start.day, alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec, alarm_info->end.year, alarm_info->end.month,
2484 alarm_info->end.day, alarm_info->mode.u_interval.day_of_week, alarm_info->mode.repeat, alarm_info->alarm_type, alarm_info->reserved_info, return_code));
2490 gboolean alarm_manager_alarm_get_next_duetime(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2491 alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2493 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2495 GSList *gs_iter = NULL;
2496 __alarm_info_t *entry = NULL;
2497 __alarm_info_t *find_item = NULL;
2499 int return_code = ALARMMGR_RESULT_SUCCESS;
2502 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2503 if (retval != ALARMMGR_RESULT_SUCCESS) {
2504 return_code = retval;
2505 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2509 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2510 entry = gs_iter->data;
2511 if (entry->alarm_id == alarm_id) {
2517 if (find_item == NULL) {
2518 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2519 return_code = ERR_ALARM_INVALID_ID;
2520 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2524 duetime = _alarm_next_duetime(find_item);
2525 ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&duetime));
2527 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2531 gboolean alarm_manager_alarm_get_all_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie, gpointer user_data)
2533 sqlite3 *alarmmgr_tool_db;
2534 char *db_path = NULL;
2535 char db_path_tmp[50] = {0,};
2536 time_t current_time = 0;
2537 struct tm current_tm;
2538 const char *query_for_creating_table = "create table alarmmgr_tool \
2539 (alarm_id integer primary key,\
2540 duetime_epoch integer,\
2542 start_epoch integer,\
2547 app_unique_name text,\
2548 app_service_name text,\
2549 dst_service_name text,\
2550 day_of_week integer,\
2552 alarm_type integer)";
2553 const char *query_for_deleting_table = "drop table alarmmgr_tool";
2554 int return_code = ALARMMGR_RESULT_SUCCESS;
2555 GSList *gs_iter = NULL;
2556 __alarm_info_t *entry = NULL;
2557 char *error_message = NULL;
2559 return_code = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2560 if (return_code != ALARMMGR_RESULT_SUCCESS) {
2561 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2566 time(¤t_time);
2567 localtime_r(¤t_time, ¤t_tm);
2568 sprintf(db_path_tmp, "/tmp/alarmmgr_%d%d%d_%02d%02d%02d.db",
2569 current_tm.tm_year + 1900, current_tm.tm_mon + 1, current_tm.tm_mday, current_tm.tm_hour, current_tm.tm_min, current_tm.tm_sec);
2570 db_path = strdup(db_path_tmp);
2572 if (db_util_open(db_path, &alarmmgr_tool_db, DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
2573 ALARM_MGR_EXCEPTION_PRINT("Opening [%s] failed", db_path);
2574 return_code = ERR_ALARM_SYSTEM_FAIL;
2575 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2581 if (sqlite3_exec(alarmmgr_tool_db, query_for_deleting_table, NULL, NULL, &error_message) != SQLITE_OK) {
2582 ALARM_MGR_EXCEPTION_PRINT("Deleting the table is failed. error message = %s", error_message);
2585 // Create a table if it does not exist
2586 if (sqlite3_exec(alarmmgr_tool_db, query_for_creating_table, NULL, NULL, &error_message) != SQLITE_OK) {
2587 ALARM_MGR_EXCEPTION_PRINT("Creating the table is failed. error message = %s", error_message);
2588 sqlite3_close(alarmmgr_tool_db);
2589 return_code = ERR_ALARM_SYSTEM_FAIL;
2590 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2595 // Get information of all alarms and save those into the DB.
2597 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2598 entry = gs_iter->data;
2600 SECURE_LOGD("#%d alarm id[%d] app_name[%s] duetime[%d]",
2601 index, entry->alarm_id, g_quark_to_string(entry->quark_app_unique_name), entry->start);
2603 alarm_info_t *alarm_info = (alarm_info_t *) &(entry->alarm_info);
2604 alarm_mode_t *mode = &alarm_info->mode;
2606 char *query = sqlite3_mprintf("insert into alarmmgr_tool( alarm_id, duetime_epoch, duetime, start_epoch,\
2607 end_epoch, pid, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, dst_service_name, day_of_week, repeat, alarm_type)\
2608 values (%d,%d,%Q,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%d,%d,%d)",
2610 (int)entry->due_time,
2611 ctime(&(entry->due_time)),
2615 (char *)g_quark_to_string(entry->quark_caller_pkgid),
2616 (char *)g_quark_to_string(entry->quark_callee_pkgid),
2617 (char *)g_quark_to_string(entry->quark_app_unique_name),
2618 (char *)g_quark_to_string(entry->quark_app_service_name),
2619 (char *)g_quark_to_string(entry->quark_dst_service_name),
2620 mode->u_interval.day_of_week,
2622 entry->alarm_info.alarm_type);
2624 if (sqlite3_exec(alarmmgr_tool_db, query, NULL, NULL, &error_message) != SQLITE_OK) {
2625 SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
2628 sqlite3_free(query);
2631 sqlite3_close(alarmmgr_tool_db);
2633 return_code = ALARMMGR_RESULT_SUCCESS;
2634 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2639 static void __timer_glib_finalize(GSource *src)
2644 fd_list = src->poll_fds;
2646 tmp = (GPollFD *) fd_list->data;
2649 fd_list = fd_list->next;
2655 static gboolean __timer_glib_check(GSource *src)
2660 fd_list = src->poll_fds;
2662 tmp = (GPollFD *) fd_list->data;
2663 if (tmp->revents & (POLLIN | POLLPRI)) {
2666 fd_list = fd_list->next;
2672 static gboolean __timer_glib_dispatch(GSource *src, GSourceFunc callback,
2679 static gboolean __timer_glib_prepare(GSource *src, gint *timeout)
2684 GSourceFuncs funcs = {
2685 .prepare = __timer_glib_prepare,
2686 .check = __timer_glib_check,
2687 .dispatch = __timer_glib_dispatch,
2688 .finalize = __timer_glib_finalize
2691 static void __initialize_timer()
2698 fd = timerfd_create(CLOCK_REALTIME, 0);
2700 ALARM_MGR_EXCEPTION_PRINT("timerfd_create() is failed.\n");
2703 src = g_source_new(&funcs, sizeof(GSource));
2705 gpollfd = (GPollFD *) g_malloc(sizeof(GPollFD));
2706 if (gpollfd == NULL) {
2707 ALARM_MGR_EXCEPTION_PRINT("out of memory.\n");
2709 g_source_unref(src);
2713 gpollfd->events = POLLIN;
2716 g_source_add_poll(src, gpollfd);
2717 g_source_set_callback(src, (GSourceFunc) __alarm_handler_idle,
2718 (gpointer) gpollfd, NULL);
2719 g_source_set_priority(src, G_PRIORITY_HIGH);
2721 ret = g_source_attach(src, NULL);
2723 ALARM_MGR_EXCEPTION_PRINT("g_source_attach() is failed.\n");
2727 g_source_unref(src);
2729 alarm_context.timer = fd;
2732 static void __initialize_alarm_list()
2734 alarm_context.alarms = NULL;
2735 alarm_context.c_due_time = -1;
2737 _load_alarms_from_registry();
2739 __rtc_set(); /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
2742 static void __initialize_scheduled_alarm_list()
2744 _init_scheduled_alarm_list();
2747 static bool __initialize_noti()
2749 // system state change noti
2750 if (vconf_notify_key_changed
2751 (VCONFKEY_SETAPPL_TIMEZONE_ID, __on_time_zone_changed, NULL) < 0) {
2752 ALARM_MGR_LOG_PRINT(
2753 "Failed to add callback for time zone changing event\n");
2756 if (vconf_notify_key_changed
2757 (VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, __on_system_time_external_changed, NULL) < 0) {
2758 ALARM_MGR_LOG_PRINT(
2759 "Failed to add callback for time external changing event\n");
2762 // If the caller or callee app is uninstalled, all registered alarms will be canceled.
2763 int event_type = PMINFO_CLIENT_STATUS_UNINSTALL;
2764 pkgmgrinfo_client* pc = pkgmgrinfo_client_new(PMINFO_LISTENING);
2765 pkgmgrinfo_client_set_status_type(pc, event_type);
2766 pkgmgrinfo_client_listen_status(pc, __on_app_uninstalled, NULL);
2771 void on_bus_name_owner_changed(GDBusConnection *connection,
2772 const gchar *sender_name,
2773 const gchar *object_path,
2774 const gchar *interface_name,
2775 const gchar *signal_name,
2776 GVariant *parameters,
2779 // On expiry, the killed app can be launched by aul. Then, the owner of the bus name which was registered by the app is changed.
2780 // In this case, "NameOwnerChange" signal is broadcasted.
2781 if (signal_name && strcmp(signal_name , "NameOwnerChanged") == 0) {
2782 GSList *entry = NULL;
2783 __expired_alarm_t *expire_info = NULL;
2784 char *service_name = NULL;
2785 g_variant_get(parameters, "(sss)", &service_name, NULL, NULL);
2787 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
2789 expire_info = (__expired_alarm_t *) entry->data;
2790 SECURE_LOGD("expired service(%s), owner changed service(%s)", expire_info->service_name, service_name);
2792 if (strcmp(expire_info->service_name, service_name) == 0) {
2793 SECURE_LOGE("expired service name(%s) alarm_id (%d)", expire_info->service_name, expire_info->alarm_id);
2794 __alarm_send_noti_to_application(expire_info->service_name, expire_info->alarm_id);
2795 g_expired_alarm_list = g_slist_remove(g_expired_alarm_list, entry->data);
2796 g_free(expire_info);
2800 g_free(service_name);
2804 static void on_bus_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
2806 ALARM_MGR_EXCEPTION_PRINT("on_bus_acquired");
2808 interface = alarm_manager_skeleton_new();
2809 if (interface == NULL) {
2810 ALARM_MGR_EXCEPTION_PRINT("Creating a skeleton object is failed.");
2814 g_signal_connect(interface, "handle_alarm_create", G_CALLBACK(alarm_manager_alarm_create), NULL);
2815 g_signal_connect(interface, "handle_alarm_create_periodic", G_CALLBACK(alarm_manager_alarm_create_periodic), NULL);
2816 g_signal_connect(interface, "handle_alarm_create_appsvc", G_CALLBACK(alarm_manager_alarm_create_appsvc), NULL);
2817 g_signal_connect(interface, "handle_alarm_delete", G_CALLBACK(alarm_manager_alarm_delete), NULL);
2818 g_signal_connect(interface, "handle_alarm_delete_all", G_CALLBACK(alarm_manager_alarm_delete_all), NULL);
2819 g_signal_connect(interface, "handle_alarm_get_appsvc_info", G_CALLBACK(alarm_manager_alarm_get_appsvc_info), NULL);
2820 g_signal_connect(interface, "handle_alarm_get_info", G_CALLBACK(alarm_manager_alarm_get_info), NULL);
2821 g_signal_connect(interface, "handle_alarm_get_list_of_ids", G_CALLBACK(alarm_manager_alarm_get_list_of_ids), NULL);
2822 g_signal_connect(interface, "handle_alarm_get_next_duetime", G_CALLBACK(alarm_manager_alarm_get_next_duetime), NULL);
2823 g_signal_connect(interface, "handle_alarm_get_number_of_ids", G_CALLBACK(alarm_manager_alarm_get_number_of_ids), NULL);
2824 g_signal_connect(interface, "handle_alarm_set_rtc_time", G_CALLBACK(alarm_manager_alarm_set_rtc_time), NULL);
2825 g_signal_connect(interface, "handle_alarm_set_time", G_CALLBACK(alarm_manager_alarm_set_time), NULL);
2826 g_signal_connect(interface, "handle_alarm_set_timezone", G_CALLBACK(alarm_manager_alarm_set_timezone), NULL);
2827 g_signal_connect(interface, "handle_alarm_update", G_CALLBACK(alarm_manager_alarm_update), NULL);
2828 g_signal_connect(interface, "handle_alarm_get_all_info", G_CALLBACK(alarm_manager_alarm_get_all_info), NULL);
2830 guint subsc_id = g_dbus_connection_signal_subscribe(connection, "org.freedesktop.DBus", "org.freedesktop.DBus",
2831 "NameOwnerChanged", "/org/freedesktop/DBus", NULL, G_DBUS_SIGNAL_FLAGS_NONE,
2832 on_bus_name_owner_changed, NULL, NULL);
2833 if (subsc_id == 0) {
2834 ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
2835 g_object_unref(interface);
2840 if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, ALARM_MGR_DBUS_PATH, NULL)) {
2841 ALARM_MGR_EXCEPTION_PRINT("Exporting the interface is failed.");
2842 g_object_unref(interface);
2847 alarm_context.connection = connection;
2848 g_dbus_object_manager_server_set_connection(alarmmgr_server, alarm_context.connection);
2851 static bool __initialize_dbus()
2853 ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
2855 alarmmgr_server = g_dbus_object_manager_server_new(ALARM_MGR_DBUS_PATH);
2856 if (alarmmgr_server == NULL) {
2857 ALARM_MGR_EXCEPTION_PRINT("Creating a new server object is failed.");
2861 guint owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, ALARM_MGR_DBUS_NAME,
2862 G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, NULL, NULL, NULL, NULL);
2864 if (owner_id == 0) {
2865 ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
2866 g_object_unref(alarmmgr_server);
2873 #define ALARMMGR_DB_FILE "/opt/dbspace/.alarmmgr.db"
2874 sqlite3 *alarmmgr_db;
2875 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
2876 (alarm_id integer primary key,\
2882 app_unique_name text,\
2883 app_service_name text,\
2884 app_service_name_mod text,\
2892 day_of_week integer,\
2894 alarm_type integer,\
2895 reserved_info integer,\
2896 dst_service_name text, \
2897 dst_service_name_mod text \
2900 static bool __initialize_db()
2902 char *error_message = NULL;
2905 if (access("/opt/dbspace/.alarmmgr.db", F_OK) == 0) {
2906 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2908 if (ret != SQLITE_OK) {
2909 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2916 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2918 if (ret != SQLITE_OK) {
2919 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2923 if (SQLITE_OK != sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL, &error_message)) {
2924 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, error message = %s", QUERY_CREATE_TABLE_ALARMMGR, error_message);
2931 static void __initialize()
2935 __initialize_timer();
2936 if (__initialize_dbus() == false) { /* because dbus's initialize
2937 failed, we cannot continue any more. */
2938 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
2939 "alarm-server cannot be runned.\n");
2942 __initialize_scheduled_alarm_list();
2944 __initialize_alarm_list();
2945 __initialize_noti();
2947 __initialize_module_log(); // for module log
2953 GMainLoop *mainloop = NULL;
2955 ALARM_MGR_LOG_PRINT("Enter main loop\n");
2957 mainloop = g_main_loop_new(NULL, FALSE);
2961 g_main_loop_run(mainloop);