Add alarm update API

- int alarmmgr_update_alarm(alarm_id_t alarm_id, alarm_entry_t *alarm, int update_flag)

Change-Id: I835f3b595331e8fcae4d30843ec1c8b4a17e4e9f
Signed-off-by: Jiwoong Im <jiwoong.im@samsung.com>

diff --git a/alarm-manager.c b/alarm-manager.c
index cb1928f..694271b 100644 (file)
--- a/alarm-manager.c
+++ b/alarm-manager.c
@@ -124,10 +124,12 @@ bool is_time_changed = false; /* for calculating next duetime */
 #define BILLION 1000000000 /* for calculating nano seconds */
 static time_t periodic_alarm_standard_time = 0;
 
+static int __is_ui_app(const char *appid, uid_t uid);
+static long __get_proper_interval(long interval, int alarm_type);
 static bool __alarm_add_to_list(__alarm_info_t *__alarm_info);
 static void __alarm_generate_alarm_id(__alarm_info_t *__alarm_info, alarm_id_t *alarm_id);
-static bool __alarm_update_in_list(__alarm_info_t *__alarm_info,
-                                  int *error_code);
+static __alarm_info_t *__alarm_update_in_list(int uid, alarm_id_t alarm_id,
+               alarm_info_t *alarm_info, int update_flag, int *error_code);
 static bool __alarm_remove_from_list(uid_t uid, alarm_id_t alarm_id,
                                     int *error_code);
 static bool __alarm_set_start_and_end_time(alarm_info_t *alarm_info,
@@ -142,8 +144,8 @@ static bool __alarm_create_appsvc(alarm_info_t *alarm_info, alarm_id_t *alarm_id
                           long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code);
 
 static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code);
-static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_t alarm_id,
-                          alarm_info_t *alarm_info, int *error_code);
+static bool __alarm_update(uid_t uid, int pid, alarm_id_t alarm_id,
+                          alarm_info_t *alarm_info, int update_flag, int *error_code);
 static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id, int msec, uid_t uid);
 static void __alarm_expired();
 static gboolean __alarm_handler_idle(gpointer user_data);
@@ -507,26 +509,73 @@ static bool __alarm_add_to_list(__alarm_info_t *__alarm_info)
        return true;
 }
 
