pid_t pid = __get_caller_pid(name);
if (g_strcmp0(method_name, "alarm_create_periodic") == 0) {
- ret = alarm_manager_alarm_create_periodic(parameters, uid, pid, &alarm_id);
+ ret = alarm_manager_alarm_create_periodic(parameters, uid, pid, sender, &alarm_id);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
} else if (g_strcmp0(method_name, "alarm_create") == 0) {
- ret = alarm_manager_alarm_create(parameters, uid, pid, &alarm_id);
+ ret = alarm_manager_alarm_create(parameters, uid, pid, sender, &alarm_id);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
} else if (g_strcmp0(method_name, "alarm_create_appsvc") == 0) {
- ret = alarm_manager_alarm_create_appsvc(parameters, uid, pid, &alarm_id);
+ ret = alarm_manager_alarm_create_appsvc(parameters, uid, pid, sender, &alarm_id);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
} else if (g_strcmp0(method_name, "alarm_create_noti") == 0) {
const char *notification_priv = "http://tizen.org/privilege/notification";
ret = _cynara_check(invoc, notification_priv, pid);
if (ret == ALARMMGR_RESULT_SUCCESS) {
- ret = alarm_manager_alarm_create_noti(parameters, uid, pid, &alarm_id);
+ ret = alarm_manager_alarm_create_noti(parameters, uid, pid, sender, &alarm_id);
}
g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
} else if (g_strcmp0(method_name, "alarm_delete") == 0) {
- ret = alarm_manager_alarm_delete(parameters, uid, pid);
+ ret = alarm_manager_alarm_delete(parameters, uid, pid, sender);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
} else if (g_strcmp0(method_name, "alarm_delete_all") == 0) {
- ret = alarm_manager_alarm_delete_all(parameters, uid, pid);
+ ret = alarm_manager_alarm_delete_all(parameters, uid, pid, sender);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
} else if (g_strcmp0(method_name, "alarm_update") == 0) {
- ret = alarm_manager_alarm_update(parameters, uid, pid);
+ ret = alarm_manager_alarm_update(parameters, uid, pid, sender);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
} else if (g_strcmp0(method_name, "alarm_get_number_of_ids") == 0) {
- ret = alarm_manager_alarm_get_number_of_ids(uid, pid, &num_of_alarm);
+ ret = alarm_manager_alarm_get_number_of_ids(uid, pid, sender, &num_of_alarm);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_alarm, ret));
} else if (g_strcmp0(method_name, "alarm_get_list_of_ids") == 0) {
GVariantBuilder *arr = g_variant_builder_new(G_VARIANT_TYPE("a(i)"));
- ret = alarm_manager_alarm_get_list_of_ids(parameters, uid, pid, arr, &num_of_alarm);
+ ret = alarm_manager_alarm_get_list_of_ids(parameters, uid, pid, sender, arr, &num_of_alarm);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(a(i)ii)", arr, num_of_alarm, ret));
g_variant_builder_unref(arr);
_display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
} else if (g_strcmp0(method_name, "alarm_set_time") == 0) {
_display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0);
- ret = alarm_manager_alarm_set_time(parameters, pid);
+ ret = alarm_manager_alarm_set_time(parameters, pid, sender);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
_display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
} else if (g_strcmp0(method_name, "alarm_set_time_with_propagation_delay") == 0) {
_display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0);
- ret = alarm_manager_alarm_set_time_with_propagation_delay(parameters, pid);
+ ret = alarm_manager_alarm_set_time_with_propagation_delay(parameters, pid, sender);
g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
_display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN);
} else if (g_strcmp0(method_name, "alarm_set_timezone") == 0) {
typedef struct {
int pid;
bool is_app;
+ char *sender;
char *unique_name;
} appid_cache_t;
__alarm_info_t *__alarm_info);
static void __alarm_update_due_time_of_all_items_in_list(time_t new_time,double diff_time);
static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
- int pid, periodic_method_e method, long requested_interval, int is_ref,
- char *app_service_name, char *app_service_name_mod,
- const char *dst_service_name, const char *dst_service_name_mod,
- int *error_code);
+ int pid, const gchar *sender, periodic_method_e method,
+ long requested_interval, int is_ref, char *app_service_name,
+ char *app_service_name_mod, const char *dst_service_name,
+ const char *dst_service_name_mod, int *error_code);
static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
- long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code);
+ long requested_interval, uid_t uid, int pid, const gchar *sender,
+ 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, alarm_id_t alarm_id,
return false;
}
-static bool __get_cached_unique_name(int pid, char *unique_name, int size, bool *is_app, uid_t uid)
+static bool __get_cached_unique_name(int pid, const gchar *sender,
+ char *unique_name, int size, bool *is_app, uid_t uid)
{
appid_cache_t *data;
bool ret = false;
bool _is_app;
- data = (appid_cache_t *)g_hash_table_lookup(caller_appid_cache_table, GINT_TO_POINTER(pid));
+ data = (appid_cache_t *)g_hash_table_lookup(caller_appid_cache_table, (gpointer)sender);
if (data) {
snprintf(unique_name, size, "%s", data->unique_name);
if (is_app)
data = (appid_cache_t *)calloc(1, sizeof(appid_cache_t));
if (data) {
data->unique_name = strdup(unique_name);
+ data->sender = strdup(sender);
data->is_app = _is_app;
data->pid = pid;
- g_hash_table_insert(caller_appid_cache_table, GINT_TO_POINTER(data->pid), (gpointer)data);
+
+ if (data->unique_name && data->sender) {
+ if (g_hash_table_size(caller_appid_cache_table) > MAX_APPID_CACHE_SIZE) {
+ g_hash_table_remove_all(caller_appid_cache_table);
+ }
+ g_hash_table_insert(caller_appid_cache_table, (gpointer)data->sender, (gpointer)data);
+ } else {
+ LOGE("Out of memory");
+ __free_cached_value(data);
+ }
}
if (is_app)
if (value) {
if (value->unique_name)
free(value->unique_name);
+ if (value->sender)
+ free(value->sender);
free(value);
}
}
}
static bool __alarm_create_appsvc(base_info_t *base_info, alarm_id_t *alarm_id,
- long requested_interval, uid_t uid, int pid, char *bundle_data, int *error_code)
+ long requested_interval, uid_t uid, int pid, const gchar *sender,
+ char *bundle_data, int *error_code)
{
char app_name[MAX_APP_ID_LEN] = { 0 };
bundle *b;
__alarm_info->global = false;
__alarm_info->method = CUT_OFF;
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), &caller_is_app, uid) == false) {
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
+ &caller_is_app, uid) == false) {
*error_code = ERR_ALARM_SYSTEM_FAIL;
_release_alarm_info_t(__alarm_info);
return false;
return true;
}
-static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id, uid_t uid,
- int pid, periodic_method_e method, long requested_interval, int is_ref,
- char *app_service_name, char *app_service_name_mod,
- const char *dst_service_name, const char *dst_service_name_mod,
- int *error_code)
+static bool __alarm_create(base_info_t *base_info, alarm_id_t *alarm_id,
+ uid_t uid, int pid, const gchar *sender, periodic_method_e method,
+ long requested_interval, int is_ref, char *app_service_name,
+ char *app_service_name_mod, const char *dst_service_name,
+ const char *dst_service_name_mod, int *error_code)
{
char unique_name[MAX_APP_ID_LEN] = { 0 };
bool caller_is_app = false;
__alarm_info->is_ref = is_ref;
__alarm_info->global = false;
- if (__get_cached_unique_name(pid, unique_name, sizeof(unique_name),
+ if (__get_cached_unique_name(pid, sender, unique_name, sizeof(unique_name),
&caller_is_app, uid) == false) {
*error_code = ERR_ALARM_SYSTEM_FAIL;
_release_alarm_info_t(__alarm_info);
}
static bool __alarm_create_noti(base_info_t *base_info, alarm_id_t *alarm_id,
- long requested_interval, uid_t uid, int pid, char *noti_data, int *error_code)
+ long requested_interval, uid_t uid, int pid, const gchar *sender,
+ char *noti_data, int *error_code)
{
char app_name[MAX_APP_ID_LEN] = { 0 };
bool caller_is_app = false;
__alarm_info->global = false;
__alarm_info->method = CUT_OFF;
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), &caller_is_app, uid) == false) {
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
+ &caller_is_app, uid) == false) {
*error_code = ERR_ALARM_SYSTEM_FAIL;
_release_alarm_info_t(__alarm_info);
return false;
const char *caller_pkgid = entry->caller_pkgid;
const char *callee_pkgid = entry->callee_pkgid;
- int pid = _get_pid_from_appid(entry->app_unique_name, entry->uid);
gs_iter = g_slist_next(gs_iter);
if ((caller_pkgid && strncmp(pkgid, caller_pkgid, strlen(pkgid)) == 0) ||
g_disabled_alarm_list = g_slist_append(g_disabled_alarm_list, entry);
alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
} else {
- if (g_hash_table_remove(caller_appid_cache_table, GINT_TO_POINTER(pid)) == true)
- LOGD("Remove cachd data of pid[%d]", pid);
-
LOGD("Remove pkgid[%s], alarm_id[%d]", pkgid, entry->alarm_id);
alarm_context.alarms = g_slist_remove(alarm_context.alarms, entry);
_release_alarm_info_t(entry);
return;
}
-static int __check_modifiable(uid_t uid, pid_t pid, int alarm_id)
+static int __check_modifiable(uid_t uid, pid_t pid, const gchar *sender, int alarm_id)
{
bool caller_is_app = false;
char app_name[MAX_APP_ID_LEN] = { 0 };
__alarm_info_t *entry = NULL;
char *caller_pkgid = NULL;
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name),
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name),
&caller_is_app, uid) == false)
return ERR_ALARM_SYSTEM_FAIL;
static int accrue_nsec = 0; /* To check a millisecond part of current time at changing the system time(sec) */
-int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid)
+int alarm_manager_alarm_set_time(GVariant* parameters, pid_t pid, const gchar *sender)
{
double diff_time = 0.0;
struct timespec cur_time;
__reschedule_alarms_with_newtime(cur_time.tv_sec, new_time, diff_time);
- __get_cached_unique_name(pid, sender_id, MAX_APP_ID_LEN, NULL, 5001);
+ __get_cached_unique_name(pid, sender, sender_id, MAX_APP_ID_LEN, NULL, 5001);
snprintf(log_message, sizeof(log_message), "requested by %s (pid %d)", sender_id, pid);
_save_module_log("SET TIME END", log_message);
return ALARMMGR_RESULT_SUCCESS;;
}
-int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters, pid_t pid)
+int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters,
+ pid_t pid, const gchar *sender)
{
double diff_time = 0.0;
struct timespec cur_time = {0,};
LOGD("Requested(%ld.%09ld) Delay(%ld.%09ld) Sleep(%09ld)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
__reschedule_alarms_with_newtime(cur_time.tv_sec, real_newtime, diff_time);
- __get_cached_unique_name(pid, sender_id, MAX_APP_ID_LEN, NULL, 5001);
+ __get_cached_unique_name(pid, sender, sender_id, MAX_APP_ID_LEN, NULL, 5001);
snprintf(log_message, sizeof(log_message), "requested by %s (pid %d)", sender_id, pid);
_save_module_log("SET TIME PROPAGATION END", log_message);
return return_code;
}
-int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
+int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid,
+ const gchar *sender, int *alarm_id)
{
base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
base_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_appsvc(&base_info, &_alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
+ if (!__alarm_create_appsvc(&base_info, &_alarm_id, mode_interval, uid, pid,
+ sender, bundle_data, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE SVC", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message),
}
int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
- int *alarm_id)
+ const gchar *sender, int *alarm_id)
{
base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
base_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_noti(&base_info, &_alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
+ if (!__alarm_create_noti(&base_info, &_alarm_id, mode_interval, uid, pid,
+ sender, noti_data, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE NOTI", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
return return_code;
}
-int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
+int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid,
+ const gchar *sender, int *alarm_id)
{
base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
if (strcmp(reserved_service_name_mod, "null") == 0)
_reserved_service_name_mod = NULL;
- if (!__alarm_create(&base_info, &_alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
+ if (!__alarm_create(&base_info, &_alarm_id, uid, pid, sender, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
_reserved_service_name, _reserved_service_name_mod, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
}
int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
- pid_t pid, int *alarm_id)
+ pid_t pid, const gchar *sender, int *alarm_id)
{
base_info_t base_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
base_info.mode.u_interval.interval = __get_proper_interval(interval * 60);
}
- if (!__alarm_create(&base_info, &_alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
- app_service_name, app_service_name_mod,
- NULL, NULL, &return_code)) {
+ if (!__alarm_create(&base_info, &_alarm_id, uid, pid, sender,
+ (periodic_method_e)method, interval * 60, is_ref, app_service_name,
+ app_service_name_mod, NULL, NULL, &return_code)) {
LOGE("Unable to create alarm! return_code[%d]", return_code);
strncpy(log_tag, "FAIL: CREAT PERIOD", sizeof(log_tag) - 1);
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
return return_code;
}
-int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid,
+ const gchar *sender)
{
int return_code = ALARMMGR_RESULT_SUCCESS;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
g_variant_get(parameters, "(i)", &alarm_id);
- return_code = __check_modifiable(uid, pid, alarm_id);
+ return_code = __check_modifiable(uid, pid, sender, alarm_id);
if (return_code != ALARMMGR_RESULT_SUCCESS)
return return_code;
return return_code;
}
-int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid,
+ const gchar *sender)
{
GSList *gs_iter = NULL;
char app_name[MAX_APP_ID_LEN] = { 0 };
bool is_deleted = false;
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false) {
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false) {
snprintf(log_message, sizeof(log_message), "pid: %d. Can not get the unique_name.", pid);
_save_module_log("FAIL: DELETE ALL", log_message);
return ERR_ALARM_SYSTEM_FAIL;
return ALARMMGR_RESULT_SUCCESS;
}
-int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
+int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid, const gchar *sender)
{
int return_code = ALARMMGR_RESULT_SUCCESS;
base_info_t base_info;
mode_interval = (time_t)tmp_mode_interval;
reserved_info = (time_t)tmp_reserved_info;
- return_code = __check_modifiable(uid, pid, alarm_id);
+ return_code = __check_modifiable(uid, pid, sender, alarm_id);
if (return_code != ALARMMGR_RESULT_SUCCESS)
return return_code;
return return_code;
}
-int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids)
+int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid,
+ const gchar *sender, int *num_of_ids)
{
GSList *gs_iter = NULL;
char app_name[MAX_APP_ID_LEN] = { 0 };
*num_of_ids = _num_of_ids;
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false)
return ERR_ALARM_SYSTEM_FAIL;
SECURE_LOGD("Called by process (uid:%d, pid:%d, unique_name:%s)", uid, pid, app_name);
}
int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid,
- pid_t pid, GVariantBuilder *alarm_array, int *num_of_alarm)
+ pid_t pid, const gchar *sender, GVariantBuilder *alarm_array, int *num_of_alarm)
{
GSList *gs_iter = NULL;
char app_name[MAX_APP_ID_LEN] = { 0 };
return ALARMMGR_RESULT_SUCCESS;
}
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+ if (__get_cached_unique_name(pid, sender, app_name, sizeof(app_name), NULL, uid) == false)
return ERR_ALARM_SYSTEM_FAIL;
SECURE_LOGD("Called by process (uid: %d, pid:%d, unique_name=%s).", uid, pid, app_name);
__initialize_noti();
if (!caller_appid_cache_table) {
- caller_appid_cache_table = g_hash_table_new_full(g_direct_hash,
- g_direct_equal, NULL, __free_cached_value);
+ caller_appid_cache_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, NULL, __free_cached_value);
}
if (using_rtc) {
return 0;
}
+static char *ver = "2.0";
static int __pkgmgrinfo_pkginfo_get_api_version_fake(
pkgmgrinfo_pkginfo_h handle, char **version)
{
+ *version = ver;
return 0;
}
2019, 11, 1, 12, 59, 59, 400, 2020, 12, 29, 3, 1, 1, reserved,
"reserved_service_name", "reserved_service_name_mod");
- ret = alarm_manager_alarm_create(param, 5001, 1, &alarm_id);
+ ret = alarm_manager_alarm_create(param, 5001, 1, "sender", &alarm_id);
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
2020, 12, 29,
1, reserved, 1, 0, reserved,
(char *)b_data);
- ret = alarm_manager_alarm_create_appsvc(param, 5001, 1, &alarm_id);
+ ret = alarm_manager_alarm_create_appsvc(param, 5001, 1, "sender", &alarm_id);
bundle_free(b);
if (b_data)
free(b_data);
param = g_variant_new("(ssiii)",
"app_service_name", "app_service_name_mod", 1, 0, 1);
- ret = alarm_manager_alarm_create_periodic(param, 5001, 1, &alarm_id);
+ ret = alarm_manager_alarm_create_periodic(param, 5001, 1, "sender", &alarm_id);
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
"bundle");
- ret = alarm_manager_alarm_create_noti(param, 5001, 1, &alarm_id);
+ ret = alarm_manager_alarm_create_noti(param, 5001, 1, "sender", &alarm_id);
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
param = g_variant_new("(i)", 1);
- ret = alarm_manager_alarm_delete(param, 5001, 1);
+ ret = alarm_manager_alarm_delete(param, 5001, 1, "sender");
EXPECT_EQ(ERR_ALARM_INVALID_ID, ret);
}
int ret;
GVariant *param = NULL;
- ret = alarm_manager_alarm_delete_all(param, 5001, 1);
+ ret = alarm_manager_alarm_delete_all(param, 5001, 1, "sender");
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
2020, 12, 29, 0,
reserved, 0, 0, reserved, 0);
- ret = alarm_manager_alarm_update(param, 5001, 1);
+ ret = alarm_manager_alarm_update(param, 5001, 1, "sender");
EXPECT_EQ(ERR_ALARM_INVALID_ID, ret);
}
int ret;
int num_of_ids;
- ret = alarm_manager_alarm_get_number_of_ids(5001, 1, &num_of_ids);
+ ret = alarm_manager_alarm_get_number_of_ids(5001, 1, "sender", &num_of_ids);
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
param = g_variant_new("(i)", 10);
- ret = alarm_manager_alarm_get_list_of_ids(param, 5001, 1, &alarm_array,
+ ret = alarm_manager_alarm_get_list_of_ids(param, 5001, 1, "sender", &alarm_array,
&num_of_alarm);
EXPECT_EQ(ALARMMGR_RESULT_SUCCESS, ret);
}
param = g_variant_new("(x)", 20190012);
- ret = alarm_manager_alarm_set_time(param, 1);
+ ret = alarm_manager_alarm_set_time(param, 1, "sender");
EXPECT_EQ(ERR_ALARM_SYSTEM_FAIL, ret);
}
param = g_variant_new("(xxxx)", 20190012, 2949294, 292929, 29299292);
- ret = alarm_manager_alarm_set_time_with_propagation_delay(param, 1);
+ ret = alarm_manager_alarm_set_time_with_propagation_delay(param, 1, "sender");
EXPECT_EQ(ERR_ALARM_SYSTEM_FAIL, ret);
}
2019, 11, 1, 12, 59, 59, 400, 2020, 12, 29, 3, 1, 1, reserved,
"reserved_service_name", "reserved_service_name_mod");
- ret = alarm_manager_alarm_create(param, 5001, 1, &alarm_id);
+ ret = alarm_manager_alarm_create(param, 5001, 1, "sender", &alarm_id);
param2 = g_variant_new("(ib)", alarm_id, true);
ret = alarm_manager_alarm_set_global(param2, 5001);