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.
23 #define _BSD_SOURCE /*localtime_r requires */
34 #include"alarm-internal.h"
35 #define WAKEUP_ALARM_APP_ID "org.tizen.alarm.ALARM" /*alarm ui
36 application's alarm's dbus_service name instead of 21 value */
37 #define DST_TIME_DIFF 1
39 extern __alarm_server_context_t alarm_context;
40 extern GSList *g_scheduled_alarm_list;
42 static time_t __alarm_next_duetime_once(__alarm_info_t *__alarm_info);
43 static time_t __alarm_next_duetime_repeat(__alarm_info_t *__alarm_info);
44 static time_t __alarm_next_duetime_annually(__alarm_info_t *__alarm_info);
45 static time_t __alarm_next_duetime_monthly(__alarm_info_t *__alarm_info);
46 static time_t __alarm_next_duetime_weekly(__alarm_info_t *__alarm_info);
47 static bool __find_next_alarm_to_be_scheduled(time_t *min_due_time);
48 bool _alarm_schedule(void);
50 bool _clear_scheduled_alarm_list()
52 g_slist_free_full(g_scheduled_alarm_list, g_free);
53 g_scheduled_alarm_list = NULL;
58 bool _init_scheduled_alarm_list()
60 _clear_scheduled_alarm_list();
65 bool _add_to_scheduled_alarm_list(__alarm_info_t *__alarm_info)
68 * 20080328. Sewook Park(sewook7.park@samsung.com)
69 * When multiple alarms are expired at same time, dbus rpc call for alarm
70 * ui should be invoked first.(Ui conflicting manager cannot manage the
71 * different kinds of alarm popups(wake up alarm/org alarm) correctly,
72 * when they are displayed at same time)So when arranging the schedule
73 * alarm list, wake up alarm element is located ahead.
79 __scheduled_alarm_t *alarm = NULL;
80 __scheduled_alarm_t *entry = NULL;
82 alarm = g_malloc(sizeof(__scheduled_alarm_t));
88 alarm->alarm_id = __alarm_info->alarm_id;
89 alarm->pid = __alarm_info->pid;
90 alarm->__alarm_info = __alarm_info;
92 SECURE_LOGD("%s :alarm->pid =%d, app_service_name=%s(%u)\n",
93 __FUNCTION__, alarm->pid,
94 g_quark_to_string(alarm->__alarm_info->quark_app_service_name),
95 alarm->__alarm_info->quark_app_service_name);
97 if (alarm->__alarm_info->quark_app_service_name != g_quark_from_string(WAKEUP_ALARM_APP_ID)) {
98 g_scheduled_alarm_list = g_slist_append(g_scheduled_alarm_list, alarm);
101 for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
104 if (entry->__alarm_info->quark_app_service_name != g_quark_from_string(WAKEUP_ALARM_APP_ID)) {
111 g_scheduled_alarm_list = g_slist_append(g_scheduled_alarm_list, alarm);
112 ALARM_MGR_LOG_PRINT("appended : prior is %d\tcount is %d\n", prior, count);
115 g_scheduled_alarm_list = g_slist_insert(g_scheduled_alarm_list, alarm, count - 1);
116 ALARM_MGR_LOG_PRINT("appended : prior is %d\tcount is %d\n", prior, count);
123 bool _remove_from_scheduled_alarm_list(int pid, alarm_id_t alarm_id)
127 __scheduled_alarm_t *alarm = NULL;
129 for (iter = g_scheduled_alarm_list; iter != NULL; iter = g_slist_next(iter)) {
131 if (alarm->alarm_id == alarm_id) {
132 g_scheduled_alarm_list = g_slist_remove(g_scheduled_alarm_list, iter->data);
139 if (g_slist_length(g_scheduled_alarm_list) == 0) {
140 alarm_context.c_due_time = -1;
146 static time_t __alarm_next_duetime_once(__alarm_info_t *__alarm_info)
149 time_t due_time_tmp = 0;
150 time_t current_time = 0;
151 struct tm duetime_tm;
155 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
156 alarm_date_t *start = &alarm_info->start;
160 localtime_r(¤t_time, &duetime_tm);
161 duetime_tm.tm_hour = start->hour;
162 duetime_tm.tm_min = start->min;
163 duetime_tm.tm_sec = start->sec;
165 current_dst = duetime_tm.tm_isdst;
166 duetime_tm.tm_isdst = -1;
168 if (start->year == 0 && start->month == 0 && start->day == 0)
170 due_time = mktime(&duetime_tm);
171 if (!(due_time > current_time)) {
172 due_time = due_time + 60 * 60 * 24;
174 } else /*specific date*/ {
175 duetime_tm.tm_year = start->year - 1900;
176 duetime_tm.tm_mon = start->month - 1;
177 duetime_tm.tm_mday = start->day;
178 due_time = mktime(&duetime_tm);
181 if (due_time <= current_time) {
182 ALARM_MGR_EXCEPTION_PRINT("duetime is less than or equal to current time. current_dst = %d", current_dst);
183 duetime_tm.tm_isdst = 0; // DST off
185 due_time_tmp = mktime(&duetime_tm);
186 localtime_r(&due_time_tmp, &tmp_tm);
188 ALARM_MGR_LOG_PRINT("%d:%d:%d. duetime = %d", tmp_tm.tm_hour, tmp_tm.tm_min, tmp_tm.tm_sec, due_time);
189 if (tmp_tm.tm_hour == start->hour && tmp_tm.tm_min == start->min && tmp_tm.tm_sec == start->sec ) {
190 due_time = due_time_tmp;
191 ALARM_MGR_EXCEPTION_PRINT("due_time = %d",due_time);
195 localtime_r(&due_time, &tmp_tm);
196 ALARM_MGR_LOG_PRINT("%d:%d:%d. current_dst = %d, duetime_dst = %d", tmp_tm.tm_hour, tmp_tm.tm_min, tmp_tm.tm_sec, current_dst, tmp_tm.tm_isdst);
198 if (current_dst == 1 && tmp_tm.tm_isdst == 1 && tmp_tm.tm_hour == start->hour + 1) {
199 // When the calculated duetime is forwarded 1hour due to DST, Adds 23hours.
200 due_time += 60 * 60 * 23;
201 localtime_r(&due_time, &duetime_tm);
202 ALARM_MGR_EXCEPTION_PRINT("due_time = %d",due_time);
206 ALARM_MGR_EXCEPTION_PRINT("Final due_time = %d, %s",due_time, ctime(&due_time));
210 static time_t __alarm_next_duetime_repeat(__alarm_info_t *__alarm_info)
213 time_t current_time = 0;
214 struct tm duetime_tm;
216 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
217 alarm_date_t *start = &alarm_info->start;
220 /*localtime_r(¤t_time, &duetime_tm); */
222 duetime_tm.tm_hour = start->hour;
223 duetime_tm.tm_min = start->min;
224 duetime_tm.tm_sec = start->sec;
226 duetime_tm.tm_year = start->year - 1900;
227 duetime_tm.tm_mon = start->month - 1;
228 duetime_tm.tm_mday = start->day;
229 duetime_tm.tm_isdst = -1;
231 due_time = mktime(&duetime_tm);
233 while (__alarm_info->start > due_time || current_time >= due_time) {
234 due_time += alarm_info->mode.u_interval.interval;
236 /* due_time = mktime(&duetime_tm); */
239 if (due_time - current_time < 10)
240 due_time += alarm_info->mode.u_interval.interval;
242 localtime_r(&due_time, &duetime_tm);
244 start->year = duetime_tm.tm_year + 1900;
245 start->month = duetime_tm.tm_mon + 1;
246 start->day = duetime_tm.tm_mday;
247 start->hour = duetime_tm.tm_hour;
248 start->min = duetime_tm.tm_min;
249 start->sec = duetime_tm.tm_sec;
255 static time_t __alarm_next_duetime_annually(__alarm_info_t *__alarm_info)
258 time_t current_time = 0;
259 struct tm duetime_tm;
261 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
262 alarm_date_t *start = &alarm_info->start;
265 localtime_r(¤t_time, &duetime_tm);
266 duetime_tm.tm_hour = start->hour;
267 duetime_tm.tm_min = start->min;
268 duetime_tm.tm_sec = start->sec;
270 if (start->year != 0) {
271 duetime_tm.tm_year = start->year - 1900;
274 duetime_tm.tm_mon = start->month - 1;
275 duetime_tm.tm_mday = start->day;
277 due_time = mktime(&duetime_tm);
279 while (__alarm_info->start > due_time || current_time > due_time) {
280 duetime_tm.tm_year += 1;
281 due_time = mktime(&duetime_tm);
288 static time_t __alarm_next_duetime_monthly(__alarm_info_t *__alarm_info)
291 time_t current_time = 0;
292 struct tm duetime_tm;
294 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
295 alarm_date_t *start = &alarm_info->start;
298 localtime_r(¤t_time, &duetime_tm);
299 duetime_tm.tm_hour = start->hour;
300 duetime_tm.tm_min = start->min;
301 duetime_tm.tm_sec = start->sec;
303 if (start->year != 0) {
304 duetime_tm.tm_year = start->year - 1900;
307 if (start->month != 0) {
309 duetime_tm.tm_mon = start->month - 1;
312 duetime_tm.tm_mday = start->day;
314 due_time = mktime(&duetime_tm);
316 while (__alarm_info->start > due_time || current_time > due_time) {
317 duetime_tm.tm_mon += 1;
318 if (duetime_tm.tm_mon == 12) {
319 duetime_tm.tm_mon = 0;
320 duetime_tm.tm_year += 1;
322 due_time = mktime(&duetime_tm);
329 static time_t __alarm_next_duetime_weekly(__alarm_info_t *__alarm_info)
332 time_t current_time = 0;
333 struct tm duetime_tm;
340 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
341 alarm_date_t *start = &alarm_info->start;
342 alarm_mode_t *mode = &alarm_info->mode;
346 localtime_r(¤t_time, &duetime_tm);
347 wday = duetime_tm.tm_wday;
348 duetime_tm.tm_hour = start->hour;
349 duetime_tm.tm_min = start->min;
350 duetime_tm.tm_sec = start->sec;
351 current_dst = duetime_tm.tm_isdst;
353 duetime_tm.tm_isdst = -1;
355 if (__alarm_info->start != 0) {
356 if (__alarm_info->start >= current_time) {
357 duetime_tm.tm_year = start->year - 1900;
358 duetime_tm.tm_mon = start->month - 1;
359 duetime_tm.tm_mday = start->day;
363 due_time = mktime(&duetime_tm);
364 localtime_r(&due_time, &tmp_tm);
365 ALARM_MGR_EXCEPTION_PRINT("%d:%d:%d. duetime = %d, isdst = %d", tmp_tm.tm_hour, tmp_tm.tm_min, tmp_tm.tm_sec, due_time, tmp_tm.tm_isdst);
367 if (due_time <= current_time) {
368 ALARM_MGR_EXCEPTION_PRINT("duetime is less than or equal to current time. current_dst = %d", current_dst);
369 duetime_tm.tm_isdst = 0;
371 due_time = mktime(&duetime_tm);
372 localtime_r(&due_time, &tmp_tm);
374 SECURE_LOGD("%d:%d:%d. duetime = %d", tmp_tm.tm_hour, tmp_tm.tm_min, tmp_tm.tm_sec, due_time);
375 if (tmp_tm.tm_hour != start->hour || tmp_tm.tm_min != start->min || tmp_tm.tm_sec != start->sec ) {
376 duetime_tm.tm_hour = start->hour;
377 duetime_tm.tm_min = start->min;
378 duetime_tm.tm_sec = start->sec;
379 duetime_tm.tm_isdst = -1;
380 due_time = mktime(&duetime_tm);
381 ALARM_MGR_EXCEPTION_PRINT("due_time = %d",due_time);
385 if (current_dst == 1 && tmp_tm.tm_isdst == 1 && tmp_tm.tm_hour == start->hour + 1) {
386 // When the calculated duetime is forwarded 1hour due to DST, Adds 23hours.
387 due_time += 60 * 60 * 23;
388 localtime_r(&due_time, &duetime_tm);
389 ALARM_MGR_EXCEPTION_PRINT("due_time = %d",due_time);
393 // Gets the dst before calculating the duedate as interval
394 localtime_r(&due_time, &before_tm);
395 SECURE_LOGD("before_dst = %d", before_tm.tm_isdst);
397 wday = duetime_tm.tm_wday;
399 ALARM_MGR_EXCEPTION_PRINT("current_time(%d) due_time(%d)", current_time, due_time);
401 /* CQ defect(72810) : only one time alarm function is not working
402 under all recurrence_disabled. */
403 if (due_time > current_time && mode->u_interval.day_of_week == 0) {
407 if (current_time >= due_time || !(mode->u_interval.day_of_week & 1 << wday)) {
416 while (!(mode->u_interval.day_of_week & 1 << day) && interval < 8) {
425 ALARM_MGR_LOG_PRINT("interval : %d\n", interval);
426 due_time += 60 * 60 * 24 * interval;
429 // Gets the dst after calculating the duedate as interval
430 localtime_r(&due_time, &after_tm);
431 SECURE_LOGD("after_dst = %d", after_tm.tm_isdst);
433 // Revise the duetime as difference in tm_isdst
434 if (before_tm.tm_isdst == 1 && after_tm.tm_isdst == 0) {
435 due_time += 60 * 60; // Add an hour
436 } else if (before_tm.tm_isdst == 0 && after_tm.tm_isdst == 1) {
437 due_time -= 60 * 60; // Subtract an hour
440 ALARM_MGR_EXCEPTION_PRINT("Final due_time = %d", due_time);
444 time_t _alarm_next_duetime(__alarm_info_t *__alarm_info)
447 time_t current_time = 0;
449 struct tm *cur_tm = NULL ;
450 struct tm *due_tm = NULL ;
452 alarm_info_t *alarm_info = &__alarm_info->alarm_info;
453 alarm_mode_t *mode = &alarm_info->mode;
456 cur_tm = localtime(¤t_time);
457 if (cur_tm && cur_tm->tm_isdst > 0)
460 ALARM_MGR_LOG_PRINT("mode->repeat is %d\n", mode->repeat);
462 if (mode->repeat == ALARM_REPEAT_MODE_ONCE) {
463 due_time = __alarm_next_duetime_once(__alarm_info);
464 } else if (mode->repeat == ALARM_REPEAT_MODE_REPEAT) {
465 due_time = __alarm_next_duetime_repeat(__alarm_info);
466 } else if (mode->repeat == ALARM_REPEAT_MODE_ANNUALLY) {
467 due_time = __alarm_next_duetime_annually(__alarm_info);
468 } else if (mode->repeat == ALARM_REPEAT_MODE_MONTHLY) {
469 due_time = __alarm_next_duetime_monthly(__alarm_info);
470 } else if (mode->repeat == ALARM_REPEAT_MODE_WEEKLY) {
471 due_time = __alarm_next_duetime_weekly(__alarm_info);
473 ALARM_MGR_EXCEPTION_PRINT("repeat mode(%d) is wrong\n",
478 if (mode->repeat != ALARM_REPEAT_MODE_WEEKLY && mode->repeat != ALARM_REPEAT_MODE_ONCE) {
479 due_tm = localtime(&due_time);
480 if (is_dst==0 && due_tm && due_tm->tm_isdst==1){
481 ALARM_MGR_LOG_PRINT("DST alarm found, enable\n");
482 due_tm->tm_hour = due_tm->tm_hour - DST_TIME_DIFF;
483 } else if (is_dst==1 && due_tm && due_tm->tm_isdst==0){
484 ALARM_MGR_LOG_PRINT("DST alarm found. disable\n");
485 due_tm->tm_hour = due_tm->tm_hour + DST_TIME_DIFF;
489 due_time = mktime(due_tm);
492 ALARM_MGR_EXCEPTION_PRINT("alarm_id: %d, next duetime: %d", __alarm_info->alarm_id, due_time);
494 if (__alarm_info->end != 0 && __alarm_info->end < due_time) {
495 ALARM_MGR_LOG_PRINT("due time > end time");
496 __alarm_info->due_time = 0;
499 __alarm_info->due_time = due_time;
504 static bool __find_next_alarm_to_be_scheduled(time_t *min_due_time)
507 time_t min_time = -1;
510 __alarm_info_t *entry = NULL;
514 for (iter = alarm_context.alarms; iter != NULL;
515 iter = g_slist_next(iter)) {
517 due_time = entry->due_time;
521 SECURE_LOGD("alarm[%d] with duetime(%u) at current(%u) pid: (%d)\n",
522 entry->alarm_id, due_time, current_time, entry->pid);
523 if (due_time == 0) /*0 means this alarm has been disabled*/ {
527 interval = difftime(due_time, current_time);
529 if (interval <= 0) /*2008.08.06 when the alarm expires, it may makes an error.*/ {
530 ALARM_MGR_EXCEPTION_PRINT("The duetime of alarm(%d) is OVER.", entry->alarm_id);
534 interval = difftime(due_time, min_time);
536 if ((interval < 0) || min_time == -1) {
542 *min_due_time = min_time;
546 bool _alarm_schedule()
551 __alarm_info_t *entry = NULL;
553 __find_next_alarm_to_be_scheduled(&min_time);
555 if (min_time == -1) {
556 ALARM_MGR_LOG_PRINT("[alarm-server][schedule]: There is no alarm to be scheduled.");
558 for (iter = alarm_context.alarms; iter != NULL; iter = g_slist_next(iter)) {
560 due_time = entry->due_time;
562 if (due_time == min_time) {
563 _add_to_scheduled_alarm_list(entry);
566 _alarm_set_timer(&alarm_context, alarm_context.timer, min_time);