-static bool __alarm_update_in_list(__alarm_info_t *__alarm_info,
-                                  int *error_code)
+static bool __check_bundle_for_update(const gchar *b_data, uid_t uid)
+{
+       const char *callee_appid;
+       bundle *b;
+
+       if (strlen(b_data) == 4 && strncmp(b_data, "null", 4) == 0)
+               return true;
+
+       b = bundle_decode((bundle_raw *)b_data, strlen(b_data));
+       callee_appid = appsvc_get_appid(b);
+       if (callee_appid == NULL)
+               return false;
+
+       if (__is_ui_app(callee_appid, uid))
+               return true;
+
+       return false;
+}
+
+static __alarm_info_t *__alarm_update_in_list(int uid, alarm_id_t alarm_id,
+               alarm_info_t *alarm_info, int update_flag, int *error_code)
 {
        bool found = false;
-       alarm_info_t *alarm_info = &__alarm_info->alarm_info;
        GSList *iter = NULL;
        __alarm_info_t *entry = NULL;
+       alarm_info_t *_alarm_info = NULL;
 
        for (iter = alarm_context.alarms; iter != NULL;
             iter = g_slist_next(iter)) {
                entry = iter->data;
-               if (entry->uid == __alarm_info->uid &&
-                               entry->alarm_id == __alarm_info->alarm_id) {
+               if (entry->uid == uid &&
+                               entry->alarm_id == alarm_id) {
                        found = true;
-                       __alarm_info->quark_app_unique_name =
-                           entry->quark_app_unique_name;
-                       __alarm_info->quark_dst_service_name =
-                           entry->quark_dst_service_name;
-                       memcpy(entry, __alarm_info, sizeof(__alarm_info_t));
+                       _alarm_info = &entry->alarm_info;
+
+                       if (update_flag == ALARM_UPDATE_FLAG_TIME ||
+                                       ALARM_UPDATE_FLAG_WEEK) {
+                               if (!__check_bundle_for_update(g_quark_to_string(entry->quark_bundle),
+                                               entry->uid)) {
+                                       *error_code = ERR_ALARM_NOT_PERMITTED_APP;
+                                       return NULL;
+                               }
+                       }
 
+                       if (update_flag == ALARM_UPDATE_FLAG_TIME) {
+                               __alarm_set_start_and_end_time(alarm_info, entry);
+                       } else if (update_flag == ALARM_UPDATE_FLAG_PERIOD) {
+                               _alarm_info->alarm_type |= ALARM_TYPE_INEXACT;
+                               _alarm_info->alarm_type |= ALARM_TYPE_PERIOD;
+                               _alarm_info->mode.repeat = ALARM_REPEAT_MODE_REPEAT;
+                               _alarm_info->mode.u_interval.interval =
+                                       __get_proper_interval(alarm_info->mode.u_interval.interval,
+                                                       _alarm_info->alarm_type);
+                       } else if (update_flag == ALARM_UPDATE_FLAG_WEEK) {
+                               _alarm_info->alarm_type &= ~ALARM_TYPE_INEXACT;
+                               _alarm_info->mode = alarm_info->mode;
+                       } else if (update_flag == ALARM_UPDATE_FLAG_CLEAR_PERIOD) {
+                               if (_alarm_info->mode.repeat == ALARM_REPEAT_MODE_REPEAT) {
+                                       _alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+                                       _alarm_info->mode.u_interval.interval = 0;
+                               }
+                       } else if (update_flag == ALARM_UPDATE_FLAG_CLEAR_WEEK_FLAG) {
+                               if (_alarm_info->mode.repeat == ALARM_REPEAT_MODE_WEEKLY) {
+                                       _alarm_info->mode.repeat = ALARM_REPEAT_MODE_ONCE;
+                                       _alarm_info->mode.u_interval.interval = 0;
+                               }
+                       }
                        break;
                }
        }
@@ -534,15 +583,15 @@ static bool __alarm_update_in_list(__alarm_info_t *__alarm_info,
        if (!found) {
                if (error_code)
                        *error_code = ERR_ALARM_INVALID_ID;
-               return false;
+               return NULL;
        }
 
        if (!(alarm_info->alarm_type & ALARM_TYPE_VOLATILE)) {
-               if (!_update_alarms(__alarm_info))
-                       ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", __alarm_info->alarm_id);
+               if (!_update_alarms(entry))
+                       ALARM_MGR_EXCEPTION_PRINT("Updating alarm_id(%d) in DB is failed.", alarm_id);
        }
 
-       return true;
+       return entry;
 }
 
 static bool __alarm_remove_from_list(uid_t uid, alarm_id_t alarm_id,
@@ -1170,8 +1219,8 @@ static bool __alarm_create_noti(alarm_info_t *alarm_info, alarm_id_t *alarm_id,
        return true;
 }
 
-static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_t alarm_id,
-                          alarm_info_t *alarm_info, int *error_code)
+static bool __alarm_update(uid_t uid, int pid, alarm_id_t alarm_id,
+                          alarm_info_t *alarm_info, int update_flag, int *error_code)
 {
        time_t current_time;
        time_t due_time;
@@ -1179,25 +1228,6 @@ static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_
        __alarm_info_t *__alarm_info = NULL;
        bool result = false;
 
-       __alarm_info = malloc(sizeof(__alarm_info_t));
-       if (__alarm_info == NULL) {
-               SECURE_LOGE("Caution!! app_pid=%d, malloc failed. it seems to be OOM.", pid);
-               *error_code = ERR_ALARM_SYSTEM_FAIL;
-               return false;
-       }
-
-       __alarm_info->uid = uid;
-       __alarm_info->pid = pid;
-       __alarm_info->alarm_id = alarm_id;
-
-       /* we should consider to check whether  pid is running or Not
-        */
-
-       __alarm_info->quark_app_service_name =
-           g_quark_from_string(app_service_name);
-       __alarm_set_start_and_end_time(alarm_info, __alarm_info);
-       memcpy(&(__alarm_info->alarm_info), alarm_info, sizeof(alarm_info_t));
-
        time(&current_time);
 
        if (alarm_context.c_due_time < current_time) {
@@ -1206,14 +1236,16 @@ static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_
                alarm_context.c_due_time = -1;
        }
 
-       due_time = _alarm_next_duetime(__alarm_info);
-       if (!__alarm_update_in_list(__alarm_info, error_code)) {
-               free(__alarm_info);
+       __alarm_info = __alarm_update_in_list(uid, alarm_id, alarm_info,
+                       update_flag, error_code);
+       if (!__alarm_info) {
                ALARM_MGR_EXCEPTION_PRINT("[alarm-server]: requested alarm_id "
                "(%d) does not exist. so this value is invalid id.", alarm_id);
                return false;
        }
 
+       due_time = _alarm_next_duetime(__alarm_info);
+
        result = _remove_from_scheduled_alarm_list(uid, alarm_id);
 
        if (result == true && g_slist_length(g_scheduled_alarm_list) == 0) {
@@ -1228,24 +1260,20 @@ static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_
                if (due_time == 0)
                        ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: due_time is 0.");
 
-               free(__alarm_info);
                return true;
        }
 
        if (due_time == 0) {
                ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
                                "due_time is 0, alarm(%d)\n", alarm_id);
-               free(__alarm_info);
                return true;
        } else if (current_time == due_time) {
                ALARM_MGR_EXCEPTION_PRINT("[alarm-server]:Update alarm: "
                "current_time(%d) is same as due_time(%d)", current_time,
                due_time);
-               free(__alarm_info);
                return true;
        } else if (difftime(due_time, current_time) < 0) {
                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);
-               free(__alarm_info);
                return true;
        } else {
                char due_time_r[100] = { 0 };
@@ -1273,8 +1301,6 @@ static bool __alarm_update(uid_t uid, int pid, char *app_service_name, alarm_id_
 
        __rtc_set();
 
-       free(__alarm_info);
-
        return true;
 }
 
@@ -3116,13 +3142,15 @@ gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation
 }
 
 gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc,
-                                   char *app_service_name, alarm_id_t alarm_id,
+                                   alarm_id_t alarm_id,
                                    int start_year, int start_month,
                                    int start_day, int start_hour,
                                    int start_min, int start_sec, int end_year,
                                    int end_month, int end_day,
-                                   int mode_day_of_week, int mode_repeat,
+                                   int mode_interval,
+                                   int mode_repeat,
                                    int alarm_type, int reserved_info,
+                                   int update_flag,
                                    gpointer user_data)
 {
        int return_code = ALARMMGR_RESULT_SUCCESS;
@@ -3155,13 +3183,14 @@ gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *i
        alarm_info.end.month = end_month;
        alarm_info.end.day = end_day;
 
-       alarm_info.mode.u_interval.day_of_week = mode_day_of_week;
+       alarm_info.mode.u_interval.interval = mode_interval;
        alarm_info.mode.repeat = mode_repeat;
 
        alarm_info.alarm_type = alarm_type;
        alarm_info.reserved_info = reserved_info;
 
-       if (!__alarm_update(uid, pid, app_service_name, alarm_id, &alarm_info, &return_code)) {
+       if (!__alarm_update(uid, pid, alarm_id, &alarm_info,
+                               update_flag, &return_code)) {
                ALARM_MGR_EXCEPTION_PRINT("Unable to update the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
                strncpy(log_tag, "FAIL: UPDATE", strlen("FAIL: UPDATE"));
@@ -3176,8 +3205,8 @@ gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *i
        g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
 
 #ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
-       snprintf(log_message, sizeof(log_message), "alarmID: %d, appname: %s, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
-               alarm_id, app_service_name, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
+       snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
+               alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
        __save_module_log(log_tag, log_message);
 #endif
 

diff --git a/alarm_mgr.xml b/alarm_mgr.xml
index 804cfac..bcdee08 100644 (file)
--- a/alarm_mgr.xml
+++ b/alarm_mgr.xml
@@ -78,7 +78,6 @@
       <arg type="i" name="alarm_info_return_code" direction="out" />
     </method>
     <method name="alarm_update">
-      <arg type="s" name="app_service_name" direction="in" />
       <arg type="i" name="alarm_id" direction="in" />
       <arg type="i" name="alarm_info_start_year" direction="in" />
       <arg type="i" name="alarm_info_start_month" direction="in" />
@@ -93,6 +92,7 @@
       <arg type="i" name="alarm_info_mode_repeat" direction="in" />
       <arg type="i" name="alarm_info_alarm_type" direction="in" />
       <arg type="i" name="alarm_info_reserved_info" direction="in" />
+      <arg type="i" name="update_flag" direction="in" />
       <arg type="i" name="return_code" direction="out" />
     </method>
     <method name="alarm_get_number_of_ids">

diff --git a/include/alarm-internal.h b/include/alarm-internal.h
index eb892fe..dd4495c 100644 (file)
--- a/include/alarm-internal.h
+++ b/include/alarm-internal.h
@@ -140,8 +140,8 @@ bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info
                        alarm_id_t *alarm_id, bundle *b,int *error_code);
 bool _send_alarm_create_noti(alarm_context_t context, alarm_info_t *alarm_info,
                        alarm_id_t *alarm_id, notification_h noti, int *error_code);
-bool _send_alarm_update(alarm_context_t context, int pid, alarm_id_t alarm_id,
-                       alarm_info_t *alarm_info, int *error_code);
+bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
+                       alarm_info_t *alarm_info, int update_flag, int *error_code);
 bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id, int *error_code);
 bool _send_alarm_delete_all(alarm_context_t context, int *error_code);
 bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,

diff --git a/include/alarm.h b/include/alarm.h
index 2c67bfb..1ac82f6 100644 (file)
--- a/include/alarm.h
+++ b/include/alarm.h
@@ -246,6 +246,14 @@ typedef struct {
        int sec;                /**< specifies the second*/
 } alarm_date_t;
 
+enum {
+       ALARM_UPDATE_FLAG_TIME,
+       ALARM_UPDATE_FLAG_PERIOD,
+       ALARM_UPDATE_FLAG_WEEK,
+       ALARM_UPDATE_FLAG_CLEAR_PERIOD,
+       ALARM_UPDATE_FLAG_CLEAR_WEEK_FLAG,
+};
+
 
 typedef struct alarm_info_t alarm_entry_t;
 
@@ -1673,6 +1681,8 @@ int alarmmgr_add_periodic_alarm_withcb(int interval, periodic_method_e method, a
 int alarmmgr_add_reference_periodic_alarm_withcb(int interval, alarm_cb_t handler,
                void *user_param, alarm_id_t *alarm_id);
 
+int alarmmgr_update_alarm(alarm_id_t alarm_id,
+               alarm_entry_t *alarm, int update_flag);
 
 #ifdef __cplusplus
 }

diff --git a/src/alarm-lib-stub.c b/src/alarm-lib-stub.c
index 14f5be3..adb7b38 100644 (file)
--- a/src/alarm-lib-stub.c
+++ b/src/alarm-lib-stub.c
@@ -926,3 +926,49 @@ bool _send_alarm_get_global(alarm_context_t context, const alarm_id_t alarm_id,
        *global = _global;
        return true;
 }
+
+bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
+               alarm_info_t *alarm_info, int update_flag, int *error_code)
+{
+       GError *error = NULL;
+       int return_code = 0;
+
+       if (!alarm_manager_call_alarm_update_sync((AlarmManager *)context.proxy,
+                               alarm_id,
+                               alarm_info->start.year,
+                               alarm_info->start.month,
+                               alarm_info->start.day,
+                               alarm_info->start.hour,
+                               alarm_info->start.min,
+                               alarm_info->start.sec,
+                               alarm_info->end.year,
+                               alarm_info->end.month,
+                               alarm_info->end.day,
+                               alarm_info->mode.u_interval.interval,
+                               alarm_info->mode.repeat,
+                               alarm_info->alarm_type,
+                               alarm_info->reserved_info,
+                               update_flag,
+                               &return_code,
+                               NULL, &error)) {
+               ALARM_MGR_EXCEPTION_PRINT(
+                               "alarm_manager_call_alarm_update_sync()failed. alarm_id[%d], return_code[%d]", alarm_id, return_code);
+               ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
+               if (error_code) {
+                       if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+                               *error_code = ERR_ALARM_NO_PERMISSION;
+                       else
+                               *error_code = ERR_ALARM_SYSTEM_FAIL;
+               }
+               g_error_free(error);
+               return false;
+       }
+
+       if (return_code != 0) {
+               if (error_code)
+                       *error_code = return_code;
+               return false;
+       }
+
+       return true;
+}

diff --git a/src/alarm-lib.c b/src/alarm-lib.c
index 01e7325..b3b2ead 100644 (file)
--- a/src/alarm-lib.c
+++ b/src/alarm-lib.c
@@ -1990,3 +1990,54 @@ EXPORT_API int alarmmgr_get_global(const alarm_id_t alarm_id,
 
        return ALARMMGR_RESULT_SUCCESS;
 }
+
+EXPORT_API int alarmmgr_update_alarm(alarm_id_t alarm_id,
+               alarm_entry_t *alarm, int update_flag)
+{
+       alarm_info_t *alarm_info;       /* = (alarm_info_t*)alarm; */
+       int ret;
+
+       ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_update_alarm() is called\n");
+
+       if (alarm == NULL)
+               return ERR_ALARM_INVALID_PARAM;
+
+       alarm_info = (alarm_info_t *) alarm;
+       if (alarm_info == NULL || alarm_id <= 0)
+               return ERR_ALARM_INVALID_PARAM;
+
+       int error_code;
+       alarm_mode_t *mode = &alarm_info->mode;
+
+       ret = __sub_init();
+       if (ret < 0)
+               return ret;
+
+       ALARM_MGR_LOG_PRINT("start(%d-%d-%d, %02d:%02d:%02d), end(%d-%d-%d), repeat(%d), interval(%d), type(%d)",
+                       alarm_info->start.day, alarm_info->start.month, alarm_info->start.year,
+                       alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec,
+                       alarm_info->end.year, alarm_info->end.month, alarm_info->end.day,
+                       alarm_info->mode.repeat, alarm_info->mode.u_interval, alarm_info->alarm_type);
+
+       if (update_flag == ALARM_UPDATE_FLAG_TIME) {
+               if (!__alarm_validate_date(&alarm_info->start, &error_code)) {
+                       ALARM_MGR_EXCEPTION_PRINT("start date error\n");
+                       return error_code;
+               }
+
+               if (!__alarm_validate_time(&alarm_info->start, &error_code)) {
+                       ALARM_MGR_EXCEPTION_PRINT("start time error\n");
+                       return error_code;
+               }
+
+               if (!__alarm_validate_date(&alarm_info->end, &error_code)) {
+                       ALARM_MGR_EXCEPTION_PRINT("end date error\n");
+                       return error_code;
+               }
+       }
+
+       if (!_send_alarm_update(alarm_context, alarm_id, alarm_info, update_flag, &error_code))
+               return error_code;
+
+       return ALARMMGR_RESULT_SUCCESS;
+}