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>
57 #define SIG_TIMER 0x32
58 #define WAKEUP_ALARM_APP_ID "com.samsung.alarm.ALARM"
59 /* alarm ui application's alarm's dbus_service name instead of 21
60 (alarm application's app_id) value */
62 __alarm_server_context_t alarm_context;
63 bool g_dummy_timer_is_set = FALSE;
65 GSList *g_scheduled_alarm_list = NULL;
66 GSList *g_expired_alarm_list = NULL;
68 #ifndef RTC_WKALM_BOOT_SET
69 #define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
72 /* 2008. 6. 3 sewook7.park
73 When the alarm becoms sleeping mode, alarm timer is not expired.
74 So using RTC, phone is awaken before alarm rings.
76 #define __WAKEUP_USING_RTC__
77 #ifdef __WAKEUP_USING_RTC__
79 #include <linux/rtc.h>
80 #include <sys/ioctl.h>
83 #define ALARM_RTC_WAKEUP 0
85 #define ALARM_IOW(c, type, size) _IOW('a', (c) | ((type) << 4), size)
86 #define ALARM_SET(type) ALARM_IOW(2, type, struct timespec)
87 #define ALARM_SET_RTC _IOW('a', 5, struct timespec)
88 #define ALARM_CLEAR(type) _IO('a', 0 | ((type) << 4))
91 #define ALARMMGR_LOG_BUFFER_SIZE 10000
92 #define ALARMMGR_LOG_BUFFER_STRING_SIZE 200
93 #define ALARMMGR_LOG_TAG_SIZE 20
94 #define ALARMMGR_LOG_MESSAGE_SIZE 120
95 #define ALARMMGR_LOG_FILE_PATH "/var/log/alarmmgr.log"
96 static int log_index = 0;
97 static int log_fd = 0;
99 // display lock and unlock
100 #define DEVICED_BUS_NAME "org.tizen.system.deviced"
101 #define DEVICED_PATH_DISPLAY "/Org/Tizen/System/DeviceD/Display"
102 #define DEVICED_INTERFACE_DISPLAY "org.tizen.system.deviced.display"
103 #define DEVICED_LOCK_STATE "lockstate"
104 #define DEVICED_UNLOCK_STATE "unlockstate"
105 #define DEVICED_DBUS_REPLY_TIMEOUT (120*1000)
106 #define DEVICED_LCD_OFF "lcdoff"
107 #define DEVICED_STAY_CUR_STATE "staycurstate"
108 #define DEVICED_SLEEP_MARGIN "sleepmargin"
110 static const char default_rtc[] = "/dev/alarm";
114 #endif /*__WAKEUP_USING_RTC__*/
116 /* GDBus Declaration */
117 #define ALARM_MGR_DBUS_PATH "/com/samsung/alarm/manager"
118 #define ALARM_MGR_DBUS_NAME "com.samsung.alarm.manager"
119 GDBusObjectManagerServer *alarmmgr_server = NULL;
120 static AlarmManager* interface = NULL;
122 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info);
123 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
124 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
125 __alarm_info_t *__alarm_info,
127 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
129 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
130 __alarm_info_t *__alarm_info);
131 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time);
132 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
133 int pid, char *app_service_name, char *app_service_name_mod,
134 const char *dst_service_name, const char *dst_service_name_mod, int *error_code);
135 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
136 int pid, char *bundle_data, int *error_code);
138 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code);
139 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
140 alarm_info_t *alarm_info, int *error_code);
141 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id);
142 static void __alarm_expired();
143 static gboolean __alarm_handler_idle(gpointer user_data);
144 static void __clean_registry();
145 static bool __alarm_manager_reset();
146 static void __on_system_time_external_changed(keynode_t *node, void *data);
147 static void __initialize_timer();
148 static void __initialize_alarm_list();
149 static void __initialize_scheduled_alarm_list();
150 static bool __initialize_noti();
152 static bool __initialize_dbus();
153 static bool __initialize_db();
154 static void __initialize();
155 void on_bus_name_owner_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
156 const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data);
157 bool __get_caller_unique_name(int pid, char *unique_name);
159 static void __initialize_module_log(void);
160 static bool __save_module_log(const char *tag, const char *messgae);
162 int __display_lock_state(char *state, char *flag, unsigned int timeout);
163 int __display_unlock_state(char *state, char *flag);
165 static void __rtc_set()
167 #ifdef __WAKEUP_USING_RTC__
168 const char *rtc = default_rtc;
169 struct rtc_wkalrm rtc_wk;
171 struct timespec alarm_time;
172 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
173 #ifdef _SIMUL /*if build is simulator, we don't need to set
174 RTC because RTC does not work in simulator.*/
175 ALARM_MGR_EXCEPTION_PRINT("because it is simulator's mode, we don't set RTC.");
180 gfd = open(rtc, O_RDWR);
182 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
187 /* Read the RTC time/date */
189 char *timebuf = ctime(&alarm_context.c_due_time);
190 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid new line
191 sprintf(log_message, "wakeup time: %d, %s", alarm_context.c_due_time, timebuf);
193 ALARM_MGR_LOG_PRINT("alarm_context.c_due_time is %d.", alarm_context.c_due_time);
195 if (alarm_context.c_due_time != -1) {
196 retval = ioctl(gfd, ALARM_CLEAR(ALARM_RTC_WAKEUP));
198 if (errno == ENOTTY) {
199 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
201 ALARM_MGR_EXCEPTION_PRINT("ALARM_CLEAR ioctl is failed. errno = %s", strerror(errno));
204 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]ALARM_CLEAR ioctl is successfully done.");
206 time_t due_time = alarm_context.c_due_time;
207 gmtime_r(&due_time, &due_tm);
209 ALARM_MGR_EXCEPTION_PRINT("Setted RTC Alarm date/time is %d-%d-%d, %02d:%02d:%02d (UTC).",
210 due_tm.tm_mday, due_tm.tm_mon + 1, due_tm.tm_year + 1900,
211 due_tm.tm_hour, due_tm.tm_min, due_tm.tm_sec);
213 alarm_time.tv_sec = due_time - 1;
214 alarm_time.tv_nsec = 500000000; // Wakeup is 500ms faster than expiring time to correct RTC error.
215 retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
217 if (errno == ENOTTY) {
218 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
220 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
221 __save_module_log("FAIL: SET RTC", log_message);
224 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]RTC ALARM_SET ioctl is successfully done.");
225 __save_module_log("SET RTC", log_message);
228 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]alarm_context.c_due_time is"
229 "less than 10 sec. RTC alarm does not need to be set");
231 #endif /* __WAKEUP_USING_RTC__ */
235 int _set_rtc_time(time_t _time)
238 const char *rtc0 = default_rtc;
239 struct timespec rtc_time;
240 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
241 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
244 gfd = open(rtc0, O_RDWR);
247 ALARM_MGR_LOG_PRINT("error to open /dev/alarm.");
252 rtc_time.tv_sec = _time;
253 rtc_time.tv_nsec = 0;
255 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
256 char *timebuf = ctime(&_time);
257 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid new line
258 sprintf(log_message, "rtc time = %d, %s", _time, timebuf);
260 ret = ioctl(gfd, ALARM_SET_RTC, &rtc_time);
262 ALARM_MGR_LOG_PRINT("ALARM_SET_RTC ioctl is failed. errno = %s", strerror(errno));
263 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
268 __save_module_log(log_tag, log_message);
273 bool __alarm_clean_list()
275 g_slist_free_full(alarm_context.alarms, g_free);
279 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id)
281 bool unique_id = false;
282 __alarm_info_t *entry = NULL;
285 srand((unsigned int)time(NULL));
286 __alarm_info->alarm_id = (rand() % INT_MAX) + 1;
287 ALARM_MGR_LOG_PRINT("__alarm_info->alarm_id is %d", __alarm_info->alarm_id);
289 while (unique_id == false) {
292 for (iter = alarm_context.alarms; iter != NULL;
293 iter = g_slist_next(iter)) {
295 if (entry->alarm_id == __alarm_info->alarm_id) {
296 __alarm_info->alarm_id++;
302 *alarm_id = __alarm_info->alarm_id;
307 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info)
309 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
310 __alarm_info_t *entry = NULL;
313 ALARM_MGR_LOG_PRINT("[alarm-server]: Before add alarm_id(%d)", __alarm_info->alarm_id);
315 alarm_context.alarms = g_slist_append(alarm_context.alarms, __alarm_info);
316 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: After add alarm_id(%d)", __alarm_info->alarm_id);
319 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
321 ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d).", entry->alarm_id);
324 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
325 if (!_save_alarms(__alarm_info)) {
326 ALARM_MGR_EXCEPTION_PRINT("Saving alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
333 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
334 __alarm_info_t *__alarm_info,
338 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
340 __alarm_info_t *entry = NULL;
342 for (iter = alarm_context.alarms; iter != NULL;
343 iter = g_slist_next(iter)) {
345 if (entry->alarm_id == alarm_id) {
348 __alarm_info->quark_app_unique_name =
349 entry->quark_app_unique_name;
350 __alarm_info->quark_dst_service_name =
351 entry->quark_dst_service_name;
352 memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
360 *error_code = ERR_ALARM_INVALID_ID;
364 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
365 if (!_update_alarms(__alarm_info)) {
366 ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
373 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
378 alarm_info_t *alarm_info = NULL;
381 __alarm_info_t *entry = NULL;
384 ALARM_MGR_LOG_PRINT("[alarm-server]: before del : alarm id(%d)", alarm_id);
386 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
388 if (entry->alarm_id == alarm_id) {
389 alarm_info = &entry->alarm_info;
391 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Remove alarm id(%d)", entry->alarm_id);
393 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
394 _delete_alarms(alarm_id);
397 alarm_context.alarms = g_slist_remove(alarm_context.alarms, iter->data);
405 ALARM_MGR_LOG_PRINT("[alarm-server]: after del\n");
409 *error_code = ERR_ALARM_INVALID_ID;
416 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
417 __alarm_info_t *__alarm_info)
419 alarm_date_t *start = &alarm_info->start;
420 alarm_date_t *end = &alarm_info->end;
422 struct tm alarm_tm = { 0, };
424 if (start->year != 0) {
425 alarm_tm.tm_year = start->year - 1900;
426 alarm_tm.tm_mon = start->month - 1;
427 alarm_tm.tm_mday = start->day;
429 alarm_tm.tm_hour = start->hour;
430 alarm_tm.tm_min = start->min;
431 alarm_tm.tm_sec = start->sec;
432 alarm_tm.tm_isdst = -1;
434 __alarm_info->start = mktime(&alarm_tm);
436 __alarm_info->start = 0;
439 if (end->year != 0) {
440 alarm_tm.tm_year = end->year - 1900;
441 alarm_tm.tm_mon = end->month - 1;
442 alarm_tm.tm_mday = end->day;
444 alarm_tm.tm_hour = end->hour;
445 alarm_tm.tm_min = end->min;
446 alarm_tm.tm_sec = end->sec;
448 __alarm_info->end = mktime(&alarm_tm);
450 __alarm_info->end = 0;
457 static bool alarm_get_tz_info(int *gmt_idx, int *dst)
459 GConfValue *value1 = NULL;
460 GConfValue *value2 = NULL;
461 GConfClient* gConfClient = NULL;
464 gConfClient = gconf_client_get_default();
467 value1 = gconf_client_get(gConfClient, SETTINGS_CLOCKTIMEZONE,
470 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
471 gconf_client_get() failed:
472 error:[%s]\n", err->message);
476 *gmt_idx = gconf_value_get_int(value1);
477 ALARM_MGR_LOG_PRINT("gconf return gmt_idx =%d\n ", *gmt_idx);
479 value2 = gconf_client_get(gConfClient,
480 SETTINGS_DAYLIGHTSTATUS, &err);
482 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
483 gconf_client_get() failed: error:[%s]\n", err->message);
488 *dst = gconf_value_get_int(value2);
489 ALARM_MGR_LOG_PRINT("gconf return dst =%d\n ", *dst);
491 if(gConfClient != NULL) {
492 g_object_unref(gConfClient);
497 ALARM_MGR_LOG_PRINT("check the gconf setting failed!!!!! \n ");
500 gconf_value_free(value1);
504 gconf_value_free(value2);
512 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time)
515 time_t min_time = -1;
518 __alarm_info_t *entry = NULL;
519 struct tm *p_time = NULL ;
520 struct tm due_time_result ;
521 struct tm fixed_time = { 0, };
523 for (iter = alarm_context.alarms; iter != NULL;
524 iter = g_slist_next(iter)) {
526 alarm_info_t *alarm_info = &(entry->alarm_info);
527 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
528 /*diff_time ó\B8\AE */
530 entry->due_time += diff_time;
532 alarm_date_t *start = &alarm_info->start; /**< start
534 alarm_date_t *end = &alarm_info->end;;
535 /**< end time of the alarm */
538 p_time = localtime_r(&entry->due_time, &due_time_result);
539 if (p_time != NULL) {
540 start->year = p_time->tm_year + 1900;
541 start->month = p_time->tm_mon + 1;
542 start->day = p_time->tm_mday;
543 start->hour = p_time->tm_hour;
544 start->min = p_time->tm_min;
545 start->sec = p_time->tm_sec;
547 end->year = p_time->tm_year + 1900;
548 end->month = p_time->tm_mon + 1;
549 end->day = p_time->tm_mday;
552 memset(&fixed_time, 0, sizeof(fixed_time));
553 fixed_time.tm_year = p_time->tm_year;
554 fixed_time.tm_mon = p_time->tm_mon;
555 fixed_time.tm_mday = p_time->tm_mday;
556 fixed_time.tm_hour = 0;
557 fixed_time.tm_min = 0;
558 fixed_time.tm_sec = 0;
560 entry->start = mktime(&fixed_time);
562 fixed_time.tm_hour = 23;
563 fixed_time.tm_min = 59;
564 fixed_time.tm_sec = 59;
566 entry->end = mktime(&fixed_time);
568 ALARM_MGR_LOG_PRINT("alarm_info->alarm_type is "
569 "ALARM_TYPE_RELATIVE\n");
571 _update_alarms(entry);
574 _alarm_next_duetime(entry);
575 ALARM_MGR_LOG_PRINT("entry->due_time is %d\n", entry->due_time);
580 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
582 due_time = entry->due_time;
586 ALARM_MGR_LOG_PRINT("alarm[%d] with duetime(%u) at "
587 "current(%u)\n", entry->alarm_id, due_time, current_time);
588 if (due_time == 0) { /* 0 means this alarm has been disabled */
592 interval = difftime(due_time, current_time);
595 ALARM_MGR_EXCEPTION_PRINT("The duetime of alarm(%d) is OVER.", entry->alarm_id);
599 interval = difftime(due_time, min_time);
601 if ((interval < 0) || min_time == -1) {
607 alarm_context.c_due_time = min_time;
612 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
613 int pid, char *bundle_data, int *error_code)
618 char due_time_r[100] = { 0 };
619 char app_name[512] = { 0 };
621 char caller_appid[256] = { 0 };
622 char* callee_appid = NULL;
623 char* caller_pkgid = NULL;
624 char* callee_pkgid = NULL;
625 pkgmgrinfo_pkginfo_h caller_handle;
626 pkgmgrinfo_pkginfo_h callee_handle;
627 bundle_raw *b_data = NULL;
630 __alarm_info_t *__alarm_info = NULL;
632 __alarm_info = malloc(sizeof(__alarm_info_t));
633 if (__alarm_info == NULL) {
634 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
635 *error_code = ERR_ALARM_SYSTEM_FAIL;
639 __alarm_info->pid = pid;
640 __alarm_info->alarm_id = -1;
642 if (!__get_caller_unique_name(pid, app_name)) {
643 *error_code = ERR_ALARM_SYSTEM_FAIL;
647 __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
649 // Get caller_appid and callee_appid to get each package id
651 __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
653 if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
654 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
655 if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
657 __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
660 pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
665 __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
667 b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
668 callee_appid = appsvc_get_appid(b);
669 if (pkgmgrinfo_appinfo_get_appinfo(callee_appid, &callee_handle) == PMINFO_R_OK) {
670 if (pkgmgrinfo_appinfo_get_pkgid(callee_handle, &callee_pkgid) == PMINFO_R_OK) {
672 __alarm_info->quark_callee_pkgid = g_quark_from_string(callee_pkgid);
675 pkgmgrinfo_appinfo_destroy_appinfo(callee_handle);
678 SECURE_LOGD("caller_pkgid = %s, callee_pkgid = %s",
679 g_quark_to_string(__alarm_info->quark_caller_pkgid), g_quark_to_string(__alarm_info->quark_callee_pkgid));
681 bundle_encode(b, &b_data, &datalen);
682 __alarm_info->quark_bundle=g_quark_from_string(b_data);
683 __alarm_info->quark_app_service_name = g_quark_from_string("null");
684 __alarm_info->quark_dst_service_name = g_quark_from_string("null");
685 __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
686 __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
694 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
695 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
696 __alarm_generate_alarm_id(__alarm_info, alarm_id);
700 if (alarm_context.c_due_time < current_time) {
701 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
702 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
703 alarm_context.c_due_time = -1;
706 due_time = _alarm_next_duetime(__alarm_info);
707 if (__alarm_add_to_list(__alarm_info) == false) {
709 *error_code = ERR_ALARM_SYSTEM_FAIL;
714 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
715 "due_time is 0, alarm(%d) \n", *alarm_id);
717 } else if (current_time == due_time) {
718 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
719 "current_time(%d) is same as due_time(%d)", current_time,
722 } else if (difftime(due_time, current_time) < 0) {
723 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);
726 localtime_r(&due_time, &ts_ret);
727 strftime(due_time_r, 30, "%c", &ts_ret);
728 SECURE_LOGD("[alarm-server]:Create a new alarm: "
729 "alarm(%d) due_time(%s)", *alarm_id,
733 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
735 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
736 _clear_scheduled_alarm_list();
737 _add_to_scheduled_alarm_list(__alarm_info);
738 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
739 alarm_context.c_due_time = due_time;
740 } else if (due_time == alarm_context.c_due_time) {
741 _add_to_scheduled_alarm_list(__alarm_info);
749 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
750 int pid, char *app_service_name, char *app_service_name_mod,
751 const char *dst_service_name,const char *dst_service_name_mod, int *error_code)
755 char app_name[512] = { 0 };
756 char caller_appid[256] = { 0 };
757 char* caller_pkgid = NULL;
758 pkgmgrinfo_pkginfo_h caller_handle;
760 __alarm_info_t *__alarm_info = NULL;
762 __alarm_info = malloc(sizeof(__alarm_info_t));
763 if (__alarm_info == NULL) {
764 SECURE_LOGE("Caution!! app_pid=%d, malloc "
765 "failed. it seems to be OOM\n", pid);
766 *error_code = ERR_ALARM_SYSTEM_FAIL;
769 __alarm_info->pid = pid;
770 __alarm_info->alarm_id = -1;
771 __alarm_info->quark_caller_pkgid = g_quark_from_string("null");
773 // Get caller_appid to get caller's package id. There is no callee.
774 if (aul_app_get_appid_bypid(pid, caller_appid, 256) == AUL_R_OK) {
775 if (pkgmgrinfo_appinfo_get_appinfo(caller_appid, &caller_handle) == PMINFO_R_OK) {
776 if (pkgmgrinfo_appinfo_get_pkgid(caller_handle, &caller_pkgid) == PMINFO_R_OK) {
778 __alarm_info->quark_caller_pkgid = g_quark_from_string(caller_pkgid);
781 pkgmgrinfo_appinfo_destroy_appinfo(caller_handle);
785 __alarm_info->quark_callee_pkgid = g_quark_from_string("null");
786 SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null", g_quark_to_string(__alarm_info->quark_caller_pkgid));
788 if (!__get_caller_unique_name(pid, app_name)) {
789 *error_code = ERR_ALARM_SYSTEM_FAIL;
794 __alarm_info->quark_app_unique_name = g_quark_from_string(app_name);
795 __alarm_info->quark_app_service_name = g_quark_from_string(app_service_name);
796 __alarm_info->quark_app_service_name_mod = g_quark_from_string(app_service_name_mod);
797 __alarm_info->quark_dst_service_name = g_quark_from_string(dst_service_name);
798 __alarm_info->quark_dst_service_name_mod = g_quark_from_string(dst_service_name_mod);
799 __alarm_info->quark_bundle = g_quark_from_string("null");
801 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
802 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
803 __alarm_generate_alarm_id(__alarm_info, alarm_id);
807 SECURE_LOGD("[alarm-server]:pid=%d, app_unique_name=%s, "
808 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
809 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
810 g_quark_to_string(__alarm_info->quark_app_service_name), \
811 g_quark_to_string(__alarm_info->quark_dst_service_name), \
812 alarm_context.c_due_time);
814 if (alarm_context.c_due_time < current_time) {
815 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
816 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
817 alarm_context.c_due_time = -1;
820 due_time = _alarm_next_duetime(__alarm_info);
821 if (__alarm_add_to_list(__alarm_info) == false) {
827 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: due_time is 0, alarm(%d).", *alarm_id);
829 } else if (current_time == due_time) {
830 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: current_time(%d) is same as due_time(%d).",
831 current_time, due_time);
833 } else if (difftime(due_time, current_time) < 0) {
834 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: Expired Due Time.[Due time=%d, Current Time=%d]!!!Do not add to schedule list.",
835 due_time, current_time);
838 char due_time_r[100] = { 0 };
840 localtime_r(&due_time, &ts_ret);
841 strftime(due_time_r, 30, "%c", &ts_ret);
842 SECURE_LOGD("[alarm-server]:Create a new alarm: alarm(%d) due_time(%s)", *alarm_id, due_time_r);
845 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
847 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
848 _clear_scheduled_alarm_list();
849 _add_to_scheduled_alarm_list(__alarm_info);
850 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
851 alarm_context.c_due_time = due_time;
852 } else if (due_time == alarm_context.c_due_time) {
853 _add_to_scheduled_alarm_list(__alarm_info);
861 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
862 alarm_info_t *alarm_info, int *error_code)
867 __alarm_info_t *__alarm_info = NULL;
870 __alarm_info = malloc(sizeof(__alarm_info_t));
871 if (__alarm_info == NULL) {
872 SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
873 *error_code = ERR_ALARM_SYSTEM_FAIL;
877 __alarm_info->pid = pid;
878 __alarm_info->alarm_id = alarm_id;
880 /* we should consider to check whether pid is running or Not
883 __alarm_info->quark_app_service_name =
884 g_quark_from_string(app_service_name);
885 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
886 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
890 if (alarm_context.c_due_time < current_time) {
891 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
892 "(%d) is less than current time(%d)", alarm_context.c_due_time, current_time);
893 alarm_context.c_due_time = -1;
896 due_time = _alarm_next_duetime(__alarm_info);
897 if (!__alarm_update_in_list(pid, alarm_id, __alarm_info, error_code)) {
899 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
900 "(%d) does not exist. so this value is invalid id.", alarm_id);
904 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
906 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
907 /*there is no scheduled alarm */
908 _alarm_disable_timer(alarm_context);
911 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d).", alarm_id);
916 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: due_time is 0.");
923 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
924 "due_time is 0, alarm(%d)\n", alarm_id);
927 } else if (current_time == due_time) {
928 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
929 "current_time(%d) is same as due_time(%d)", current_time,
933 } else if (difftime(due_time, current_time)< 0) {
934 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);
938 char due_time_r[100] = { 0 };
940 localtime_r(&due_time, &ts_ret);
941 strftime(due_time_r, 30, "%c", &ts_ret);
942 SECURE_LOGD("[alarm-server]:Update alarm: alarm(%d) "
943 "due_time(%s)\n", alarm_id, due_time_r);
946 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:alarm_context.c_due_time(%d), due_time(%d)", alarm_context.c_due_time, due_time);
948 if (alarm_context.c_due_time == -1 || due_time < alarm_context.c_due_time) {
949 _clear_scheduled_alarm_list();
950 _add_to_scheduled_alarm_list(__alarm_info);
951 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time);
952 alarm_context.c_due_time = due_time;
953 ALARM_MGR_LOG_PRINT("[alarm-server1]:alarm_context.c_due_time "
954 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
955 } else if (due_time == alarm_context.c_due_time) {
956 _add_to_scheduled_alarm_list(__alarm_info);
957 ALARM_MGR_LOG_PRINT("[alarm-server2]:alarm_context.c_due_time "
958 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
968 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code)
972 SECURE_LOGD("[alarm-server]:delete alarm: alarm(%d) pid(%d)\n", alarm_id, pid);
973 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
975 if (!__alarm_remove_from_list(pid, alarm_id, error_code)) {
977 SECURE_LOGE("[alarm-server]:delete alarm: "
978 "alarm(%d) pid(%d) has failed with error_code(%d)\n",
979 alarm_id, pid, *error_code);
983 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
984 _alarm_disable_timer(alarm_context);
993 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id)
995 char service_name[MAX_SERVICE_NAME_LEN] = {0,};
997 if (app_service_name == NULL || strlen(app_service_name) == 0) {
998 ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
1002 memcpy(service_name, app_service_name, strlen(app_service_name));
1003 SECURE_LOGI("[alarm server][send expired_alarm(alarm_id=%d) to app_service_name(%s)]", alarm_id, service_name);
1005 g_dbus_connection_call(alarm_context.connection,
1007 "/com/samsung/alarm/client",
1008 "com.samsung.alarm.client",
1010 g_variant_new("(is)", alarm_id, service_name),
1012 G_DBUS_CALL_FLAGS_NONE,
1019 static void __alarm_expired()
1021 const char *destination_app_service_name = NULL;
1022 alarm_id_t alarm_id = -1;
1024 __alarm_info_t *__alarm_info = NULL;
1025 char alarm_id_val[32]={0,};
1029 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1030 GError *error = NULL;
1031 GVariant *result = NULL;
1032 gboolean name_has_owner_reply = false;
1034 ALARM_MGR_LOG_PRINT("[alarm-server]: Enter");
1036 time_t current_time;
1039 time(¤t_time);
1041 interval = difftime(alarm_context.c_due_time, current_time);
1042 ALARM_MGR_LOG_PRINT("[alarm-server]: c_due_time(%d), current_time(%d), interval(%d)",
1043 alarm_context.c_due_time, current_time, interval);
1045 if (alarm_context.c_due_time > current_time + 1) {
1046 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds future",
1047 alarm_context.c_due_time - current_time);
1050 // 10 seconds is maximum permitted delay from timer expire to this function
1051 if (alarm_context.c_due_time + 10 < current_time) {
1052 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: False Alarm. due time is (%d) seconds past\n",
1053 current_time - alarm_context.c_due_time);
1057 GSList *iter = NULL;
1058 __scheduled_alarm_t *alarm = NULL;
1060 for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
1062 alarm_id = alarm->alarm_id;
1064 __alarm_info = alarm->__alarm_info;
1066 app_pid = __alarm_info->pid;
1068 if (strncmp(g_quark_to_string(__alarm_info->quark_bundle), "null", 4) != 0) {
1069 b_len = strlen(g_quark_to_string(__alarm_info->quark_bundle));
1071 b = bundle_decode((bundle_raw *)g_quark_to_string(__alarm_info->quark_bundle), b_len);
1075 ALARM_MGR_EXCEPTION_PRINT("Error!!!..Unable to decode the bundle!!\n");
1079 snprintf(alarm_id_val,31,"%d",alarm_id);
1081 if (bundle_add_str(b,"http://tizen.org/appcontrol/data/alarm_id", alarm_id_val)){
1082 ALARM_MGR_EXCEPTION_PRINT("Unable to add alarm id to the bundle\n");
1086 appid = (char *)appsvc_get_appid(b);
1087 if( (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid))
1089 ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
1093 if ( appsvc_run_service(b, 0, NULL, NULL) < 0)
1095 ALARM_MGR_EXCEPTION_PRINT("Unable to run app svc\n");
1099 ALARM_MGR_LOG_PRINT("Successfuly ran app svc\n");
1109 if (strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null", 4) == 0) {
1110 SECURE_LOGD("[alarm-server]:destination is null, so we send expired alarm to %s(%u).",
1111 g_quark_to_string(__alarm_info->quark_app_service_name), __alarm_info->quark_app_service_name);
1112 destination_app_service_name = g_quark_to_string(__alarm_info->quark_app_service_name_mod);
1114 SECURE_LOGD("[alarm-server]:destination :%s(%u)",
1115 g_quark_to_string(__alarm_info->quark_dst_service_name), __alarm_info->quark_dst_service_name);
1116 destination_app_service_name = g_quark_to_string(__alarm_info->quark_dst_service_name_mod);
1120 * we should consider a situation that
1121 * destination_app_service_name is owner_name like (:xxxx) and
1122 * application's pid which registered this alarm was killed.In that case,
1123 * we don't need to send the expire event because the process was killed.
1124 * this causes needless message to be sent.
1126 SECURE_LOGD("[alarm-server]: destination_app_service_name :%s, app_pid=%d", destination_app_service_name, app_pid);
1128 result = g_dbus_connection_call_sync(alarm_context.connection,
1129 "org.freedesktop.DBus",
1130 "/org/freedesktop/DBus",
1131 "org.freedesktop.DBus",
1133 g_variant_new ("(s)", destination_app_service_name),
1134 G_VARIANT_TYPE ("(b)"),
1135 G_DBUS_CALL_FLAGS_NONE,
1139 if (result == NULL) {
1140 ALARM_MGR_EXCEPTION_PRINT("g_dbus_connection_call_sync() is failed. err: %s", error->message);
1141 g_error_free(error);
1143 g_variant_get (result, "(b)", &name_has_owner_reply);
1146 if (name_has_owner_reply == false) {
1147 __expired_alarm_t *expire_info;
1148 char appid[MAX_SERVICE_NAME_LEN] = { 0, };
1149 char alarm_id_str[32] = { 0, };
1151 if (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_WITHCB) {
1152 __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1156 expire_info = malloc(sizeof(__expired_alarm_t));
1157 if (G_UNLIKELY(NULL == expire_info)) {
1158 ALARM_MGR_ASSERT_PRINT("[alarm-server]:Malloc failed!Can't notify alarm expiry info\n");
1161 memset(expire_info, '\0', sizeof(__expired_alarm_t));
1162 strncpy(expire_info->service_name, destination_app_service_name, MAX_SERVICE_NAME_LEN-1);
1163 expire_info->alarm_id = alarm_id;
1164 g_expired_alarm_list = g_slist_append(g_expired_alarm_list, expire_info);
1166 if (strncmp(g_quark_to_string(__alarm_info->quark_dst_service_name), "null",4) == 0) {
1167 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);
1170 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);
1173 snprintf(alarm_id_str, 31, "%d", alarm_id);
1175 SECURE_LOGD("before aul_launch appid(%s) alarm_id_str(%s)", appid, alarm_id_str);
1178 kb = bundle_create();
1179 bundle_add_str(kb, "__ALARM_MGR_ID", alarm_id_str);
1180 aul_launch_app(appid, kb);
1183 ALARM_MGR_LOG_PRINT("before alarm_send_noti_to_application");
1184 ALARM_MGR_LOG_PRINT("WAKEUP pid: %d", __alarm_info->pid);
1186 aul_update_freezer_status(__alarm_info->pid, "wakeup");
1187 __alarm_send_noti_to_application(destination_app_service_name, alarm_id);
1188 ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application");
1192 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is expired.", alarm_id);
1194 sprintf(log_message, "alarmID: %d, pid: %d, unique_name: %s, duetime: %d",
1195 alarm_id, app_pid, g_quark_to_string(__alarm_info->quark_app_unique_name), __alarm_info->due_time);
1196 __save_module_log("EXPIRED", log_message);
1197 memset(log_message, '\0', sizeof(log_message));
1199 if (__alarm_info->alarm_info.mode.repeat == ALARM_REPEAT_MODE_ONCE) {
1200 __alarm_remove_from_list(__alarm_info->pid, alarm_id, NULL);
1202 _alarm_next_duetime(__alarm_info);
1207 _clear_scheduled_alarm_list();
1208 alarm_context.c_due_time = -1;
1210 ALARM_MGR_LOG_PRINT("[alarm-server]: Leave");
1213 static gboolean __alarm_handler_idle(gpointer user_data)
1215 GPollFD *gpollfd = (GPollFD *) user_data;
1217 if (gpollfd == NULL) {
1218 ALARM_MGR_EXCEPTION_PRINT("gpollfd is NULL");
1221 if (read(gpollfd->fd, &exp, sizeof(uint64_t)) < 0) {
1222 ALARM_MGR_EXCEPTION_PRINT("Reading the fd is failed.");
1226 ALARM_MGR_EXCEPTION_PRINT("Lock the display not to enter LCD OFF");
1227 if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS) {
1228 ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
1231 if (g_dummy_timer_is_set == true) {
1232 ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
1235 ALARM_MGR_LOG_PRINT("__alarm_handler_idle");
1243 ALARM_MGR_EXCEPTION_PRINT("Unlock the display from LCD OFF");
1244 if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS) {
1245 ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
1251 static void __clean_registry()
1254 /*TODO:remove all db entries */
1257 static bool __alarm_manager_reset()
1259 _alarm_disable_timer(alarm_context);
1261 __alarm_clean_list();
1263 _clear_scheduled_alarm_list();
1269 static void __on_system_time_external_changed(keynode_t *node, void *data)
1271 double diff_time = 0.0;
1272 time_t cur_time = 0;
1274 _alarm_disable_timer(alarm_context);
1277 diff_time = vconf_keynode_get_dbl(node);
1279 if (vconf_get_dbl(VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, &diff_time) != VCONF_OK) {
1280 ALARM_MGR_EXCEPTION_PRINT("Failed to get value of VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL.");
1288 ALARM_MGR_EXCEPTION_PRINT("diff_time is %f, New time is %s\n", diff_time, ctime(&cur_time));
1290 ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed externally\n");
1291 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n",
1292 alarm_context.c_due_time);
1294 // set rtc time only because the linux time is set externally
1295 _set_rtc_time(cur_time);
1297 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1299 __alarm_update_due_time_of_all_items_in_list(diff_time);
1301 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n",
1302 alarm_context.c_due_time);
1303 _clear_scheduled_alarm_list();
1310 static void __on_time_zone_changed(keynode_t *node, void *data)
1312 double diff_time = 0;
1314 _alarm_disable_timer(alarm_context);
1318 ALARM_MGR_LOG_PRINT("[alarm-server] time zone has been changed\n");
1319 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1321 __alarm_update_due_time_of_all_items_in_list(diff_time);
1323 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1324 _clear_scheduled_alarm_list();
1331 static int __on_app_uninstalled(int req_id, const char *pkg_type,
1332 const char *pkgid, const char *key, const char *val,
1333 const void *pmsg, void *user_data)
1335 GSList* gs_iter = NULL;
1336 __alarm_info_t* entry = NULL;
1337 alarm_info_t* alarm_info = NULL;
1338 bool is_deleted = false;
1340 SECURE_LOGD("pkg_type(%s), pkgid(%s), key(%s), value(%s)", pkg_type, pkgid, key, val);
1342 if (strncmp(key, "end", 3) == 0 && strncmp(val, "ok", 2) == 0)
1344 for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
1346 bool is_found = false;
1347 entry = gs_iter->data;
1349 char* caller_pkgid = g_quark_to_string(entry->quark_caller_pkgid);
1350 char* callee_pkgid = g_quark_to_string(entry->quark_callee_pkgid);
1352 if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
1353 (callee_pkgid && strncmp(pkgid, callee_pkgid, strlen(pkgid)) == 0))
1355 if (_remove_from_scheduled_alarm_list(pkgid, entry->alarm_id))
1360 alarm_info = &entry->alarm_info;
1361 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
1363 if(!_delete_alarms(entry->alarm_id))
1365 SECURE_LOGE("_delete_alarms() is failed. pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1371 gs_iter = g_slist_next(gs_iter);
1375 SECURE_LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
1376 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1381 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
1383 _alarm_disable_timer(alarm_context);
1390 return ALARMMGR_RESULT_SUCCESS;
1393 int __check_privilege_by_cookie(char *e_cookie, const char *label, const char *access, bool check_root, int pid) {
1394 guchar *cookie = NULL;
1397 char buf[128] = {0,};
1399 char title[128] = {0,};
1403 // Gets the userID from /proc/pid/status to check if the process is the root or not.
1404 snprintf(buf, sizeof(buf), "/proc/%d/status", pid);
1405 fp = fopen(buf, "r");
1407 while (fgets(buf, sizeof(buf), fp) != NULL) {
1408 if(strncmp(buf, "Uid:", 4) == 0) {
1409 sscanf(buf, "%s %d", title, &uid);
1416 ALARM_MGR_LOG_PRINT("uid : %d", uid);
1419 if (uid != 0) { // Checks the cookie only when the process is not the root
1420 cookie = g_base64_decode(e_cookie, &size);
1421 if (cookie == NULL) {
1422 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!");
1423 return ERR_ALARM_SYSTEM_FAIL;
1426 retval = security_server_check_privilege_by_cookie((const char *)cookie, label, access);
1430 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1431 ALARM_MGR_EXCEPTION_PRINT("Access to alarm-server has been denied by smack.");
1433 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege_by_cookie() : %d.", retval);
1434 return ERR_ALARM_NO_PERMISSION;
1438 ALARM_MGR_LOG_PRINT("The process(%d) was authenticated successfully.", pid);
1439 return ALARMMGR_RESULT_SUCCESS;
1442 bool __get_caller_unique_name(int pid, char *unique_name)
1444 char caller_appid[256] = {0,};
1446 if (unique_name == NULL)
1448 ALARM_MGR_EXCEPTION_PRINT("unique_name should not be NULL.");
1452 if (aul_app_get_appid_bypid(pid, caller_appid, sizeof(caller_appid)) == AUL_R_OK)
1454 // When a caller is an application, the unique name is appID.
1455 strncpy(unique_name, caller_appid, strlen(caller_appid));
1459 // Otherwise, the unique name is /proc/pid/cmdline.
1460 char proc_file[512] = {0,};
1461 char process_name[512] = {0,};
1465 snprintf(proc_file, 512, "/proc/%d/cmdline", pid);
1467 fd = open(proc_file, O_RDONLY);
1469 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);
1473 if (read(fd, process_name, 512) <= 0)
1475 ALARM_MGR_EXCEPTION_PRINT("Unable to get the process name.");
1481 while (process_name[i] != '\0') {
1482 if (process_name[i] == ' ') {
1483 process_name[i] = '\0';
1488 strncpy(unique_name, process_name, strlen(process_name));
1492 SECURE_LOGD("unique_name= %s", unique_name);
1496 static void __initialize_module_log(void)
1498 log_fd = open(ALARMMGR_LOG_FILE_PATH, O_CREAT | O_WRONLY, 0644);
1500 ALARM_MGR_EXCEPTION_PRINT("Opening the file for alarmmgr log is failed.");
1504 int offset = lseek(log_fd, 0, SEEK_END);
1506 log_index = (int)(offset / ALARMMGR_LOG_BUFFER_STRING_SIZE);
1507 if (log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1509 lseek(log_fd, 0, SEEK_SET);
1515 static bool __save_module_log(const char *tag, const char *message)
1517 char buffer[ALARMMGR_LOG_BUFFER_STRING_SIZE] = {0,};
1522 ALARM_MGR_EXCEPTION_PRINT("The file is not ready.");
1526 if (log_index != 0) {
1527 offset = lseek(log_fd, 0, SEEK_CUR);
1529 offset = lseek(log_fd, 0, SEEK_SET);
1533 snprintf(buffer, ALARMMGR_LOG_BUFFER_STRING_SIZE, "[%-6d] %-20s %-120s %d-%s", log_index, tag, message, (int)now, ctime(&now));
1535 int ret = write(log_fd, buffer, strlen(buffer));
1537 ALARM_MGR_EXCEPTION_PRINT("Writing the alarmmgr log is failed.");
1541 if (++log_index >= ALARMMGR_LOG_BUFFER_SIZE) {
1547 int __display_lock_state(char *state, char *flag, unsigned int timeout)
1549 GDBusMessage *msg = NULL;
1550 GDBusMessage *reply = NULL;
1551 GVariant *body = NULL;
1552 GError *error = NULL;
1553 int ret = ALARMMGR_RESULT_SUCCESS;
1556 msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1558 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
1559 return ERR_ALARM_SYSTEM_FAIL;
1562 g_dbus_message_set_body(msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
1564 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);
1566 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1567 g_error_free(error);
1568 ret = ERR_ALARM_SYSTEM_FAIL;
1570 body = g_dbus_message_get_body(reply);
1572 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1573 ret = ERR_ALARM_SYSTEM_FAIL;
1575 g_variant_get(body, "(i)", &val);
1577 ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
1578 ret = ERR_ALARM_SYSTEM_FAIL;
1580 ALARM_MGR_EXCEPTION_PRINT("Lock LCD OFF is successfully done");
1585 g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1586 g_object_unref(msg);
1587 g_object_unref(reply);
1592 int __display_unlock_state(char *state, char *flag)
1594 GDBusMessage *msg = NULL;
1595 GDBusMessage *reply = NULL;
1596 GVariant *body = NULL;
1597 GError *error = NULL;
1598 int ret = ALARMMGR_RESULT_SUCCESS;
1601 msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1603 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
1604 return ERR_ALARM_SYSTEM_FAIL;
1607 g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag ));
1609 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);
1611 ALARM_MGR_EXCEPTION_PRINT("No reply. error = %s", error->message);
1612 g_error_free(error);
1613 ret = ERR_ALARM_SYSTEM_FAIL;
1615 body = g_dbus_message_get_body(reply);
1617 ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
1618 ret = ERR_ALARM_SYSTEM_FAIL;
1620 g_variant_get(body, "(i)", &val);
1622 ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
1623 ret = ERR_ALARM_SYSTEM_FAIL;
1625 ALARM_MGR_EXCEPTION_PRINT("Unlock LCD OFF is successfully done");
1630 g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
1631 g_object_unref(msg);
1632 g_object_unref(reply);
1637 gboolean alarm_manager_alarm_set_rtc_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
1638 int year, int mon, int day,
1639 int hour, int min, int sec, char *e_cookie,
1640 gpointer user_data) {
1641 const char *rtc = default_rtc;
1642 struct timespec alarm_time;
1644 int return_code = ALARMMGR_RESULT_SUCCESS;
1646 struct rtc_time rtc_tm = {0,};
1647 struct rtc_wkalrm rtc_wk;
1648 struct tm *alarm_tm = NULL;
1650 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1651 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1653 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1654 if (retval != ALARMMGR_RESULT_SUCCESS) {
1655 return_code = retval;
1656 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1660 /*extract day of the week, day in the year & daylight saving time from system*/
1661 time_t current_time;
1662 current_time = time(NULL);
1663 alarm_tm = localtime(¤t_time);
1665 alarm_tm->tm_year = year;
1666 alarm_tm->tm_mon = mon;
1667 alarm_tm->tm_mday = day;
1668 alarm_tm->tm_hour = hour;
1669 alarm_tm->tm_min = min;
1670 alarm_tm->tm_sec = sec;
1672 /*convert to calendar time representation*/
1673 time_t rtc_time = mktime(alarm_tm);
1676 gfd = open(rtc, O_RDWR);
1678 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
1679 return_code = ERR_ALARM_SYSTEM_FAIL;
1680 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1685 alarm_time.tv_sec = rtc_time;
1686 alarm_time.tv_nsec = 0;
1688 retval = ioctl(gfd, ALARM_SET(ALARM_RTC_WAKEUP), &alarm_time);
1690 if (errno == ENOTTY) {
1691 ALARM_MGR_EXCEPTION_PRINT("Alarm IRQs is not supported.");
1693 ALARM_MGR_EXCEPTION_PRINT("RTC ALARM_SET ioctl is failed. errno = %s", strerror(errno));
1694 return_code = ERR_ALARM_SYSTEM_FAIL;
1695 strncpy(log_tag, "FAIL: SET RTC", strlen("FAIL: SET RTC"));
1698 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
1699 strncpy(log_tag, "SET RTC", strlen("SET RTC"));
1702 sprintf(log_message, "wakeup rtc time: %d, %s", rtc_time, ctime(&rtc_time));
1703 __save_module_log(log_tag, log_message);
1705 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1709 gboolean alarm_manager_alarm_set_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int _time, gpointer user_data)
1711 static int diff_msec = 0; // To check a millisecond part of current time at changing the system time
1712 double diff_time = 0.0;
1713 struct timeval before;
1714 int return_code = ALARMMGR_RESULT_SUCCESS;
1715 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1717 _alarm_disable_timer(alarm_context);
1719 gettimeofday(&before, NULL);
1720 diff_msec += (before.tv_usec / 1000); // Accrue the millisecond to compensate the time
1721 ALARM_MGR_LOG_PRINT("Current time = %s. usec = %ld. diff_msec = %d.\n", ctime(&before.tv_sec), before.tv_usec, diff_msec);
1723 if (diff_msec > 500) {
1724 diff_time = difftime(_time, before.tv_sec) - 1;
1728 diff_time = difftime(_time, before.tv_sec);
1733 char *timebuf = ctime(&_time);
1734 timebuf[strlen(timebuf) - 1] = '\0'; // to avoid newline
1735 sprintf(log_message, "Current: %d, New: %d, %s, diff: %f", before.tv_sec, _time, timebuf, diff_time);
1736 __save_module_log("CHANGE TIME", log_message);
1738 ALARM_MGR_EXCEPTION_PRINT("[TIMESTAMP]Current time(%d), New time(%d)(%s), diff_time(%f)", before.tv_sec, _time, ctime(&_time), diff_time);
1740 ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed\n");
1741 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1743 _set_time(_time - 1);
1744 __alarm_update_due_time_of_all_items_in_list(diff_time);
1746 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d", alarm_context.c_due_time);
1747 _clear_scheduled_alarm_list();
1752 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1754 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1758 gboolean alarm_manager_alarm_create_appsvc(AlarmManager *pObject, GDBusMethodInvocation *invoc,
1761 int start_month, int start_day,
1762 int start_hour, int start_min,
1763 int start_sec, int end_year, int end_month,
1764 int end_day, int mode_day_of_week,
1765 int mode_repeat, int alarm_type,
1767 char *bundle_data, char *e_cookie,
1770 alarm_info_t alarm_info;
1772 int return_code = ALARMMGR_RESULT_SUCCESS;
1774 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1775 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1778 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", false, pid);
1779 if (retval != ALARMMGR_RESULT_SUCCESS) {
1780 return_code = retval;
1781 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1782 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1783 __save_module_log("FAIL: CREATE", log_message);
1787 alarm_info.start.year = start_year;
1788 alarm_info.start.month = start_month;
1789 alarm_info.start.day = start_day;
1790 alarm_info.start.hour = start_hour;
1791 alarm_info.start.min = start_min;
1792 alarm_info.start.sec = start_sec;
1794 alarm_info.end.year = end_year;
1795 alarm_info.end.month = end_month;
1796 alarm_info.end.day = end_day;
1798 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1799 alarm_info.mode.repeat = mode_repeat;
1801 alarm_info.alarm_type = alarm_type;
1802 alarm_info.reserved_info = reserved_info;
1804 if (!__alarm_create_appsvc(&alarm_info, &alarm_id, pid, bundle_data, &return_code)) {
1805 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
1806 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
1809 strncpy(log_tag, "CREATE", strlen("CREATE"));
1813 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1815 sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
1816 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
1817 __save_module_log(log_tag, log_message);
1822 gboolean alarm_manager_alarm_create(AlarmManager *obj, GDBusMethodInvocation *invoc, int pid,
1823 char *app_service_name, char *app_service_name_mod, int start_year,
1824 int start_month, int start_day,
1825 int start_hour, int start_min,
1826 int start_sec, int end_year, int end_month,
1827 int end_day, int mode_day_of_week,
1828 int mode_repeat, int alarm_type,
1830 char *reserved_service_name, char *reserved_service_name_mod, char *e_cookie,
1833 alarm_info_t alarm_info;
1835 int return_code = ALARMMGR_RESULT_SUCCESS;
1837 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1838 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1841 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1842 if (retval != ALARMMGR_RESULT_SUCCESS) {
1843 return_code = retval;
1844 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1845 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1846 __save_module_log("FAIL: CREATE", log_message);
1850 alarm_info.start.year = start_year;
1851 alarm_info.start.month = start_month;
1852 alarm_info.start.day = start_day;
1853 alarm_info.start.hour = start_hour;
1854 alarm_info.start.min = start_min;
1855 alarm_info.start.sec = start_sec;
1857 alarm_info.end.year = end_year;
1858 alarm_info.end.month = end_month;
1859 alarm_info.end.day = end_day;
1861 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1862 alarm_info.mode.repeat = mode_repeat;
1864 alarm_info.alarm_type = alarm_type;
1865 alarm_info.reserved_info = reserved_info;
1867 if (!__alarm_create(&alarm_info, &alarm_id, pid, app_service_name,app_service_name_mod,
1868 reserved_service_name, reserved_service_name_mod, &return_code)) {
1869 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
1870 strncpy(log_tag, "FAIL: CREATE", strlen("FAIL: CREATE"));
1873 strncpy(log_tag, "CREATE", strlen("CREATE"));
1877 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
1879 sprintf(log_message, "alarmID: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
1880 alarm_id, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
1881 __save_module_log(log_tag, log_message);
1886 gboolean alarm_manager_alarm_delete(AlarmManager *obj, GDBusMethodInvocation *invoc,
1887 int pid, alarm_id_t alarm_id,
1888 char *e_cookie, gpointer user_data)
1891 int return_code = ALARMMGR_RESULT_SUCCESS;
1892 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
1893 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1896 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1897 if (retval != ALARMMGR_RESULT_SUCCESS) {
1898 return_code = retval;
1899 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1900 sprintf(log_message, "alarmID: %d, pid: %d, Smack denied (alarm-server::alarm, w)", alarm_id, pid);
1901 __save_module_log("FAIL: DELETE", log_message);
1905 if (!__alarm_delete(pid, alarm_id, &return_code)) {
1906 ALARM_MGR_EXCEPTION_PRINT("Unable to delete the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
1907 strncpy(log_tag, "FAIL: DELETE", strlen("FAIL: DELETE"));
1910 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", alarm_id);
1911 strncpy(log_tag, "DELETE", strlen("DELETE"));
1915 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1917 sprintf(log_message, "alarmID: %d, pid: %d", alarm_id, pid);
1918 __save_module_log(log_tag, log_message);
1923 gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation *invoc,
1924 int pid, char *e_cookie, gpointer user_data)
1926 GSList* gs_iter = NULL;
1927 char app_name[512] = { 0 };
1928 alarm_info_t* alarm_info = NULL;
1929 __alarm_info_t* entry = NULL;
1930 bool is_deleted = false;
1932 int return_code = ALARMMGR_RESULT_SUCCESS;
1933 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
1935 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "w", true, pid);
1936 if (retval != ALARMMGR_RESULT_SUCCESS) {
1937 return_code = retval;
1938 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1939 sprintf(log_message, "pid: %d, Smack denied (alarm-server::alarm, w)", pid);
1940 __save_module_log("FAIL: DELETE ALL", log_message);
1944 if (!__get_caller_unique_name(pid, app_name)) {
1945 return_code = ERR_ALARM_SYSTEM_FAIL;
1946 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
1947 sprintf(log_message, "pid: %d. Can not get the unique_name.", pid);
1948 __save_module_log("FAIL: DELETE ALL", log_message);
1952 SECURE_LOGD("Called by process (pid:%d, unique_name=%s)", pid, app_name);
1954 for (gs_iter = alarm_context.alarms; gs_iter != NULL; )
1956 bool is_found = false;
1957 entry = gs_iter->data;
1958 char* tmp_appname = g_quark_to_string(entry->quark_app_unique_name);
1959 SECURE_LOGD("Try to remove app_name[%s], alarm_id[%d]\n", tmp_appname, entry->alarm_id);
1960 if (tmp_appname && strncmp(app_name, tmp_appname, strlen(tmp_appname)) == 0)
1962 if (_remove_from_scheduled_alarm_list(pid, entry->alarm_id))
1967 alarm_info = &entry->alarm_info;
1968 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE))
1970 if(!_delete_alarms(entry->alarm_id))
1972 SECURE_LOGE("_delete_alarms() is failed. pid[%d], alarm_id[%d]", pid, entry->alarm_id);
1978 gs_iter = g_slist_next(gs_iter);
1982 ALARM_MGR_EXCEPTION_PRINT("alarm_id[%d] is removed.", entry->alarm_id);
1983 SECURE_LOGD("Removing is done. app_name[%s], alarm_id [%d]\n", tmp_appname, entry->alarm_id);
1984 alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
1989 if (is_deleted && (g_slist_length(g_scheduled_alarm_list) == 0))
1991 _alarm_disable_timer(alarm_context);
1996 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2000 gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc, int pid,
2001 char *app_service_name, alarm_id_t alarm_id,
2002 int start_year, int start_month,
2003 int start_day, int start_hour,
2004 int start_min, int start_sec, int end_year,
2005 int end_month, int end_day,
2006 int mode_day_of_week, int mode_repeat,
2007 int alarm_type, int reserved_info,
2010 int return_code = ALARMMGR_RESULT_SUCCESS;
2011 alarm_info_t alarm_info;
2013 char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
2014 char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
2016 alarm_info.start.year = start_year;
2017 alarm_info.start.month = start_month;
2018 alarm_info.start.day = start_day;
2019 alarm_info.start.hour = start_hour;
2020 alarm_info.start.min = start_min;
2021 alarm_info.start.sec = start_sec;
2023 alarm_info.end.year = end_year;
2024 alarm_info.end.month = end_month;
2025 alarm_info.end.day = end_day;
2027 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2028 alarm_info.mode.repeat = mode_repeat;
2030 alarm_info.alarm_type = alarm_type;
2031 alarm_info.reserved_info = reserved_info;
2033 if (!__alarm_update(pid, app_service_name, alarm_id, &alarm_info, &return_code)) {
2034 ALARM_MGR_EXCEPTION_PRINT("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
2035 strncpy(log_tag, "FAIL: UPDATE", strlen("FAIL: UPDATE"));
2038 strncpy(log_tag, "UPDATE", strlen("UPDATE"));
2042 g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
2044 sprintf(log_message, "alarmID: %d, appname: %s, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
2045 alarm_id, app_service_name, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
2046 __save_module_log(log_tag, log_message);
2051 gboolean alarm_manager_alarm_get_number_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie,
2054 GSList *gs_iter = NULL;
2055 char app_name[256] = { 0 };
2056 __alarm_info_t *entry = NULL;
2059 int return_code = ALARMMGR_RESULT_SUCCESS;
2061 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2062 if (retval != ALARMMGR_RESULT_SUCCESS) {
2063 return_code = retval;
2064 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2068 if (!__get_caller_unique_name(pid, app_name)) {
2069 return_code = ERR_ALARM_SYSTEM_FAIL;
2070 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2074 SECURE_LOGD("Called by process (pid:%d, unique_name:%s)", pid, app_name);
2076 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2077 entry = gs_iter->data;
2078 SECURE_LOGD("app_name=%s, quark_app_unique_name=%s", app_name, g_quark_to_string(entry->quark_app_unique_name));
2079 if (strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
2081 SECURE_LOGD("inc number of alarms of app (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2085 SECURE_LOGD("number of alarms of the process (pid:%d, unique_name:%s) is %d.", pid, app_name, num_of_ids);
2086 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
2090 gboolean alarm_manager_alarm_get_list_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2091 int max_number_of_ids, gpointer user_data)
2093 GSList *gs_iter = NULL;
2094 char app_name[512] = { 0 };
2095 __alarm_info_t *entry = NULL;
2097 GVariant* arr = NULL;
2098 GVariantBuilder* builder = NULL;
2100 int return_code = ALARMMGR_RESULT_SUCCESS;
2102 if (max_number_of_ids <= 0) {
2103 SECURE_LOGE("called for pid(%d), but max_number_of_ids(%d) is less than 0.", pid, max_number_of_ids);
2104 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2108 if (!__get_caller_unique_name(pid, app_name)) {
2109 return_code = ERR_ALARM_SYSTEM_FAIL;
2110 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
2114 SECURE_LOGD("Called by process (pid:%d, unique_name=%s).", pid, app_name);
2116 builder = g_variant_builder_new(G_VARIANT_TYPE ("ai"));
2117 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2118 entry = gs_iter->data;
2119 if (strncmp(app_name, g_quark_to_string(entry->quark_app_unique_name), strlen(app_name)) == 0) {
2120 g_variant_builder_add (builder, "i", entry->alarm_id);
2122 SECURE_LOGE("called for alarmid(%d), but max_number_of_ids(%d) index %d.", entry->alarm_id, max_number_of_ids, index);
2126 arr = g_variant_new("ai", builder);
2129 SECURE_LOGE("Called by pid (%d), but max_number_of_ids(%d) return code %d.", pid, num_of_ids, return_code);
2130 g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_ids, return_code));
2132 g_variant_builder_unref(builder);
2136 gboolean alarm_manager_alarm_get_appsvc_info(AlarmManager *pObject, GDBusMethodInvocation *invoc ,
2137 int pid, alarm_id_t alarm_id,
2138 char *e_cookie, gpointer user_data)
2141 GSList *gs_iter = NULL;
2142 __alarm_info_t *entry = NULL;
2144 int return_code = ALARMMGR_RESULT_SUCCESS;
2145 gchar *b_data = NULL;
2147 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2149 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", false, pid);
2150 if (retval != ALARMMGR_RESULT_SUCCESS) {
2151 return_code = retval;
2152 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2156 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2157 entry = gs_iter->data;
2158 if (entry->alarm_id == alarm_id) {
2160 b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
2166 if (b_data && strlen(b_data) == 4 && strncmp(b_data, "null", 4) == 0) {
2167 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
2168 return_code = ERR_ALARM_INVALID_TYPE;
2171 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2172 return_code = ERR_ALARM_INVALID_ID;
2175 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
2180 gboolean alarm_manager_alarm_get_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2181 alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2183 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2185 GSList *gs_iter = NULL;
2186 __alarm_info_t *entry = NULL;
2187 alarm_info_t *alarm_info = NULL;
2189 int return_code = ALARMMGR_RESULT_SUCCESS;
2191 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2192 if (retval != ALARMMGR_RESULT_SUCCESS) {
2193 return_code = retval;
2194 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));
2198 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2199 entry = gs_iter->data;
2200 if (entry->alarm_id == alarm_id) {
2201 alarm_info = &(entry->alarm_info);
2206 if (alarm_info == NULL) {
2207 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2208 return_code = ERR_ALARM_INVALID_ID;
2209 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));
2211 ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
2212 g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", alarm_info->start.year, alarm_info->start.month,
2213 alarm_info->start.day, alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec, alarm_info->end.year, alarm_info->end.month,
2214 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));
2220 gboolean alarm_manager_alarm_get_next_duetime(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid,
2221 alarm_id_t alarm_id, char *e_cookie, gpointer user_data)
2223 SECURE_LOGD("called for pid(%d) and alarm_id(%d)\n", pid, alarm_id);
2225 GSList *gs_iter = NULL;
2226 __alarm_info_t *entry = NULL;
2227 __alarm_info_t *find_item = NULL;
2229 int return_code = ALARMMGR_RESULT_SUCCESS;
2232 retval = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2233 if (retval != ALARMMGR_RESULT_SUCCESS) {
2234 return_code = retval;
2235 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2239 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2240 entry = gs_iter->data;
2241 if (entry->alarm_id == alarm_id) {
2247 if (find_item == NULL) {
2248 ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
2249 return_code = ERR_ALARM_INVALID_ID;
2250 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2254 duetime = _alarm_next_duetime(find_item);
2255 ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&duetime));
2257 g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
2261 gboolean alarm_manager_alarm_get_all_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, int pid, char *e_cookie, gpointer user_data)
2263 sqlite3 *alarmmgr_tool_db;
2264 char *db_path = NULL;
2265 char db_path_tmp[50] = {0,};
2266 time_t current_time = 0;
2267 struct tm current_tm;
2268 const char *query_for_creating_table = "create table alarmmgr_tool \
2269 (alarm_id integer primary key,\
2270 duetime_epoch integer,\
2272 start_epoch integer,\
2277 app_unique_name text,\
2278 app_service_name text,\
2279 dst_service_name text,\
2280 day_of_week integer,\
2282 alarm_type integer)";
2283 const char *query_for_deleting_table = "drop table alarmmgr_tool";
2284 int return_code = ALARMMGR_RESULT_SUCCESS;
2285 GSList *gs_iter = NULL;
2286 __alarm_info_t *entry = NULL;
2287 char *error_message = NULL;
2289 return_code = __check_privilege_by_cookie(e_cookie, "alarm-server::alarm", "r", true, pid);
2290 if (return_code != ALARMMGR_RESULT_SUCCESS) {
2291 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2296 time(¤t_time);
2297 localtime_r(¤t_time, ¤t_tm);
2298 sprintf(db_path_tmp, "/tmp/alarmmgr_%d%d%d_%02d%02d%02d.db",
2299 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);
2300 db_path = strdup(db_path_tmp);
2302 if (db_util_open(db_path, &alarmmgr_tool_db, DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
2303 ALARM_MGR_EXCEPTION_PRINT("Opening [%s] failed", db_path);
2304 return_code = ERR_ALARM_SYSTEM_FAIL;
2305 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2311 if (sqlite3_exec(alarmmgr_tool_db, query_for_deleting_table, NULL, NULL, &error_message) != SQLITE_OK) {
2312 ALARM_MGR_EXCEPTION_PRINT("Deleting the table is failed. error message = %s", error_message);
2315 // Create a table if it does not exist
2316 if (sqlite3_exec(alarmmgr_tool_db, query_for_creating_table, NULL, NULL, &error_message) != SQLITE_OK) {
2317 ALARM_MGR_EXCEPTION_PRINT("Creating the table is failed. error message = %s", error_message);
2318 sqlite3_close(alarmmgr_tool_db);
2319 return_code = ERR_ALARM_SYSTEM_FAIL;
2320 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2325 // Get information of all alarms and save those into the DB.
2327 for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
2328 entry = gs_iter->data;
2330 SECURE_LOGD("#%d alarm id[%d] app_name[%s] duetime[%d]",
2331 index, entry->alarm_id, g_quark_to_string(entry->quark_app_unique_name), entry->start);
2333 alarm_info_t *alarm_info = (alarm_info_t *) &(entry->alarm_info);
2334 alarm_mode_t *mode = &alarm_info->mode;
2336 char *query = sqlite3_mprintf("insert into alarmmgr_tool( alarm_id, duetime_epoch, duetime, start_epoch,\
2337 end_epoch, pid, caller_pkgid, callee_pkgid, app_unique_name, app_service_name, dst_service_name, day_of_week, repeat, alarm_type)\
2338 values (%d,%d,%Q,%d,%d,%d,%Q,%Q,%Q,%Q,%Q,%d,%d,%d)",
2340 (int)entry->due_time,
2341 ctime(&(entry->due_time)),
2345 (char *)g_quark_to_string(entry->quark_caller_pkgid),
2346 (char *)g_quark_to_string(entry->quark_callee_pkgid),
2347 (char *)g_quark_to_string(entry->quark_app_unique_name),
2348 (char *)g_quark_to_string(entry->quark_app_service_name),
2349 (char *)g_quark_to_string(entry->quark_dst_service_name),
2350 mode->u_interval.day_of_week,
2352 entry->alarm_info.alarm_type);
2354 if (sqlite3_exec(alarmmgr_tool_db, query, NULL, NULL, &error_message) != SQLITE_OK) {
2355 SECURE_LOGE("sqlite3_exec() is failed. error message = %s", error_message);
2358 sqlite3_free(query);
2361 sqlite3_close(alarmmgr_tool_db);
2363 return_code = ALARMMGR_RESULT_SUCCESS;
2364 g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
2369 static void __timer_glib_finalize(GSource *src)
2374 fd_list = src->poll_fds;
2376 tmp = (GPollFD *) fd_list->data;
2379 fd_list = fd_list->next;
2385 static gboolean __timer_glib_check(GSource *src)
2390 fd_list = src->poll_fds;
2392 tmp = (GPollFD *) fd_list->data;
2393 if (tmp->revents & (POLLIN | POLLPRI)) {
2396 fd_list = fd_list->next;
2402 static gboolean __timer_glib_dispatch(GSource *src, GSourceFunc callback,
2409 static gboolean __timer_glib_prepare(GSource *src, gint *timeout)
2414 GSourceFuncs funcs = {
2415 .prepare = __timer_glib_prepare,
2416 .check = __timer_glib_check,
2417 .dispatch = __timer_glib_dispatch,
2418 .finalize = __timer_glib_finalize
2421 static void __initialize_timer()
2428 fd = timerfd_create(CLOCK_REALTIME, 0);
2430 ALARM_MGR_EXCEPTION_PRINT("timerfd_create() is failed.\n");
2433 src = g_source_new(&funcs, sizeof(GSource));
2435 gpollfd = (GPollFD *) g_malloc(sizeof(GPollFD));
2436 gpollfd->events = POLLIN;
2439 g_source_add_poll(src, gpollfd);
2440 g_source_set_callback(src, (GSourceFunc) __alarm_handler_idle,
2441 (gpointer) gpollfd, NULL);
2442 g_source_set_priority(src, G_PRIORITY_HIGH);
2444 ret = g_source_attach(src, NULL);
2446 ALARM_MGR_EXCEPTION_PRINT("g_source_attach() is failed.\n");
2450 g_source_unref(src);
2452 alarm_context.timer = fd;
2455 static void __initialize_alarm_list()
2457 alarm_context.alarms = NULL;
2458 alarm_context.c_due_time = -1;
2460 _load_alarms_from_registry();
2462 __rtc_set(); /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
2465 static void __initialize_scheduled_alarm_list()
2467 _init_scheduled_alarm_list();
2470 static bool __initialize_noti()
2472 // system state change noti
2473 if (vconf_notify_key_changed
2474 (VCONFKEY_SETAPPL_TIMEZONE_ID, __on_time_zone_changed, NULL) < 0) {
2475 ALARM_MGR_LOG_PRINT(
2476 "Failed to add callback for time zone changing event\n");
2479 if (vconf_notify_key_changed
2480 (VCONFKEY_SYSTEM_TIMECHANGE_EXTERNAL, __on_system_time_external_changed, NULL) < 0) {
2481 ALARM_MGR_LOG_PRINT(
2482 "Failed to add callback for time external changing event\n");
2485 // If the caller or callee app is uninstalled, all registered alarms will be canceled.
2486 int event_type = PMINFO_CLIENT_STATUS_UNINSTALL;
2487 pkgmgrinfo_client* pc = pkgmgrinfo_client_new(PMINFO_LISTENING);
2488 pkgmgrinfo_client_set_status_type(pc, event_type);
2489 pkgmgrinfo_client_listen_status(pc, __on_app_uninstalled, NULL);
2494 void on_bus_name_owner_changed(GDBusConnection *connection,
2495 const gchar *sender_name,
2496 const gchar *object_path,
2497 const gchar *interface_name,
2498 const gchar *signal_name,
2499 GVariant *parameters,
2502 // 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.
2503 // In this case, "NameOwnerChange" signal is broadcasted.
2504 if (signal_name && strcmp(signal_name , "NameOwnerChanged") == 0) {
2505 GSList *entry = NULL;
2506 __expired_alarm_t *expire_info = NULL;
2507 char *service_name = NULL;
2508 g_variant_get(parameters, "(sss)", &service_name, NULL, NULL);
2510 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
2512 expire_info = (__expired_alarm_t *) entry->data;
2513 SECURE_LOGD("expired service(%s), owner changed service(%s)", expire_info->service_name, service_name);
2515 if (strcmp(expire_info->service_name, service_name) == 0) {
2516 SECURE_LOGE("expired service name(%s) alarm_id (%d)", expire_info->service_name, expire_info->alarm_id);
2517 __alarm_send_noti_to_application(expire_info->service_name, expire_info->alarm_id);
2518 g_expired_alarm_list = g_slist_remove(g_expired_alarm_list, entry->data);
2519 g_free(expire_info);
2523 g_free(service_name);
2527 static void on_bus_acquired(GDBusConnection *connection, const gchar *name, gpointer user_data)
2529 ALARM_MGR_EXCEPTION_PRINT("on_bus_acquired");
2531 interface = alarm_manager_skeleton_new();
2532 if (interface == NULL) {
2533 ALARM_MGR_EXCEPTION_PRINT("Creating a skeleton object is failed.");
2537 g_signal_connect(interface, "handle_alarm_create", G_CALLBACK(alarm_manager_alarm_create), NULL);
2538 g_signal_connect(interface, "handle_alarm_create_appsvc", G_CALLBACK(alarm_manager_alarm_create_appsvc), NULL);
2539 g_signal_connect(interface, "handle_alarm_delete", G_CALLBACK(alarm_manager_alarm_delete), NULL);
2540 g_signal_connect(interface, "handle_alarm_delete_all", G_CALLBACK(alarm_manager_alarm_delete_all), NULL);
2541 g_signal_connect(interface, "handle_alarm_get_appsvc_info", G_CALLBACK(alarm_manager_alarm_get_appsvc_info), NULL);
2542 g_signal_connect(interface, "handle_alarm_get_info", G_CALLBACK(alarm_manager_alarm_get_info), NULL);
2543 g_signal_connect(interface, "handle_alarm_get_list_of_ids", G_CALLBACK(alarm_manager_alarm_get_list_of_ids), NULL);
2544 g_signal_connect(interface, "handle_alarm_get_next_duetime", G_CALLBACK(alarm_manager_alarm_get_next_duetime), NULL);
2545 g_signal_connect(interface, "handle_alarm_get_number_of_ids", G_CALLBACK(alarm_manager_alarm_get_number_of_ids), NULL);
2546 g_signal_connect(interface, "handle_alarm_set_rtc_time", G_CALLBACK(alarm_manager_alarm_set_rtc_time), NULL);
2547 g_signal_connect(interface, "handle_alarm_set_time", G_CALLBACK(alarm_manager_alarm_set_time), NULL);
2548 g_signal_connect(interface, "handle_alarm_update", G_CALLBACK(alarm_manager_alarm_update), NULL);
2549 g_signal_connect(interface, "handle_alarm_get_all_info", G_CALLBACK(alarm_manager_alarm_get_all_info), NULL);
2551 guint subsc_id = g_dbus_connection_signal_subscribe(connection, "org.freedesktop.DBus", "org.freedesktop.DBus",
2552 "NameOwnerChanged", "/org/freedesktop/DBus", NULL, G_DBUS_SIGNAL_FLAGS_NONE,
2553 on_bus_name_owner_changed, NULL, NULL);
2554 if (subsc_id == 0) {
2555 ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
2556 g_object_unref(interface);
2561 if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, ALARM_MGR_DBUS_PATH, NULL)) {
2562 ALARM_MGR_EXCEPTION_PRINT("Exporting the interface is failed.");
2563 g_object_unref(interface);
2568 alarm_context.connection = connection;
2569 g_dbus_object_manager_server_set_connection(alarmmgr_server, alarm_context.connection);
2572 static bool __initialize_dbus()
2574 ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
2576 alarmmgr_server = g_dbus_object_manager_server_new(ALARM_MGR_DBUS_PATH);
2577 if (alarmmgr_server == NULL) {
2578 ALARM_MGR_EXCEPTION_PRINT("Creating a new server object is failed.");
2582 guint owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, ALARM_MGR_DBUS_NAME,
2583 G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, NULL, NULL, NULL, NULL);
2585 if (owner_id == 0) {
2586 ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
2587 g_object_unref(alarmmgr_server);
2594 #define ALARMMGR_DB_FILE "/opt/dbspace/.alarmmgr.db"
2595 sqlite3 *alarmmgr_db;
2596 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
2597 (alarm_id integer primary key,\
2603 app_unique_name text,\
2604 app_service_name text,\
2605 app_service_name_mod text,\
2613 day_of_week integer,\
2615 alarm_type integer,\
2616 reserved_info integer,\
2617 dst_service_name text, \
2618 dst_service_name_mod text \
2621 static bool __initialize_db()
2623 char *error_message = NULL;
2626 if (access("/opt/dbspace/.alarmmgr.db", F_OK) == 0) {
2627 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2629 if (ret != SQLITE_OK) {
2630 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2637 ret = db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db, DB_UTIL_REGISTER_HOOK_METHOD);
2639 if (ret != SQLITE_OK) {
2640 ALARM_MGR_EXCEPTION_PRINT("====>>>> connect menu_db [%s] failed", ALARMMGR_DB_FILE);
2644 if (SQLITE_OK != sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL, &error_message)) {
2645 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, error message = %s", QUERY_CREATE_TABLE_ALARMMGR, error_message);
2652 static void __initialize()
2656 __initialize_timer();
2657 if (__initialize_dbus() == false) { /* because dbus's initialize
2658 failed, we cannot continue any more. */
2659 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
2660 "alarm-server cannot be runned.\n");
2663 __initialize_scheduled_alarm_list();
2665 __initialize_alarm_list();
2666 __initialize_noti();
2668 __initialize_module_log(); // for module log
2674 GMainLoop *mainloop = NULL;
2676 ALARM_MGR_LOG_PRINT("Enter main loop\n");
2678 mainloop = g_main_loop_new(NULL, FALSE);
2682 g_main_loop_run(mainloop);