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.
31 #include <sys/types.h>
37 #include "alarm-internal.h"
38 #include "alarm-mgr-stub.h"
44 #define MAX_KEY_SIZE 256
45 #define MAX_PROC_NAME_LEN 512
47 static alarm_context_t alarm_context = { NULL, NULL, NULL, NULL, -1 };
49 static bool b_initialized = false;
50 static bool sub_initialized = false;
52 pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
54 static void __handle_expiry_method_call(GDBusConnection *conn,
55 const gchar *name, const gchar *path, const gchar *interface,
56 const gchar *method, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data);
58 static int __alarm_validate_date(alarm_date_t *date, int *error_code);
59 static bool __alarm_validate_time(alarm_date_t *date, int *error_code);
60 static int __sub_init(void);
61 static int __alarmmgr_init_appsvc(void);
63 typedef struct _alarm_cb_info_t {
67 struct _alarm_cb_info_t *next;
70 static alarm_cb_info_t *alarmcb_head = NULL;
72 guint registration_id = 0;
74 static GDBusNodeInfo *introspection_data = NULL;
76 static const gchar introspection_xml[] =
77 "<node name='/org/tizen/alarm/client'>"
78 " <interface name='org.tizen.alarm.client'>"
79 " <method name='alarm_expired'>"
80 " <arg type='i' name='alarm_id' direction='in'/>"
81 " <arg type='s' name='service_name' direction='in'/>"
86 static const GDBusInterfaceVTable interface_vtable =
88 __handle_expiry_method_call,
93 static void __add_resultcb(alarm_id_t alarm_id, alarm_cb_t cb_func, void *data)
95 alarm_cb_info_t *info;
97 info = (alarm_cb_info_t *) malloc(sizeof(alarm_cb_info_t));
100 info->alarm_id = alarm_id;
101 info->cb_func = cb_func;
102 info->priv_data = data;
104 info->next = alarmcb_head;
108 static alarm_cb_info_t *__find_resultcb(alarm_id_t alarm_id)
110 alarm_cb_info_t *tmp;
114 if (tmp->alarm_id == alarm_id) {
115 ALARM_MGR_LOG_PRINT("matched alarm id = %d", alarm_id);
123 static void __remove_resultcb(alarm_cb_info_t *info)
125 alarm_cb_info_t *tmp;
127 if (alarmcb_head == NULL || info == NULL)
130 if (alarmcb_head == info) {
131 alarmcb_head = info->next;
138 if (tmp->next == info) {
139 tmp->next = info->next;
147 static void __handle_expiry_method_call(GDBusConnection *conn,
148 const gchar *name, const gchar *path, const gchar *interface,
149 const gchar *method, GVariant *param, GDBusMethodInvocation *invocation, gpointer user_data)
151 if (method && strcmp(method, "alarm_expired") == 0) {
152 const gchar *package_name = NULL;
153 alarm_id_t alarm_id = 0;
154 alarm_cb_info_t *info = NULL;
155 g_variant_get(param, "(is)", &alarm_id, &package_name);
156 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib] : Alarm expired for [%s] : Alarm id [%d]", package_name, alarm_id);
158 if (alarm_context.alarm_handler != NULL) {
159 alarm_context.alarm_handler(alarm_id, alarm_context.user_param);
162 info = __find_resultcb(alarm_id);
163 if (info && info->cb_func) {
164 info->cb_func(alarm_id, info->priv_data);
166 g_free(package_name);
170 static int __alarm_validate_date(alarm_date_t *date, int *error_code)
173 if (date->year == 0 && date->month == 0 && date->day == 0) {
177 int year = date->year;
178 int month = date->month;
181 if (month < 1 || month > 12) {
183 *error_code = ERR_ALARM_INVALID_DATE;
187 if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8
188 || month == 10 || month == 12)
189 && (day < 1 || day > 31)) {
191 *error_code = ERR_ALARM_INVALID_DATE;
195 if ((month == 4 || month == 6 || month == 9 || month == 11)
196 && (day < 1 || day > 30)) {
198 *error_code = ERR_ALARM_INVALID_DATE;
203 if ((year % 100 != 0 && year % 4 == 0) || (year % 400 == 0)) {
204 if (day < 1 || day > 29) {
206 *error_code = ERR_ALARM_INVALID_DATE;
210 if (day < 1 || day > 28) {
212 *error_code = ERR_ALARM_INVALID_DATE;
223 static bool __alarm_validate_time(alarm_date_t *date, int *error_code)
225 if (date->hour < 0 || date->hour > 23) {
227 *error_code = ERR_ALARM_INVALID_TIME;
231 if (date->min < 0 || date->min > 59) {
233 *error_code = ERR_ALARM_INVALID_TIME;
240 static int __sub_init()
242 GError *error = NULL;
243 char proc_file[MAX_PROC_NAME_LEN] = {0, };
244 char process_name[MAX_PROC_NAME_LEN] = {0, };
247 const int MAX_LEN = MAX_PROC_NAME_LEN;
249 pthread_mutex_lock(&init_lock);
251 if (sub_initialized) {
252 pthread_mutex_unlock(&init_lock);
253 return ALARMMGR_RESULT_SUCCESS;
256 #if !GLIB_CHECK_VERSION(2,32,0)
261 alarm_context.connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
262 if (alarm_context.connection == NULL) {
263 ALARM_MGR_EXCEPTION_PRINT("g_bus_get_sync() is failed. error: %s", error->message);
265 pthread_mutex_unlock(&init_lock);
266 return ERR_ALARM_SYSTEM_FAIL;
269 alarm_context.proxy = g_dbus_proxy_new_sync(alarm_context.connection,
270 G_DBUS_PROXY_FLAGS_NONE,
272 "org.tizen.alarm.manager",
273 "/org/tizen/alarm/manager",
274 "org.tizen.alarm.manager",
278 if (alarm_context.proxy == NULL) {
279 ALARM_MGR_EXCEPTION_PRINT("Creating a proxy is failed.");
280 g_object_unref (alarm_context.connection);
281 pthread_mutex_unlock(&init_lock);
282 return ERR_ALARM_SYSTEM_FAIL;
285 // Only webapp which has a pid of WebProcess uses the sid. Otherwise, the pid is used.
286 snprintf(proc_file, MAX_LEN, "/proc/%d/cmdline", getpid());
287 fd = open(proc_file, O_RDONLY);
289 SECURE_LOGE("Unable to get the proc file(%d).\n", getpid());
290 g_object_unref(alarm_context.proxy);
291 g_object_unref(alarm_context.connection);
292 pthread_mutex_unlock(&init_lock);
293 return ERR_ALARM_SYSTEM_FAIL;
296 ret = read(fd, process_name, MAX_LEN);
299 ALARM_MGR_EXCEPTION_PRINT("Unable to read the proc file(%d).", getpid());
300 g_object_unref(alarm_context.proxy);
301 g_object_unref(alarm_context.connection);
302 pthread_mutex_unlock(&init_lock);
303 return ERR_ALARM_SYSTEM_FAIL;
306 if (strncmp(process_name, "/usr/bin/WebProcess", strlen("/usr/bin/WebProcess")) == 0) {
307 alarm_context.pid = getsid(getpid());
308 SECURE_LOGD("alarm_context.pid is set to sessionID, %d.", alarm_context.pid);
311 alarm_context.pid = getpid();
312 SECURE_LOGD("alarm_context.pid is set to processID, %d.", alarm_context.pid);
317 sub_initialized = true;
319 pthread_mutex_unlock(&init_lock);
321 return ALARMMGR_RESULT_SUCCESS;
324 EXPORT_API int alarmmgr_init(const char *appid)
326 SECURE_LOGD("Enter");
327 int request_name_result = 0;
328 char service_name[MAX_SERVICE_NAME_LEN] = { 0 };
329 char service_name_mod[MAX_SERVICE_NAME_LEN]= { 0 };
330 int ret = ALARMMGR_RESULT_SUCCESS;
337 return ERR_ALARM_INVALID_PARAM;
339 if (strlen(appid) >= MAX_PKG_NAME_LEN)
340 return ERR_ALARM_INVALID_PARAM;
343 SECURE_LOGD("alarm was already initialized. app_service_name=%s",
344 g_quark_to_string(alarm_context.quark_app_service_name));
345 return ALARMMGR_RESULT_SUCCESS;
352 memset(service_name_mod, 'a', MAX_SERVICE_NAME_LEN - 1);
354 len = strlen("ALARM.");
355 strncpy(service_name, "ALARM.", len);
356 strncpy(service_name + len, appid, strlen(appid));
358 for(i = 0; i <= strlen(service_name); i++) {
359 if (service_name[i] == '.') {
360 service_name_mod[j] = service_name[i];
364 service_name_mod[j] = service_name[i];
369 SECURE_LOGD("[alarm-lib]: dbus own name: %s", service_name_mod);
370 owner_id = g_bus_own_name_on_connection(alarm_context.connection, service_name_mod,
371 G_BUS_NAME_OWNER_FLAGS_NONE, NULL, NULL, NULL, NULL);
373 ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed. %s", service_name_mod);
377 introspection_data = g_dbus_node_info_new_for_xml(introspection_xml, NULL);
378 if (introspection_data == NULL) {
379 ALARM_MGR_EXCEPTION_PRINT("g_dbus_node_info_new_for_xml() is failed.");
383 registration_id = g_dbus_connection_register_object(alarm_context.connection,
384 "/org/tizen/alarm/client",
385 introspection_data->interfaces[0],
386 &interface_vtable, NULL, NULL, NULL);
387 if (registration_id == 0) {
388 ALARM_MGR_EXCEPTION_PRINT("Registering the callback is failed.");
392 alarm_context.quark_app_service_name = g_quark_from_string(service_name);
393 alarm_context.quark_app_service_name_mod= g_quark_from_string(service_name_mod);
395 b_initialized = true;
397 SECURE_LOGD("Leave");
398 return ALARMMGR_RESULT_SUCCESS;
401 if (introspection_data) {
402 g_dbus_node_info_unref(introspection_data);
404 if (registration_id != 0) {
405 g_dbus_connection_unregister_object(alarm_context.connection, registration_id);
407 g_object_unref(alarm_context.proxy);
408 alarm_context.proxy = NULL;
410 g_object_unref(alarm_context.connection);
411 alarm_context.connection = NULL;
413 sub_initialized = false;
414 return ERR_ALARM_INVALID_PARAM;
417 EXPORT_API void alarmmgr_fini()
419 SECURE_LOGD("Enter");
420 if (introspection_data) {
421 g_dbus_node_info_unref(introspection_data);
424 if (alarm_context.connection != NULL && registration_id != 0) {
425 g_dbus_connection_unregister_object(alarm_context.connection, registration_id);
428 if (alarm_context.proxy) {
429 g_object_unref(alarm_context.proxy);
430 alarm_context.proxy = NULL;
433 if (alarm_context.connection) {
434 g_object_unref(alarm_context.connection);
435 alarm_context.connection = NULL;
438 b_initialized = false;
439 sub_initialized = false;
441 SECURE_LOGD("Leave");
444 EXPORT_API int alarmmgr_set_cb(alarm_cb_t handler, void *user_param)
446 SECURE_LOGD("Enter");
448 if (handler == NULL) {
449 ALARM_MGR_EXCEPTION_PRINT("callback is NULL.");
450 return ERR_ALARM_INVALID_PARAM;
452 alarm_context.alarm_handler = handler;
453 alarm_context.user_param = user_param;
455 SECURE_LOGD("Leave");
456 return ALARMMGR_RESULT_SUCCESS;
459 EXPORT_API alarm_entry_t *alarmmgr_create_alarm(void)
461 alarm_info_t *alarm = (alarm_info_t *) malloc(sizeof(alarm_info_t));
468 alarm->start.year = 0;
469 alarm->start.month = 0;
470 alarm->start.day = 0;
471 alarm->start.hour = 0;
472 alarm->start.min = 0;
473 alarm->start.sec = 0;
476 alarm->end.month = 0;
482 alarm->mode.repeat = ALARM_REPEAT_MODE_ONCE;
483 alarm->mode.u_interval.interval = 0;
485 alarm->alarm_type = ALARM_TYPE_DEFAULT;
487 alarm->reserved_info = 0;
489 return (alarm_entry_t *) alarm;
492 EXPORT_API int alarmmgr_free_alarm(alarm_entry_t *alarm)
495 return ERR_ALARM_INVALID_PARAM;
499 return ALARMMGR_RESULT_SUCCESS;
502 EXPORT_API int alarmmgr_set_time(alarm_entry_t *alarm, alarm_date_t time)
504 alarm_info_t *alarm_info; /*= (alarm_info_t*)alarm;*/
508 return ERR_ALARM_INVALID_PARAM;
511 alarm_info = (alarm_info_t *) alarm;
513 if (!__alarm_validate_date(&time, &error_code)) {
514 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
518 if (!__alarm_validate_time(&time, &error_code)) {
519 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
523 memcpy(&alarm_info->start, &time, sizeof(alarm_date_t));
525 return ALARMMGR_RESULT_SUCCESS;
528 EXPORT_API int alarmmgr_get_time(const alarm_entry_t *alarm,
531 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
534 return ERR_ALARM_INVALID_PARAM;
538 memcpy(time, &alarm_info->start, sizeof(alarm_date_t));
540 return ALARMMGR_RESULT_SUCCESS;
543 EXPORT_API int alarmmgr_set_repeat_mode(alarm_entry_t *alarm,
544 alarm_repeat_mode_t repeat,
547 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
549 if (repeat >= ALARM_REPEAT_MODE_MAX) {
550 return ERR_ALARM_INVALID_PARAM;
553 alarm_info->mode.repeat = repeat;
555 if (repeat == ALARM_REPEAT_MODE_REPEAT
556 || repeat == ALARM_REPEAT_MODE_WEEKLY) {
557 alarm_info->mode.u_interval.interval = interval;
560 return ALARMMGR_RESULT_SUCCESS;
563 EXPORT_API int alarmmgr_get_repeat_mode(const alarm_entry_t *alarm,
564 alarm_repeat_mode_t *repeat,
567 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
570 return ERR_ALARM_INVALID_PARAM;
574 *repeat = alarm_info->mode.repeat;
575 if (interval != NULL)
576 *interval = alarm_info->mode.u_interval.interval;
578 return ALARMMGR_RESULT_SUCCESS;
581 EXPORT_API int alarmmgr_set_type(alarm_entry_t *alarm, int alarm_type)
583 alarm_info_t *alarm_info; /*= (alarm_info_t*)alarm;*/
586 return ERR_ALARM_INVALID_PARAM;
589 alarm_info = (alarm_info_t *) alarm;
591 alarm_info->alarm_type = alarm_type;
592 alarm_info->alarm_type &= (~ALARM_TYPE_RELATIVE);
594 return ALARMMGR_RESULT_SUCCESS;
597 EXPORT_API int alarmmgr_get_type(const alarm_entry_t *alarm, int *alarm_type)
599 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
602 return ERR_ALARM_INVALID_PARAM;
605 if (alarm_type != NULL)
606 *alarm_type = alarm_info->alarm_type;
608 return ALARMMGR_RESULT_SUCCESS;
612 static int __alarmmgr_init_appsvc(void)
617 ALARM_MGR_EXCEPTION_PRINT("alarm was already initialized\n");
618 return ALARMMGR_RESULT_SUCCESS;
620 #if !GLIB_CHECK_VERSION(2,32,0)
624 dbus_g_thread_init();
630 b_initialized = true;
632 return ALARMMGR_RESULT_SUCCESS;
636 EXPORT_API void *alarmmgr_get_alarm_appsvc_info(alarm_id_t alarm_id, int *return_code){
648 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_alarm_appsvc_info() is called.");
652 *return_code = ERR_ALARM_INVALID_ID;
657 return _send_alarm_get_appsvc_info(alarm_context, alarm_id, return_code);
661 EXPORT_API int alarmmgr_set_rtc_time(alarm_date_t *time){
667 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter time\n");
668 return ERR_ALARM_INVALID_PARAM;
676 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_rtc_time() is called\n");
678 if (!__alarm_validate_date(time, &error_code)) {
679 ALARM_MGR_EXCEPTION_PRINT("RTC date error\n");
683 if (!__alarm_validate_time(time, &error_code)) {
684 ALARM_MGR_EXCEPTION_PRINT("RTC time error\n");
691 if (!_send_alarm_set_rtc_time
692 (alarm_context, time, &error_code)){
696 return ALARMMGR_RESULT_SUCCESS;
700 EXPORT_API int alarmmgr_add_alarm_appsvc_with_localtime(alarm_entry_t *alarm, void *bundle_data, alarm_id_t *alarm_id)
702 alarm_info_t *alarm_info = NULL; /* = (alarm_info_t*)alarm; */
703 const char *operation = NULL;
705 const char *appid = NULL;
707 bundle *b=(bundle *)bundle_data;
709 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
712 return ERR_ALARM_INVALID_PARAM;
717 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
718 return ERR_ALARM_INVALID_PARAM;
721 operation = appsvc_get_operation(b);
723 if (NULL == operation)
725 appsvc_set_operation(b, APPSVC_OPERATION_DEFAULT);
728 if (__alarmmgr_init_appsvc() < 0)
730 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
731 return ERR_ALARM_SYSTEM_FAIL;
734 alarm_info = (alarm_info_t *) alarm;
736 appid = appsvc_get_appid(b);
738 if ( (NULL == appid && (alarm_info->alarm_type & ALARM_TYPE_NOLAUNCH)) ||
739 (NULL == appid && operation && !strcmp(operation, APPSVC_OPERATION_DEFAULT)) )
741 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
742 return ERR_ALARM_INVALID_PARAM;
745 if (alarm_info == NULL || alarm_id == NULL) {
746 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
747 return ERR_ALARM_INVALID_PARAM;
749 alarm_mode_t *mode = &alarm_info->mode;
751 ALARM_MGR_EXCEPTION_PRINT("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
752 alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
753 alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
754 alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
755 alarm_info->mode.repeat, alarm_info->mode.u_interval, alarm_info->alarm_type);
757 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
758 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
759 return ERR_ALARM_INVALID_PARAM;
762 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
763 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
767 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
768 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
772 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
773 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
778 if (!_send_alarm_create_appsvc(alarm_context, alarm_info, alarm_id, b, &error_code)) {
782 return ALARMMGR_RESULT_SUCCESS;
788 EXPORT_API int alarmmgr_add_alarm_with_localtime(alarm_entry_t *alarm,
789 const char *destination,
790 alarm_id_t *alarm_id)
792 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
793 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
794 alarm_info_t *alarm_info; /* = (alarm_info_t*)alarm; */
799 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
802 return ERR_ALARM_INVALID_PARAM;
805 alarm_info = (alarm_info_t *) alarm;
806 if (alarm_info == NULL || alarm_id == NULL) {
807 return ERR_ALARM_INVALID_PARAM;
811 alarm_mode_t *mode = &alarm_info->mode;
817 ALARM_MGR_EXCEPTION_PRINT("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
818 alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
819 alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
820 alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
821 alarm_info->mode.repeat, alarm_info->mode.u_interval, alarm_info->alarm_type);
823 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
824 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
825 return ERR_ALARM_INVALID_PARAM;
828 if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
829 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
830 return ERR_ALARM_INVALID_PARAM;
834 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
835 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
839 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
840 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
844 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
845 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
849 if (destination != NULL) {
850 memset(dst_service_name, 0, strlen(destination) + strlen("ALARM.") + 2);
851 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s", destination);
852 memset(dst_service_name_mod, 'a', MAX_SERVICE_NAME_LEN-1);
854 for (i=0; i<=strlen(dst_service_name); i++)
856 if (dst_service_name[i] == '.' )
858 dst_service_name_mod[j] = dst_service_name[i];
863 dst_service_name_mod[j] = dst_service_name[i];
868 if (!_send_alarm_create(alarm_context, alarm_info, alarm_id, dst_service_name, dst_service_name_mod, &error_code)) {
872 if (!_send_alarm_create(alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
877 return ALARMMGR_RESULT_SUCCESS;
882 EXPORT_API int alarmmgr_add_alarm_appsvc(int alarm_type, time_t trigger_at_time,
883 time_t interval, void *bundle_data,
884 alarm_id_t *alarm_id)
887 struct timeval current_time;
888 struct tm duetime_tm;
889 alarm_info_t alarm_info;
890 const char *operation = NULL;
893 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
895 bundle *b=(bundle *)bundle_data;
899 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter bundle\n");
900 return ERR_ALARM_INVALID_PARAM;
902 operation = appsvc_get_operation(b);
904 if (NULL == operation)
906 appsvc_set_operation(b, APPSVC_OPERATION_DEFAULT);
909 appid = appsvc_get_appid(b);
911 if ( (NULL == appid && (alarm_type & ALARM_TYPE_NOLAUNCH)) ||
912 (NULL == appid && operation && !strcmp(operation, APPSVC_OPERATION_DEFAULT)) )
914 ALARM_MGR_EXCEPTION_PRINT("Invalid parameter\n");
915 return ERR_ALARM_INVALID_PARAM;
918 if (__alarmmgr_init_appsvc() < 0)
920 ALARM_MGR_EXCEPTION_PRINT("Unable to initialize dbus!!!\n");
921 return ERR_ALARM_SYSTEM_FAIL;
924 if (alarm_id == NULL) {
925 return ERR_ALARM_INVALID_PARAM;
928 if (trigger_at_time < 0) {
929 return ERR_ALARM_INVALID_PARAM;
932 alarm_info.alarm_type = alarm_type;
933 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
935 gettimeofday(¤t_time, NULL);
937 if (current_time.tv_usec > 500 * 1000)
939 // When the millisecond part of the current_time is bigger than 500ms,
940 // the duetime increases by extra 1sec.
941 current_time.tv_sec += (trigger_at_time + 1);
945 current_time.tv_sec += trigger_at_time;
948 tzset(); // Processes the TZ environment variable, and Set timezone, daylight, and tzname.
949 localtime_r(¤t_time.tv_sec, &duetime_tm);
951 alarm_info.start.year = duetime_tm.tm_year + 1900;
952 alarm_info.start.month = duetime_tm.tm_mon + 1;
953 alarm_info.start.day = duetime_tm.tm_mday;
955 alarm_info.end.year = 0;
956 alarm_info.end.month = 0;
957 alarm_info.end.day = 0;
959 alarm_info.start.hour = duetime_tm.tm_hour;
960 alarm_info.start.min = duetime_tm.tm_min;
961 alarm_info.start.sec = duetime_tm.tm_sec;
964 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
965 alarm_info.mode.u_interval.interval = 0;
967 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
968 alarm_info.mode.u_interval.interval = interval;
971 ALARM_MGR_EXCEPTION_PRINT("trigger_at_time(%d), start(%d-%d-%d, %02d:%02d:%02d), repeat(%d), interval(%d), type(%d)",
972 trigger_at_time, alarm_info.start.day, alarm_info.start.month, alarm_info.start.year,
973 alarm_info.start.hour, alarm_info.start.min, alarm_info.start.sec,
974 alarm_info.mode.repeat, alarm_info.mode.u_interval, alarm_info.alarm_type);
976 if (!_send_alarm_create_appsvc(alarm_context, &alarm_info, alarm_id, b, &error_code)) {
980 return ALARMMGR_RESULT_SUCCESS;
984 EXPORT_API int alarmmgr_add_alarm(int alarm_type, time_t trigger_at_time,
985 time_t interval, const char *destination,
986 alarm_id_t *alarm_id)
988 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
989 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
993 struct timeval current_time;
994 struct tm duetime_tm;
995 alarm_info_t alarm_info;
998 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
1004 if (alarm_id == NULL) {
1005 return ERR_ALARM_INVALID_PARAM;
1008 if (trigger_at_time < 0) {
1009 return ERR_ALARM_INVALID_PARAM;
1012 if (destination && strlen(destination) >= MAX_PKG_NAME_LEN){
1013 ALARM_MGR_EXCEPTION_PRINT("[alarm-lib]: destination name is too long!\n");
1014 return ERR_ALARM_INVALID_PARAM;
1017 alarm_info.alarm_type = alarm_type;
1018 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
1020 gettimeofday(¤t_time, NULL);
1022 if (current_time.tv_usec > 500 * 1000)
1024 // When the millisecond part of the current_time is bigger than 500ms,
1025 // the duetime increases by extra 1sec.
1026 current_time.tv_sec += (trigger_at_time + 1);
1030 current_time.tv_sec += trigger_at_time;
1033 tzset(); // Processes the TZ environment variable, and Set timezone, daylight, and tzname.
1034 localtime_r(¤t_time.tv_sec, &duetime_tm);
1036 alarm_info.start.year = duetime_tm.tm_year + 1900;
1037 alarm_info.start.month = duetime_tm.tm_mon + 1;
1038 alarm_info.start.day = duetime_tm.tm_mday;
1040 alarm_info.end.year = 0;
1041 alarm_info.end.month = 0;
1042 alarm_info.end.day = 0;
1044 alarm_info.start.hour = duetime_tm.tm_hour;
1045 alarm_info.start.min = duetime_tm.tm_min;
1046 alarm_info.start.sec = duetime_tm.tm_sec;
1048 if (interval <= 0) {
1049 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
1050 alarm_info.mode.u_interval.interval = 0;
1052 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
1053 alarm_info.mode.u_interval.interval = interval;
1056 ALARM_MGR_EXCEPTION_PRINT("trigger_at_time(%d), start(%d-%d-%d, %02d:%02d:%02d), repeat(%d), interval(%d), type(%d)",
1057 trigger_at_time, alarm_info.start.day, alarm_info.start.month, alarm_info.start.year,
1058 alarm_info.start.hour, alarm_info.start.min, alarm_info.start.sec,
1059 alarm_info.mode.repeat, alarm_info.mode.u_interval, alarm_info.alarm_type);
1061 if (destination != NULL) {
1062 memset(dst_service_name, 0,
1063 strlen(destination) + strlen("ALARM.") + 2);
1064 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s",
1066 memset(dst_service_name_mod,'a',MAX_SERVICE_NAME_LEN-1);
1070 for(i=0;i<=strlen(dst_service_name);i++)
1072 if (dst_service_name[i] == '.')
1074 dst_service_name_mod[j]=dst_service_name[i];
1079 dst_service_name_mod[j]=dst_service_name[i];
1084 if (!_send_alarm_create
1085 (alarm_context, &alarm_info, alarm_id, dst_service_name,dst_service_name_mod,
1090 if (!_send_alarm_create
1091 (alarm_context, &alarm_info, alarm_id, "null","null", &error_code)) {
1095 return ALARMMGR_RESULT_SUCCESS;
1098 EXPORT_API int alarmmgr_add_alarm_withcb(int alarm_type, time_t trigger_at_time,
1099 time_t interval, alarm_cb_t handler, void *user_param, alarm_id_t *alarm_id)
1101 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
1102 char dst_service_name_mod[MAX_SERVICE_NAME_LEN] = { 0 };
1106 struct timeval current_time;
1107 struct tm duetime_tm;
1108 alarm_info_t alarm_info;
1110 char appid[256] = {0,};
1112 if (aul_app_get_appid_bypid(getpid(), appid, sizeof(appid)) != AUL_R_OK) {
1113 ALARM_MGR_LOG_PRINT("aul_app_get_appid_bypid() is failed. PID %d may not be app.", getpid());
1116 ret = alarmmgr_init(appid);
1120 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_add_alarm_withcb() is called");
1122 if (alarm_id == NULL) {
1123 return ERR_ALARM_INVALID_PARAM;
1126 if (trigger_at_time < 0) {
1127 return ERR_ALARM_INVALID_PARAM;
1130 alarm_info.alarm_type = alarm_type;
1131 alarm_info.alarm_type |= ALARM_TYPE_RELATIVE;
1132 alarm_info.alarm_type |= ALARM_TYPE_WITHCB;
1134 gettimeofday(¤t_time, NULL);
1136 if (current_time.tv_usec > 500 * 1000)
1138 // When the millisecond part of the current_time is bigger than 500ms,
1139 // the duetime increases by extra 1sec.
1140 current_time.tv_sec += (trigger_at_time + 1);
1144 current_time.tv_sec += trigger_at_time;
1147 tzset(); // Processes the TZ environment variable, and Set timezone, daylight, and tzname.
1148 localtime_r(¤t_time.tv_sec, &duetime_tm);
1150 alarm_info.start.year = duetime_tm.tm_year + 1900;
1151 alarm_info.start.month = duetime_tm.tm_mon + 1;
1152 alarm_info.start.day = duetime_tm.tm_mday;
1154 alarm_info.end.year = 0;
1155 alarm_info.end.month = 0;
1156 alarm_info.end.day = 0;
1158 alarm_info.start.hour = duetime_tm.tm_hour;
1159 alarm_info.start.min = duetime_tm.tm_min;
1160 alarm_info.start.sec = duetime_tm.tm_sec;
1162 if (interval <= 0) {
1163 alarm_info.mode.repeat = ALARM_REPEAT_MODE_ONCE;
1164 alarm_info.mode.u_interval.interval = 0;
1166 alarm_info.mode.repeat = ALARM_REPEAT_MODE_REPEAT;
1167 alarm_info.mode.u_interval.interval = interval;
1170 ALARM_MGR_EXCEPTION_PRINT("trigger_at_time(%d), start(%d-%d-%d, %02d:%02d:%02d), repeat(%d), interval(%d), type(%d)",
1171 trigger_at_time, alarm_info.start.day, alarm_info.start.month, alarm_info.start.year,
1172 alarm_info.start.hour, alarm_info.start.min, alarm_info.start.sec,
1173 alarm_info.mode.repeat, alarm_info.mode.u_interval.interval, alarm_info.alarm_type);
1175 if (!_send_alarm_create(alarm_context, &alarm_info, alarm_id, "null","null", &error_code)) {
1178 __add_resultcb(*alarm_id, handler, user_param);
1180 return ALARMMGR_RESULT_SUCCESS;
1183 EXPORT_API int alarmmgr_remove_alarm(alarm_id_t alarm_id)
1187 alarm_cb_info_t *info;
1194 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_delete(%d) is called\n", alarm_id);
1196 if (alarm_id <= 0) {
1197 return ERR_ALARM_INVALID_ID;
1200 if (!_send_alarm_delete(alarm_context, alarm_id, &error_code))
1203 info = __find_resultcb(alarm_id);
1204 __remove_resultcb(info);
1206 return ALARMMGR_RESULT_SUCCESS;
1209 EXPORT_API int alarmmgr_remove_all(void)
1212 int return_code = ALARMMGR_RESULT_SUCCESS;
1213 int ret = __sub_init();
1219 if (!_send_alarm_delete_all(alarm_context, &error_code))
1225 EXPORT_API int alarmmgr_enum_alarm_ids(alarm_enum_fn_t fn, void *user_param)
1227 SECURE_LOGD("Enter");
1228 GError *error = NULL;
1229 GVariant *alarm_array = NULL;
1230 int return_code = 0;
1231 int maxnum_of_ids = 0;
1233 alarm_id_t alarm_id = -1;
1235 char *e_cookie = NULL;
1236 char cookie[256] = {0,};
1238 GVariantIter *iter = NULL;
1241 return ERR_ALARM_INVALID_PARAM;
1244 size = security_server_get_cookie_size();
1245 ret = security_server_request_cookie(cookie, size);
1247 ALARM_MGR_EXCEPTION_PRINT("security_server_request_cookie() is failed.");
1248 return ERR_ALARM_SYSTEM_FAIL;
1251 e_cookie = g_base64_encode((const guchar *)cookie, size);
1252 if (e_cookie == NULL) {
1253 ALARM_MGR_EXCEPTION_PRINT("g_base64_encode() is failed.");
1254 return ERR_ALARM_SYSTEM_FAIL;
1259 ALARM_MGR_EXCEPTION_PRINT("__sub_init() is failed.");
1264 SECURE_LOGD("alarm_manager_call_alarm_get_number_of_ids_sync() is called");
1265 if (!alarm_manager_call_alarm_get_number_of_ids_sync(
1266 (AlarmManager*)alarm_context.proxy, alarm_context.pid, e_cookie, &maxnum_of_ids, &return_code, NULL, &error)) {
1267 /* dbus-glib error */
1268 /* error_code should be set */
1269 ALARM_MGR_EXCEPTION_PRINT(
1270 "alarm_manager_call_alarm_get_number_of_ids_sync() is failed by dbus. return_code[%d], err message[%s]",
1271 return_code, error->message);
1273 return ERR_ALARM_SYSTEM_FAIL;
1278 if (return_code != ALARMMGR_RESULT_SUCCESS) {
1279 ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_number_of_ids_sync() is failed. return_code[%d]", return_code);
1282 ALARM_MGR_LOG_PRINT("maxnum_of_ids[%d]", maxnum_of_ids);
1285 SECURE_LOGD("alarm_manager_call_alarm_get_list_of_ids_sync() is called");
1286 if (!alarm_manager_call_alarm_get_list_of_ids_sync(
1287 (AlarmManager*)alarm_context.proxy, alarm_context.pid, maxnum_of_ids, &alarm_array, &num_of_ids, &return_code, NULL, &error)) {
1288 /*dbus-glib error */
1289 /* error_code should be set */
1290 ALARM_MGR_EXCEPTION_PRINT(
1291 "alarm_manager_call_alarm_get_list_of_ids_sync() failed by dbus. num_of_ids[%d], return_code[%d].", num_of_ids, return_code);
1292 return ERR_ALARM_SYSTEM_FAIL;
1295 if (return_code != ALARMMGR_RESULT_SUCCESS) {
1299 if (error != NULL) {
1300 ALARM_MGR_LOG_PRINT("Alarm server is not ready dbus. error message %s.", error->message);
1301 return ERR_ALARM_SYSTEM_FAIL;
1304 if (alarm_array == NULL) {
1305 ALARM_MGR_LOG_PRINT("alarm server is not initilized.");
1306 return ERR_ALARM_SYSTEM_FAIL;
1309 g_variant_get(alarm_array, "ai", &iter);
1310 while (g_variant_iter_loop(iter, "i", &alarm_id))
1312 (*fn) (alarm_id, user_param);
1313 ALARM_MGR_LOG_PRINT("alarm_id (%d)", alarm_id);
1315 g_variant_iter_free(iter);
1316 g_variant_unref(alarm_array);
1318 SECURE_LOGD("Leave");
1319 return ALARMMGR_RESULT_SUCCESS;
1322 EXPORT_API int alarmmgr_get_info(alarm_id_t alarm_id, alarm_entry_t *alarm)
1325 alarm_info_t *alarm_info = (alarm_info_t *) alarm;
1333 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_info() is called\n");
1335 if (alarm_id < 0 || alarm_info == NULL) {
1336 return ERR_ALARM_INVALID_PARAM;
1339 if (!_send_alarm_get_info(alarm_context, alarm_id, alarm_info, &error_code)) {
1343 return ALARMMGR_RESULT_SUCCESS;
1346 int alarmmgr_create(alarm_info_t *alarm_info, char *destination,
1347 alarm_id_t *alarm_id)
1349 char dst_service_name[MAX_SERVICE_NAME_LEN] = { 0 };
1350 alarm_mode_t *mode = &alarm_info->mode;
1353 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_create() is called\n");
1355 if (alarm_info == NULL || alarm_id == NULL) {
1356 return ERR_ALARM_INVALID_PARAM;
1359 ALARM_MGR_LOG_PRINT("alarm_info->start.year(%d), "
1360 "alarm_info->start.month(%d), alarm_info->start.day(%d)",
1361 alarm_info->start.year, alarm_info->start.month,
1362 alarm_info->start.day);
1364 /* TODO: This should be changed to > ALARM_REPEAT_MODE_MAX ? */
1365 if (mode->repeat >= ALARM_REPEAT_MODE_MAX) {
1366 return ERR_ALARM_INVALID_PARAM;
1369 if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
1370 ALARM_MGR_EXCEPTION_PRINT("start date error\n");
1374 if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
1375 ALARM_MGR_EXCEPTION_PRINT("start time error\n");
1379 if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
1380 ALARM_MGR_EXCEPTION_PRINT("end date error\n");
1384 if (destination != NULL) {
1385 memset(dst_service_name, 0,
1386 strlen(destination) + strlen("ALARM.") + 2);
1387 snprintf(dst_service_name, MAX_SERVICE_NAME_LEN, "ALARM.%s",
1389 if (!_send_alarm_create
1390 (alarm_context, alarm_info, alarm_id, dst_service_name,"null",
1395 /*TODO: Currently this API is not exported. Hence not modifying*/
1396 if (!_send_alarm_create
1397 (alarm_context, alarm_info, alarm_id, "null", "null", &error_code)) {
1401 return ALARMMGR_RESULT_SUCCESS;
1405 int alarmmgr_get_number_of_ids(int *num_of_ids)
1408 ALARM_MGR_LOG_PRINT("[alarm-lib]: alarm_get_number_of_ids() is called.");
1410 if (num_of_ids == NULL) {
1411 return ERR_ALARM_INVALID_PARAM;
1413 ALARM_MGR_LOG_PRINT("call alarm_get_number_of_ids\n");
1414 if (!_send_alarm_get_number_of_ids(alarm_context, num_of_ids, &error_code)) {
1418 return ALARMMGR_RESULT_SUCCESS;
1421 int alarmmgr_get_list_of_ids(int maxnum_of_ids, alarm_id_t *alarm_id,
1425 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_list_of_ids() is called.");
1427 if (maxnum_of_ids < 0 || alarm_id == NULL || num_of_ids == NULL) {
1428 return ERR_ALARM_INVALID_PARAM;
1431 if (maxnum_of_ids == 0) {
1433 return ALARMMGR_RESULT_SUCCESS;
1436 if (!_send_alarm_get_list_of_ids
1437 (alarm_context, maxnum_of_ids, alarm_id, num_of_ids, &error_code)) {
1441 return ALARMMGR_RESULT_SUCCESS;
1444 EXPORT_API int alarmmgr_get_next_duetime(alarm_id_t alarm_id, time_t* duetime)
1447 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_next_duetime() is called.");
1449 if (duetime == NULL) {
1450 return ERR_ALARM_INVALID_PARAM;
1453 if (!_send_alarm_get_next_duetime(alarm_context, alarm_id, duetime, &error_code)) {
1457 return ALARMMGR_RESULT_SUCCESS;
1460 EXPORT_API int alarmmgr_get_all_info(char **db_path)
1463 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_get_all_info() is called.");
1465 if (db_path == NULL) {
1466 return ERR_ALARM_INVALID_PARAM;
1469 if (!_send_alarm_get_all_info(alarm_context, db_path, &error_code)) {
1473 ALARM_MGR_LOG_PRINT("[alarm-lib]: successfully save info in %s.", *db_path);
1474 return ALARMMGR_RESULT_SUCCESS;
1477 EXPORT_API int alarmmgr_add_periodic_alarm_withcb(int interval, periodic_method_e method,
1478 alarm_cb_t handler, void *user_param, alarm_id_t *alarm_id)
1481 alarm_info_t alarm_info;
1483 char appid[256] = {0,};
1485 if (aul_app_get_appid_bypid(getpid(), appid, sizeof(appid)) != AUL_R_OK) {
1486 ALARM_MGR_LOG_PRINT("aul_app_get_appid_bypid() is failed. PID %d may not be app.",
1490 ret = alarmmgr_init(appid);
1494 if (alarm_id == NULL) {
1495 return ERR_ALARM_INVALID_PARAM;
1498 if (!_send_alarm_create_periodic(alarm_context, interval, 0, (int)method, alarm_id,
1502 __add_resultcb(*alarm_id, handler, user_param);
1504 return ALARMMGR_RESULT_SUCCESS;
1507 EXPORT_API int alarmmgr_add_reference_periodic_alarm_withcb(int interval,
1508 alarm_cb_t handler, void *user_param, alarm_id_t *alarm_id)
1511 alarm_info_t alarm_info;
1513 char appid[256] = {0,};
1515 if (aul_app_get_appid_bypid(getpid(), appid, sizeof(appid)) != AUL_R_OK) {
1516 ALARM_MGR_LOG_PRINT("aul_app_get_appid_bypid() is failed. PID %d may not be app.",
1520 ret = alarmmgr_init(appid);
1524 if (alarm_id == NULL) {
1525 return ERR_ALARM_INVALID_PARAM;
1528 if (!_send_alarm_create_periodic(alarm_context, interval, 1, 0,
1529 alarm_id, &error_code)) {
1533 __add_resultcb(*alarm_id, handler, user_param);
1535 return ALARMMGR_RESULT_SUCCESS;
1538 EXPORT_API int alarmmgr_set_systime(int new_time)
1541 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_systime() is called.");
1543 if (__sub_init() < 0) {
1544 return ERR_ALARM_SYSTEM_FAIL;
1547 if (!_send_alarm_set_time(alarm_context, new_time, &error_code)) {
1551 ALARM_MGR_LOG_PRINT("[alarm-lib]: successfully set the time(%d) by pid(%d).", new_time, alarm_context.pid);
1552 return ALARMMGR_RESULT_SUCCESS;
1555 EXPORT_API int alarmmgr_set_timezone(char *tzpath_str)
1558 ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_timezone() is called.");
1560 if (tzpath_str == NULL) {
1561 return ERR_ALARM_INVALID_PARAM;
1564 if (__sub_init() < 0) {
1565 return ERR_ALARM_SYSTEM_FAIL;
1568 if (!_send_alarm_set_timezone(alarm_context, tzpath_str, &error_code)) {
1572 ALARM_MGR_LOG_PRINT("[alarm-lib]: successfully set the timezone(%s) by pid(%d)", tzpath_str, alarm_context.pid);
1573 return ALARMMGR_RESULT_SUCCESS;