/* * libnotification * * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Seungtaek Chung , Mi-Ju Lee , Xi Zhichan * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static void (*posted_toast_message_cb) (void *data); #define NOTI_TEXT_RESULT_LEN 2048 #define NOTI_PKGNAME_LEN 512 char *notification_get_pkgname_by_pid(void) { char pkgname[NOTI_PKGNAME_LEN + 1] = { 0, }; int pid = 0, ret = AUL_R_OK; int fd; char *dup_pkgname; pid = getpid(); ret = aul_app_get_pkgname_bypid(pid, pkgname, sizeof(pkgname)); if (ret != AUL_R_OK) { char buf[NOTI_PKGNAME_LEN + 1] = { 0, }; snprintf(buf, sizeof(buf), "/proc/%d/cmdline", pid); fd = open(buf, O_RDONLY); if (fd < 0) { return NULL; } ret = read(fd, pkgname, sizeof(pkgname) - 1); close(fd); if (ret <= 0) { return NULL; } pkgname[ret] = '\0'; /*! * \NOTE * "ret" is not able to be larger than "sizeof(pkgname) - 1", * if the system is not going wrong. */ } else { if (strlen(pkgname) <= 0) { return NULL; } } dup_pkgname = strdup(pkgname); if (!dup_pkgname) NOTIFICATION_ERR("Heap: %d\n", errno); return dup_pkgname; } EXPORT_API int notification_set_image(notification_h noti, notification_image_type_e type, const char *image_path) { bundle *b = NULL; char buf_key[32] = { 0, }; char *ret_val = NULL; /* Check noti and image_path are valid data */ if (noti == NULL || image_path == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check image type is valid type */ if (type <= NOTIFICATION_IMAGE_TYPE_NONE || type >= NOTIFICATION_IMAGE_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check image path bundle is exist */ if (noti->b_image_path) { /* If image path bundle is exist, store local bundle value */ b = noti->b_image_path; /* Set image type to key as char string type */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value using key */ bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { /* If key is exist, remove this value to store new image path */ bundle_del(b, buf_key); } /* Add new image path with type key */ bundle_add_str(b, buf_key, image_path); } else { /* If image path bundle is not exist, create new one */ b = bundle_create(); /* Set image type to key as char string type */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Add new image path with type key */ bundle_add_str(b, buf_key, image_path); /* Save to image path bundle */ noti->b_image_path = b; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_image(notification_h noti, notification_image_type_e type, char **image_path) { bundle *b = NULL; char buf_key[32] = { 0, }; char *ret_val = NULL; /* Check noti and image_path is valid data */ if (noti == NULL || image_path == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check image type is valid data */ if (type <= NOTIFICATION_IMAGE_TYPE_NONE || type >= NOTIFICATION_IMAGE_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check image path bundle exist */ if (noti->b_image_path) { /* If image path bundle exist, store local bundle data */ b = noti->b_image_path; /* Set image type to key as char string type */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value of key */ bundle_get_str(b, buf_key, &ret_val); *image_path = ret_val; } else { /* If image path bundle does not exist, image path is NULL */ *image_path = NULL; } /* If image path is NULL and type is ICON, icon path set from AIL */ /* order : user icon -> launch_pkgname icon -> caller_pkgname icon -> service app icon */ if (*image_path == NULL && type == NOTIFICATION_IMAGE_TYPE_ICON) { /* Check App icon path is already set */ if (noti->app_icon_path != NULL) { /* image path will be app icon path */ *image_path = noti->app_icon_path; } else { *image_path = NULL; } } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_time(notification_h noti, time_t input_time) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (input_time == 0) { /* If input time is 0, set current time */ noti->time = time(NULL); } else { /* save input time */ noti->time = input_time; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_time(notification_h noti, time_t * ret_time) { /* Check noti and time is valid data */ if (noti == NULL || ret_time == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set time infomation */ *ret_time = noti->time; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_insert_time(notification_h noti, time_t * ret_time) { /* Check noti and ret_time is valid data */ if (noti == NULL || ret_time == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set insert time information */ *ret_time = noti->insert_time; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_text(notification_h noti, notification_text_type_e type, const char *text, const char *key, int args_type, ...) { bundle *b = NULL; char buf_key[32] = { 0, }; char buf_val[1024] = { 0, }; char *ret_val = NULL; va_list var_args; notification_variable_type_e var_type; int num_args = 0; int noti_err = NOTIFICATION_ERROR_NONE; int var_value_int = 0; double var_value_double = 0.0; char *var_value_string = NULL; notification_count_pos_type_e var_value_count = NOTIFICATION_COUNT_POS_NONE; /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check text type is valid type */ if (type <= NOTIFICATION_TEXT_TYPE_NONE || type >= NOTIFICATION_TEXT_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check text bundle exist */ if (text != NULL) { if (noti->b_text != NULL) { /* If text bundle exist, store local bundle data */ b = noti->b_text; /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value using type key */ bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { /* If value exist, remove this to add new value */ bundle_del(b, buf_key); } snprintf(buf_val, sizeof(buf_val), "%s", text); /* Add new text value */ bundle_add_str(b, buf_key, buf_val); } else { /* If text bundle does not exist, create new one */ b = bundle_create(); /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); snprintf(buf_val, sizeof(buf_val), "%s", text); /* Add new text value */ bundle_add_str(b, buf_key, buf_val); /* Save text bundle */ noti->b_text = b; } } else { /* Reset if text is NULL */ if (noti->b_text != NULL) { /* If text bundle exist, store local bundle data */ b = noti->b_text; /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value using type key */ bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { /* If value exist, remove this */ bundle_del(b, buf_key); } } } /* Save key if key is valid data */ if (key != NULL) { /* Check key bundle exist */ if (noti->b_key != NULL) { /* If key bundle exist, store local bundle data */ b = noti->b_key; /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value using type key */ bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { /* If value exist, remove this to add new value */ bundle_del(b, buf_key); } snprintf(buf_val, sizeof(buf_val), "%s", key); /* Add new key value */ bundle_add_str(b, buf_key, buf_val); } else { /* If key bundle does not exist, create new one */ b = bundle_create(); /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); snprintf(buf_val, sizeof(buf_val), "%s", key); /* Add new key value */ bundle_add_str(b, buf_key, buf_val); /* Save key bundle */ noti->b_key = b; } } else { /* Reset if key is NULL */ if (noti->b_key != NULL) { /* If key bundle exist, store local bundle data */ b = noti->b_key; /* Make type to key as char string */ snprintf(buf_key, sizeof(buf_key), "%d", type); /* Get value using type key */ bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { /* If value exist, remove this */ bundle_del(b, buf_key); } } } if (noti->b_format_args != NULL) { b = noti->b_format_args; } else { b = bundle_create(); } va_start(var_args, args_type); var_type = args_type; num_args = 0; while (var_type != NOTIFICATION_VARIABLE_TYPE_NONE) { /* Type */ snprintf(buf_key, sizeof(buf_key), "%dtype%d", type, num_args); snprintf(buf_val, sizeof(buf_val), "%d", var_type); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); switch (var_type) { case NOTIFICATION_VARIABLE_TYPE_INT: var_value_int = va_arg(var_args, int); /* Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type, num_args); snprintf(buf_val, sizeof(buf_val), "%d", var_value_int); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); break; case NOTIFICATION_VARIABLE_TYPE_DOUBLE: var_value_double = va_arg(var_args, double); /* Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type, num_args); snprintf(buf_val, sizeof(buf_val), "%.2f", var_value_double); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); break; case NOTIFICATION_VARIABLE_TYPE_STRING: var_value_string = va_arg(var_args, char *); /* Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type, num_args); snprintf(buf_val, sizeof(buf_val), "%s", var_value_string); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); break; case NOTIFICATION_VARIABLE_TYPE_COUNT: var_value_count = va_arg(var_args, notification_count_pos_type_e); /* Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", type, num_args); snprintf(buf_val, sizeof(buf_val), "%d", var_value_count); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); break; default: NOTIFICATION_ERR("Error. invalid variable type. : %d", var_type); noti_err = NOTIFICATION_ERROR_INVALID_PARAMETER; break; } num_args++; var_type = va_arg(var_args, notification_variable_type_e); } va_end(var_args); if (noti_err == NOTIFICATION_ERROR_NONE) { noti->num_format_args = num_args; } else { noti->num_format_args = 0; } snprintf(buf_key, sizeof(buf_key), "num%d", type); snprintf(buf_val, sizeof(buf_val), "%d", noti->num_format_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { bundle_del(b, buf_key); } bundle_add_str(b, buf_key, buf_val); noti->b_format_args = b; return noti_err; } EXPORT_API int notification_get_text(notification_h noti, notification_text_type_e type, char **text) { bundle *b = NULL; char buf_key[32] = { 0, }; char *ret_val = NULL; char *get_str = NULL; notification_text_type_e check_type = NOTIFICATION_TEXT_TYPE_NONE; //int display_option_flag = 0; char *temp_str = NULL; char *translated_str = NULL; char result_str[NOTI_TEXT_RESULT_LEN] = { 0, }; char buf_str[1024] = { 0, }; int num_args = 0; notification_variable_type_e ret_var_type = 0; int ret_variable_int = 0; double ret_variable_double = 0.0; int src_len = 0; int max_len = 0; /* Check noti is valid data */ if (noti == NULL || text == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check text type is valid type */ if (type <= NOTIFICATION_TEXT_TYPE_NONE || type >= NOTIFICATION_TEXT_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check key */ if (noti->b_key != NULL) { b = noti->b_key; /* Get text domain and dir */ //_notification_get_text_domain(noti); snprintf(buf_key, sizeof(buf_key), "%d", type); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL && noti->domain != NULL && noti->dir != NULL) { /* Get application string */ bindtextdomain(noti->domain, noti->dir); get_str = dgettext(noti->domain, ret_val); } else if (ret_val != NULL) { /* Get system string */ get_str = dgettext("sys_string", ret_val); } else { get_str = NULL; } } if (get_str == NULL && noti->b_text != NULL) { b = noti->b_text; /* Get basic text */ snprintf(buf_key, sizeof(buf_key), "%d", type); bundle_get_str(b, buf_key, &get_str); } check_type = type; if (get_str != NULL) { /* Get number format args */ b = noti->b_format_args; noti->num_format_args = 0; if (b != NULL) { snprintf(buf_key, sizeof(buf_key), "num%d", check_type); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { noti->num_format_args = atoi(ret_val); } } if (noti->num_format_args == 0) { *text = (char *)get_str; } else { /* Check first variable is count, LEFT pos */ snprintf(buf_key, sizeof(buf_key), "%dtype%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_var_type = atoi(ret_val); } if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_int = atoi(ret_val); } if (ret_variable_int == NOTIFICATION_COUNT_POS_LEFT) { notification_noti_get_count(noti->type, noti->caller_pkgname, noti->group_id, noti->priv_id, &ret_variable_int); snprintf(buf_str, sizeof(buf_str), "%d ", ret_variable_int); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); num_args++; } } /* Check variable IN pos */ for (temp_str = (char *)get_str; *temp_str != '\0'; temp_str++) { if (*temp_str != '%') { strncat(result_str, temp_str, 1); } else { if (*(temp_str + 1) == '%') { strncat(result_str, temp_str, 1); } else if (*(temp_str + 1) == 'd') { /* Get var Type */ ret_variable_int = 0; snprintf(buf_key, sizeof(buf_key), "%dtype%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_var_type = atoi(ret_val); } if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) { /* Get notification count */ notification_noti_get_count (noti->type, noti->caller_pkgname, noti->group_id, noti->priv_id, &ret_variable_int); } else { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_int = atoi(ret_val); } } snprintf(buf_str, sizeof(buf_str), "%d", ret_variable_int); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); temp_str++; num_args++; } else if (*(temp_str + 1) == 's') { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL && noti->domain != NULL && noti->dir != NULL) { /* Get application string */ bindtextdomain(noti->domain, noti->dir); translated_str = dgettext(noti->domain, ret_val); NOTIFICATION_INFO("translated_str[%s]", translated_str); } else if (ret_val != NULL) { /* Get system string */ translated_str = dgettext("sys_string", ret_val); NOTIFICATION_INFO("translated_str[%s]", translated_str); } else { translated_str = NULL; } if (translated_str != NULL) { strncpy(buf_str, translated_str, sizeof(buf_str) - 1); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); } temp_str++; num_args++; } else if (*(temp_str + 1) == 'f') { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_double = atof(ret_val); } snprintf(buf_str, sizeof(buf_str), "%.2f", ret_variable_double); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); temp_str++; num_args++; } else if (*(temp_str + 1) >= '1' && *(temp_str + 1) <= '9') { if (*(temp_str + 3) == 'd') { /* Get var Type */ ret_variable_int = 0; snprintf(buf_key, sizeof(buf_key), "%dtype%d", check_type, num_args + *(temp_str + 1) - 49); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_var_type = atoi(ret_val); } if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) { /* Get notification count */ notification_noti_get_count (noti->type, noti->caller_pkgname, noti->group_id, noti->priv_id, &ret_variable_int); } else { /* Get var Value */ snprintf(buf_key, sizeof (buf_key), "%dvalue%d", check_type, num_args + *(temp_str + 1) - 49); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_int = atoi(ret_val); } } snprintf(buf_str, sizeof(buf_str), "%d", ret_variable_int); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); temp_str += 3; } else if (*(temp_str + 3) == 's') { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args + *(temp_str + 1) - 49); bundle_get_str(b, buf_key, &ret_val); snprintf(buf_str, sizeof(buf_str), "%s", ret_val); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); temp_str += 3; } else if (*(temp_str + 3) == 'f') { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args + *(temp_str + 1) - 49); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_double = atof(ret_val); } snprintf(buf_str, sizeof(buf_str), "%.2f", ret_variable_double); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); temp_str += 3; } } } } /* Check last variable is count, LEFT pos */ if (num_args < noti->num_format_args) { snprintf(buf_key, sizeof(buf_key), "%dtype%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_var_type = atoi(ret_val); } if (ret_var_type == NOTIFICATION_VARIABLE_TYPE_COUNT) { /* Get var Value */ snprintf(buf_key, sizeof(buf_key), "%dvalue%d", check_type, num_args); bundle_get_str(b, buf_key, &ret_val); if (ret_val != NULL) { ret_variable_int = atoi(ret_val); } if (ret_variable_int == NOTIFICATION_COUNT_POS_RIGHT) { notification_noti_get_count (noti->type, noti->caller_pkgname, noti->group_id, noti->priv_id, &ret_variable_int); snprintf(buf_str, sizeof(buf_str), " %d", ret_variable_int); src_len = strlen(result_str); max_len = NOTI_TEXT_RESULT_LEN - src_len - 1; strncat(result_str, buf_str, max_len); num_args++; } } } switch (check_type) { case NOTIFICATION_TEXT_TYPE_TITLE: case NOTIFICATION_TEXT_TYPE_GROUP_TITLE: if (noti->temp_title != NULL) free(noti->temp_title); noti->temp_title = strdup(result_str); *text = noti->temp_title; break; case NOTIFICATION_TEXT_TYPE_CONTENT: case NOTIFICATION_TEXT_TYPE_CONTENT_FOR_DISPLAY_OPTION_IS_OFF: case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT: case NOTIFICATION_TEXT_TYPE_GROUP_CONTENT_FOR_DISPLAY_OPTION_IS_OFF: if (noti->temp_content != NULL) free(noti->temp_content); noti->temp_content = strdup(result_str); *text = noti->temp_content; break; default: break; } } } else { *text = NULL; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_text_domain(notification_h noti, const char *domain, const char *dir) { /* check noti and domain is valid data */ if (noti == NULL || domain == NULL || dir == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check domain */ if (noti->domain) { /* Remove previous domain */ free(noti->domain); } /* Copy domain */ noti->domain = strdup(domain); /* Check locale dir */ if (noti->dir) { /* Remove previous locale dir */ free(noti->dir); } /* Copy locale dir */ noti->dir = strdup(dir); return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_text_domain(notification_h noti, char **domain, char **dir) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Get domain */ if (domain != NULL && noti->domain != NULL) { *domain = noti->domain; } /* Get locale dir */ if (dir != NULL && noti->dir != NULL) { *dir = noti->dir; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_time_to_text(notification_h noti, notification_text_type_e type, time_t time) { int ret = NOTIFICATION_ERROR_NONE; char buf[256] = { 0, }; char buf_tag[512] = { 0, }; if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (time <= 0) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (type <= NOTIFICATION_TEXT_TYPE_NONE || type >= NOTIFICATION_TEXT_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } snprintf(buf, sizeof(buf), "%lu", time); ret = notification_noti_set_tag(TAG_TIME, buf, buf_tag, sizeof(buf_tag)); if (ret != NOTIFICATION_ERROR_NONE) { return ret; } return notification_set_text(noti, type, buf_tag, NULL, NOTIFICATION_VARIABLE_TYPE_NONE); } EXPORT_API int notification_get_time_from_text(notification_h noti, notification_text_type_e type, time_t *time) { int ret = NOTIFICATION_ERROR_NONE; if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (time == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (type <= NOTIFICATION_TEXT_TYPE_NONE || type >= NOTIFICATION_TEXT_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } char *ret_text = NULL; ret = notification_get_text(noti, type, &ret_text); if (ret != NOTIFICATION_ERROR_NONE || ret_text == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (notification_noti_get_tag_type(ret_text) == TAG_TYPE_INVALID) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } char *tag_value = NULL; tag_value = notification_noti_strip_tag(ret_text); if (tag_value == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } *time = atol(tag_value); free(tag_value); return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_sound(notification_h noti, notification_sound_type_e type, const char *path) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check type is valid */ if (type < NOTIFICATION_SOUND_TYPE_NONE || type >= NOTIFICATION_SOUND_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save sound type */ noti->sound_type = type; /* Save sound path if user data type */ if (type == NOTIFICATION_SOUND_TYPE_USER_DATA && path != NULL) { if (noti->sound_path != NULL) { free(noti->sound_path); } noti->sound_path = strdup(path); } else { if (noti->sound_path != NULL) { free(noti->sound_path); noti->sound_path = NULL; } if (type == NOTIFICATION_SOUND_TYPE_USER_DATA) { noti->sound_type = NOTIFICATION_SOUND_TYPE_DEFAULT; return NOTIFICATION_ERROR_INVALID_PARAMETER; } } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_sound(notification_h noti, notification_sound_type_e *type, const char **path) { /* check noti and type is valid data */ if (noti == NULL || type == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set sound type */ *type = noti->sound_type; /* Set sound path if user data type */ if (noti->sound_type == NOTIFICATION_SOUND_TYPE_USER_DATA && path != NULL) { *path = noti->sound_path; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_vibration(notification_h noti, notification_vibration_type_e type, const char *path) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check type is valid */ if (type < NOTIFICATION_VIBRATION_TYPE_NONE || type >= NOTIFICATION_VIBRATION_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save vibration type */ noti->vibration_type = type; /* Save sound path if user data type */ if (type == NOTIFICATION_VIBRATION_TYPE_USER_DATA && path != NULL) { if (noti->vibration_path != NULL) { free(noti->vibration_path); } noti->vibration_path = strdup(path); } else { if (noti->vibration_path != NULL) { free(noti->vibration_path); noti->vibration_path = NULL; } if (type == NOTIFICATION_VIBRATION_TYPE_USER_DATA) { noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_DEFAULT; return NOTIFICATION_ERROR_INVALID_PARAMETER; } } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_vibration(notification_h noti, notification_vibration_type_e *type, const char **path) { /* check noti and type is valid data */ if (noti == NULL || type == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set vibration type */ *type = noti->vibration_type; /* Set sound path if user data type */ if (noti->vibration_type == NOTIFICATION_VIBRATION_TYPE_USER_DATA && path != NULL) { *path = noti->vibration_path; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_led(notification_h noti, notification_led_op_e operation, int led_argb) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check operation is valid */ if (operation < NOTIFICATION_LED_OP_OFF || operation >= NOTIFICATION_LED_OP_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save led operation */ noti->led_operation = operation; /* Save led argb if operation is turning on LED with custom color */ if (operation == NOTIFICATION_LED_OP_ON_CUSTOM_COLOR) { noti->led_argb = led_argb; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_led(notification_h noti, notification_led_op_e *operation, int *led_argb) { /* check noti and operation is valid data */ if (noti == NULL || operation == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set led operation */ *operation = noti->led_operation; /* Save led argb if operation is turning on LED with custom color */ if (noti->led_operation == NOTIFICATION_LED_OP_ON_CUSTOM_COLOR && led_argb != NULL) { *led_argb = noti->led_argb; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_led_time_period(notification_h noti, int on_ms, int off_ms) { /* Check noti is valid data */ if (noti == NULL || on_ms < 0 || off_ms < 0) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save led operation */ noti->led_on_ms = on_ms; noti->led_off_ms = off_ms; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_led_time_period(notification_h noti, int *on_ms, int *off_ms) { /* check noti and operation is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (on_ms) *(on_ms) = noti->led_on_ms; if (off_ms) *(off_ms) = noti->led_off_ms; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_launch_option(notification_h noti, notification_launch_option_type type, void *option) { int err = NOTIFICATION_ERROR_NONE; int ret = 0; bundle *b = NULL; app_control_h app_control = option; if (noti == NULL || app_control == NULL || type != NOTIFICATION_LAUNCH_OPTION_APP_CONTROL) { err = NOTIFICATION_ERROR_INVALID_PARAMETER; goto out; } if ((ret = app_control_export_as_bundle(app_control, &b)) != APP_CONTROL_ERROR_NONE) { NOTIFICATION_ERR("Failed to convert appcontrol to bundle:%d", ret); err = NOTIFICATION_ERROR_INVALID_PARAMETER; goto out; } err = notification_set_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, NULL, b); out: if (b) bundle_free(b); return err; } EXPORT_API int notification_get_launch_option(notification_h noti, notification_launch_option_type type, void *option) { int ret = 0; bundle *b = NULL; app_control_h *app_control = (app_control_h *)option; app_control_h app_control_new = NULL; if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (app_control == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (type != NOTIFICATION_LAUNCH_OPTION_APP_CONTROL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } ret = notification_get_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_SINGLE_LAUNCH, NULL, &b); if (ret == NOTIFICATION_ERROR_NONE && b != NULL) { ret = app_control_create(&app_control_new); if (ret == APP_CONTROL_ERROR_NONE && app_control_new != NULL) { ret = app_control_import_from_bundle(app_control_new, b); if (ret == APP_CONTROL_ERROR_NONE) { *app_control = app_control_new; } else { app_control_destroy(app_control_new); NOTIFICATION_ERR("Failed to import app control from bundle:%d", ret); return NOTIFICATION_ERROR_IO_ERROR; } } else { NOTIFICATION_ERR("Failed to create app control:%d", ret); return NOTIFICATION_ERROR_IO_ERROR; } } else { NOTIFICATION_ERR("Failed to get execute option:%d", ret); return ret; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_event_handler(notification_h noti, notification_event_type_e event_type, app_control_h event_handler) { int err = NOTIFICATION_ERROR_NONE; bundle *app_control_bundle = NULL; if (noti == NULL) { err = NOTIFICATION_ERROR_INVALID_PARAMETER; NOTIFICATION_ERR("NOTIFICATION_ERROR_INVALID_PARAMETER"); goto out; } if (event_type < NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1 || event_type > NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL) { NOTIFICATION_ERR("NOTIFICATION_ERROR_INVALID_PARAMETER"); err = NOTIFICATION_ERROR_INVALID_PARAMETER; goto out; } if ((err = app_control_export_as_bundle(event_handler, &app_control_bundle)) != APP_CONTROL_ERROR_NONE) { NOTIFICATION_ERR("app_control_to_bundle failed [%d]", err); goto out; } if (noti->b_event_handler[event_type] != NULL) { bundle_free(noti->b_event_handler[event_type]); } noti->b_event_handler[event_type] = app_control_bundle; out: return err; } EXPORT_API int notification_get_event_handler(notification_h noti, notification_event_type_e event_type, app_control_h *event_handler) { int err = NOTIFICATION_ERROR_NONE; bundle *b = NULL; app_control_h app_control_new = NULL; if (noti == NULL) { err = NOTIFICATION_ERROR_INVALID_PARAMETER; NOTIFICATION_ERR("NOTIFICATION_ERROR_INVALID_PARAMETER"); goto out; } if (event_handler == NULL) { err = NOTIFICATION_ERROR_INVALID_PARAMETER; NOTIFICATION_ERR("NOTIFICATION_ERROR_INVALID_PARAMETER"); goto out; } if (event_type < NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1 || event_type > NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL) { NOTIFICATION_ERR("NOTIFICATION_ERROR_INVALID_PARAMETER"); err = NOTIFICATION_ERROR_INVALID_PARAMETER; goto out; } b = noti->b_event_handler[event_type]; if (b == NULL) { NOTIFICATION_DBG("No event handler\n"); err = NOTIFICATION_ERROR_NOT_EXIST_ID; goto out; } err = app_control_create(&app_control_new); if (err != APP_CONTROL_ERROR_NONE || app_control_new == NULL) { NOTIFICATION_ERR("app_control_create failed [%d]", err); err = NOTIFICATION_ERROR_IO_ERROR; goto out; } err = app_control_import_from_bundle(app_control_new, b); if (err == APP_CONTROL_ERROR_NONE) { *event_handler = app_control_new; } else { app_control_destroy(app_control_new); app_control_new = NULL; NOTIFICATION_ERR("Failed to import app control from bundle [%d]", err); err = NOTIFICATION_ERROR_IO_ERROR; goto out; } out: if (event_handler) *event_handler = app_control_new; return err; } EXPORT_API int notification_set_property(notification_h noti, int flags) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set flags */ noti->flags_for_property = flags; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_property(notification_h noti, int *flags) { /* Check noti and flags are valid data */ if (noti == NULL || flags == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set flags */ *flags = noti->flags_for_property; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_display_applist(notification_h noti, int applist) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set app list */ if (applist == 0xffffffff) { /* 0xffffffff means old NOTIFICATION_DISPLAY_APP_ALL */ applist = NOTIFICATION_DISPLAY_APP_ALL; } noti->display_applist = applist; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_display_applist(notification_h noti, int *applist) { /* Check noti and applist are valid data */ if (noti == NULL || applist == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set app list */ *applist = noti->display_applist; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_size(notification_h noti, double size) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save progress size */ noti->progress_size = size; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_size(notification_h noti, double *size) { /* Check noti and size is valid data */ if (noti == NULL || size == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set progress size */ *size = noti->progress_size; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_progress(notification_h noti, double percentage) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save progress percentage */ noti->progress_percentage = percentage; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_progress(notification_h noti, double *percentage) { /* Check noti and percentage are valid data */ if (noti == NULL || percentage == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set progress percentage */ *percentage = noti->progress_percentage; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_pkgname(notification_h noti, char **pkgname) { /* Check noti and pkgname are valid data */ if (noti == NULL || pkgname == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Get caller pkgname */ if (noti->caller_pkgname) { *pkgname = noti->caller_pkgname; } else { *pkgname = NULL; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_layout(notification_h noti, notification_ly_type_e layout) { /* check noti and pkgname are valid data */ if (noti == NULL || (layout < NOTIFICATION_LY_NONE || layout >= NOTIFICATION_LY_MAX)) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } noti->layout = layout; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_layout(notification_h noti, notification_ly_type_e *layout) { /* Check noti and pkgname are valid data */ if (noti == NULL || layout == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } *layout = noti->layout; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_type(notification_h noti, notification_type_e *type) { /* Check noti and type is valid data */ if (noti == NULL || type == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Set noti type */ *type = noti->type; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_post(notification_h noti) { int ret = 0; int id = 0; /* Check noti is vaild data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Check noti type is valid type */ if (noti->type <= NOTIFICATION_TYPE_NONE || noti->type >= NOTIFICATION_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } /* Save insert time */ noti->insert_time = time(NULL); ret = notification_ipc_request_insert(noti, &id); if (ret != NOTIFICATION_ERROR_NONE) { return ret; } noti->priv_id = id; NOTIFICATION_DBG("from master:%d", id); return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_update(notification_h noti) { int ret = 0; /* Check noti is valid data */ if (noti != NULL) { /* Update insert time ? */ noti->insert_time = time(NULL); ret = notification_ipc_request_update(noti); } else { notification_ipc_request_refresh(); return NOTIFICATION_ERROR_INVALID_PARAMETER; } return ret; } EXPORT_API int notification_delete_all(notification_type_e type) { int ret = 0; char *caller_pkgname = NULL; if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } caller_pkgname = notification_get_pkgname_by_pid(); ret = notification_ipc_request_delete_multiple(type, caller_pkgname); if (caller_pkgname) { free(caller_pkgname); } return ret; } EXPORT_API int notification_delete(notification_h noti) { int ret = 0; if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } ret = notification_ipc_request_delete_single(NOTIFICATION_TYPE_NONE, noti->caller_pkgname, noti->priv_id); return ret; } static notification_h _notification_create(notification_type_e type) { notification_h noti = NULL; package_info_h package_info = NULL; char *app_id = NULL; char *domain_name = NULL; char *app_root_path = NULL; char locale_directory[PATH_MAX] = { 0, }; /* PATH_MAX 4096 */ int err_app_manager = APP_MANAGER_ERROR_NONE; if (type <= NOTIFICATION_TYPE_NONE || type >= NOTIFICATION_TYPE_MAX) { NOTIFICATION_ERR("INVALID TYPE : %d", type); set_last_result(NOTIFICATION_ERROR_INVALID_PARAMETER); return NULL; } noti = (notification_h) calloc(1, sizeof(struct _notification)); if (noti == NULL) { NOTIFICATION_ERR("NO MEMORY : noti == NULL"); set_last_result(NOTIFICATION_ERROR_OUT_OF_MEMORY); return NULL; } noti->type = type; if (type == NOTIFICATION_TYPE_NOTI) noti->layout = NOTIFICATION_LY_NOTI_EVENT_SINGLE; else if (type == NOTIFICATION_TYPE_ONGOING) noti->layout = NOTIFICATION_LY_ONGOING_PROGRESS; noti->caller_pkgname = notification_get_pkgname_by_pid(); noti->group_id = NOTIFICATION_GROUP_ID_NONE; noti->priv_id = NOTIFICATION_PRIV_ID_NONE; noti->sound_type = NOTIFICATION_SOUND_TYPE_NONE; noti->vibration_type = NOTIFICATION_VIBRATION_TYPE_NONE; noti->led_operation = NOTIFICATION_LED_OP_OFF; noti->display_applist = NOTIFICATION_DISPLAY_APP_NOTIFICATION_TRAY | NOTIFICATION_DISPLAY_APP_TICKER | NOTIFICATION_DISPLAY_APP_INDICATOR; noti->auto_remove = true; err_app_manager = app_manager_get_app_id(getpid(), &app_id); if (err_app_manager != APP_MANAGER_ERROR_NONE || app_id == NULL) { NOTIFICATION_WARN("app_manager_get_app_id failed err[%d] app_id[%p]", err_app_manager, app_id); goto out; } /* app name is used as domain name */ /* domain_name is allocated by app_get_package_app_name */ err_app_manager = app_get_package_app_name(app_id, &domain_name); if (err_app_manager != APP_ERROR_NONE || domain_name == NULL) { NOTIFICATION_WARN("app_get_package_app_name failed err[%d] domain_name[%p]", err_app_manager, domain_name); goto out; } err_app_manager = package_info_create(noti->caller_pkgname, &package_info); if (err_app_manager != PACKAGE_MANAGER_ERROR_NONE || package_info == NULL) { NOTIFICATION_WARN("package_info_create failed err[%d] package_info[%p] caller_pkgname[%s]", err_app_manager, package_info, noti->caller_pkgname); goto out; } err_app_manager = package_info_get_root_path(package_info, &app_root_path); if (err_app_manager != PACKAGE_MANAGER_ERROR_NONE || app_root_path == NULL) { NOTIFICATION_WARN("package_info_get_root_path failed err[%d] app_root_path[%p]", err_app_manager, app_root_path); goto out; } snprintf(locale_directory, PATH_MAX, "%s/res/locale", app_root_path); noti->domain = strdup(domain_name); noti->dir = strdup(locale_directory); out: if (domain_name) { free(domain_name); } if (app_id) { free(app_id); } if (app_root_path) { free(app_root_path); } if (package_info) { package_info_destroy(package_info); } /*! * \NOTE * Other fields are already initialized with ZERO. */ set_last_result(NOTIFICATION_ERROR_NONE); return noti; } EXPORT_API notification_h notification_create(notification_type_e type) { return _notification_create(type); } EXPORT_API notification_h notification_load_by_tag(const char *tag) { int ret = 0; notification_h noti = NULL; char *caller_pkgname = NULL; if (tag == NULL) { NOTIFICATION_ERR("Invalid parameter"); set_last_result(NOTIFICATION_ERROR_INVALID_PARAMETER); return NULL; } caller_pkgname = notification_get_pkgname_by_pid(); if (!caller_pkgname) { NOTIFICATION_ERR("Failed to get a package name"); set_last_result(NOTIFICATION_ERROR_OUT_OF_MEMORY); return NULL; } noti = (notification_h) calloc(1, sizeof(struct _notification)); if (noti == NULL) { NOTIFICATION_ERR("Failed to alloc a new notification"); set_last_result(NOTIFICATION_ERROR_OUT_OF_MEMORY); free(caller_pkgname); return NULL; } ret = notification_noti_get_by_tag(noti, caller_pkgname, (char*)tag); free(caller_pkgname); set_last_result(ret); if (ret != NOTIFICATION_ERROR_NONE) { notification_free(noti); return NULL; } return noti; } EXPORT_API int notification_clone(notification_h noti, notification_h *clone) { int i = 0; notification_h new_noti = NULL; if (noti == NULL || clone == NULL) { NOTIFICATION_ERR("INVALID PARAMETER."); return NOTIFICATION_ERROR_INVALID_PARAMETER; } new_noti = (notification_h) calloc(1, sizeof(struct _notification)); if (new_noti == NULL) { NOTIFICATION_ERR("NO MEMORY : noti == NULL"); return NOTIFICATION_ERROR_OUT_OF_MEMORY; } new_noti->type = noti->type; new_noti->layout = noti->layout; new_noti->group_id = noti->group_id; new_noti->internal_group_id = noti->internal_group_id; new_noti->priv_id = noti->priv_id; if (noti->caller_pkgname != NULL) { new_noti->caller_pkgname = strdup(noti->caller_pkgname); } else { new_noti->caller_pkgname = notification_get_pkgname_by_pid(); } if (noti->launch_pkgname != NULL) { new_noti->launch_pkgname = strdup(noti->launch_pkgname); } else { new_noti->launch_pkgname = NULL; } if (noti->args != NULL) { new_noti->args = bundle_dup(noti->args); } else { new_noti->args = NULL; } if (noti->group_args != NULL) { new_noti->group_args = bundle_dup(noti->group_args); } else { new_noti->group_args = NULL; } if (noti->b_execute_option != NULL) { new_noti->b_execute_option = bundle_dup(noti->b_execute_option); } else { new_noti->b_execute_option = NULL; } if (noti->b_service_responding != NULL) { new_noti->b_service_responding = bundle_dup(noti->b_service_responding); } else { new_noti->b_service_responding = NULL; } if (noti->b_service_single_launch != NULL) { new_noti->b_service_single_launch = bundle_dup(noti->b_service_single_launch); } else { new_noti->b_service_single_launch = NULL; } if (noti->b_service_multi_launch != NULL) { new_noti->b_service_multi_launch = bundle_dup(noti->b_service_multi_launch); } else { new_noti->b_service_multi_launch = NULL; } for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) { if (noti->b_event_handler[i] != NULL) { new_noti->b_event_handler[i] = bundle_dup(noti->b_event_handler[i]); } else { new_noti->b_event_handler[i] = NULL; } } new_noti->sound_type = noti->sound_type; if (noti->sound_path != NULL) { new_noti->sound_path = strdup(noti->sound_path); } else { new_noti->sound_path = NULL; } new_noti->vibration_type = noti->vibration_type; if (noti->vibration_path != NULL) { new_noti->vibration_path = strdup(noti->vibration_path); } else { new_noti->vibration_path = NULL; } new_noti->led_operation = noti->led_operation; new_noti->led_argb = noti->led_argb; new_noti->led_on_ms = noti->led_on_ms; new_noti->led_off_ms = noti->led_off_ms; if (noti->domain != NULL) { new_noti->domain = strdup(noti->domain); } else { new_noti->domain = NULL; } if (noti->dir != NULL) { new_noti->dir = strdup(noti->dir); } else { new_noti->dir = NULL; } if (noti->b_text != NULL) { new_noti->b_text = bundle_dup(noti->b_text); } else { new_noti->b_text = NULL; } if (noti->b_key != NULL) { new_noti->b_key = bundle_dup(noti->b_key); } else { new_noti->b_key = NULL; } if (noti->b_format_args != NULL) { new_noti->b_format_args = bundle_dup(noti->b_format_args); } else { new_noti->b_format_args = NULL; } new_noti->num_format_args = noti->num_format_args; if (noti->b_image_path != NULL) { new_noti->b_image_path = bundle_dup(noti->b_image_path); } else { new_noti->b_image_path = NULL; } new_noti->time = noti->time; new_noti->insert_time = noti->insert_time; new_noti->flags_for_property = noti->flags_for_property; new_noti->display_applist = noti->display_applist; new_noti->progress_size = noti->progress_size; new_noti->progress_percentage = noti->progress_percentage; new_noti->ongoing_flag = noti->ongoing_flag; new_noti->auto_remove = noti->auto_remove; new_noti->app_icon_path = NULL; new_noti->app_name = NULL; new_noti->temp_title = NULL; new_noti->temp_content = NULL; *clone = new_noti; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_free(notification_h noti) { int i = 0; if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (noti->caller_pkgname) { free(noti->caller_pkgname); } if (noti->launch_pkgname) { free(noti->launch_pkgname); } if (noti->args) { bundle_free(noti->args); } if (noti->group_args) { bundle_free(noti->group_args); } if (noti->b_execute_option) { bundle_free(noti->b_execute_option); } if (noti->b_service_responding) { bundle_free(noti->b_service_responding); } if (noti->b_service_single_launch) { bundle_free(noti->b_service_single_launch); } if (noti->b_service_multi_launch) { bundle_free(noti->b_service_multi_launch); } for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) { if (noti->b_event_handler[i] != NULL) { bundle_free(noti->b_event_handler[i]); } } if (noti->sound_path) { free(noti->sound_path); } if (noti->vibration_path) { free(noti->vibration_path); } if (noti->domain) { free(noti->domain); } if (noti->dir) { free(noti->dir); } if (noti->b_text) { bundle_free(noti->b_text); } if (noti->b_key) { bundle_free(noti->b_key); } if (noti->b_format_args) { bundle_free(noti->b_format_args); } if (noti->b_image_path) { bundle_free(noti->b_image_path); } if (noti->app_icon_path) { free(noti->app_icon_path); } if (noti->app_name) { free(noti->app_name); } if (noti->temp_title) { free(noti->temp_title); } if (noti->temp_content) { free(noti->temp_content); } if (noti->tag) { free(noti->tag); } free(noti); return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_tag(notification_h noti, const char *tag) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } if (tag != NULL) { /* save input TAG */ if (noti->tag != NULL) { free(noti->tag); } noti->tag = strdup(tag); } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_tag(notification_h noti, const char **tag) { /* Check noti is valid data */ if (noti == NULL) { return NOTIFICATION_ERROR_INVALID_PARAMETER; } *tag = noti->tag; return NOTIFICATION_ERROR_NONE; } void notification_call_posted_toast_cb(const char *message) { if (posted_toast_message_cb != NULL) { posted_toast_message_cb((void*)message); } } EXPORT_API int notification_set_ongoing_flag(notification_h noti, bool ongoing_flag) { if (noti == NULL) return NOTIFICATION_ERROR_INVALID_PARAMETER; noti->ongoing_flag = ongoing_flag; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_ongoing_flag(notification_h noti, bool *ongoing_flag) { if (noti == NULL || ongoing_flag == NULL) return NOTIFICATION_ERROR_INVALID_PARAMETER; *ongoing_flag = noti->ongoing_flag; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_add_button(notification_h noti, notification_button_index_e button_index) { if (noti == NULL || button_index < NOTIFICATION_BUTTON_1 || button_index > NOTIFICATION_BUTTON_6) return NOTIFICATION_ERROR_INVALID_PARAMETER; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_remove_button(notification_h noti, notification_button_index_e button_index) { if (noti == NULL || button_index < NOTIFICATION_BUTTON_1 || button_index > NOTIFICATION_BUTTON_6) return NOTIFICATION_ERROR_INVALID_PARAMETER; if (noti->b_event_handler[button_index - 1]) { bundle_free(noti->b_event_handler[button_index - 1]); noti->b_event_handler[button_index - 1] = NULL; } return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_set_auto_remove(notification_h noti, bool auto_remove) { if (noti == NULL) return NOTIFICATION_ERROR_INVALID_PARAMETER; noti->auto_remove = auto_remove; return NOTIFICATION_ERROR_NONE; } EXPORT_API int notification_get_auto_remove(notification_h noti, bool *auto_remove) { if (noti == NULL || auto_remove == NULL) return NOTIFICATION_ERROR_INVALID_PARAMETER; *auto_remove = noti->auto_remove; return NOTIFICATION_ERROR_NONE; }