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*/
36 #include<dbus/dbus-glib-lowlevel.h>
38 #if !GLIB_CHECK_VERSION (2, 31, 0)
39 #include <glib/gmacros.h>
43 /*#include "global-gconf.h"*/
45 #include"alarm-internal.h"
47 /*#include"limo-event-delivery.h"*/
52 #include <security-server.h>
55 #include <vconf-keys.h>
57 #define SIG_TIMER 0x32
58 #define WAKEUP_ALARM_APP_ID "org.tizen.alarm.ALARM"
59 /* alarm ui application's alarm's dbus_service name instead of 21
60 (alarm application's app_id) value */
61 #define WAKEUP_ALARMBOOTING_APP_ID "org.tizen.alarmboot.ui.ALARM"
62 /*alrmbooting ui application's dbus_service name instead of 121(alarmbooting
63 application's app_id) value */
65 #include "tapi_misc_ext.h"
67 #include "tapi_misc_data.h"
68 #include "tapi_power.h"
73 __alarm_server_context_t alarm_context;
74 bool g_dummy_timer_is_set = FALSE;
76 GSList *g_scheduled_alarm_list = NULL;
78 GSList *g_expired_alarm_list = NULL;
80 #ifndef RTC_WKALM_BOOT_SET
81 #define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
85 bool enable_power_on_alarm;
87 time_t ab_due_time = -1;
88 bool poweron_alarm_expired = false;
91 /* 2008. 6. 3 sewook7.park
92 When the alarm becoms sleeping mode, alarm timer is not expired.
93 So using RTC, phone is awaken before alarm rings.
95 #define __WAKEUP_USING_RTC__
96 #ifdef __WAKEUP_USING_RTC__
98 #include <linux/rtc.h>
99 #include <sys/ioctl.h>
102 static const char default_rtc[] = "/dev/rtc1";
103 static const char power_rtc[] = "/dev/rtc0";
105 #endif /*__WAKEUP_USING_RTC__*/
107 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info,
108 alarm_id_t *alarm_id);
109 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
110 __alarm_info_t *__alarm_info,
112 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
114 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
115 __alarm_info_t *__alarm_info);
116 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time);
117 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
118 int pid, char *app_service_name, char *app_service_name_mod,
119 const char *dst_service_name, const char *dst_service_name_mod, int *error_code);
120 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
121 int pid, char *bundle_data, int *error_code);
123 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code);
124 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
125 alarm_info_t *alarm_info, int *error_code);
126 static bool __alarm_power_on(int app_id, bool on_off, int *error_code);
127 static bool __alarm_power_off(int app_id, int *error_code);
128 static bool __alarm_check_next_duetime(int app_id, int *error_code);
129 static void __alarm_send_noti_to_application(const char *app_service_name,
130 alarm_id_t alarm_id);
131 static void __alarm_expired();
132 static gboolean __alarm_handler_idle();
133 static void __alarm_handler(int sigNum, siginfo_t *pSigInfo, void *pUContext);
134 static void __clean_registry();
135 static bool __alarm_manager_reset();
136 static void __on_system_time_changed(keynode_t *node, void *data);
137 static void __initialize_timer();
138 static void __initialize_alarm_list();
139 static void __initialize_scheduled_alarm_lsit();
140 static void __hibernation_leave_callback();
141 static bool __initialize_noti();
143 static bool __initialize_dbus();
144 static bool __initialize_db();
145 static void __initialize();
146 static bool __check_false_alarm();
147 static DBusHandlerResult __alarm_server_filter(DBusConnection *connection,
148 DBusMessage *message,
151 static void __rtc_set()
153 #ifdef __WAKEUP_USING_RTC__
155 const char *rtc = default_rtc;
157 struct rtc_time rtc_tm;
158 struct rtc_wkalrm rtc_wk;
161 #ifdef _SIMUL /*if build is simulator, we don't need to set
162 RTC because RTC does not work in simulator.*/
163 ALARM_MGR_EXCEPTION_PRINT("because it is simulator's mode, "
164 "we don't set RTC.\n");
168 fd = open(rtc, O_RDONLY);
170 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.\n");
174 /* Read the RTC time/date */
175 int retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
177 ALARM_MGR_EXCEPTION_PRINT("RTC_RD_TIME ioctl failed");
182 ALARM_MGR_LOG_PRINT("\n\nCurrent RTC date/time is %d-%d-%d, "
183 "%02d:%02d:%02d.\n", rtc_tm.tm_mday, rtc_tm.tm_mon + 1,
184 rtc_tm.tm_year + 1900, rtc_tm.tm_hour, rtc_tm.tm_min,
187 ALARM_MGR_LOG_PRINT("alarm_context.c_due_time is %d\n", \
188 alarm_context.c_due_time);
190 if (alarm_context.c_due_time != -1) {
191 time_t due_time = alarm_context.c_due_time - 1;
192 gmtime_r(&due_time, &due_tm);
194 rtc_tm.tm_mday = due_tm.tm_mday;
195 rtc_tm.tm_mon = due_tm.tm_mon;
196 rtc_tm.tm_year = due_tm.tm_year;
197 rtc_tm.tm_hour = due_tm.tm_hour;
198 rtc_tm.tm_min = due_tm.tm_min;
199 rtc_tm.tm_sec = due_tm.tm_sec;
200 memcpy(&rtc_wk.time, &rtc_tm, sizeof(rtc_tm));
204 ALARM_MGR_LOG_PRINT("\n\nSetted RTC Alarm date/time is "
205 "%d-%d-%d, %02d:%02d:%02d.\n", rtc_tm.tm_mday,
206 rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,
207 rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
209 retval = ioctl(fd, RTC_WKALM_SET, &rtc_wk);
211 if (errno == ENOTTY) {
212 ALARM_MGR_EXCEPTION_PRINT("\nAlarm IRQs not"
215 ALARM_MGR_EXCEPTION_PRINT("RTC_ALM_SET ioctl");
219 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
221 /* Enable alarm interrupts */
222 retval = ioctl(fd, RTC_AIE_ON, 0);
224 ALARM_MGR_EXCEPTION_PRINT("RTC_AIE_ON ioctl failed");
228 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is on");
230 ALARM_MGR_LOG_PRINT("[alarm-server]alarm_context.c_due_time is"
231 "less than 10 sec. RTC alarm does not need to be set\n");
235 #endif /* __WAKEUP_USING_RTC__ */
238 int _set_rtc_time(time_t _time)
244 struct rtc_time rtc_tm = { 0, };
245 const char *rtc0 = power_rtc;
246 const char *rtc1 = default_rtc;
247 struct tm *_tm = NULL;
248 struct tm time_r = { 0, };
250 fd0 = open(rtc0, O_RDONLY);
251 fd1 = open(rtc1, O_RDONLY);
254 ALARM_MGR_LOG_PRINT("error to open /dev/rtc0.");
259 ALARM_MGR_LOG_PRINT("error to open /dev/rtc1.");
263 memset(&rtc_tm, 0, sizeof(struct rtc_time));
266 (void) gmtime_r(&_time, &time_r);
268 /* Write the RTC time/date 2008:05:21 19:20:00 */
271 rtc_tm.tm_mday = time_r.tm_mday;
272 rtc_tm.tm_mon = time_r.tm_mon;
273 rtc_tm.tm_year = time_r.tm_year;
274 rtc_tm.tm_hour = time_r.tm_hour;
275 rtc_tm.tm_min = time_r.tm_min;
279 retval0 = ioctl(fd0, RTC_SET_TIME, &rtc_tm);
284 ALARM_MGR_LOG_PRINT("error to ioctl fd0.");
290 retval1 = ioctl(fd1, RTC_SET_TIME, &rtc_tm);
295 ALARM_MGR_LOG_PRINT("error to ioctl fd1.");
304 bool __alarm_clean_list()
308 for (iter = alarm_context.alarms; iter != NULL;
309 iter = g_slist_next(iter)) {
313 g_slist_free(alarm_context.alarms);
317 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info,
318 alarm_id_t *alarm_id)
321 bool unique_id = false;
322 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
323 __alarm_info_t *entry = NULL;
327 /* FIXME: alarm id must be unique. */
328 __alarm_info->alarm_id = (int)(void *)__alarm_info;
329 ALARM_MGR_LOG_PRINT("__alarm_info->alarm_id is %d", \
330 __alarm_info->alarm_id);
332 while (unique_id == false) {
335 for (iter = alarm_context.alarms; iter != NULL;
336 iter = g_slist_next(iter)) {
338 if (entry->alarm_id == __alarm_info->alarm_id) {
339 __alarm_info->alarm_id++;
347 ALARM_MGR_LOG_PRINT("[alarm-server]: before add\n");
348 for (iter = alarm_context.alarms; iter != NULL;
349 iter = g_slist_next(iter)) {
351 /*ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d)\n",
355 alarm_context.alarms =
356 g_slist_append(alarm_context.alarms, __alarm_info);
358 ALARM_MGR_LOG_PRINT("[alarm-server]: after add\n");
359 for (iter = alarm_context.alarms; iter != NULL;
360 iter = g_slist_next(iter)) {
362 ALARM_MGR_LOG_PRINT("[alarm-server]: alarm_id(%d)\n",
366 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
367 _save_alarms(__alarm_info);
370 *alarm_id = __alarm_info->alarm_id;
375 static bool __alarm_update_in_list(int pid, alarm_id_t alarm_id,
376 __alarm_info_t *__alarm_info,
380 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
382 __alarm_info_t *entry = NULL;
384 for (iter = alarm_context.alarms; iter != NULL;
385 iter = g_slist_next(iter)) {
387 if (entry->alarm_id == alarm_id) {
390 __alarm_info->quark_app_unique_name =
391 entry->quark_app_unique_name;
392 __alarm_info->quark_dst_service_name =
393 entry->quark_dst_service_name;
394 memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
402 *error_code = ERR_ALARM_INVALID_ID;
406 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
407 _update_alarms(__alarm_info);
413 static bool __alarm_remove_from_list(int pid, alarm_id_t alarm_id,
418 alarm_info_t *alarm_info = NULL;
421 __alarm_info_t *entry = NULL;
424 ALARM_MGR_LOG_PRINT("[alarm-server]: before del : alarm id(%d)\n",
427 for (iter = alarm_context.alarms; iter != NULL;
428 iter = g_slist_next(iter)) {
430 if (entry->alarm_id == alarm_id) {
431 alarm_info = &entry->alarm_info;
433 ALARM_MGR_LOG_PRINT("[alarm-server]: "
434 "__alarm_remove_from_list : alarm id(%d)\n",
437 if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
438 _delete_alarms(alarm_id);
441 alarm_context.alarms =
442 g_slist_remove(alarm_context.alarms, iter->data);
449 ALARM_MGR_LOG_PRINT("[alarm-server]: after del\n");
453 *error_code = ERR_ALARM_INVALID_ID;
460 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
461 __alarm_info_t *__alarm_info)
463 alarm_date_t *start = &alarm_info->start;
464 alarm_date_t *end = &alarm_info->end;
466 struct tm alarm_tm = { 0, };
468 if (start->year != 0) {
469 alarm_tm.tm_year = start->year - 1900;
470 alarm_tm.tm_mon = start->month - 1;
471 alarm_tm.tm_mday = start->day;
473 alarm_tm.tm_hour = 0;
477 __alarm_info->start = mktime(&alarm_tm);
479 __alarm_info->start = 0;
482 if (end->year != 0) {
483 alarm_tm.tm_year = end->year - 1900;
484 alarm_tm.tm_mon = end->month - 1;
485 alarm_tm.tm_mday = end->day;
487 alarm_tm.tm_hour = 23;
488 alarm_tm.tm_min = 59;
489 alarm_tm.tm_sec = 59;
491 __alarm_info->end = mktime(&alarm_tm);
493 __alarm_info->end = 0;
500 static bool alarm_get_tz_info(int *gmt_idx, int *dst)
502 GConfValue *value1 = NULL;
503 GConfValue *value2 = NULL;
504 GConfClient* gConfClient = NULL;
507 gConfClient = gconf_client_get_default();
510 value1 = gconf_client_get(gConfClient, SETTINGS_CLOCKTIMEZONE,
513 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
514 gconf_client_get() failed:
515 error:[%s]\n", err->message);
519 *gmt_idx = gconf_value_get_int(value1);
520 ALARM_MGR_LOG_PRINT("gconf return gmt_idx =%d\n ", *gmt_idx);
522 value2 = gconf_client_get(gConfClient,
523 SETTINGS_DAYLIGHTSTATUS, &err);
525 ALARM_MGR_LOG_PRINT("__on_system_time_changed:
526 gconf_client_get() failed: error:[%s]\n", err->message);
531 *dst = gconf_value_get_int(value2);
532 ALARM_MGR_LOG_PRINT("gconf return dst =%d\n ", *dst);
534 if(gConfClient != NULL) {
535 g_object_unref(gConfClient);
540 ALARM_MGR_LOG_PRINT("check the gconf setting failed!!!!! \n ");
543 gconf_value_free(value1);
547 gconf_value_free(value2);
555 static bool __alarm_update_due_time_of_all_items_in_list(double diff_time)
558 time_t min_time = -1;
561 __alarm_info_t *entry = NULL;
562 struct tm *p_time = NULL ;
563 struct tm due_time_result ;
564 struct tm fixed_time = { 0, };
566 for (iter = alarm_context.alarms; iter != NULL;
567 iter = g_slist_next(iter)) {
569 alarm_info_t *alarm_info = &(entry->alarm_info);
570 if (alarm_info->alarm_type & ALARM_TYPE_RELATIVE) {
571 /*diff_time ó¸® */
573 entry->due_time += diff_time;
575 alarm_date_t *start = &alarm_info->start; /**< start
577 alarm_date_t *end = &alarm_info->end;;
578 /**< end time of the alarm */
581 p_time = localtime_r(&entry->due_time, &due_time_result);
582 if (p_time != NULL) {
583 start->year = p_time->tm_year + 1900;
584 start->month = p_time->tm_mon + 1;
585 start->day = p_time->tm_mday;
586 start->hour = p_time->tm_hour;
587 start->min = p_time->tm_min;
588 start->sec = p_time->tm_sec;
590 end->year = p_time->tm_year + 1900;
591 end->month = p_time->tm_mon + 1;
592 end->day = p_time->tm_mday;
595 memset(&fixed_time, 0, sizeof(fixed_time));
596 fixed_time.tm_year = p_time->tm_year;
597 fixed_time.tm_mon = p_time->tm_mon;
598 fixed_time.tm_mday = p_time->tm_mday;
599 fixed_time.tm_hour = 0;
600 fixed_time.tm_min = 0;
601 fixed_time.tm_sec = 0;
603 entry->start = mktime(&fixed_time);
605 fixed_time.tm_hour = 23;
606 fixed_time.tm_min = 59;
607 fixed_time.tm_sec = 59;
609 entry->end = mktime(&fixed_time);
611 ALARM_MGR_LOG_PRINT("alarm_info->alarm_type is "
612 "ALARM_TYPE_RELATIVE\n");
614 _update_alarms(entry);
617 _alarm_next_duetime(entry);
618 ALARM_MGR_LOG_PRINT("entry->due_time is %d\n", entry->due_time);
623 for (iter = alarm_context.alarms; iter != NULL;
624 iter = g_slist_next(iter)) {
626 due_time = entry->due_time;
630 ALARM_MGR_LOG_PRINT("alarm[%d] with duetime(%u) at "
631 "current(%u)\n", entry->alarm_id, due_time, current_time);
632 if (due_time == 0) { /* 0 means this alarm has been
637 interval = difftime(due_time, current_time);
640 ALARM_MGR_LOG_PRINT("this may be error.. alarm[%d]\n", \
645 interval = difftime(due_time, min_time);
647 if ((interval < 0) || min_time == -1) {
653 alarm_context.c_due_time = min_time;
658 static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
659 int pid,char *bundle_data, int *error_code){
664 char due_time_r[100] = { 0 };
665 char proc_file[512] = { 0 };
666 char process_name[512] = { 0 };
667 char app_name[512] = { 0 };
669 char *proc_name_ptr = NULL;
674 __alarm_info_t *__alarm_info = NULL;
676 __alarm_info = malloc(sizeof(__alarm_info_t));
677 if (__alarm_info == NULL) {
678 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid=%d, malloc "
679 "failed. it seems to be OOM\n", pid);
680 *error_code = -1; /* -1 means that system
681 failed internally. */
684 __alarm_info->pid = pid;
685 __alarm_info->alarm_id = -1;
688 /* we should consider to check whether pid is running or Not
690 memset(process_name, '\0', 512);
691 memset(proc_file, '\0', 512);
692 snprintf(proc_file, 512, "/proc/%d/cmdline", pid);
694 fd = open(proc_file, O_RDONLY);
695 if (fd < 0) { /* failure */
696 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
697 "killed, so we failed to get proc file(%s) and do not create "
698 "alarm_info\n", pid, proc_file);
699 *error_code = -1; /*-1 means that system failed
704 ret = read(fd, process_name, 512);
708 ALARM_MGR_EXCEPTION_PRINT("Unable to get application name\n");
713 while (process_name[i] != '\0') {
714 if (process_name[i] == ' ') {
715 process_name[i] = '\0';
721 word = strtok_r(process_name, "/", &proc_name_ptr);
722 while (word != NULL) {
723 memset(app_name, 0, 512);
724 snprintf(app_name, 512, "%s", word);
725 word = strtok_r(NULL, "/", &proc_name_ptr);
727 __alarm_info->quark_app_unique_name =
728 g_quark_from_string(app_name);
731 __alarm_info->quark_bundle=g_quark_from_string(bundle_data);
732 __alarm_info->quark_app_service_name = g_quark_from_string("null");
733 __alarm_info->quark_dst_service_name = g_quark_from_string("null");
734 __alarm_info->quark_app_service_name_mod = g_quark_from_string("null");
735 __alarm_info->quark_dst_service_name_mod = g_quark_from_string("null");
737 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
738 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
742 if (alarm_context.c_due_time < current_time) {
743 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
744 "(%d) is less than current time(%d)", alarm_context.c_due_time,
746 alarm_context.c_due_time = -1;
749 due_time = _alarm_next_duetime(__alarm_info);
750 if (__alarm_add_to_list(__alarm_info, alarm_id) == false) {
757 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
758 "due_time is 0, alarm(%d) \n", *alarm_id);
760 } else if (current_time == due_time) {
761 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
762 "current_time(%d) is same as due_time(%d)", current_time,
765 }else if (difftime(due_time, current_time) < 0){
766 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);
769 localtime_r(&due_time, &ts_ret);
770 strftime(due_time_r, 30, "%c", &ts_ret);
771 ALARM_MGR_LOG_PRINT("[alarm-server]:Create a new alarm: "
772 "alarm(%d) due_time(%s)", *alarm_id,
776 ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), "
777 "due_time(%d)", alarm_context.c_due_time, due_time);
779 if (alarm_context.c_due_time == -1
780 || due_time < alarm_context.c_due_time) {
781 _clear_scheduled_alarm_list();
782 _add_to_scheduled_alarm_list(__alarm_info);
783 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time,
785 alarm_context.c_due_time = due_time;
787 } else if (due_time == alarm_context.c_due_time) {
788 _add_to_scheduled_alarm_list(__alarm_info);
796 if (enable_power_on_alarm) {
797 __alarm_power_on(0, enable_power_on_alarm, NULL);
805 static bool __alarm_create(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
806 int pid, char *app_service_name, char *app_service_name_mod,
807 const char *dst_service_name,const char *dst_service_name_mod, int *error_code)
812 char proc_file[256] = { 0 };
813 char process_name[512] = { 0 };
814 char app_name[256] = { 0 };
816 char *proc_name_ptr = NULL;
818 __alarm_info_t *__alarm_info = NULL;
820 __alarm_info = malloc(sizeof(__alarm_info_t));
821 if (__alarm_info == NULL) {
822 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid=%d, malloc "
823 "failed. it seems to be OOM\n", pid);
824 *error_code = -1; /* -1 means that system
825 failed internally. */
828 __alarm_info->pid = pid;
829 __alarm_info->alarm_id = -1;
831 /* we should consider to check whether pid is running or Not
833 memset(process_name, '\0', 512);
834 memset(proc_file, '\0', 256);
835 snprintf(proc_file, 256, "/proc/%d/cmdline", pid);
840 fd = open(proc_file, O_RDONLY);
841 if (fd < 0) { /* failure */
842 __alarm_info->quark_app_unique_name =
843 g_quark_from_string("unknown");
844 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
845 "killed, so we failed to get proc file(%s) and do not create "
846 "alarm_info\n", pid, proc_file);
847 *error_code = -1; /*-1 means that system failed
852 ret = read(fd, process_name, 512);
854 while (process_name[i] != '\0') {
855 if (process_name[i] == ' ') {
856 process_name[i] = '\0';
861 /* if (readlink(proc_file, process_name, 256)!=-1) */
864 word = strtok_r(process_name, "/", &proc_name_ptr);
865 while (word != NULL) {
866 memset(app_name, 0, 256);
867 snprintf(app_name, 256, "%s", word);
868 word = strtok_r(NULL, "/", &proc_name_ptr);
870 __alarm_info->quark_app_unique_name =
871 g_quark_from_string(app_name);
874 __alarm_info->quark_app_service_name =
875 g_quark_from_string(app_service_name);
876 __alarm_info->quark_app_service_name_mod =
877 g_quark_from_string(app_service_name_mod);
878 __alarm_info->quark_dst_service_name =
879 g_quark_from_string(dst_service_name);
880 __alarm_info->quark_dst_service_name_mod =
881 g_quark_from_string(dst_service_name_mod);
882 __alarm_info->quark_bundle = g_quark_from_string("null");
885 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
886 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
890 ALARM_MGR_LOG_PRINT("[alarm-server]:pid=%d, app_unique_name=%s, "
891 "app_service_name=%s,dst_service_name=%s, c_due_time=%d", \
892 pid, g_quark_to_string(__alarm_info->quark_app_unique_name), \
893 g_quark_to_string(__alarm_info->quark_app_service_name), \
894 g_quark_to_string(__alarm_info->quark_dst_service_name), \
895 alarm_context.c_due_time);
897 if (alarm_context.c_due_time < current_time) {
898 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
899 "(%d) is less than current time(%d)", alarm_context.c_due_time,
901 alarm_context.c_due_time = -1;
904 due_time = _alarm_next_duetime(__alarm_info);
905 if (__alarm_add_to_list(__alarm_info, alarm_id) == false) {
911 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create a new alarm: "
912 "due_time is 0, alarm(%d) \n", *alarm_id);
914 } else if (current_time == due_time) {
915 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Create alarm: "
916 "current_time(%d) is same as due_time(%d)", current_time,
919 }else if (difftime(due_time, current_time) < 0){
920 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);
923 char due_time_r[100] = { 0 };
925 localtime_r(&due_time, &ts_ret);
926 strftime(due_time_r, 30, "%c", &ts_ret);
927 ALARM_MGR_LOG_PRINT("[alarm-server]:Create a new alarm: "
928 "alarm(%d) due_time(%s)", *alarm_id,
932 ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), "
933 "due_time(%d)", alarm_context.c_due_time, due_time);
935 if (alarm_context.c_due_time == -1
936 || due_time < alarm_context.c_due_time) {
937 _clear_scheduled_alarm_list();
938 _add_to_scheduled_alarm_list(__alarm_info);
939 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time,
941 alarm_context.c_due_time = due_time;
943 } else if (due_time == alarm_context.c_due_time) {
944 _add_to_scheduled_alarm_list(__alarm_info);
952 if (enable_power_on_alarm) {
953 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID) in a
954 * platform with app-server.because __alarm_power_on(..) fuction don't
955 * use first parameter internally, we set this value to 0(zero)
957 __alarm_power_on(0, enable_power_on_alarm, NULL);
963 static bool __alarm_update(int pid, char *app_service_name, alarm_id_t alarm_id,
964 alarm_info_t *alarm_info, int *error_code)
969 __alarm_info_t *__alarm_info = NULL;
972 __alarm_info = malloc(sizeof(__alarm_info_t));
973 if (__alarm_info == NULL) {
974 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid=%d, "
975 "malloc failed. it seems to be OOM\n", pid);
976 *error_code = -1; /*-1 means that system failed
981 __alarm_info->pid = pid;
982 __alarm_info->alarm_id = alarm_id;
984 /* we should consider to check whether pid is running or Not
987 __alarm_info->quark_app_service_name =
988 g_quark_from_string(app_service_name);
989 __alarm_set_start_and_end_time(alarm_info, __alarm_info);
990 memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
994 if (alarm_context.c_due_time < current_time) {
995 ALARM_MGR_EXCEPTION_PRINT("Caution!! alarm_context.c_due_time "
996 "(%d) is less than current time(%d)", alarm_context.c_due_time,
998 alarm_context.c_due_time = -1;
1001 due_time = _alarm_next_duetime(__alarm_info);
1002 if (!__alarm_update_in_list(pid, alarm_id, __alarm_info, error_code)) {
1004 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
1005 "(%d) does not exist. so this value is invalid id.", alarm_id);
1008 /* ALARM_MGR_LOG_PRINT("[alarm-server]:request_pid=%d, alarm_id=%d,
1009 * app_unique_name=%s, app_service_name=%s, dst_service_name=%s,
1010 * c_due_time=%d", pid, alarm_id, g_quark_to_string
1011 * (__alarm_info->quark_app_unique_name), g_quark_to_string
1012 * (__alarm_info->quark_app_service_name), g_quark_to_string
1013 * (__alarm_info->quark_dst_service_name), alarm_context.c_due_time);
1016 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
1018 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
1019 /*there is no scheduled alarm */
1020 _alarm_disable_timer(alarm_context);
1023 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d)\n",
1030 if (enable_power_on_alarm) {
1031 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID) in
1032 * a platform with app-server.because __alarm_power_on(..) fuction don't
1033 * use first parameter internally, we set this value to 0(zero)
1035 __alarm_power_on(0, enable_power_on_alarm, NULL);
1039 if (due_time == 0) {
1040 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
1047 if (due_time == 0) {
1048 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
1049 "due_time is 0, alarm(%d)\n", alarm_id);
1052 } else if (current_time == due_time) {
1053 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
1054 "current_time(%d) is same as due_time(%d)", current_time,
1058 }else if (difftime(due_time, current_time)< 0){
1059 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);
1063 char due_time_r[100] = { 0 };
1065 localtime_r(&due_time, &ts_ret);
1066 strftime(due_time_r, 30, "%c", &ts_ret);
1067 ALARM_MGR_LOG_PRINT("[alarm-server]:Update alarm: alarm(%d) "
1068 "due_time(%s)\n", alarm_id, due_time_r);
1071 ALARM_MGR_LOG_PRINT("[alarm-server]:alarm_context.c_due_time(%d), "
1072 "due_time(%d)", alarm_context.c_due_time, due_time);
1074 if (alarm_context.c_due_time == -1
1075 || due_time < alarm_context.c_due_time) {
1076 _clear_scheduled_alarm_list();
1077 _add_to_scheduled_alarm_list(__alarm_info);
1078 _alarm_set_timer(&alarm_context, alarm_context.timer, due_time,
1080 alarm_context.c_due_time = due_time;
1081 ALARM_MGR_LOG_PRINT("[alarm-server1]:alarm_context.c_due_time "
1082 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1083 } else if (due_time == alarm_context.c_due_time) {
1084 _add_to_scheduled_alarm_list(__alarm_info);
1085 ALARM_MGR_LOG_PRINT("[alarm-server2]:alarm_context.c_due_time "
1086 "(%d), due_time(%d)", alarm_context.c_due_time, due_time);
1093 if (enable_power_on_alarm) {
1094 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID)
1095 * in a platform with app-server.because __alarm_power_on(..) fuction
1096 * don't use first parameter internally, we set this value to 0(zero)
1098 __alarm_power_on(0, enable_power_on_alarm, NULL);
1106 static bool __alarm_delete(int pid, alarm_id_t alarm_id, int *error_code)
1108 bool result = false;
1110 ALARM_MGR_LOG_PRINT("[alarm-server]:delete alarm: alarm(%d) pid(%d)\n",\
1112 result = _remove_from_scheduled_alarm_list(pid, alarm_id);
1114 if (!__alarm_remove_from_list(pid, alarm_id, error_code)) {
1116 ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:delete alarm: "
1117 "alarm(%d) pid(%d) has failed with error_code(%d)\n",
1118 alarm_id, pid, *error_code);
1122 if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
1123 _alarm_disable_timer(alarm_context);
1131 if (enable_power_on_alarm) {
1132 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID) in a
1133 * platform with app-server.because __alarm_power_on(..) fuction don't
1134 * use first parameter internally, we set this value to 0(zero)
1136 __alarm_power_on(0, enable_power_on_alarm, NULL);
1143 static bool __alarm_power_on(int app_id, bool on_off, int *error_code)
1146 time_t min_time = 0;
1147 time_t current_time = 0;
1148 struct rtc_time rtc_tm = { 0, };
1149 struct tm min_time_r = { 0, };
1153 enable_power_on_alarm = on_off;
1154 /*_update_power_on(on_off); */ /*currently its empty*/
1156 fd = open(power_rtc, O_RDONLY);
1158 ALARM_MGR_EXCEPTION_PRINT("cannot open /dev/rtc0\n");
1162 if (on_off == true) {
1163 if (_alarm_find_mintime_power_on(&min_time) == true) {
1165 ab_due_time = min_time;
1167 min_time = min_time - 60;
1169 time(¤t_time);
1171 if (min_time <= current_time)
1172 min_time = current_time + 5;
1174 gmtime_r(&min_time, &min_time_r);
1176 ALARM_MGR_LOG_PRINT("__alarm_power_on : %d %d %d %d "
1178 min_time_r.tm_year,\
1180 min_time_r.tm_mday,\
1181 min_time_r.tm_hour,\
1183 ALARM_MGR_LOG_PRINT("__alarm_power_on : %d %d %d %d "
1185 min_time_r.tm_year,\
1187 min_time_r.tm_mday,\
1188 min_time_r.tm_hour,\
1191 rtc_tm.tm_mday = min_time_r.tm_mday;
1192 rtc_tm.tm_mon = min_time_r.tm_mon;
1193 rtc_tm.tm_year = min_time_r.tm_year;
1194 rtc_tm.tm_hour = min_time_r.tm_hour;
1195 rtc_tm.tm_min = min_time_r.tm_min;
1196 rtc_tm.tm_sec = min_time_r.tm_sec;
1197 /*set_info.time_zone = 0; */
1198 /*set_info.u_interval.day_of_week = 0; */
1200 /*ALARM_MGR_LOG_PRINT("####__alarm_power_on : %d %d
1201 %d %d %d\n",set_info.year,set_info.month,set_info.day,
1202 set_info.hour,set_info.minute); */
1204 ALARM_MGR_LOG_PRINT("due_time : %d \n", ab_due_time);
1206 ALARM_MGR_LOG_PRINT("\n\nSetted RTC Alarm date/time is "
1207 "%d-%d-%d, %02d:%02d:%02d.\n",
1208 rtc_tm.tm_mday, rtc_tm.tm_mon + 1,
1209 rtc_tm.tm_year + 1900, rtc_tm.tm_hour,
1210 rtc_tm.tm_min, rtc_tm.tm_sec);
1212 retval = ioctl(fd, RTC_ALM_SET, &rtc_tm);
1214 if (errno == ENOTTY) {
1215 ALARM_MGR_EXCEPTION_PRINT(
1216 "\n...Alarm IRQs not supported.\n");
1218 ALARM_MGR_EXCEPTION_PRINT("RTC_ALM_SET ioctl");
1222 ALARM_MGR_LOG_PRINT("[alarm-server]RTC "
1223 "alarm(POWER ON) is setted");
1225 /* Enable alarm interrupts */
1226 retval = ioctl(fd, RTC_AIE_ON, 0);
1228 ALARM_MGR_EXCEPTION_PRINT(
1229 "RTC_AIE_ON ioctl failed");
1233 ALARM_MGR_LOG_PRINT("[alarm-server]RTC(POWER ON) "
1237 retval = ioctl(fd, RTC_AIE_OFF, 0);
1239 ALARM_MGR_LOG_PRINT("__alarm_power_on : off\n");
1240 retval = ioctl(fd, RTC_AIE_OFF, 0);
1244 #endif /* #ifdef __ALARM_BOOT */
1249 static bool __alarm_power_off(int app_id, int *error_code)
1253 #endif /* #ifdef __ALARM_BOOT */
1257 static bool __alarm_check_next_duetime(int app_id, int *error_code)
1260 time_t current_time;
1263 time(¤t_time);
1265 interval = ab_due_time - current_time;
1267 ALARM_MGR_LOG_PRINT("due_time : %d / current_time %d\n", ab_due_time,
1270 if (interval > 0 && interval <= 60)
1274 #else /* #ifdef __ALARM_BOOT */
1279 static void __alarm_send_noti_to_application(const char *app_service_name,
1280 alarm_id_t alarm_id)
1284 char service_name[MAX_SERVICE_NAME_LEN];
1285 char object_name[MAX_SERVICE_NAME_LEN];
1287 DBusMessage *message;
1288 DBusMessageIter iter;
1290 if (app_service_name == NULL || strlen(app_service_name) == 0) {
1291 ALARM_MGR_EXCEPTION_PRINT("This alarm destination is "
1295 memset(service_name, 0, MAX_SERVICE_NAME_LEN);
1296 memcpy(service_name, app_service_name, strlen(app_service_name));
1298 snprintf(object_name, MAX_SERVICE_NAME_LEN,
1299 "/org/tizen/alarm/client");
1301 ALARM_MGR_LOG_PRINT("[alarm server][send expired_alarm(alarm_id=%d)to"
1302 "app_service_name(%s), object_name(%s), interface_name(%s)]\n",\
1303 alarm_id, service_name, object_name, "org.tizen.alarm.client");
1305 message = dbus_message_new_method_call(service_name,
1307 "org.tizen.alarm.client",
1309 if (message == NULL) {
1310 ALARM_MGR_EXCEPTION_PRINT("[alarm server] "
1311 "dbus_message_new_method_call faild. maybe OOM!.\n");
1312 ALARM_MGR_EXCEPTION_PRINT("[alarm server] so we cannot "
1313 "send expired alarm to %s\n", service_name);
1317 dbus_message_set_no_reply(message, TRUE);
1318 /* if(service_name[0]==':') */
1319 /* we don't need auto activation in a case that
1320 destination_app_service_name starts with a charactor like (:) */
1321 dbus_message_set_auto_start(message, FALSE);
1323 dbus_message_iter_init_append(message, &iter);
1324 if (!dbus_message_iter_append_basic
1325 (&iter, DBUS_TYPE_INT32, &alarm_id)) {
1326 dbus_message_unref(message);
1327 ALARM_MGR_EXCEPTION_PRINT("[alarm server] "
1328 "dbus_message_iter_append_basic faild. maybe OOM!.\n");
1332 dbus_connection_send(dbus_g_connection_get_connection
1333 (alarm_context.bus), message, NULL);
1334 dbus_connection_flush(dbus_g_connection_get_connection
1335 (alarm_context.bus));
1336 dbus_message_unref(message);
1340 static void __alarm_expired()
1342 const char *destination_app_service_name = NULL;
1343 alarm_id_t alarm_id = -1;
1345 __alarm_info_t *__alarm_info = NULL;
1346 char alarm_id_val[32]={0,};
1351 ALARM_MGR_LOG_PRINT("[alarm-server]: Enter \n");
1353 time_t current_time;
1356 time(¤t_time);
1358 interval = difftime(alarm_context.c_due_time, current_time);
1359 ALARM_MGR_LOG_PRINT("[alarm-server]: c_due_time(%d), "
1360 "current_time(%d), interval(%d)\n", alarm_context.c_due_time,
1361 current_time, interval);
1363 if (alarm_context.c_due_time > current_time) {
1364 ALARM_MGR_LOG_PRINT("[alarm-server]: False Alarm\n");
1368 GSList *iter = NULL;
1369 __scheduled_alarm_t *alarm = NULL;
1371 for (iter = g_scheduled_alarm_list; iter != NULL;
1372 iter = g_slist_next(iter)) {
1374 alarm_id = alarm->alarm_id;
1376 __alarm_info = alarm->__alarm_info;
1378 app_pid = __alarm_info->pid;
1381 (g_quark_to_string(__alarm_info->quark_bundle),
1384 b_len = strlen(g_quark_to_string(__alarm_info->quark_bundle));
1386 b = bundle_decode((bundle_raw *)g_quark_to_string(__alarm_info->quark_bundle), b_len);
1390 ALARM_MGR_EXCEPTION_PRINT("Error!!!..Unable to decode the bundle!!\n");
1394 snprintf(alarm_id_val,31,"%d",alarm_id);
1396 if (bundle_add(b,"http://tizen.org/appcontrol/data/alarm_id", alarm_id_val)){
1397 ALARM_MGR_EXCEPTION_PRINT("Unable to add alarm id to the bundle\n");
1401 appid = appsvc_get_appid(b);
1402 if( (__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid))
1404 ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
1408 if ( appsvc_run_service(b, 0, NULL, NULL) < 0)
1410 ALARM_MGR_EXCEPTION_PRINT("Unable to run app svc\n");
1414 ALARM_MGR_LOG_PRINT("Successfuly ran app svc\n");
1425 (g_quark_to_string(__alarm_info->quark_dst_service_name),
1427 ALARM_MGR_LOG_PRINT("[alarm-server]:destination is "
1428 "null, so we send expired alarm to %s(%u)\n",\
1430 __alarm_info->quark_app_service_name),
1431 __alarm_info->quark_app_service_name);
1432 destination_app_service_name = g_quark_to_string(
1433 __alarm_info->quark_app_service_name_mod);
1435 ALARM_MGR_LOG_PRINT("[alarm-server]:destination "
1438 __alarm_info->quark_dst_service_name),
1439 __alarm_info->quark_dst_service_name);
1440 destination_app_service_name = g_quark_to_string(
1441 __alarm_info->quark_dst_service_name_mod);
1445 /* orginally this code had if(__alarm_info->app_id==21) in a
1446 platform with app-server. */
1447 /*if(__alarm_info->quark_dst_service_name ==
1448 g_quark_from_string (WAKEUP_ALARM_APP_ID)) */
1450 (g_quark_to_string(__alarm_info->quark_dst_service_name),
1451 WAKEUP_ALARM_APP_ID) == 0) {
1453 fd = open(power_rtc, O_RDONLY);
1455 ALARM_MGR_LOG_PRINT("cannot open /dev/rtc0\n");
1457 ioctl(fd, RTC_AIE_OFF, 0);
1464 * we should consider a situation that
1465 * destination_app_service_name is owner_name like (:xxxx) and
1466 * application's pid which registered this alarm was killed.In that case,
1467 * we don't need to send the expire event because the process was killed.
1468 * this causes needless message to be sent.
1470 ALARM_MGR_LOG_PRINT("[alarm-server]: "
1471 "destination_app_service_name :%s, app_pid=%d\n",
1472 destination_app_service_name, app_pid);
1473 /* the following is a code that checks the above situation.
1474 please verify this code. */
1476 if (dbus_bus_name_has_owner(
1477 dbus_g_connection_get_connection(alarm_context.bus),
1478 destination_app_service_name, NULL) == FALSE) {
1479 __expired_alarm_t *expire_info;
1480 char appid[MAX_SERVICE_NAME_LEN] = { 0, };
1481 char alarm_id_str[32] = { 0, };
1483 expire_info = malloc(sizeof(__expired_alarm_t));
1484 if (G_UNLIKELY(NULL == expire_info)){
1485 ALARM_MGR_ASSERT_PRINT("[alarm-server]:Malloc failed!Can't notify alarm expiry info\n");
1488 memset(expire_info, '\0', MAX_SERVICE_NAME_LEN);
1489 strncpy(expire_info->service_name,
1490 destination_app_service_name,
1491 MAX_SERVICE_NAME_LEN-1);
1492 expire_info->alarm_id = alarm_id;
1493 g_expired_alarm_list =
1494 g_slist_append(g_expired_alarm_list, expire_info);
1498 (g_quark_to_string(__alarm_info->quark_dst_service_name),
1500 strncpy(appid,g_quark_to_string(__alarm_info->quark_app_service_name),strlen(g_quark_to_string(__alarm_info->quark_app_service_name))-6);
1504 strncpy(appid,g_quark_to_string(__alarm_info->quark_dst_service_name),strlen(g_quark_to_string(__alarm_info->quark_dst_service_name))-6);
1507 snprintf(alarm_id_str, 31, "%d", alarm_id);
1509 ALARM_MGR_LOG_PRINT("before aul_launch appid(%s) "
1510 "alarm_id_str(%s)\n", appid, alarm_id_str);
1513 kb = bundle_create();
1514 bundle_add(kb, "__ALARM_MGR_ID", alarm_id_str);
1515 aul_launch_app(appid, kb);
1518 ALARM_MGR_LOG_PRINT(
1519 "before alarm_send_noti_to_application\n");
1520 __alarm_send_noti_to_application(
1521 destination_app_service_name, alarm_id);
1524 ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application\n");
1526 /* if( !(__alarm_info->alarm_info.alarm_type
1527 & ALARM_TYPE_VOLATILE) ) {
1528 __alarm_remove_from_list(__alarm_info->pid,
1532 if (__alarm_info->alarm_info.mode.repeat
1533 == ALARM_REPEAT_MODE_ONCE) {
1534 /* _alarm_next_duetime(__alarm_info);*/
1535 /* _update_alarms(__alarm_info);*/
1536 __alarm_remove_from_list(__alarm_info->pid, alarm_id,
1540 _alarm_next_duetime(__alarm_info);
1541 /* _update_alarms(__alarm_info);*/
1547 _clear_scheduled_alarm_list();
1548 alarm_context.c_due_time = -1;
1550 ALARM_MGR_LOG_PRINT("[alarm-server]: Leave \n");
1553 static gboolean __alarm_handler_idle()
1555 if (g_dummy_timer_is_set == true) {
1556 ALARM_MGR_LOG_PRINT("dummy alarm timer has expired\n");
1558 ALARM_MGR_LOG_PRINT("__alarm_handler \n");
1559 ALARM_MGR_LOG_PRINT("__alarm_handler \n");
1571 if (enable_power_on_alarm) {
1572 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID)
1573 *in a platform with app-server.because __alarm_power_on(..) fuction
1574 *don't use first parameter internally, we set this value to 0(zero)
1576 __alarm_power_on(0, enable_power_on_alarm, NULL);
1579 pm_unlock_state(LCD_OFF, PM_SLEEP_MARGIN);
1584 static void __alarm_handler(int sigNum, siginfo_t *pSigInfo, void *pUContext)
1587 pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
1589 /* we moved __alarm_expired() function to __alarm_handler_idle GSource
1590 because of signal safety. */
1591 g_idle_add_full(G_PRIORITY_HIGH_IDLE, __alarm_handler_idle, NULL, NULL);
1594 static void __clean_registry()
1597 /*TODO:remove all db entries */
1600 static bool __alarm_manager_reset()
1603 _alarm_disable_timer(alarm_context);
1605 __alarm_clean_list();
1607 _clear_scheduled_alarm_list();
1613 static void __on_system_time_changed(keynode_t *node, void *data)
1619 _alarm_disable_timer(alarm_context);
1622 _time = vconf_keynode_get_int(node);
1624 vconf_get_int(VCONFKEY_SYSTEM_TIMECHANGE, (int *)&_time);
1628 diff_time = difftime(_time, before);
1632 ALARM_MGR_ASSERT_PRINT("diff_time is %f\n", diff_time);
1634 ALARM_MGR_LOG_PRINT("[alarm-server] System time has been changed\n");
1635 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n",
1636 alarm_context.c_due_time);
1640 vconf_set_dbl(VCONFKEY_SYSTEM_TIMEDIFF, diff_time);
1641 vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED,(int)diff_time);
1643 __alarm_update_due_time_of_all_items_in_list(diff_time);
1645 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n",
1646 alarm_context.c_due_time);
1647 _clear_scheduled_alarm_list();
1652 if (enable_power_on_alarm) {
1653 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_
1654 APP_ID) in a platform with app-server. because _alarm_power_
1655 on(..) fuction don't use first parameter internally, we set
1656 this value to 0(zero)
1658 __alarm_power_on(0, enable_power_on_alarm, NULL);
1664 static void __on_time_zone_changed(keynode_t *node, void *data)
1666 double diff_time = 0;
1668 _alarm_disable_timer(alarm_context);
1672 ALARM_MGR_LOG_PRINT("[alarm-server] time zone has been changed\n");
1673 ALARM_MGR_LOG_PRINT("1.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1675 __alarm_update_due_time_of_all_items_in_list(diff_time);
1677 ALARM_MGR_LOG_PRINT("2.alarm_context.c_due_time is %d\n", alarm_context.c_due_time);
1678 _clear_scheduled_alarm_list();
1683 if (enable_power_on_alarm) {
1684 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_
1685 APP_ID) in a platform with app-server. because _alarm_power_
1686 on(..) fuction don't use first parameter internally, we set
1687 this value to 0(zero)
1689 __alarm_power_on(0, enable_power_on_alarm, NULL);
1696 gboolean alarm_manager_alarm_set_rtc_time(void *pObject, int pid,
1697 int year, int mon, int day,
1698 int hour, int min, int sec, char *e_cookie,
1700 guchar *cookie = NULL;
1703 gboolean result = true;
1706 const char *rtc = power_rtc;
1708 struct rtc_time rtc_tm = {0,};
1709 struct rtc_wkalrm rtc_wk;
1710 struct tm *alarm_tm = NULL;
1711 struct tm due_tm = {0,};
1715 *return_code = ALARMMGR_RESULT_SUCCESS;
1718 cookie = g_base64_decode(e_cookie, &size);
1722 *return_code = ERR_ALARM_NO_PERMISSION;
1723 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
1727 call_gid = security_server_get_gid("alarm");
1729 ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1731 retval = security_server_check_privilege((const char *)cookie, call_gid);
1733 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1734 ALARM_MGR_EXCEPTION_PRINT(
1735 "%s", "access has been denied\n");
1737 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege()\n");
1739 *return_code = ERR_ALARM_NO_PERMISSION;
1743 /*extract day of the week, day in the year &
1744 daylight saving time from system*/
1747 alarm_tm = localtime(&ctime);
1749 alarm_tm->tm_year = year;
1750 alarm_tm->tm_mon = mon;
1751 alarm_tm->tm_mday = day;
1752 alarm_tm->tm_hour = hour;
1753 alarm_tm->tm_min = min;
1754 alarm_tm->tm_sec = sec;
1756 /*convert to calendar time representation*/
1757 time_t rtc_time = mktime(alarm_tm);
1759 /*convert to Coordinated Universal Time (UTC)*/
1760 gmtime_r(&rtc_time, &due_tm);
1762 fd = open(rtc, O_RDONLY);
1764 ALARM_MGR_EXCEPTION_PRINT("RTC open failed.\n");
1766 *return_code = ERR_ALARM_SYSTEM_FAIL;
1770 /* Read the RTC time/date */
1771 retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
1773 ALARM_MGR_EXCEPTION_PRINT("RTC_RD_TIME ioctl failed");
1776 *return_code = ERR_ALARM_SYSTEM_FAIL;
1780 rtc_tm.tm_mday = due_tm.tm_mday;
1781 rtc_tm.tm_mon = due_tm.tm_mon;
1782 rtc_tm.tm_year = due_tm.tm_year;
1783 rtc_tm.tm_hour = due_tm.tm_hour;
1784 rtc_tm.tm_min = due_tm.tm_min;
1785 rtc_tm.tm_sec = due_tm.tm_sec;
1787 memcpy(&rtc_wk.time, &rtc_tm, sizeof(rtc_tm));
1792 retval = ioctl(fd, RTC_WKALM_BOOT_SET, &rtc_wk);
1794 if (errno == ENOTTY) {
1795 ALARM_MGR_EXCEPTION_PRINT("\nAlarm IRQs not"
1798 ALARM_MGR_EXCEPTION_PRINT("RTC_ALM_SET ioctl");
1801 *return_code = ERR_ALARM_SYSTEM_FAIL;
1804 ALARM_MGR_LOG_PRINT("[alarm-server]RTC alarm is setted");
1805 /* Enable alarm interrupts */
1806 retval = ioctl(fd, RTC_AIE_ON, 0);
1808 ALARM_MGR_EXCEPTION_PRINT("RTC_AIE_ON ioctl failed");
1810 *return_code = ERR_ALARM_SYSTEM_FAIL;
1825 gboolean alarm_manager_alarm_create_appsvc(void *pObject, int pid,
1827 int start_month, int start_day,
1828 int start_hour, int start_min,
1829 int start_sec, int end_year, int end_month,
1830 int end_day, int mode_day_of_week,
1831 int mode_repeat, int alarm_type,
1833 char *bundle_data, char *e_cookie,
1834 int *alarm_id, int *return_code)
1836 alarm_info_t alarm_info;
1837 guchar *cookie = NULL;
1841 gboolean result = true;
1843 alarm_info.start.year = start_year;
1844 alarm_info.start.month = start_month;
1845 alarm_info.start.day = start_day;
1846 alarm_info.start.hour = start_hour;
1847 alarm_info.start.min = start_min;
1848 alarm_info.start.sec = start_sec;
1850 alarm_info.end.year = end_year;
1851 alarm_info.end.month = end_month;
1852 alarm_info.end.day = end_day;
1854 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1855 alarm_info.mode.repeat = mode_repeat;
1857 alarm_info.alarm_type = alarm_type;
1858 alarm_info.reserved_info = reserved_info;
1862 cookie = g_base64_decode(e_cookie, &size);
1866 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
1870 call_gid = security_server_get_gid("alarm");
1872 ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1874 retval = security_server_check_privilege((const char *)cookie, call_gid);
1876 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1877 ALARM_MGR_EXCEPTION_PRINT(
1878 "%s", "access has been denied\n");
1880 ALARM_MGR_EXCEPTION_PRINT("Error has occurred in security_server_check_privilege()\n");
1885 result = __alarm_create_appsvc(&alarm_info, alarm_id, pid,
1886 bundle_data, return_code);
1887 if (false == result)
1889 ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm!\n");
1901 gboolean alarm_manager_alarm_create(void *pObject, int pid,
1902 char *app_service_name, char *app_service_name_mod, int start_year,
1903 int start_month, int start_day,
1904 int start_hour, int start_min,
1905 int start_sec, int end_year, int end_month,
1906 int end_day, int mode_day_of_week,
1907 int mode_repeat, int alarm_type,
1909 char *reserved_service_name, char *reserved_service_name_mod, char *e_cookie,
1910 int *alarm_id, int *return_code)
1912 alarm_info_t alarm_info;
1918 alarm_info.start.year = start_year;
1919 alarm_info.start.month = start_month;
1920 alarm_info.start.day = start_day;
1921 alarm_info.start.hour = start_hour;
1922 alarm_info.start.min = start_min;
1923 alarm_info.start.sec = start_sec;
1925 alarm_info.end.year = end_year;
1926 alarm_info.end.month = end_month;
1927 alarm_info.end.day = end_day;
1929 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
1930 alarm_info.mode.repeat = mode_repeat;
1932 alarm_info.alarm_type = alarm_type;
1933 alarm_info.reserved_info = reserved_info;
1937 cookie = g_base64_decode(e_cookie, &size);
1938 call_gid = security_server_get_gid("alarm");
1940 ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1942 retval = security_server_check_privilege((const char *)cookie, call_gid);
1944 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1945 ALARM_MGR_EXCEPTION_PRINT(
1946 "%s", "access has been denied\n");
1948 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
1954 /* return valule and return_code should be checked */
1955 __alarm_create(&alarm_info, alarm_id, pid, app_service_name,app_service_name_mod,
1956 reserved_service_name, reserved_service_name_mod, return_code);
1964 gboolean alarm_manager_alarm_delete(void *pObject, int pid, alarm_id_t alarm_id,
1965 char *e_cookie, int *return_code)
1972 cookie = g_base64_decode(e_cookie, &size);
1973 call_gid = security_server_get_gid("alarm");
1975 ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
1977 retval = security_server_check_privilege((const char *)cookie, call_gid);
1979 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
1980 ALARM_MGR_EXCEPTION_PRINT("%s",
1981 "access has been denied\n");
1983 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
1989 __alarm_delete(pid, alarm_id, return_code);
1997 gboolean alarm_manager_alarm_power_on(void *pObject, int pid, bool on_off,
2001 return __alarm_power_on(pid, on_off, return_code);
2004 gboolean alarm_manager_alarm_power_off(void *pObject, int pid, int *return_code)
2007 return __alarm_power_off(pid, return_code);
2010 bool alarm_manager_alarm_check_next_duetime(void *pObject, int pid,
2013 return __alarm_check_next_duetime(pid, return_code);
2016 gboolean alarm_manager_alarm_update(void *pObject, int pid,
2017 char *app_service_name, alarm_id_t alarm_id,
2018 int start_year, int start_month,
2019 int start_day, int start_hour,
2020 int start_min, int start_sec, int end_year,
2021 int end_month, int end_day,
2022 int mode_day_of_week, int mode_repeat,
2023 int alarm_type, int reserved_info,
2026 alarm_info_t alarm_info;
2027 alarm_info.start.year = start_year;
2028 alarm_info.start.month = start_month;
2029 alarm_info.start.day = start_day;
2030 alarm_info.start.hour = start_hour;
2031 alarm_info.start.min = start_min;
2032 alarm_info.start.sec = start_sec;
2034 alarm_info.end.year = end_year;
2035 alarm_info.end.month = end_month;
2036 alarm_info.end.day = end_day;
2038 alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
2039 alarm_info.mode.repeat = mode_repeat;
2041 alarm_info.alarm_type = alarm_type;
2042 alarm_info.reserved_info = reserved_info;
2046 __alarm_update(pid, app_service_name, alarm_id, &alarm_info,
2052 gboolean alarm_manager_alarm_get_number_of_ids(void *pObject, int pid,
2056 GSList *gs_iter = NULL;
2057 GQuark quark_app_unique_name; /* the fullpath of pid(pid) is
2058 converted to quark value. */
2059 char proc_file[256] = { 0 };
2060 char process_name[512] = { 0 };
2061 char app_name[256] = { 0 };
2063 __alarm_info_t *entry = NULL;
2064 char *proc_name_ptr = NULL;
2069 /* we should consider to check whether pid is running or Not
2071 memset(process_name, '\0', 512);
2072 memset(proc_file, '\0', 256);
2073 snprintf(proc_file, 256, "/proc/%d/cmdline", pid);
2078 fd = open(proc_file, O_RDONLY);
2079 if (fd < 0) { /* failure */
2080 quark_app_unique_name = g_quark_from_string("unknown");
2081 memcpy(app_name, "unknown", strlen("unknown") + 1);
2083 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
2084 "killed, so we failed to get proc file(%s) \n",
2086 *return_code = -1; /* -1 means that system
2087 failed internally. */
2090 ret = read(fd, process_name, 512);
2092 while (process_name[i] != '\0') {
2093 if (process_name[i] == ' ') {
2094 process_name[i] = '\0';
2099 /*if (readlink(proc_file, process_name, 256)!=-1) */
2102 word = strtok_r(process_name, "/", &proc_name_ptr);
2103 while (word != NULL) {
2104 memset(app_name, 0, 256);
2105 snprintf(app_name, 256, "%s", word);
2106 word = strtok_r(NULL, "/", &proc_name_ptr);
2108 quark_app_unique_name = g_quark_from_string(app_name);
2111 ALARM_MGR_LOG_PRINT("called for app(pid:%d, name=%s)\n",
2114 for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2115 gs_iter = g_slist_next(gs_iter)) {
2116 entry = gs_iter->data;
2117 ALARM_MGR_LOG_PRINT("alarm_manager_alarm_get_number_of_ids(): "
2118 "app_name=%s,quark_app_unique_name=%s\n",
2119 app_name, g_quark_to_string(entry->quark_app_unique_name));
2122 g_quark_to_string(entry->quark_app_unique_name)) == 0
2123 && strcmp(app_name, "unknown") != 0) {
2125 ALARM_MGR_LOG_PRINT("inc number of alarms of app "
2126 "(pid:%d, name:%s) is %d\n",
2127 pid, app_name, *num_of_ids);
2131 ALARM_MGR_LOG_PRINT("number of alarms of app(pid:%d, name:%s) is %d\n",
2132 pid, app_name, *num_of_ids);
2136 gboolean alarm_manager_alarm_get_list_of_ids(void *pObject, int pid,
2137 int max_number_of_ids,
2138 GArray **arr, int *num_of_ids,
2141 GSList *gs_iter = NULL;
2142 GQuark quark_app_unique_name; /* the fullpath of pid(pid) is converted
2144 char proc_file[256] = { 0 };
2145 char process_name[512] = { 0 };
2146 char app_name[256] = { 0 };
2148 __alarm_info_t *entry = NULL;
2150 char *proc_name_ptr = NULL;
2154 GArray *garray = NULL;
2158 garray = g_array_new(false, true, sizeof(alarm_id_t));
2160 /* we should check that there is a resource leak.
2161 * Now we don't have free code for g_array_new().
2163 if (max_number_of_ids <= 0) {
2165 ALARM_MGR_EXCEPTION_PRINT("called for pid(%d), but "
2166 "max_number_of_ids(%d) is less than 0.\n",
2167 pid, max_number_of_ids);
2171 /* we should consider to check whether pid is running or Not
2173 memset(process_name, '\0', 512);
2174 memset(proc_file, '\0', 256);
2175 snprintf(proc_file, 256, "/proc/%d/cmdline", pid);
2177 fd = open(proc_file, O_RDONLY);
2178 if (fd < 0) { /* failure */
2179 quark_app_unique_name = g_quark_from_string("unknown");
2180 memcpy(app_name, "unknown", strlen("unknown") + 1);
2182 ALARM_MGR_EXCEPTION_PRINT("Caution!! app_pid(%d) seems to be "
2183 "killed, so we failed to get proc file(%s)\n", pid, proc_file);
2185 /* -1 means that system failed internally. */
2188 ret = read(fd, process_name, 512);
2190 while (process_name[i] != '\0') {
2191 if (process_name[i] == ' ') {
2192 process_name[i] = '\0';
2197 /* if (readlink(proc_file, process_name, 256)!=-1) */
2200 word = strtok_r(process_name, "/", &proc_name_ptr);
2201 while (word != NULL) {
2202 memset(app_name, 0, 256);
2203 snprintf(app_name, 256, "%s", word);
2204 word = strtok_r(NULL, "/", &proc_name_ptr);
2206 quark_app_unique_name = g_quark_from_string(app_name);
2209 ALARM_MGR_LOG_PRINT("called for app(pid:%d, name=%s)\n",
2212 for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2213 gs_iter = g_slist_next(gs_iter)) {
2214 entry = gs_iter->data;
2217 g_quark_to_string(entry->quark_app_unique_name)) == 0
2218 && strcmp(app_name, "unknown") != 0) {
2219 g_array_append_val(garray, entry->alarm_id);
2223 *num_of_ids = index;
2230 gboolean alarm_manager_alarm_get_appsvc_info(void *pObject, int pid, alarm_id_t alarm_id,
2231 char *e_cookie, gchar **b_data, int *return_code)
2235 GSList *gs_iter = NULL;
2236 __alarm_info_t *entry = NULL;
2238 guchar *cookie = NULL;
2243 ALARM_MGR_LOG_PRINT("called for pid(%d) and alarm_id(%d)\n", pid,
2246 cookie = g_base64_decode(e_cookie, &size);
2250 *return_code = ERR_ALARM_SYSTEM_FAIL;
2251 ALARM_MGR_EXCEPTION_PRINT("Unable to decode cookie!!!\n");
2254 call_gid = security_server_get_gid("alarm");
2256 ALARM_MGR_LOG_PRINT("call_gid : %d\n", call_gid);
2258 retval = security_server_check_privilege((const char *)cookie, call_gid);
2260 if (retval == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) {
2261 ALARM_MGR_EXCEPTION_PRINT(
2262 "%s", "access has been denied\n");
2264 ALARM_MGR_EXCEPTION_PRINT("%s", "Error has occurred\n");
2267 *return_code = ERR_ALARM_NO_PERMISSION;
2278 for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2279 gs_iter = g_slist_next(gs_iter)) {
2280 entry = gs_iter->data;
2281 if (entry->alarm_id == alarm_id) {
2283 *b_data = g_strdup(g_quark_to_string(entry->quark_bundle));
2289 if ( *b_data && strlen(*b_data) == 4 && strncmp(*b_data,"null",4) == 0){
2290 ALARM_MGR_EXCEPTION_PRINT("Regular alarm,not svc alarm");
2292 *return_code = ERR_ALARM_INVALID_TYPE;
2296 *return_code = ERR_ALARM_INVALID_ID;
2305 gboolean alarm_manager_alarm_get_info(void *pObject, int pid,
2306 alarm_id_t alarm_id, int *start_year,
2307 int *start_month, int *start_day,
2308 int *start_hour, int *start_min,
2309 int *start_sec, int *end_year,
2310 int *end_month, int *end_day,
2311 int *mode_day_of_week, int *mode_repeat,
2312 int *alarm_type, int *reserved_info,
2315 ALARM_MGR_LOG_PRINT("called for pid(%d) and alarm_id(%d)\n", pid,
2318 GSList *gs_iter = NULL;
2319 __alarm_info_t *entry = NULL;
2321 alarm_info_t *alarm_info = NULL;
2324 for (gs_iter = alarm_context.alarms; gs_iter != NULL;
2325 gs_iter = g_slist_next(gs_iter)) {
2326 entry = gs_iter->data;
2327 if (entry->alarm_id == alarm_id) {
2328 alarm_info = &(entry->alarm_info);
2333 if (alarm_info == NULL)
2335 ALARM_MGR_EXCEPTION_PRINT("alarm id(%d) was not found\n",
2337 *return_code = ERR_ALARM_INVALID_ID;
2339 ALARM_MGR_LOG_PRINT("alarm was found\n");
2340 *start_year = alarm_info->start.year;
2341 *start_month = alarm_info->start.month;
2342 *start_day = alarm_info->start.day;
2343 *start_hour = alarm_info->start.hour;
2344 *start_min = alarm_info->start.min;
2345 *start_sec = alarm_info->start.sec;
2347 *end_year = alarm_info->end.year;
2348 *end_year = alarm_info->end.month;
2349 *end_year = alarm_info->end.day;
2351 *mode_day_of_week = alarm_info->mode.u_interval.day_of_week;
2352 *mode_repeat = alarm_info->mode.repeat;
2354 *alarm_type = alarm_info->alarm_type;
2355 *reserved_info = alarm_info->reserved_info;
2362 #include "alarm-skeleton.h"
2364 typedef struct AlarmManagerObject AlarmManagerObject;
2365 typedef struct AlarmManagerObjectClass AlarmManagerObjectClass;
2366 GType Server_Object_get_type(void);
2367 struct AlarmManagerObject {
2370 struct AlarmManagerObjectClass {
2371 GObjectClass parent;
2374 #define DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT 0
2376 #define ALARM_MANAGER_TYPE_OBJECT (Server_Object_get_type())
2377 #define ALARM_MANAGER_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST \
2378 ((object), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObject))
2379 #define ALARM_MANAGER_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \
2380 ((klass), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObjectClass))
2381 #define ALARM_MANAGER_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE \
2382 ((object), ALARM_MANAGER_TYPE_OBJECT))
2383 #define ALARM_MANAGER_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \
2384 ((klass), ALARM_MANAGER_TYPE_OBJECT))
2385 #define ALARM_MANAGER_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \
2386 ((obj), ALARM_MANAGER_TYPE_OBJECT, AlarmManagerObjectClass))
2387 G_DEFINE_TYPE(AlarmManagerObject, Server_Object, G_TYPE_OBJECT)
2388 static void Server_Object_init(AlarmManagerObject * obj)
2393 static void Server_Object_class_init(AlarmManagerObjectClass *klass)
2398 static void __initialize_timer()
2400 struct sigaction sig_timer;
2401 sigemptyset(&sig_timer.sa_mask);
2402 sig_timer.sa_flags = SA_SIGINFO;
2403 sig_timer.sa_sigaction = (void *)__alarm_handler;
2404 sigaction(SIG_TIMER, &sig_timer, NULL);
2406 alarm_context.timer = _alarm_create_timer();
2410 static void __initialize_alarm_list()
2413 alarm_context.alarms = NULL;
2414 alarm_context.c_due_time = -1;
2416 _load_alarms_from_registry();
2418 __rtc_set(); /*Set RTC1 Alarm with alarm due time for alarm-manager initialization*/
2423 if (enable_power_on_alarm) {
2424 /* orginally first arg's value was 21(app_id, WAKEUP_ALARM_APP_ID) in a
2425 * platform with app-server. because __alarm_power_on(..) fuction don't
2426 * use first parameter internally, we set this value to 0(zero)
2428 __alarm_power_on(0, enable_power_on_alarm, NULL);
2433 static void __initialize_scheduled_alarm_lsit()
2435 _init_scheduled_alarm_list();
2439 static void __hibernation_leave_callback()
2442 __initialize_scheduled_alarm_lsit();
2444 __alarm_clean_list();
2446 __initialize_alarm_list();
2449 static bool __initialize_noti()
2452 int fd = heynoti_init();
2454 ALARM_MGR_EXCEPTION_PRINT("fail to heynoti_init\n");
2457 heynoti_subscribe(fd, "HIBERNATION_LEAVE", __hibernation_leave_callback,
2459 ret = heynoti_attach_handler(fd);
2461 ALARM_MGR_EXCEPTION_PRINT("heynoti_attach_handler fail");
2464 if (vconf_notify_key_changed
2465 (VCONFKEY_SYSTEM_TIMECHANGE, __on_system_time_changed, NULL) < 0) {
2466 ALARM_MGR_LOG_PRINT(
2467 "Failed to add callback for time changing event\n");
2469 /*system state change noti ó¸® */
2471 if (vconf_notify_key_changed
2472 (VCONFKEY_SETAPPL_TIMEZONE_ID, __on_time_zone_changed, NULL) < 0) {
2473 ALARM_MGR_LOG_PRINT(
2474 "Failed to add callback for time changing event\n");
2481 static DBusHandlerResult __alarm_server_filter(DBusConnection *connection,
2482 DBusMessage *message,
2486 if (dbus_message_is_signal
2487 (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
2492 __expired_alarm_t *expire_info;
2494 dbus_message_get_args(message,
2496 DBUS_TYPE_STRING, &service,
2497 DBUS_TYPE_STRING, &old_owner,
2498 DBUS_TYPE_STRING, &new_owner,
2501 for (entry = g_expired_alarm_list; entry; entry = entry->next) {
2503 expire_info = (__expired_alarm_t *) entry->data;
2505 if (strcmp(expire_info->service_name, service)
2507 ALARM_MGR_EXCEPTION_PRINT(
2508 "__alarm_server_filter : "
2509 "service name(%s) alarm_id (%d)\n",
2510 expire_info->service_name,\
2511 expire_info->alarm_id);
2513 __alarm_send_noti_to_application(
2514 expire_info->service_name,
2515 expire_info->alarm_id);
2516 g_expired_alarm_list =
2517 g_slist_remove(g_expired_alarm_list,
2524 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2527 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2530 static bool __initialize_dbus()
2532 GError *error = NULL;
2533 GObject *obj = NULL;
2534 DBusGConnection *connection = NULL;
2536 int request_name_result = 0;
2538 dbus_g_object_type_install_info(ALARM_MANAGER_TYPE_OBJECT,
2539 &dbus_glib_alarm_manager_object_info);
2541 connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
2544 ALARM_MGR_EXCEPTION_PRINT("dbus_g_bus_get failed\n");
2548 dbus_error_init(&derror);
2550 request_name_result =
2551 dbus_bus_request_name(dbus_g_connection_get_connection(connection),
2552 "org.tizen.alarm.manager",
2553 DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT, &derror);
2554 if (dbus_error_is_set(&derror)) { /* failure */
2555 ALARM_MGR_EXCEPTION_PRINT("Failed to dbus_bus_request_name "
2556 "(org.tizen.alarm.manager): %s\n", derror.message);
2557 dbus_error_free(&derror);
2561 if (!(obj = g_object_new(ALARM_MANAGER_TYPE_OBJECT, NULL))) {
2562 ALARM_MGR_EXCEPTION_PRINT("Could not allocate new object\n");
2566 dbus_g_connection_register_g_object(connection,
2567 "/org/tizen/alarm/manager",
2570 /*dbus_bus_add_match (dbus_g_connection_get_connection(connection),
2571 "type='signal',member='NameOwnerChanged'",NULL); */
2573 dbus_bus_add_match(dbus_g_connection_get_connection(connection),
2574 "type='signal',sender='" DBUS_SERVICE_DBUS
2575 "',path='" DBUS_PATH_DBUS
2576 "',interface='" DBUS_INTERFACE_DBUS
2577 "',member='NameOwnerChanged'", NULL);
2579 if (!dbus_connection_add_filter
2580 (dbus_g_connection_get_connection(connection),
2581 __alarm_server_filter, NULL, NULL)) {
2582 ALARM_MGR_EXCEPTION_PRINT("add __expire_alarm_filter failed\n");
2587 alarm_context.bus = connection;
2591 #define ALARMMGR_DB_FILE "/opt/dbspace/.alarmmgr.db"
2592 sqlite3 *alarmmgr_db;
2593 #define QUERY_CREATE_TABLE_ALARMMGR "create table alarmmgr \
2594 (alarm_id integer primary key,\
2598 app_unique_name text,\
2599 app_service_name text,\
2600 app_service_name_mod text,\
2608 day_of_week integer,\
2610 alarm_type integer,\
2611 reserved_info integer,\
2612 dst_service_name text, \
2613 dst_service_name_mod text \
2616 static bool __initialize_db()
2618 char *error_message = NULL;
2621 if (access("/opt/dbspace/.alarmmgr.db", F_OK) == 0) {
2623 db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db,
2624 DB_UTIL_REGISTER_HOOK_METHOD);
2626 if (ret != SQLITE_OK) {
2627 ALARM_MGR_EXCEPTION_PRINT(
2628 "====>>>> connect menu_db [%s] failed!\n",
2637 db_util_open(ALARMMGR_DB_FILE, &alarmmgr_db,
2638 DB_UTIL_REGISTER_HOOK_METHOD);
2640 if (ret != SQLITE_OK) {
2641 ALARM_MGR_EXCEPTION_PRINT(
2642 "====>>>> connect menu_db [%s] failed!\n",
2648 sqlite3_exec(alarmmgr_db, QUERY_CREATE_TABLE_ALARMMGR, NULL, NULL,\
2650 ALARM_MGR_EXCEPTION_PRINT("Don't execute query = %s, "
2651 "error message = %s\n", QUERY_CREATE_TABLE_ALARMMGR,
2659 static void __initialize()
2668 fp = fopen("/proc/alarm_boot", "r");
2673 size = fread(&temp, 1, 1, fp);
2678 alarm_boot = atoi(temp);
2686 struct rtc_time rtc_tm;
2689 fd = open(power_rtc, O_RDONLY);
2691 ALARM_MGR_EXCEPTION_PRINT("cannot open /dev/rtc0\n");
2694 retval = ioctl(fd, RTC_RD_TIME, &rtc_tm);
2697 fd2 = open(default_rtc, O_RDWR);
2699 ALARM_MGR_EXCEPTION_PRINT("cannot open /dev/rtc1\n");
2702 retval = ioctl(fd2, RTC_SET_TIME, &rtc_tm);
2705 __initialize_timer();
2706 if (__initialize_dbus() == false) { /* because dbus's initialize
2707 failed, we cannot continue any more. */
2708 ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
2709 "alarm-server cannot be runned.\n");
2712 __initialize_scheduled_alarm_lsit();
2714 __initialize_alarm_list();
2715 __initialize_noti();
2720 static bool __check_false_alarm()
2722 time_t current_time;
2725 time(¤t_time);
2727 interval = ab_due_time - current_time;
2729 ALARM_MGR_LOG_PRINT("due_time : %d / current_time %d\n", \
2730 alarm_context.c_due_time, current_time);
2732 if (interval > 0 && interval <= 30) {
2734 } else if (!poweron_alarm_expired) {
2735 /* originally, first arguement's value was 121(app_id) which means
2736 * alarm_booting ui application.and this application's dbus-service
2737 * name had a org.tizen.alarmboot.ui in a platform with app-server.
2738 * so we set "org.tizen.alarmboot.ui.ALARM" instead of 121.
2740 __alarm_send_noti_to_application(
2741 WAKEUP_ALARMBOOTING_APP_ID, -1);
2751 GMainLoop *mainloop = NULL;
2753 ALARM_MGR_LOG_PRINT("Enter main loop\n");
2755 mainloop = g_main_loop_new(NULL, FALSE);
2761 __check_false_alarm();
2765 g_main_loop_run(mainloop);