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.
34 #include<dbus/dbus-glib.h>
37 #include <dbus/dbus-glib-lowlevel.h>
40 #include "alarm-internal.h"
41 #include "alarm-stub.h"
46 #define MAX_KEY_SIZE 256
48 static alarm_context_t alarm_context = { NULL, NULL, NULL, NULL, -1 };
50 static bool b_initialized = false;
51 static bool sub_initialized = false;
53 pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
55 #define MAX_OBJECT_PATH_LEN 256
56 #define DBUS_NAME_FLAG_PROHIBIT_REPLACEMENT 0
58 static DBusHandlerResult __expire_alarm_filter(DBusConnection *connection,
61 static int __alarm_validate_date(alarm_date_t *date, int *error_code);
62 static bool __alarm_validate_time(alarm_date_t *date, int *error_code);
63 static int __sub_init(void);
64 static int __alarmmgr_init_appsvc(void);
65 bool alarm_power_off(int *error_code);
66 int alarmmgr_check_next_duetime(void);
68 typedef struct _alarm_cb_info_t {
72 struct _alarm_cb_info_t *next;
75 static alarm_cb_info_t *alarmcb_head = NULL;
77 static void __add_resultcb(int alarm_id, alarm_cb_t cb_func,
80 alarm_cb_info_t *info;
82 info = (alarm_cb_info_t *) malloc(sizeof(alarm_cb_info_t));
85 info->alarm_id = alarm_id;
86 info->cb_func = cb_func;
87 info->priv_data = data;
89 info->next = alarmcb_head;
93 static alarm_cb_info_t *__find_resultcb(int alarm_id)
99 if (tmp->alarm_id == alarm_id)
106 static void __remove_resultcb(alarm_cb_info_t *info)
108 alarm_cb_info_t *tmp;
110 if (alarmcb_head == NULL || info == NULL)
113 if (alarmcb_head == info) {
114 alarmcb_head = info->next;
121 if (tmp->next == info) {
122 tmp->next = info->next;
130 static DBusHandlerResult __expire_alarm_filter(DBusConnection *connection,
131 DBusMessage *message,
134 alarm_cb_info_t *info;
136 if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
137 const char *method_name = dbus_message_get_member(message);
140 if (strcmp(method_name, "alarm_expired") == 0) {
141 DBusMessageIter iter;
143 const char *service_name =
144 dbus_message_get_destination(message);
145 const char *object_path =
146 dbus_message_get_path(message);
147 /* "/com/samsung/alarm/client" */
148 const char *interface_name =
149 dbus_message_get_interface(message);
150 /* "com.samsung.alarm.client" */
152 dbus_message_iter_init(message, &iter);
153 dbus_message_iter_get_basic(&iter, &alarm_id);
155 SECURE_LOGD("[alarm-lib]:service_name=%s, "
156 "object_path=%s, interface_name=%s, method_name=%s, "
157 "alarm_id=%d, handler=%s\n",
158 service_name ? service_name : "no name",
159 object_path ? object_path : "no path",
160 interface_name ? interface_name : "no interface",
161 method_name ? method_name : "no method", alarm_id,
162 alarm_context.alarm_handler ? "ok" : "no handler");
164 if (alarm_context.alarm_handler != NULL)
165 /* alarm_context.alarm_handler(alarm_id); */
166 alarm_context.alarm_handler(alarm_id,
167 alarm_context.user_param);
168 info = __find_resultcb(alarm_id);
170 if( info && info->cb_func ) {
171 info->cb_func(alarm_id, info->priv_data);
172 // __remove_resultcb(info);
175 return DBUS_HANDLER_RESULT_HANDLED;
179 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
182 static int __alarm_validate_date(alarm_date_t *date, int *error_code)
185 if (date->year == 0 && date->month == 0 && date->day == 0) {
189 int year = date->year;
190 int month = date->month;
193 if (month < 1 || month > 12) {
195 *error_code = ERR_ALARM_INVALID_DATE;
199 if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8
200 || month == 10 || month == 12)
201 && (day < 1 || day > 31)) {
203 *error_code = ERR_ALARM_INVALID_DATE;
207 if ((month == 4 || month == 6 || month == 9 || month == 11)
208 && (day < 1 || day > 30)) {
210 *error_code = ERR_ALARM_INVALID_DATE;
215 if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
216 if (day < 1 || day > 29) {
218 *error_code = ERR_ALARM_INVALID_DATE;
222 if (day < 1 || day > 28) {
224 *error_code = ERR_ALARM_INVALID_DATE;
235 static bool __alarm_validate_time(alarm_date_t *date, int *error_code)
237 if (date->hour < 0 || date->hour > 23) {
239 *error_code = ERR_ALARM_INVALID_TIME;
243 if (date->min < 0 || date->min > 59) {
245 *error_code = ERR_ALARM_INVALID_TIME;
252 static int __sub_init()
254 GError *error = NULL;
256 pthread_mutex_lock(&init_lock);
258 if (sub_initialized) {
259 //ALARM_MGR_LOG_PRINT("__sub_init was already called.\n");
260 pthread_mutex_unlock(&init_lock);
261 return ALARMMGR_RESULT_SUCCESS;
265 dbus_g_thread_init();
267 alarm_context.bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
268 if (alarm_context.bus == NULL) {
269 ALARM_MGR_EXCEPTION_PRINT("dbus bus get failed\n");
270 pthread_mutex_unlock(&init_lock);
271 return ERR_ALARM_SYSTEM_FAIL;
274 alarm_context.proxy = dbus_g_proxy_new_for_name(alarm_context.bus,
275 "com.samsung.alarm.manager",
276 "/com/samsung/alarm/manager",
277 "com.samsung.alarm.manager");
278 if (alarm_context.proxy == NULL) {
279 ALARM_MGR_EXCEPTION_PRINT("dbus bus proxy get failed\n");
280 pthread_mutex_unlock(&init_lock);
281 return ERR_ALARM_SYSTEM_FAIL;
284 alarm_context.pid = getsid(getpid()); /*this running appliction's session id*/
286 sub_initialized = true;
288 pthread_mutex_unlock(&init_lock);
290 return ALARMMGR_RESULT_SUCCESS;
293 bool alarm_power_off(int *error_code)
295 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_power_off() is called\n");
298 return _send_alarm_power_off(alarm_context, error_code);
301 "[alarm-lib]:ALARM_BOOT feature is not supported. "
302 "so we return false.\n");
304 *error_code = -1; /*-1 means that system failed
310 int alarmmgr_check_next_duetime()
314 "[alarm-lib]:alarm_check_next_duetime() is called\n");
317 if (!_send_alarm_check_next_duetime(alarm_context, &error_code))
321 "[alarm-lib]:ALARM_BOOT feature is not supported. "
322 "so we return false.\n");
323 return ERR_ALARM_SYSTEM_FAIL;
326 return ALARMMGR_RESULT_SUCCESS;
329 EXPORT_API int alarmmgr_init(const char *appid)
332 int request_name_result = 0;
333 char service_name[MAX_SERVICE_NAME_LEN] = { 0 };
334 char service_name_mod[MAX_SERVICE_NAME_LEN]= { 0 };
342 return ERR_ALARM_INVALID_PARAM;
344 if (strlen(appid) >= MAX_PKG_NAME_LEN)
345 return ERR_ALARM_INVALID_PARAM;
349 "alarm was already initialized. app_service_name=%s\n",
350 g_quark_to_string(alarm_context.quark_app_service_name));
351 return ALARMMGR_RESULT_SUCCESS;
358 memset(service_name_mod, 'a', MAX_SERVICE_NAME_LEN-1);
360 len = strlen("ALARM.");
361 strncpy(service_name, "ALARM.", len);
362 strncpy(service_name + len, appid, strlen(appid));
366 for(i=0;i<=strlen(service_name);i++)
368 if (service_name[i] == '.' )
370 service_name_mod[j] = service_name[i];
374 service_name_mod[j] = service_name[i];
379 SECURE_LOGD("[alarm-lib]: service_name %s\n", service_name);
380 SECURE_LOGD("[alarm-lib]: service_name_mod %s\n", service_name_mod);
382 dbus_error_init(&derror);
384 request_name_result = dbus_bus_request_name(
385 dbus_g_connection_get_connection(alarm_context.bus),
386 service_name_mod, 0, &derror);
387 if (dbus_error_is_set(&derror)) /*failure*/ {
389 "Failed to dbus_bus_request_name(%s): %s\n", service_name,
391 dbus_error_free(&derror);
393 return ERR_ALARM_SYSTEM_FAIL;
395 alarm_context.quark_app_service_name =
396 g_quark_from_string(service_name);
397 alarm_context.quark_app_service_name_mod=
398 g_quark_from_string(service_name_mod);
401 if (!dbus_connection_add_filter(
402 dbus_g_connection_get_connection(alarm_context.bus),
403 __expire_alarm_filter, NULL, NULL)) {
404 ALARM_MGR_EXCEPTION_PRINT("add __expire_alarm_filter failed\n");
406 return ERR_ALARM_SYSTEM_FAIL;
409 b_initialized = true;
410 return ALARMMGR_RESULT_SUCCESS;
414 EXPORT_API void alarmmgr_fini()
416 dbus_connection_remove_filter(dbus_g_connection_get_connection
418 __expire_alarm_filter, NULL);
419 b_initialized = false;
422 EXPORT_API int alarmmgr_set_cb(alarm_cb_t handler, void *user_param)
424 ALARM_MGR_LOG_PRINT("alarm_set_cb is called\n");
426 if (handler == NULL) {
427 return ERR_ALARM_INVALID_PARAM;
429 alarm_context.alarm_handler = handler;
430 alarm_context.user_param = user_param;
431 return ALARMMGR_RESULT_SUCCESS;
434 EXPORT_API alarm_entry_t *alarmmgr_create_alarm(void)
436 alarm_info_t *alarm = (alarm_info_t *) malloc(sizeof(alarm_info_t));
443 alarm->start.year = 0;
444 alarm->start.month = 0;
445 alarm->start.day = 0;
446 alarm->start.hour = 0;
447 alarm->start.min = 0;
448 alarm->start.sec = 0;
451 alarm->end.month = 0;
457 alarm->mode.repeat = ALARM_REPEAT_MODE_ONCE;
458 alarm->mode.u_interval.interval = 0;
460 alarm->alarm_type = ALARM_TYPE_DEFAULT;
462 alarm->reserved_info = 0;
464 return (alarm_entry_t *) alarm;
467 EXPORT_API int alarmmgr_free_alarm(alarm_entry_t *alarm)
470 return ERR_ALARM_INVALID_PARAM;
474 return ALARMMGR_RESULT_SUCCESS;
477 EXPORT_API int alarmmgr_set_time(alarm_entry_t *alarm, alarm_date_t time)
479 alarm_info_t *alarm_info; /*= (alarm_info_t*)alarm;*/
483 return ERR_ALARM_INVALID_PARAM;
486 alarm_info = (alarm_info_t *) alarm;
488 if (!__alarm_validate_date(&time, &error_code)) {
489 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
493 if (!__alarm_validate_time(&time, &error_code)) {
494 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
498 memcpy(&alarm_info->start, &time, sizeof(alarm_date_t));
500 return ALARMMGR_RESULT_SUCCESS;
503 EXPORT_API int alarmmgr_get_time(const alarm_entry_t *alarm,
506 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
509 return ERR_ALARM_INVALID_PARAM;
513 memcpy(time, &alarm_info->start, sizeof(alarm_date_t));
515 return ALARMMGR_RESULT_SUCCESS;
518 EXPORT_API int alarmmgr_set_repeat_mode(alarm_entry_t *alarm,
519 alarm_repeat_mode_t repeat,
522 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
524 if (repeat >= ALARM_REPEAT_MODE_MAX) {
525 return ERR_ALARM_INVALID_PARAM;
528 alarm_info->mode.repeat = repeat;
530 if (repeat == ALARM_REPEAT_MODE_REPEAT
531 || repeat == ALARM_REPEAT_MODE_WEEKLY) {
532 alarm_info->mode.u_interval.interval = interval;
535 return ALARMMGR_RESULT_SUCCESS;
538 EXPORT_API int alarmmgr_get_repeat_mode(const alarm_entry_t *alarm,
539 alarm_repeat_mode_t *repeat,
542 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
545 return ERR_ALARM_INVALID_PARAM;
549 *repeat = alarm_info->mode.repeat;
550 if (interval != NULL)
551 *interval = alarm_info->mode.u_interval.interval;
553 return ALARMMGR_RESULT_SUCCESS;
556 EXPORT_API int alarmmgr_set_type(alarm_entry_t *alarm, int alarm_type)
558 alarm_info_t *alarm_info; /*= (alarm_info_t*)alarm;*/
561 return ERR_ALARM_INVALID_PARAM;
564 alarm_info = (alarm_info_t *) alarm;
566 alarm_info->alarm_type = alarm_type;
567 alarm_info->alarm_type &= (~ALARM_TYPE_RELATIVE);
569 return ALARMMGR_RESULT_SUCCESS;
572 EXPORT_API int alarmmgr_get_type(const alarm_entry_t *alarm, int *alarm_type)
574 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
577 return ERR_ALARM_INVALID_PARAM;
580 if (alarm_type != NULL)
581 *alarm_type = alarm_info->alarm_type;
583 return ALARMMGR_RESULT_SUCCESS;
587 static int __alarmmgr_init_appsvc(void)
592 ALARM_MGR_EXCEPTION_PRINT("alarm was already initialized\n");
593 return ALARMMGR_RESULT_SUCCESS;
598 dbus_g_thread_init();
604 b_initialized = true;
606 return ALARMMGR_RESULT_SUCCESS;
610 EXPORT_API void *alarmmgr_get_alarm_appsvc_info(alarm_id_t alarm_id, int *return_code){
621 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_alarm_appsvc_info() is called\n");
625 *return_code = ERR_ALARM_INVALID_ID;
629 return _send_alarm_get_appsvc_info(alarm_context, alarm_id, return_code);
633 EXPORT_API int alarmmgr_set_rtc_time(alarm_date_t *time){
639 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter time\n");
640 return ERR_ALARM_INVALID_PARAM;
648 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_rtc_time() is called\n");
650 if (!__alarm_validate_date(time, &error_code)) {
651 ALARM_MGR_EXCEPTION_PRINT("RTC date error\n");
655 if (!__alarm_validate_time(time, &error_code)) {
656 ALARM_MGR_EXCEPTION_PRINT("RTC time error\n");
663 if (!_send_alarm_set_rtc_time
664 (alarm_context, time, &error_code)){
668 return ALARMMGR_RESULT_SUCCESS;
672 EXPORT_API int alarmmgr_add_alarm_appsvc_with_localtime(alarm_entry_t *alarm, void *bundle_data, alarm_id_t *alarm_id)
674 alarm_info_t *alarm_info = NULL; /* = (alarm_info_t*)alarm; */
675 const char *operation = NULL;
679 bundle *b=(bundle *)bundle_data;
681 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
684 return ERR_ALARM_INVALID_PARAM;
689 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
690 return ERR_ALARM_INVALID_PARAM;
692 operation = appsvc_get_operation(b);
695 if (NULL == operation)
697 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle [appsvc operation not present]\n");
698 return ERR_ALARM_INVALID_PARAM;
701 if (__alarmmgr_init_appsvc() < 0)
703 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
704 return ERR_ALARM_SYSTEM_FAIL;
707 alarm_info = (alarm_info_t *) alarm;
709 appid = appsvc_get_appid(b);
711 if (NULL == appid && (alarm_info->alarm_type & ALARM_TYPE_NOLAUNCH) )
713 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
714 return ERR_ALARM_INVALID_PARAM;
717 if (alarm_info == NULL || alarm_id == NULL) {
718 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
719 return ERR_ALARM_INVALID_PARAM;
721 alarm_mode_t *mode = &alarm_info->mode;
723 ALARM_MGR_LOG_PRINT("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
724 alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
725 alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
726 alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
727 alarm_info->mode.repeat, alarm_info->mode.u_interval, alarm_info->alarm_type);
729 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
730 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
731 return ERR_ALARM_INVALID_PARAM;
734 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
735 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
739 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
740 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
744 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
745 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
750 if (!_send_alarm_create_appsvc
751 (alarm_context, alarm_info, alarm_id, b,
756 return ALARMMGR_RESULT_SUCCESS;
762 EXPORT_API int alarmmgr_add_alarm_with_localtime(alarm_entry_t *alarm,
763 const char *destination,
764 alarm_id_t *alarm_id)
766 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
767 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
768 alarm_info_t *alarm_info; /* = (alarm_info_t*)alarm; */
773 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
776 return ERR_ALARM_INVALID_PARAM;
779 alarm_info = (alarm_info_t *) alarm;
780 if (alarm_info == NULL || alarm_id == NULL) {
781 return ERR_ALARM_INVALID_PARAM;
785 alarm_mode_t *mode = &alarm_info->mode;
791 ALARM_MGR_LOG_PRINT("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
792 alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
793 alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
794 alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
795 alarm_info->mode.repeat, alarm_info->mode.u_interval, alarm_info->alarm_type);
797 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
798 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
799 return ERR_ALARM_INVALID_PARAM;
802 if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
803 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
804 return ERR_ALARM_INVALID_PARAM;
808 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
809 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
813 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
814 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
818 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
819 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
823 if (destination != NULL) {
824 memset(dst_service_name, 0,
825 strlen(destination) + strlen("ALARM.") + 2);
826 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s",
829 memset(dst_service_name_mod,'a',MAX_SERVICE_NAME_LEN-1);
833 for(i=0; i<=strlen(dst_service_name); i++)
835 if (dst_service_name[i] == '.' )
837 dst_service_name_mod[j] = dst_service_name[i];
842 dst_service_name_mod[j] = dst_service_name[i];
847 if (!_send_alarm_create
848 (alarm_context, alarm_info, alarm_id, dst_service_name, dst_service_name_mod,
853 if (!_send_alarm_create
854 (alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
858 return ALARMMGR_RESULT_SUCCESS;
863 EXPORT_API int alarmmgr_add_alarm_appsvc(int alarm_type, time_t trigger_at_time,
864 time_t interval, void *bundle_data,
865 alarm_id_t *alarm_id)
869 struct tm duetime_tm;
870 alarm_info_t alarm_info;
871 const char *operation = NULL;
874 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
876 bundle *b=(bundle *)bundle_data;
880 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
881 return ERR_ALARM_INVALID_PARAM;
883 operation = appsvc_get_operation(b);
885 if (NULL == operation)
887 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle [appsvc operation not present]\n");
888 return ERR_ALARM_INVALID_PARAM;
891 appid = appsvc_get_appid(b);
893 if (NULL == appid && (alarm_type & ALARM_TYPE_NOLAUNCH) )
895 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
896 return ERR_ALARM_INVALID_PARAM;
899 if (__alarmmgr_init_appsvc() < 0)
901 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
902 return ERR_ALARM_SYSTEM_FAIL;
905 if (alarm_id == NULL) {
906 return ERR_ALARM_INVALID_PARAM;
909 if (trigger_at_time < 0) {
910 return ERR_ALARM_INVALID_PARAM;
913 alarm_info.alarm_type = alarm_type;
914 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
918 current_time += trigger_at_time;
920 localtime_r(¤t_time, &duetime_tm);
922 alarm_info.start.year = duetime_tm.tm_year + 1900;
923 alarm_info.start.month = duetime_tm.tm_mon + 1;
924 alarm_info.start.day = duetime_tm.tm_mday;
926 alarm_info.end.year = 0;
927 alarm_info.end.month = 0;
928 alarm_info.end.day = 0;
930 alarm_info.start.hour = duetime_tm.tm_hour;
931 alarm_info.start.min = duetime_tm.tm_min;
932 alarm_info.start.sec = duetime_tm.tm_sec;
935 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
936 alarm_info.mode.u_interval.interval = 0;
938 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
939 alarm_info.mode.u_interval.interval = interval;
942 ALARM_MGR_LOG_PRINT("trigger_at_time(%d), start(%d-%d-%d, %02d:%02d:%02d), repeat(%d), interval(%d), type(%d)",
943 trigger_at_time, alarm_info.start.day, alarm_info.start.month, alarm_info.start.year,
944 alarm_info.start.hour, alarm_info.start.min, alarm_info.start.sec,
945 alarm_info.mode.repeat, alarm_info.mode.u_interval, alarm_info.alarm_type);
947 if (!_send_alarm_create_appsvc
948 (alarm_context, &alarm_info, alarm_id, b,
953 return ALARMMGR_RESULT_SUCCESS;
957 EXPORT_API int alarmmgr_add_alarm(int alarm_type, time_t trigger_at_time,
958 time_t interval, const char *destination,
959 alarm_id_t *alarm_id)
961 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
962 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
967 struct tm duetime_tm;
968 alarm_info_t alarm_info;
971 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
977 if (alarm_id == NULL) {
978 return ERR_ALARM_INVALID_PARAM;
981 if (trigger_at_time < 0) {
982 return ERR_ALARM_INVALID_PARAM;
985 if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
986 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
987 return ERR_ALARM_INVALID_PARAM;
990 alarm_info.alarm_type = alarm_type;
991 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
995 current_time += trigger_at_time;
997 localtime_r(¤t_time, &duetime_tm);
999 alarm_info.start.year = duetime_tm.tm_year + 1900;
1000 alarm_info.start.month = duetime_tm.tm_mon + 1;
1001 alarm_info.start.day = duetime_tm.tm_mday;
1003 alarm_info.end.year = 0;
1004 alarm_info.end.month = 0;
1005 alarm_info.end.day = 0;
1007 alarm_info.start.hour = duetime_tm.tm_hour;
1008 alarm_info.start.min = duetime_tm.tm_min;
1009 alarm_info.start.sec = duetime_tm.tm_sec;
1011 if (interval <= 0) {
1012 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
1013 alarm_info.mode.u_interval.interval = 0;
1015 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
1016 alarm_info.mode.u_interval.interval = interval;
1019 ALARM_MGR_LOG_PRINT("trigger_at_time(%d), start(%d-%d-%d, %02d:%02d:%02d), repeat(%d), interval(%d), type(%d)",
1020 trigger_at_time, alarm_info.start.day, alarm_info.start.month, alarm_info.start.year,
1021 alarm_info.start.hour, alarm_info.start.min, alarm_info.start.sec,
1022 alarm_info.mode.repeat, alarm_info.mode.u_interval, alarm_info.alarm_type);
1024 if (destination != NULL) {
1025 memset(dst_service_name, 0,
1026 strlen(destination) + strlen("ALARM.") + 2);
1027 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s",
1029 memset(dst_service_name_mod,'a',MAX_SERVICE_NAME_LEN-1);
1033 for(i=0;i<=strlen(dst_service_name);i++)
1035 if (dst_service_name[i] == '.')
1037 dst_service_name_mod[j]=dst_service_name[i];
1042 dst_service_name_mod[j]=dst_service_name[i];
1047 if (!_send_alarm_create
1048 (alarm_context, &alarm_info, alarm_id, dst_service_name,dst_service_name_mod,
1053 if (!_send_alarm_create
1054 (alarm_context, &alarm_info, alarm_id, "null","null", &error_code)) {
1058 return ALARMMGR_RESULT_SUCCESS;
1061 EXPORT_API int alarmmgr_add_alarm_withcb(int alarm_type, time_t trigger_at_time,
1062 time_t interval, alarm_cb_t handler, void *user_param, alarm_id_t *alarm_id)
1064 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
1065 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
1069 time_t current_time;
1070 struct tm duetime_tm;
1071 alarm_info_t alarm_info;
1075 aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
1077 ret = alarmmgr_init(appid);
1081 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_add_alarm_withcb() is called\n");
1083 ALARM_MGR_LOG_PRINT("interval(%d)", interval);
1085 if (alarm_id == NULL) {
1086 return ERR_ALARM_INVALID_PARAM;
1089 if (trigger_at_time < 0) {
1090 return ERR_ALARM_INVALID_PARAM;
1093 alarm_info.alarm_type = alarm_type;
1094 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
1095 alarm_info.alarm_type |= ALARM_TYPE_WITHCB;
1097 time(¤t_time);
1099 current_time += trigger_at_time;
1101 localtime_r(¤t_time, &duetime_tm);
1103 alarm_info.start.year = duetime_tm.tm_year + 1900;
1104 alarm_info.start.month = duetime_tm.tm_mon + 1;
1105 alarm_info.start.day = duetime_tm.tm_mday;
1107 alarm_info.end.year = 0;
1108 alarm_info.end.month = 0;
1109 alarm_info.end.day = 0;
1111 alarm_info.start.hour = duetime_tm.tm_hour;
1112 alarm_info.start.min = duetime_tm.tm_min;
1113 alarm_info.start.sec = duetime_tm.tm_sec;
1115 if (interval <= 0) {
1116 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
1117 alarm_info.mode.u_interval.interval = 0;
1119 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
1120 alarm_info.mode.u_interval.interval = interval;
1123 if (!_send_alarm_create(alarm_context, &alarm_info, alarm_id, "null","null", &error_code)) {
1126 __add_resultcb(*alarm_id, handler, user_param);
1128 return ALARMMGR_RESULT_SUCCESS;
1131 EXPORT_API int alarmmgr_remove_alarm(alarm_id_t alarm_id)
1135 alarm_cb_info_t *info;
1141 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_delete(%d) is called\n", alarm_id);
1143 if (alarm_id <= 0) {
1144 return ERR_ALARM_INVALID_ID;
1147 if (!_send_alarm_delete(alarm_context, alarm_id, &error_code))
1150 info = __find_resultcb(alarm_id);
1151 __remove_resultcb(info);
1153 return ALARMMGR_RESULT_SUCCESS;
1156 EXPORT_API int alarmmgr_remove_all(void)
1158 GError *error = NULL;
1159 int return_code = ALARMMGR_RESULT_SUCCESS;
1160 int ret = __sub_init();
1166 if(!com_samsung_alarm_manager_alarm_delete_all(alarm_context.proxy, alarm_context.pid, &return_code, &error))
1168 ALARM_MGR_EXCEPTION_PRINT("com_samsung_alarm_manager_alarm_delete_all() is failed by dbus. "
1169 "return_code[%d], err message[%s]\n", return_code, error->message);
1170 return ERR_ALARM_SYSTEM_FAIL;
1175 ALARM_MGR_EXCEPTION_PRINT("com_samsung_alarm_manager_alarm_delete_all() is failed. "
1176 "return_code[%d], err message[%s]\n", return_code, error->message);
1177 return ERR_ALARM_SYSTEM_FAIL;
1183 EXPORT_API int alarmmgr_enum_alarm_ids(alarm_enum_fn_t fn, void *user_param)
1185 GError *error = NULL;
1186 GArray *alarm_array = NULL;
1187 int return_code = 0;
1195 return ERR_ALARM_INVALID_PARAM;
1201 if (!com_samsung_alarm_manager_alarm_get_number_of_ids(
1202 alarm_context.proxy, alarm_context.pid, &maxnum_of_ids,
1203 &return_code, &error)) {
1204 /* dbus-glib error */
1205 /* error_code should be set */
1206 ALARM_MGR_EXCEPTION_PRINT(
1207 "com_samsung_alarm_manager_alarm_get_number_of_ids() "
1208 "failed. return_code[%d], err message[%s]\n",
1209 return_code, error->message);
1210 return ERR_ALARM_SYSTEM_FAIL;
1213 if (return_code != 0) {
1217 if (!com_samsung_alarm_manager_alarm_get_list_of_ids(
1218 alarm_context.proxy, alarm_context.pid, maxnum_of_ids,
1219 &alarm_array, &num_of_ids, &return_code, &error)) {
1220 /*dbus-glib error */
1221 /* error_code should be set */
1222 ALARM_MGR_EXCEPTION_PRINT(
1223 "com_samsung_alarm_manager_alarm_get_list_of_ids() "
1224 "failed. alarm_id[%d], return_code[%d]\n",
1225 alarm_id, return_code);
1226 return ERR_ALARM_SYSTEM_FAIL;
1229 if (return_code != 0) {
1232 if (error != NULL) {
1233 ALARM_MGR_LOG_PRINT(
1234 "Alarm server not ready dbus error message %s\n", error->message);
1235 return ERR_ALARM_SYSTEM_FAIL;
1237 if (NULL == alarm_array) {
1238 ALARM_MGR_LOG_PRINT(
1239 "alarm server not initilized\n");
1240 return ERR_ALARM_SYSTEM_FAIL;
1242 for (i = 0; i < alarm_array->len && i < maxnum_of_ids; i++) {
1243 alarm_id = g_array_index(alarm_array, alarm_id_t, i);
1244 (*fn) (alarm_id, user_param);
1245 ALARM_MGR_LOG_PRINT("alarm_id(%d)\n", alarm_id);
1248 g_array_free(alarm_array, true);
1251 return ALARMMGR_RESULT_SUCCESS;
1254 EXPORT_API int alarmmgr_get_info(alarm_id_t alarm_id, alarm_entry_t *alarm)
1257 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
1265 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_info() is called\n");
1267 if (alarm_id < 0 || alarm_info == NULL) {
1268 return ERR_ALARM_INVALID_PARAM;
1271 if (!_send_alarm_get_info(alarm_context, alarm_id, alarm_info,
1275 return ALARMMGR_RESULT_SUCCESS;
1278 EXPORT_API int alarmmgr_power_on(bool on_off)
1281 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_power_on() is called\n");
1284 if (!_send_alarm_power_on(alarm_context, on_off, &error_code))
1287 ALARM_MGR_LOG_PRINT("[alarm-lib]:ALARM_BOOT feature is not supported. "
1288 "so we return false.\n");
1289 return ERR_ALARM_SYSTEM_FAIL;
1292 return ALARMMGR_RESULT_SUCCESS;
1295 int alarmmgr_create(alarm_info_t *alarm_info, char *destination,
1296 alarm_id_t *alarm_id)
1298 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
1299 alarm_mode_t *mode = &alarm_info->mode;
1302 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
1304 if (alarm_info == NULL || alarm_id == NULL) {
1305 return ERR_ALARM_INVALID_PARAM;
1308 ALARM_MGR_LOG_PRINT("alarm_info->start.year(%d), "
1309 "alarm_info->start.month(%d), alarm_info->start.day(%d)",
1310 alarm_info->start.year, alarm_info->start.month,
1311 alarm_info->start.day);
1313 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
1314 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
1315 return ERR_ALARM_INVALID_PARAM;
1318 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
1319 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
1323 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
1324 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
1328 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
1329 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
1333 if (destination != NULL) {
1334 memset(dst_service_name, 0,
1335 strlen(destination) + strlen("ALARM.") + 2);
1336 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s",
1338 if (!_send_alarm_create
1339 (alarm_context, alarm_info, alarm_id, dst_service_name,"null",
1344 /*TODO: Currently this API is not exported. Hence not modifying*/
1345 if (!_send_alarm_create
1346 (alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
1350 return ALARMMGR_RESULT_SUCCESS;
1354 int alarmmgr_get_number_of_ids(int *num_of_ids)
1357 ALARM_MGR_LOG_PRINT("[alarm-lib]:"
1358 "alarm_get_number_of_ids() is called\n");
1360 if (num_of_ids == NULL) {
1361 return ERR_ALARM_INVALID_PARAM;
1363 ALARM_MGR_LOG_PRINT("call alarm_get_number_of_ids\n");
1364 if (!_send_alarm_get_number_of_ids(alarm_context, num_of_ids,
1368 return ALARMMGR_RESULT_SUCCESS;
1371 int alarmmgr_get_list_of_ids(int maxnum_of_ids, alarm_id_t *alarm_id,
1375 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_list_of_ids() is called\n");
1377 if (maxnum_of_ids < 0 || alarm_id == NULL || num_of_ids == NULL) {
1378 return ERR_ALARM_INVALID_PARAM;
1381 if (maxnum_of_ids == 0) {
1383 return ALARMMGR_RESULT_SUCCESS;
1386 if (!_send_alarm_get_list_of_ids
1387 (alarm_context, maxnum_of_ids, alarm_id, num_of_ids, &error_code))
1390 return ALARMMGR_RESULT_SUCCESS;
1393 EXPORT_API int alarmmgr_get_next_duetime(alarm_id_t alarm_id, time_t* duetime)
1396 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_next_duetime() is called\n");
1398 if (duetime == NULL) {
1399 return ERR_ALARM_INVALID_PARAM;
1402 if (!_send_alarm_get_next_duetime
1403 (alarm_context, alarm_id, duetime, &error_code))
1406 return ALARMMGR_RESULT_SUCCESS;