From 2084c8aa419e2520b579c15969a9ce7a72a3fd7d Mon Sep 17 00:00:00 2001 From: "jh9216.park" Date: Mon, 29 Apr 2024 03:13:32 -0400 Subject: [PATCH] Refactor badge - Use TIDL instead of dbus - Use C++ instead of c - Add service module using libesd - Summary coverage rate: lines......: 88.3% (227 of 257 lines) functions..: 92.5% (37 of 40 functions) - Require https://review.tizen.org/gerrit/#/c/platform/core/appfw/data-provider-master/+/309339/ Change-Id: Icb8b62406145668967121d9b3d51aff7a2dfb057 Signed-off-by: jh9216.park --- 11_badge-add.post | 1 - CMakeLists.txt | 24 +- include/badge_db.h | 55 - include/badge_internal.h | 264 --- include/badge_ipc.h | 61 - include/badge_private.h | 43 - include/badge_setting.h | 65 - include/badge_setting_service.h | 60 - include/log_private.h | 37 + modules/CMakeLists.txt | 1 + modules/badge/CMakeLists.txt | 22 + modules/badge/badge.cc | 25 + modules/badge/badge_module.cc | 52 + modules/badge/badge_module.hh | 46 + modules/badge/badge_service.cc | 328 ++++ modules/badge/badge_service.hh | 83 + packaging/badge.spec | 54 +- src/CMakeLists.txt | 12 +- src/badge.c | 125 -- src/badge.cc | 275 ++++ src/badge_db.c | 279 ---- src/badge_error.c | 60 - src/badge_internal.c | 1689 -------------------- src/badge_ipc.c | 865 ---------- src/badge_setting.c | 127 -- src/badge_setting_service.c | 933 ----------- tests/CMakeLists.txt | 1 + tests/integ_tests/CMakeLists.txt | 27 + tests/integ_tests/src/test_badge.cc | 263 +++ .../src/test_main.cc} | 28 +- tests/mock/aul_mock.cc | 9 +- tests/mock/aul_mock.h | 4 +- tests/mock/gio_mock.cc | 88 - tests/mock/gio_mock.h | 56 - .../{package_manager_mock.cc => rpc_port_mock.cc} | 12 +- tests/mock/rpc_port_mock.h | 35 + tests/unit_tests/CMakeLists.txt | 46 +- tests/unit_tests/src/test_badge.cc | 899 +++-------- tests/unit_tests/src/test_main.cc | 17 + tidl/badge.tidl | 29 + tidl/prebuild.sh | 3 + tool/CMakeLists.txt | 29 - tool/badge_init.c | 70 - 43 files changed, 1545 insertions(+), 5657 deletions(-) delete mode 100644 11_badge-add.post delete mode 100644 include/badge_db.h delete mode 100644 include/badge_internal.h delete mode 100644 include/badge_ipc.h delete mode 100644 include/badge_private.h delete mode 100644 include/badge_setting.h delete mode 100644 include/badge_setting_service.h create mode 100644 include/log_private.h create mode 100644 modules/CMakeLists.txt create mode 100644 modules/badge/CMakeLists.txt create mode 100644 modules/badge/badge.cc create mode 100644 modules/badge/badge_module.cc create mode 100644 modules/badge/badge_module.hh create mode 100644 modules/badge/badge_service.cc create mode 100644 modules/badge/badge_service.hh delete mode 100644 src/badge.c create mode 100644 src/badge.cc delete mode 100644 src/badge_db.c delete mode 100644 src/badge_error.c delete mode 100644 src/badge_internal.c delete mode 100644 src/badge_ipc.c delete mode 100644 src/badge_setting.c delete mode 100644 src/badge_setting_service.c create mode 100644 tests/integ_tests/CMakeLists.txt create mode 100644 tests/integ_tests/src/test_badge.cc rename tests/{mock/package_manager_mock.h => integ_tests/src/test_main.cc} (60%) delete mode 100644 tests/mock/gio_mock.cc delete mode 100644 tests/mock/gio_mock.h rename tests/mock/{package_manager_mock.cc => rpc_port_mock.cc} (63%) create mode 100644 tests/mock/rpc_port_mock.h create mode 100755 tidl/badge.tidl create mode 100755 tidl/prebuild.sh delete mode 100644 tool/CMakeLists.txt delete mode 100644 tool/badge_init.c diff --git a/11_badge-add.post b/11_badge-add.post deleted file mode 100644 index f535dc4..0000000 --- a/11_badge-add.post +++ /dev/null @@ -1 +0,0 @@ -badge_init --uid $2 diff --git a/CMakeLists.txt b/CMakeLists.txt index 50288a3..4af77e2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,8 +8,8 @@ SET(LIBDIR ${LIB_INSTALL_DIR}) SET(INCLUDEDIR "\${prefix}/include/badge") ## Compiler flags -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -g -Wall -Werror") -SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++14 -Wall -Werror") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -g ") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -std=c++17 ") SET(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") SET(CMAKE_CXX_FLAGS_RELEASE "-O2") @@ -21,6 +21,8 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo ## Targets SET(TARGET_BADGE "badge") SET(TARGET_BADGE_INIT "badge_init") +SET(TARGET_ESD_MOD_BADGE "esd-mod-badge") +SET(TARGET_BADGE_INTEGTESTS "badge_integtests") ENABLE_TESTING() SET(TARGET_BADGE_UNIT_TEST "badge_unittests") @@ -30,21 +32,19 @@ INCLUDE(FindPkgConfig) INCLUDE(ApplyPkgConfig) ## Find all needed packages once -PKG_CHECK_MODULES(AUL_DEP REQUIRED aul) PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog) PKG_CHECK_MODULES(VCONF_DEPS REQUIRED vconf) -PKG_CHECK_MODULES(PKGMGR_DEPS REQUIRED capi-appfw-package-manager) PKG_CHECK_MODULES(SYSTEM_INFO_DEPS REQUIRED capi-system-info) -PKG_CHECK_MODULES(DB_UTIL_DEPS REQUIRED db-util) -PKG_CHECK_MODULES(PLATFORM_CONFIG_DEPS REQUIRED libtzplatform-config) -PKG_CHECK_MODULES(PKGMGR_INFO_DEPS REQUIRED pkgmgr-info) -PKG_CHECK_MODULES(SMACK_DEPS REQUIRED libsmack) -PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0) -PKG_CHECK_MODULES(GIO_DEPS REQUIRED gio-2.0) -PKG_CHECK_MODULES(GOBJECT_DEPS REQUIRED gobject-2.0) PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle) PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock) +PKG_CHECK_MODULES(ESD_DEPS REQUIRED libesd) +PKG_CHECK_MODULES(TIZEN_DATABASE_DEPS REQUIRED tizen-database) +PKG_CHECK_MODULES(APP_MANAGER_DEPS REQUIRED capi-appfw-app-manager) +PKG_CHECK_MODULES(PACKAGE_MANAGER_DEPS REQUIRED capi-appfw-package-manager) +PKG_CHECK_MODULES(APP_COMMON_DEPS REQUIRED capi-appfw-app-common) +PKG_CHECK_MODULES(RPC_PORT_DEPS REQUIRED rpc-port) +PKG_CHECK_MODULES(GLIB_2_DEPS REQUIRED glib-2.0) ADD_SUBDIRECTORY(src) -ADD_SUBDIRECTORY(tool) +ADD_SUBDIRECTORY(modules) ADD_SUBDIRECTORY(tests) diff --git a/include/badge_db.h b/include/badge_db.h deleted file mode 100644 index f469574..0000000 --- a/include/badge_db.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - - -#ifndef __BADGE_DB_DEF_H__ -#define __BADGE_DB_DEF_H__ - -#include -#include -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define BADGE_DB_PATH tzplatform_mkpath(TZ_SYS_DB, ".badge.db") -#define BADGE_SETTING_DB_TABLE "badge_setting" -#define BADGE_TABLE_NAME "badge_data" -#define BADGE_OPTION_TABLE_NAME "badge_option" - -int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid); -int badge_db_delete(const char *pkgname, const char *caller_pkg, uid_t uid, pid_t pid); -int badge_db_delete_by_pkgname(const char *pkgname, uid_t uid); -int badge_db_set_count(const char *pkgname, const char *caller_pkg, unsigned int count, uid_t uid, pid_t pid); -int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid); -int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid); -int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid); -int badge_db_exec(sqlite3 *db, const char *query, int *num_changes); -int badge_db_get_list(GList **badge_list, uid_t uid); -int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid); -int badge_db_init(); - -#ifdef __cplusplus - } -#endif - -#endif /* __BADGE_DB_DEF_H__ */ - diff --git a/include/badge_internal.h b/include/badge_internal.h deleted file mode 100644 index 1d9b576..0000000 --- a/include/badge_internal.h +++ /dev/null @@ -1,264 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#ifndef __BADGE_INTERNAL_DEF_H__ -#define __BADGE_INTERNAL_DEF_H__ - -#include -#include -#include -#include - -#include "badge_error.h" -#include "badge.h" - -#ifndef EXPORT_API -#define EXPORT_API __attribute__ ((visibility("default"))) -#endif - -#ifndef DEPRECATED -#define DEPRECATED __attribute__((deprecated)) -#endif - -#define BADGE_ERROR (badge_error_quark()) -GQuark badge_error_quark(void); - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -typedef struct _badge_h badge_h; - -typedef struct badge_info { - char *pkg; - unsigned int badge_count; -} badge_info_s; - -/** - * @internal - * @brief Checks whether badge service is ready. - * @since_tizen 2.3 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @remarks The specific error code can be obtained using the get_last_result() method. Error codes are described in Exception section. - * @return 1 if badge service is ready, other value if badge service isn't ready - * @retval BADGE_ERROR_NONE Success - * @retval BADGE_ERROR_NOT_SUPPORTED Not supported - * @retval BADGE_ERROR_SERVICE_NOT_READY Service is not ready - */ -int badge_is_service_ready(void); - -/** - * @internal - * @brief Adds deferred task. The registered task will be executed when badge service become ready. - * @since_tizen 2.3 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @param[in] badge_add_deferred_task The callback function - * @param[in] user_data The user data to be passed to the callback function - * @return #BADGE_ERROR_NONE if success, other value if failure - * @retval BADGE_ERROR_NONE Success - * @retval BADGE_ERROR_NOT_SUPPORTED Not supported - * @retval BADGE_ERROR_PERMISSION_DENIED Permission denied - * @retval BADGE_ERROR_OUT_OF_MEMORY Out of memory - * @see #badge_error_e - * @see badge_is_service_ready() - */ -int badge_add_deferred_task( - void (*badge_add_deferred_task)(void *data), void *user_data); - -/** - * @internal - * @brief Removes deferred task. - * @since_tizen 2.3 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @param[in] badge_add_deferred_task The callback function - * @return #BADGE_ERROR_NONE if success, other value if failure - * @retval BADGE_ERROR_NONE Success - * @retval BADGE_ERROR_NOT_SUPPORTED Not supported - * @retval BADGE_ERROR_PERMISSION_DENIED Permission denied - * @retval BADGE_ERROR_INVALID_PARAMETER Invalid parameter - * @see #badge_error_e - * @see badge_is_service_ready() - */ -int badge_del_deferred_task( - void (*badge_add_deferred_task)(void *data)); - -/** - * @internal - * @brief Tests if the badge for the designated application exists or not. - * @since_tizen 2.3 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @param[in] app_id The name of the designated application - * @param[out] existing The bool value of badge existence status - * @return #BADGE_ERROR_NONE if success, other value if failure - * @retval BADGE_ERROR_NONE Success - * @retval BADGE_ERROR_NOT_SUPPORTED Not supported - * @retval BADGE_ERROR_PERMISSION_DENIED Permission denied - * @retval BADGE_ERROR_INVALID_PARAMETER Invalid parameter - * @retval BADGE_ERROR_FROM_DB Error from DB - * @retval BADGE_ERROR_OUT_OF_MEMORY Out of memory - * @retval BADGE_ERROR_NOT_EXIST Not exist - * @retval BADGE_ERROR_SERVICE_NOT_READY Service is not ready - * @see #badge_error_e - * @see badge_new() - * @see badge_remove() - * @par Sample code: - * @code -#include -... -{ - int err = BADGE_ERROR_NONE; - bool exist; - - err = badge_is_existing(app_id, &exist); - if (err != BADGE_ERROR_NONE) { - return; - } - -} - * @endcode - */ -int badge_is_existing(const char *app_id, bool *existing); - -char *_badge_get_pkgname_by_pid(void); - -int _badge_is_existing(const char *pkgname, bool *existing, uid_t uid); - -int _badge_get_list(GList **badge_list, uid_t uid); - -int _badge_insert(badge_h *badge, uid_t uid); - -int _badge_remove(const char *caller, const char *pkgname, uid_t uid, pid_t pid); - -int _badge_remove_by_pkgname(const char *pkgname, uid_t uid); - -int _badge_set_count(const char *caller, const char *pkgname, - unsigned int count, uid_t uid, pid_t pid); - -int _badge_get_count(const char *pkgname, unsigned int *count, uid_t uid); - -int _badge_set_display(const char *pkgname, unsigned int is_display, uid_t uid); - -int _badge_get_display(const char *pkgname, unsigned int *is_display, uid_t uid); - -int _badge_free(badge_h *badge); - -badge_h *_badge_new(const char *pkgname, const char *writable_pkgs, - int *err); - -char *_badge_pkgs_new(int *err, const char *pkg1, ...); - -void badge_changed_cb_call(unsigned int action, const char *pkgname, - unsigned int count, uid_t uid); - -/** - * @internal - * @brief Creates a badge for the designated package. - * @details Creates new badge to display. - * @since_tizen 2.3 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @param[in] pkgname The name of the designated package - * @param[in] writable_pkg The name of package which is authorized to change the badge - * @return #BADGE_ERROR_NONE if success, other value if failure - * @retval #BADGE_ERROR_NOT_SUPPORTED Not supported - * @see #badge_error_e - * @par Sample code: - * @code -#include -... -{ - int err = BADGE_ERROR_NONE; - - err = badge_create("org.tizen.sms", "org.tizen.sms2"); - if (err != BADGE_ERROR_NONE) { - return; - } - -} - * @endcode - */ -int badge_create(const char *pkgname, const char *writable_pkg); - -int badge_create_for_uid(const char *pkgname, const char *writable_pkg, uid_t uid); - -int badge_new_for_uid(const char *writable_app_id, uid_t uid); - -/** - * @internal - * @brief Creates a badge for the application specified by the badge_app_id. - * @details Creates new badge to display. - * @since_tizen 5.5 - * @privlevel public - * @privilege %http://tizen.org/privilege/notification - * @param[in] badge_app_id The id of the application for which the badge will be created. This should be the same package id with the caller application's package id - * @param[in] writable_app_id The id of the application which is authorized to change the badge - * @return #BADGE_ERROR_NONE if success, other value if failure - * @retval #BADGE_ERROR_NONE Success - * @retval #BADGE_ERROR_PERMISSION_DENIED Permission denied - * @retval #BADGE_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #BADGE_ERROR_IO_ERROR Error from I/O - * @retval #BADGE_ERROR_SERVICE_NOT_READY Service is not ready - * @retval #BADGE_ERROR_INVALID_PACKAGE Error while caller package is different with the id of the application badge creates - * @see #badge_error_e - * @par Sample code: - * @code -#include - -{ - int err = BADGE_ERROR_NONE; - - err = badge_new_for(badge_app_id,app_id); - if(err != BADGE_ERROR_NONE) { - return; - } -} - * @endcode - */ -int badge_new_for(const char *badge_app_id, const char *writable_app_id); -int badge_new_for_for_uid(const char *badge_app_id, const char *writable_app_id, uid_t uid); - -int badge_add_for_uid(const char *badge_app_id, uid_t uid); - -int badge_remove_for_uid(const char *app_id, uid_t uid); - -int badge_is_existing_for_uid(const char *app_id, bool *existing, uid_t uid); - -int badge_foreach_for_uid(badge_foreach_cb callback, void *user_data, uid_t uid); - -int badge_set_count_for_uid(const char *app_id, unsigned int count, uid_t uid); - -int badge_get_count_for_uid(const char *app_id, unsigned int *count, uid_t uid); - -int badge_set_display_for_uid(const char *app_id, unsigned int is_display, uid_t uid); - -int badge_get_display_for_uid(const char *app_id, unsigned int *is_display, uid_t uid); - -int badge_register_changed_cb_for_uid(badge_change_cb callback, void *data, uid_t uid); - -int badge_unregister_changed_cb_for_uid(badge_change_cb callback, uid_t uid); - - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* __BADGE_INTERNAL_DEF_H__ */ - diff --git a/include/badge_ipc.h b/include/badge_ipc.h deleted file mode 100644 index 84a5291..0000000 --- a/include/badge_ipc.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#ifndef __BADGE_IPC_H__ -#define __BADGE_IPC_H__ - -#include -#include -#include -#include - -#define BADGE_ADDR "/tmp/.badge.service" - -#ifdef __cplusplus -extern "C" { -#endif - -struct packet; - -int badge_ipc_monitor_init(uid_t uid); -int badge_ipc_monitor_fini(void); - -int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid); -int badge_ipc_request_delete(const char *pkgname, const char *caller, uid_t uid); -int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count, uid_t uid); -int badge_ipc_request_get_count(const char *pkgname, unsigned int *count, uid_t uid); -int badge_ipc_request_set_display(const char *pkgname, const char *caller, unsigned int display_option, uid_t uid); -int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display, uid_t uid); - -int badge_ipc_is_master_ready(void); -int badge_ipc_add_deferred_task(void (*badge_add_deferred_task)(void *data), void *user_data); -int badge_ipc_del_deferred_task(void (*badge_add_deferred_task)(void *data)); - -int badge_ipc_request_get_list(badge_foreach_cb callback, void *data, uid_t uid); -int badge_ipc_request_is_existing(const char *pkgname, bool *existing, uid_t uid); - -int badge_ipc_request_update_setting(badge_setting_h setting, uid_t uid); -int badge_ipc_request_get_setting_by_appid(badge_setting_h *setting, const char *appid, uid_t uid); -int badge_ipc_init_badge(uid_t uid); - -GVariant *badge_ipc_make_gvariant_from_setting(badge_setting_h setting); -int badge_ipc_make_setting_from_gvariant(badge_setting_h setting, GVariant *variant); - -#ifdef __cplusplus -} -#endif -#endif diff --git a/include/badge_private.h b/include/badge_private.h deleted file mode 100644 index c26cca1..0000000 --- a/include/badge_private.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#ifndef __BADGE_PRIVATE_H__ -#define __BADGE_PRIVATE_H__ - -#include - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#define BADGE_FEATURE "http://tizen.org/feature/badge" -#define CHECK_BADGE_FEATURE() \ - do { \ - bool is_supported = false; \ - if (!system_info_get_platform_bool(BADGE_FEATURE, &is_supported)) { \ - if (is_supported == false) { \ - LOGE("[%s] feature is disabled", BADGE_FEATURE); \ - return BADGE_ERROR_NOT_SUPPORTED; \ - } \ - } \ - } while (0) - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* __BADGE_PRIVATE_H__ */ diff --git a/include/badge_setting.h b/include/badge_setting.h deleted file mode 100644 index 674c8dc..0000000 --- a/include/badge_setting.h +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2016 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#ifndef __BADGE_SETTING_H__ -#define __BADGE_SETTING_H__ - -#include -#include -#include "badge_error.h" - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/** - * @file badge_setting.h - * @brief This file contains the badge APIs. - */ - -/** - * @addtogroup BADGE_MODULE - * @{ - */ - -typedef struct badge_setting *badge_setting_h; - -struct badge_setting { - char *pkgname; - char *appid; - int allow_to_display; -}; - -int badge_setting_get_pkgname(badge_setting_h setting, char **pkgname); -int badge_setting_get_appid(badge_setting_h setting, char **appid); -int badge_setting_set_allow_to_display(badge_setting_h setting, bool value); -int badge_setting_get_allow_to_display(badge_setting_h setting, bool *value); -int badge_setting_update_setting(badge_setting_h setting); -int badge_setting_update_setting_for_uid(badge_setting_h setting, uid_t uid); -int badge_setting_get_setting_by_appid(badge_setting_h *setting, const char *appid); -int badge_setting_get_setting_by_appid_for_uid(badge_setting_h *setting, const char *appid, uid_t uid); -int badge_setting_free_setting(badge_setting_h setting); - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* __BADGE_SETTING_H__ */ diff --git a/include/badge_setting_service.h b/include/badge_setting_service.h deleted file mode 100644 index af0f0e5..0000000 --- a/include/badge_setting_service.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2016 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#ifndef __BADGE_SETTING_SERVICE_H__ -#define __BADGE_SETTING_SERVICE_H__ - -#include -#include -#include "badge_error.h" -#include "badge_setting.h" - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -/** - * @file badge_setting_service.h - * @brief This file contains the badge APIs. - */ - -/** - * @addtogroup BADGE_MODULE - * @{ - */ - -int badge_db_get_setting_by_appid(const char *appid, badge_setting_h *setting, uid_t uid); -int badge_db_get_allow_to_display_by_appid(char *appid, int *allow_to_display, uid_t uid); -int badge_setting_insert_package_for_uid(const char *pkgname, uid_t uid); -int badge_setting_delete_package_for_uid(const char *pkgname, uid_t uid); -int badge_setting_refresh_setting_table(uid_t uid); -int badge_db_update_setting(char *pkgname, char *appid, int allow_to_display, uid_t uid); -int badge_db_update_app_disabled(const char *app_id, bool disabled, uid_t uid); -int badge_db_update_pkg_disabled(const char *pkg_id, bool disabled, uid_t uid); -int badge_setting_is_existed_appid(const char *appid, bool *is_existed, uid_t uid); -int badge_setting_arrange_tables(uid_t uid); - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* __BADGE_SETTING_SERVICE_H__ */ - diff --git a/include/log_private.h b/include/log_private.h new file mode 100644 index 0000000..fd8196b --- /dev/null +++ b/include/log_private.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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. + */ + +#ifndef BADGE_LOG_PRIVATE_H_ +#define BADGE_LOG_PRIVATE_H_ + +#include + +#undef LOG_TAG +#define LOG_TAG "BADGE" + +#undef _E +#define _E LOGE + +#undef _W +#define _W LOGW + +#undef _I +#define _I LOGI + +#undef _D +#define _D LOGD + +#endif // BADGE_LOG_PRIVATE_H_ diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt new file mode 100644 index 0000000..947ec8d --- /dev/null +++ b/modules/CMakeLists.txt @@ -0,0 +1 @@ +ADD_SUBDIRECTORY(badge) diff --git a/modules/badge/CMakeLists.txt b/modules/badge/CMakeLists.txt new file mode 100644 index 0000000..0848380 --- /dev/null +++ b/modules/badge/CMakeLists.txt @@ -0,0 +1,22 @@ +REMOVE_DEFINITIONS("-DDB_PATH") +ADD_DEFINITIONS("-DDB_PATH=\"${DB_PATH}\"") +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} ESD_MOD_BADGE_SRCS) + +ADD_LIBRARY(${TARGET_ESD_MOD_BADGE} ${ESD_MOD_BADGE_SRCS}) +TARGET_INCLUDE_DIRECTORIES(${TARGET_ESD_MOD_BADGE} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/../../include) + +TARGET_LINK_LIBRARIES(${TARGET_ESD_MOD_BADGE} PRIVATE ${TARGET_LIB_ESD}) + +APPLY_PKG_CONFIG(${TARGET_ESD_MOD_BADGE} PUBLIC + DLOG_DEPS + ESD_DEPS + RPC_PORT_DEPS + APP_MANAGER_DEPS + PACKAGE_MANAGER_DEPS + APP_COMMON_DEPS + TIZEN_DATABASE_DEPS +) + +INSTALL(TARGETS ${TARGET_ESD_MOD_BADGE} DESTINATION ${ESD_MODULES_DIR}/mod + COMPONENT RuntimeLibraries) diff --git a/modules/badge/badge.cc b/modules/badge/badge.cc new file mode 100644 index 0000000..ea5e09e --- /dev/null +++ b/modules/badge/badge.cc @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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 "badge_module.hh" + +#undef EXPORT_API +#define EXPORT_API __attribute__((visibility("default"))) + +extern "C" EXPORT_API esd::api::IModule* ESD_GET_MODULE() { + return new esd::module::BadgeModule(); +} diff --git a/modules/badge/badge_module.cc b/modules/badge/badge_module.cc new file mode 100644 index 0000000..f6970fe --- /dev/null +++ b/modules/badge/badge_module.cc @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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 "badge_module.hh" + +#include + +#include "log_private.h" +#include "badge_service.hh" + +namespace esd::module { + +bool BadgeModule::Startup(api::ToolBox* tools) { + int ret = rpc_port_register_proc_info("d::org.tizen.appfw.service.esd", + nullptr); + if (ret != RPC_PORT_ERROR_NONE) { + /* LCOV_EXCL_START */ + _I("rpc_port_register_proc_info() failed (%d)", ret); + /* LCOV_EXCL_STOP */ + } + + try { + badge_.Listen(std::shared_ptr( + new BadgeService::Factory(badge_))); + } catch (const rpc_stub::InvalidIOException& e) { + /* LCOV_EXCL_START */ + _E("InvalidIOException happened"); + return false; + /* LCOV_EXCL_STOP */ + } + + return true; +} + +void BadgeModule::Shutdown() { +} + +} //namespace esd::module diff --git a/modules/badge/badge_module.hh b/modules/badge/badge_module.hh new file mode 100644 index 0000000..d45469a --- /dev/null +++ b/modules/badge/badge_module.hh @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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. + */ + +#ifndef MODULES_BADGE_BADGE_MODULE_HH_ +#define MODULES_BADGE_BADGE_MODULE_HH_ + +#include +#include +#include +#include +#include + +#include "badge_stub.h" + +namespace esd::module { + +namespace rpc_stub = rpc_port::badge_stub::stub; + +class BadgeModule : public api::IModule { + public: + BadgeModule() = default; + virtual ~BadgeModule() = default; + + bool Startup(api::ToolBox* tools) override; + void Shutdown() override; + + private: + rpc_stub::Badge badge_; +}; + +} // namespace esd::module + +#endif // MODULES_BADGE_BADGE_MODULE_HH_ \ No newline at end of file diff --git a/modules/badge/badge_service.cc b/modules/badge/badge_service.cc new file mode 100644 index 0000000..b24803e --- /dev/null +++ b/modules/badge/badge_service.cc @@ -0,0 +1,328 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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 "badge_service.hh" + +#include + +#include "log_private.h" + +namespace esd::module { + +namespace { + +constexpr const char BADGE_DB_PATH[] = DB_PATH; +bool is_db_corrupted_ = false; + +constexpr const char QUERY_CREATE_BADGE_TABLE[] = + R"__bg(PRAGMA journal_mode = PERSIST; + PRAGMA synchronous = FULL; + CREATE TABLE IF NOT EXISTS badge_data ( + uid INTEGER, + pkgname TEXT NOT NULL, + writable_pkgs TEXT, + badge INTEGER DEFAULT 0, + rowid INTEGER PRIMARY KEY AUTOINCREMENT, + UNIQUE (uid, pkgname) + ); + CREATE TABLE IF NOT EXISTS badge_option ( + uid INTEGER, + pkgname TEXT NOT NULL, + display INTEGER DEFAULT 1, + UNIQUE (uid, pkgname) + ); + CREATE TABLE IF NOT EXISTS badge_setting ( + uid INTEGER, + pkgname TEXT NOT NULL, + appid TEXT NOT NULL, + allow_to_display INTEGER DEFAULT 1, + UNIQUE (uid, pkgname, appid) +);)__bg"; + +int CheckIntegrityCb(void* pid, int argc, char** argv, char** notUsed) { + if (strcmp(argv[0], "ok") != 0) { + _E("db integrity result : %s", argv[0]); + is_db_corrupted_ = true; + return -1; + } + + _I("db integrity result : %s", argv[0]); + return 0; +} + +void RecoverCorruptedDb() { + _I("RecoverCorruptedDb"); + unlink(BADGE_DB_PATH); + try { + tizen_base::Database db(BADGE_DB_PATH, + SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE); + db.OneStepExec({ QUERY_CREATE_BADGE_TABLE }); + } catch(const tizen_base::DbException& e) { + _E("RecoverCorruptedDb failed : %s", e.msg()); + } +} + +void DbInit() { + try { + tizen_base::Database db(BADGE_DB_PATH, + SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE); + db.OneStepExec({ QUERY_CREATE_BADGE_TABLE }); + int ret = sqlite3_exec(db.GetRaw(), "PRAGMA integrity_check", + CheckIntegrityCb, nullptr, nullptr); + if (ret != SQLITE_OK || is_db_corrupted_) { + throw tizen_base::DbException("Integrity checking failed", ret); + } + } catch(const tizen_base::DbException& e) { + int code = e.code(); + if (code == SQLITE_CORRUPT || code == SQLITE_NOTADB + || is_db_corrupted_) { + RecoverCorruptedDb(); + } + } +} + +} + +void BadgeService::OnCreate() { + DbInit(); +} + +void BadgeService::OnTerminate() { +} + +bool BadgeService::IsExist(const tizen_base::Database& db, std::string appid) { + auto q = tizen_base::Database::Sql("SELECT count(*) FROM badge_data " + "WHERE pkgname = ?") + .Bind(appid); + auto r = db.Exec(q); + if (!r) + return false; + auto rec = r.GetFirstRecord(); + if (!rec) + return false; + + if (static_cast(rec->Get(0)) > 0) + return true; + + return false; +} + +bool BadgeService::IsWritable(const tizen_base::Database& db, + const std::string& appid, const std::string& caller) { + auto q = tizen_base::Database::Sql("SELECT count(*) FROM badge_data " + "WHERE pkgname = ? AND writable_pkgs LIKE ?") + .Bind(appid) + .Bind("%" + caller + "%"); + auto r = db.Exec(q); + if (!r) + return false; + auto rec = r.GetFirstRecord(); + if (!rec) + return false; + + if (static_cast(rec->Get(0)) > 0) + return true; + + return false; +} + +std::vector BadgeService::GetList() { + std::vector ret; + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READONLY); + auto q = tizen_base::Database::Sql("SELECT pkgname, badge FROM badge_data"); + for (const auto& i : db.Exec(q)) { + ret.emplace_back(static_cast(i.Get(0)), + static_cast(i.Get(1))); + } + } catch(...) { /* LCOV_EXCL_LINE */ + return {}; /* LCOV_EXCL_LINE */ + } + + return ret; +} + +bool BadgeService::Insert(std::string appid, std::string writable_pkg, std::string caller) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READWRITE); + if (IsExist(db, appid)) + return false; + + auto q = tizen_base::Database::Sql("INSERT INTO badge_data " + "(pkgname, writable_pkgs, uid) VALUES (?, ?, ?)") + .Bind(appid) + .Bind(writable_pkg) + .Bind(5001); + auto r = db.Exec(q); + if (!r) + return false; + + const auto& services = parent_.GetServices(); + for (auto& s : services) { + auto* ptr = static_cast(s.get()); + ptr->NotifyChangedEvent(rpc::BadgeInfo::Action::Create, appid, 0); + } + } catch(...) { /* LCOV_EXCL_LINE */ + return false; /* LCOV_EXCL_LINE */ + } + + return true; +} + +bool BadgeService::Delete(std::string appid, std::string caller) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READWRITE); + if (!IsExist(db, appid)) + return false; + + if (!IsWritable(db, appid, caller)) + return false; + + auto q = tizen_base::Database::Sql("DELETE FROM badge_data " + "WHERE pkgname = ?") + .Bind(appid); + auto r = db.Exec(q); + if (!r) + return false; + + const auto& services = parent_.GetServices(); + for (auto& s : services) { + auto* ptr = static_cast(s.get()); + ptr->NotifyChangedEvent(rpc::BadgeInfo::Action::Remove, appid, 0); + } + } catch (...) { /* LCOV_EXCL_LINE */ + return false; /* LCOV_EXCL_LINE */ + } + + return true; +} + +bool BadgeService::SetCount(std::string appid, std::string caller, int count) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READWRITE); + + if (!IsExist(db, appid)) + return false; + + if (!IsWritable(db, appid, caller)) + return false; + + auto q = tizen_base::Database::Sql("UPDATE badge_data SET badge = ? " + "WHERE pkgname = ?") + .Bind(count) + .Bind(appid); + auto r = db.Exec(q); + if (!r) + return false; + + const auto& services = parent_.GetServices(); + for (auto& s : services) { + auto* ptr = static_cast(s.get()); + ptr->NotifyChangedEvent(rpc::BadgeInfo::Action::Update, appid, count); + } + } catch(...) { /* LCOV_EXCL_LINE */ + return false; /* LCOV_EXCL_LINE */ + } + + return true; +} + +int BadgeService::GetCount(std::string appid) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READONLY); + if (!IsExist(db, appid)) + return -1; + + auto q = tizen_base::Database::Sql("SELECT badge FROM badge_data " + "WHERE pkgname = ?") + .Bind(appid); + auto r = db.Exec(q); + if (!r) + return -1; + auto rec = r.GetFirstRecord(); + if (!rec) + return -1; + return static_cast(rec->Get(0)); + } catch(...) { /* LCOV_EXCL_LINE */ + return -1; /* LCOV_EXCL_LINE */ + } +} + +bool BadgeService::SetDisplayOption(std::string appid, std::string caller, bool isDisplay) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READWRITE); + if (!IsExist(db, appid)) + return false; + + auto q = tizen_base::Database::Sql("INSERT INTO badge_option " + "(pkgname, display, uid) VALUES (?, ?, 5001) ") + .Bind(appid) + .Bind(isDisplay ? 1 : 0); + auto r = db.Exec(q); + if (!r) + return false; + + const auto& services = parent_.GetServices(); + for (auto& s : services) { + auto* ptr = static_cast(s.get()); + ptr->NotifyChangedEvent(rpc::BadgeInfo::Action::ChangedDisplay, appid, 0); + } + } catch(...) { /* LCOV_EXCL_LINE */ + return -1; /* LCOV_EXCL_LINE */ + } + + return true; +} + +bool BadgeService::GetDisplayOption(std::string appid) { + try { + tizen_base::Database db(BADGE_DB_PATH, SQLITE_OPEN_READONLY); + if (!IsExist(db, appid)) + return false; + + auto q = tizen_base::Database::Sql("SELECT display FROM badge_option " + "WHERE pkgname = ?") + .Bind(appid); + auto r = db.Exec(q); + if (!r) + return false; + + auto rec = r.GetFirstRecord(); + if (!rec) + return false; + return static_cast(rec->Get(0)); + } catch(...) { /* LCOV_EXCL_LINE */ + return false; /* LCOV_EXCL_LINE */ + } +} + +bool BadgeService::Register(std::unique_ptr cb) { + changed_cb_ = std::move(cb); + return true; +} + +bool BadgeService::Unregister() { + changed_cb_.reset(); + return true; +} + +void BadgeService::NotifyChangedEvent(rpc::BadgeInfo::Action action, + const std::string& appid, int count) { + if (!changed_cb_) return; + changed_cb_->Invoke(action, appid, count); +} + +} // namespace esd::module diff --git a/modules/badge/badge_service.hh b/modules/badge/badge_service.hh new file mode 100644 index 0000000..827e62d --- /dev/null +++ b/modules/badge/badge_service.hh @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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. + */ + +#ifndef MODULES_BADGE_BADGE_SERVICE_HH_ +#define MODULES_BADGE_BADGE_SERVICE_HH_ + +#include +#include +#include +#include +#include +#include + +#include "badge_stub.h" + +namespace esd::module { + +namespace rpc_stub = rpc_port::badge_stub::stub; +namespace rpc = rpc_port::badge_stub; + +class BadgeService : public rpc_stub::Badge::ServiceBase { + public: + class Factory : public rpc_stub::Badge::ServiceBase::Factory { + public: + Factory(const rpc_stub::Badge& parent) : parent_(parent) {} + virtual ~Factory() = default; + + std::unique_ptr + CreateService(std::string sender, std::string instance) { + return std::unique_ptr(new BadgeService(sender, instance, parent_)); + } + + private: + const rpc_stub::Badge& parent_; + }; + + BadgeService(std::string sender, std::string instance, const rpc_stub::Badge& parent) : + rpc_stub::Badge::ServiceBase(sender, instance), parent_(parent) {} + + virtual ~BadgeService() = default; + + void OnCreate() override; + void OnTerminate() override; + + std::vector GetList() override; + bool Insert(std::string appid, std::string writable_pkg, std::string caller) override; + bool Delete(std::string appid, std::string caller) override; + bool SetCount(std::string appid, std::string caller, int count) override; + int GetCount(std::string appid) override; + bool SetDisplayOption(std::string appid, std::string caller, bool isDisplay) override; + bool GetDisplayOption(std::string appid) override; + bool Register(std::unique_ptr cb) override; + bool Unregister() override; + + void NotifyChangedEvent(rpc::BadgeInfo::Action action, + const std::string& appid, int count); + + private: + bool IsExist(const tizen_base::Database& db, std::string appid); + bool IsWritable(const tizen_base::Database& db, + const std::string& appid, const std::string& caller); + + private: + const rpc_stub::Badge& parent_; + std::unique_ptr changed_cb_; +}; + +} // namespace esd::module + +#endif // MODULES_BADGE_BADGE_SERVICE_HH_ \ No newline at end of file diff --git a/packaging/badge.spec b/packaging/badge.spec index 7365d67..0a260cc 100644 --- a/packaging/badge.spec +++ b/packaging/badge.spec @@ -6,17 +6,23 @@ Group: Applications/Core Applications License: Apache-2.0 Source0: %{name}-%{version}.tar.gz BuildRequires: pkgconfig(aul) -BuildRequires: pkgconfig(dbus-1) BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(vconf) -BuildRequires: pkgconfig(capi-appfw-package-manager) -BuildRequires: pkgconfig(db-util) +BuildRequires: pkgconfig(bundle) BuildRequires: pkgconfig(libtzplatform-config) -BuildRequires: pkgconfig(pkgmgr-info) -BuildRequires: pkgconfig(libsmack) +BuildRequires: pkgconfig(capi-appfw-package-manager) BuildRequires: pkgconfig(capi-system-info) -BuildRequires: pkgconfig(gio-2.0) BuildRequires: pkgconfig(gmock) +BuildRequires: pkgconfig(rpc-port) +BuildRequires: pkgconfig(capi-appfw-app-common) +BuildRequires: pkgconfig(capi-appfw-app-manager) +BuildRequires: pkgconfig(capi-appfw-package-manager) +BuildRequires: pkgconfig(libesd) +BuildRequires: pkgconfig(tizen-database) + +BuildRequires: tidl + +%define _moddir %{_datadir}/esd %if 0%{?gcov:1} BuildRequires: lcov @@ -46,6 +52,13 @@ Requires: %{name} = %{version}-%{release} %description service-devel Development files needed to build badge service +%package -n esd-mod-badge +Summary: ESD module for badge +Group: Application Framework/Service + +%description -n esd-mod-badge +This module is for badge + ################################################# # badge-unittests ################################################# @@ -71,6 +84,11 @@ gcov objects of a Badge library %prep %setup -q +tidlc -p -l C++ -i ./tidl/badge.tidl -o badge_proxy +mv badge_proxy.* ./src/ +tidlc -s -l C++ -i ./tidl/badge.tidl -o badge_stub +mv badge_stub.* ./modules/badge/ + %build %if 0%{?gcov:1} @@ -85,6 +103,8 @@ LDFLAGS="$LDFLAGS" MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` %cmake . \ -DMAJORVER=${MAJORVER} \ + -DDB_PATH=%{TZ_SYS_DB}/.badge.db \ + -DESD_MODULES_DIR=%{_moddir} \ -DFULLVER=%{version} make %{?jobs:-j%jobs} @@ -93,6 +113,10 @@ export LD_LIBRARY_PATH=../../src ctest -V %if 0%{?gcov:1} lcov -c --ignore-errors mismatch,graph,unused --no-external -q -d . -o badge.info +lcov -r badge.info "_proxy*" -o badge.info +lcov -r badge.info "_stub*" -o badge.info +lcov -r badge.info "/unit_tests/*" -o badge.info +lcov -r badge.info "/mock/*" -o badge.info genhtml badge.info -o badge.out zip -r badge.zip badge.out install -m 0644 badge.zip %{buildroot}%{_datadir}/gcov/badge.zip @@ -153,27 +177,17 @@ fi %license LICENSE %{_includedir}/badge/badge.h %{_includedir}/badge/badge_error.h -%{_includedir}/badge/badge_internal.h -%{_includedir}/badge/badge_setting.h -%{_includedir}/badge/badge_setting_service.h -%{_includedir}/badge/badge_ipc.h -%attr(755,root,root) %{_sysconfdir}/gumd/useradd.d/11_badge-add.post -%{_bindir}/badge_init %files devel %defattr(-,root,root,-) %{_includedir}/badge/badge.h %{_includedir}/badge/badge_error.h -%{_includedir}/badge/badge_internal.h -%{_includedir}/badge/badge_db.h -%{_includedir}/badge/badge_setting.h -%{_includedir}/badge/badge_setting_service.h -%{_includedir}/badge/badge_ipc.h %{_libdir}/pkgconfig/%{name}.pc %{_libdir}/libbadge.so %files unittests %{_bindir}/badge_unittests +%{_bindir}/badge_integtests %{_bindir}/tizen-unittests/%{name}/run-unittest.sh ################################################# @@ -183,4 +197,8 @@ fi %files gcov %{_datadir}/gcov/* %endif -# End of a file + +%files -n esd-mod-badge +%manifest %{name}.manifest +%license LICENSE +%{_moddir}/mod/libesd-mod-badge.so diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 0a55216..3572b2e 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -7,17 +7,11 @@ TARGET_LINK_LIBRARIES(${TARGET_BADGE} ${pkgs_LDFLAGS}) TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../include/) APPLY_PKG_CONFIG(${TARGET_BADGE} PUBLIC - AUL_DEP DLOG_DEPS VCONF_DEPS - PKGMGR_DEPS SYSTEM_INFO_DEPS - DB_UTIL_DEPS - PLATFORM_CONFIG_DEPS - PKGMGR_INFO_DEPS - SMACK_DEPS - GLIB_DEPS - GIO_DEPS + RPC_PORT_DEPS + APP_COMMON_DEPS ) CONFIGURE_FILE(../${TARGET_BADGE}.pc.in ../${TARGET_BADGE}.pc @ONLY) @@ -30,4 +24,4 @@ INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ PATTERN "*.h") INSTALL(TARGETS ${TARGET_BADGE} DESTINATION ${LIB_INSTALL_DIR}) -INSTALL(FILES ${CMAKE_BINARY_DIR}/11_badge-add.post DESTINATION ${SYSCONF_INSTALL_DIR}/gumd/useradd.d/) + diff --git a/src/badge.c b/src/badge.c deleted file mode 100644 index 77b2739..0000000 --- a/src/badge.c +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge.h" -#include "badge_error.h" -#include "badge_internal.h" -#include "badge_private.h" - -EXPORT_API -int badge_new(const char *writable_app_id) -{ - dlog_print(DLOG_WARN, LOG_TAG, "DEPRECATION WARNING: badge_new() is deprecated and will be removed from next release. Use badge_add() instead."); - CHECK_BADGE_FEATURE(); - if (writable_app_id == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_new_for_uid(writable_app_id, getuid()); -} - -EXPORT_API -int badge_add(const char *badge_app_id) -{ - CHECK_BADGE_FEATURE(); - return badge_add_for_uid(badge_app_id, getuid()); -} - -EXPORT_API -int badge_remove(const char *app_id) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_remove_for_uid(app_id, getuid()); -} - -EXPORT_API -int badge_foreach(badge_foreach_cb callback, void *user_data) -{ - CHECK_BADGE_FEATURE(); - if (callback == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_foreach_for_uid(callback, user_data, getuid()); -} - -EXPORT_API -int badge_set_count(const char *app_id, unsigned int count) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_set_count_for_uid(app_id, count, getuid()); -} - -EXPORT_API -int badge_get_count(const char *app_id, unsigned int *count) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL || count == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_get_count_for_uid(app_id, count, getuid()); -} - -EXPORT_API -int badge_set_display(const char *app_id, unsigned int is_display) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_set_display_for_uid(app_id, is_display, getuid()); -} - -EXPORT_API -int badge_get_display(const char *app_id, unsigned int *is_display) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL || is_display == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_get_display_for_uid(app_id, is_display, getuid()); -} - -EXPORT_API -int badge_register_changed_cb(badge_change_cb callback, void *data) -{ - CHECK_BADGE_FEATURE(); - if (callback == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_register_changed_cb_for_uid(callback, data, getuid()); -} - -EXPORT_API -int badge_unregister_changed_cb(badge_change_cb callback) -{ - CHECK_BADGE_FEATURE(); - if (callback == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_unregister_changed_cb_for_uid(callback, getuid()); -} diff --git a/src/badge.cc b/src/badge.cc new file mode 100644 index 0000000..f651757 --- /dev/null +++ b/src/badge.cc @@ -0,0 +1,275 @@ +/* + * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. + * + * 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 "log_private.h" +#include "badge.h" +#include "badge_error.h" +#include "badge_proxy.h" + +#define BADGE_FEATURE "http://tizen.org/feature/badge" +#define CHECK_BADGE_FEATURE() \ + do { \ + bool is_supported = false; \ + if (!system_info_get_platform_bool(BADGE_FEATURE, &is_supported)) { \ + if (is_supported == false) { \ + _E("[%s] feature is disabled", BADGE_FEATURE); \ + return BADGE_ERROR_NOT_SUPPORTED; \ + } \ + } \ + } while (0) + +namespace rpc = rpc_port::badge_proxy; +namespace rpc_proxy = rpc_port::badge_proxy::proxy; + +namespace { + +char* sAppid; +std::unique_ptr badge_proxy_; + +class BadgeConnection : public rpc_proxy::Badge::IEventListener { + public: + void OnConnected() override {} + + /* LCOV_EXCL_START */ + void OnDisconnected() override { + badge_proxy_.reset(); + } + + void OnRejected() override { + badge_proxy_.reset(); + } + /* LCOV_EXCL_STOP */ +} connection_listener_; + +class BadgeChangedCb : public rpc_proxy::Badge::ChangedCb { + public: + BadgeChangedCb(badge_change_cb callback, void* data) + : callback_(callback), data_(data) {} + + void OnReceived(rpc::BadgeInfo::Action action, std::string appid, + int count) override { + if (!callback_) + return; + callback_((unsigned int)(action), appid.c_str(), count, data_); + } + + private: + badge_change_cb callback_; + void* data_; +}; + +void Connect() { + if (!badge_proxy_) { + badge_proxy_.reset(new rpc_proxy::Badge(&connection_listener_, + "d::org.tizen.appfw.service.esd")); + badge_proxy_->Connect(true); + } + + if (!sAppid) { + app_get_id(&sAppid); + if (!sAppid) + sAppid = const_cast("daemon"); + } +} + +} // namespace + +EXPORT_API int badge_new(const char* writable_app_id) { + CHECK_BADGE_FEATURE(); + if (writable_app_id == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + if (!badge_proxy_->Insert(sAppid, writable_app_id, sAppid)) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_add(const char* badge_app_id) { + CHECK_BADGE_FEATURE(); + try { + ::Connect(); + if (!badge_proxy_->Insert(badge_app_id, sAppid, sAppid)) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_remove(const char* app_id) { + CHECK_BADGE_FEATURE(); + try { + ::Connect(); + if (!badge_proxy_->Delete(app_id, sAppid)) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_foreach(badge_foreach_cb callback, void* user_data) { + CHECK_BADGE_FEATURE(); + if (callback == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + auto info = badge_proxy_->GetList(); + for (auto& i : info) { + if (!callback(i.GetPkgName().c_str(), i.GetCount(), user_data)) + break; + } + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_set_count(const char* app_id, unsigned int count) { + CHECK_BADGE_FEATURE(); + if (app_id == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + try { + ::Connect(); + if (!badge_proxy_->SetCount(app_id, sAppid, count)) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_get_count(const char* app_id, unsigned int* count) { + CHECK_BADGE_FEATURE(); + if (app_id == nullptr || count == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + *count = badge_proxy_->GetCount(app_id); + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_set_display(const char* app_id, unsigned int is_display) { + CHECK_BADGE_FEATURE(); + if (app_id == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + try { + ::Connect(); + if (!badge_proxy_->SetDisplayOption(app_id, sAppid, is_display)) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_get_display(const char* app_id, unsigned int* is_display) { + CHECK_BADGE_FEATURE(); + if (app_id == nullptr || is_display == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + *is_display = badge_proxy_->GetDisplayOption(app_id) ? 1 : 0; + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_register_changed_cb(badge_change_cb callback, void* data) { + CHECK_BADGE_FEATURE(); + if (callback == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + if (!badge_proxy_->Register(std::make_unique(callback, data))) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} + +EXPORT_API int badge_unregister_changed_cb(badge_change_cb callback) { + CHECK_BADGE_FEATURE(); + if (callback == nullptr) + return BADGE_ERROR_INVALID_PARAMETER; + + try { + ::Connect(); + if (!badge_proxy_->Unregister()) + return BADGE_ERROR_IO_ERROR; /* LCOV_EXCL_LINE */ + } catch(...) { /* LCOV_EXCL_LINE */ + /* LCOV_EXCL_START */ + badge_proxy_.reset(); + return BADGE_ERROR_IO_ERROR; + /* LCOV_EXCL_STOP */ + } + + return BADGE_ERROR_NONE; +} diff --git a/src/badge_db.c b/src/badge_db.c deleted file mode 100644 index e143ae9..0000000 --- a/src/badge_db.c +++ /dev/null @@ -1,279 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge.h" -#include "badge_db.h" -#include "badge_log.h" -#include "badge_error.h" -#include "badge_internal.h" - -#define CREATE_BADGE_TABLE " \ -PRAGMA journal_mode = PERSIST; \ -PRAGMA synchronous = FULL; \ -CREATE TABLE IF NOT EXISTS badge_data ( \ - uid INTEGER, \ - pkgname TEXT NOT NULL, \ - writable_pkgs TEXT, \ - badge INTEGER DEFAULT 0, \ - rowid INTEGER PRIMARY KEY AUTOINCREMENT, \ - UNIQUE (uid, pkgname) \ -); \ -CREATE TABLE IF NOT EXISTS badge_option ( \ - uid INTEGER, \ - pkgname TEXT NOT NULL, \ - display INTEGER DEFAULT 1, \ - UNIQUE (uid, pkgname) \ -); \ -CREATE TABLE IF NOT EXISTS badge_setting ( \ - uid INTEGER, \ - pkgname TEXT NOT NULL, \ - appid TEXT NOT NULL, \ - allow_to_display INTEGER DEFAULT 1, \ - UNIQUE (uid, pkgname, appid) \ -); " - -static bool is_db_corrupted = false; - -/* LCOV_EXCL_START */ -static int __check_integrity_cb(void *pid, int argc, char **argv, char **notUsed) -{ - if (strcmp(argv[0], "ok") != 0) { - ERR("db integrity result : %s", argv[0]); - is_db_corrupted = true; - return -1; - } - - INFO("db integrity result : %s", argv[0]); - return 0; -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static int __recover_corrupted_db() -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - char *errmsg = NULL; - sqlite3 *db = NULL; - - INFO("DB is corrupted, start to recover corrupted db"); - unlink(BADGE_DB_PATH); - - sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, - NULL); - if (sql_ret != SQLITE_OK) { - ERR("Failed to open badge db[%d]", sql_ret); - unlink(BADGE_DB_PATH); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - - sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg); - if (sql_ret != SQLITE_OK) { - ERR("Failed to exec query[%d][%s]", sql_ret, errmsg); - ret = BADGE_ERROR_FROM_DB; - } - -out: - if (errmsg) - sqlite3_free(errmsg); - - if (db) - sqlite3_close_v2(db); - - return ret; -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -EXPORT_API int badge_db_init(void) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - sqlite3 *db = NULL; - char *errmsg = NULL; - - sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, - SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL); - if (sql_ret != SQLITE_OK) { - ERR("Failed to open badge db[%d]", sql_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - - sql_ret = sqlite3_exec(db, CREATE_BADGE_TABLE, NULL, NULL, &errmsg); - if (sql_ret != SQLITE_OK) { - ERR("Failed to exec query[%d][%s]", sql_ret, errmsg); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - - sql_ret = sqlite3_exec(db, "PRAGMA integrity_check", - __check_integrity_cb, NULL, &errmsg); - if (sql_ret != SQLITE_OK || is_db_corrupted) { - ERR("Failed to exec query[%d][%s]", sql_ret, errmsg); - ret = BADGE_ERROR_FROM_DB; - } - -out: - if (errmsg) - sqlite3_free(errmsg); - if (db) - sqlite3_close_v2(db); - - if (sql_ret == SQLITE_CORRUPT || sql_ret == SQLITE_NOTADB - || is_db_corrupted) - ret = __recover_corrupted_db(); - - return ret; -} -/* LCOV_EXCL_STOP */ - -EXPORT_API -int badge_db_is_existing(const char *pkgname, bool *existing, uid_t uid) -{ - return _badge_is_existing(pkgname, existing, uid); -} - -EXPORT_API -int badge_db_get_list(GList **badge_list, uid_t uid) -{ - return _badge_get_list(badge_list, uid); -} - -EXPORT_API -int badge_db_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid) -{ - int err = BADGE_ERROR_NONE; - badge_h *badge = NULL; - char *pkgs = NULL; - - if (!pkgname) { - ERR("package name is NULL"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - pkgs = _badge_pkgs_new(&err, writable_pkg, caller, NULL); - if (!pkgs) { - ERR("Failed to _badge_pkgs_new [%d]", err); - return err; - } - - INFO("pkgs : %s", pkgs); - - badge = _badge_new(pkgname, pkgs, &err); - if (!badge) { - ERR("Failed to _badge_new [%d]", err); - free(pkgs); - return err; - } - free(pkgs); - - err = _badge_insert(badge, uid); - if (err != BADGE_ERROR_NONE) { - ERR("Failed to _badge_insert [%d]", err); - _badge_free(badge); - return err; - } - - _badge_free(badge); - - return BADGE_ERROR_NONE; -} - -EXPORT_API -int badge_db_delete(const char *pkgname, const char *caller, uid_t uid, pid_t pid) -{ - return _badge_remove(caller, pkgname, uid, pid); -} - -EXPORT_API -int badge_db_delete_by_pkgname(const char *pkgname, uid_t uid) -{ - return _badge_remove_by_pkgname(pkgname, uid); -} - -EXPORT_API -int badge_db_set_count(const char *pkgname, const char *caller, unsigned int count, uid_t uid, pid_t pid) -{ - return _badge_set_count(caller, pkgname, count, uid, pid); -} - -EXPORT_API -int badge_db_get_count(const char *pkgname, unsigned int *count, uid_t uid) -{ - return _badge_get_count(pkgname, count, uid); -} - -EXPORT_API -int badge_db_set_display_option(const char *pkgname, unsigned int is_display, uid_t uid) -{ - return _badge_set_display(pkgname, is_display, uid); -} - -EXPORT_API -int badge_db_get_display_option(const char *pkgname, unsigned int *is_display, uid_t uid) -{ - return _badge_get_display(pkgname, is_display, uid); -} - -EXPORT_API -int badge_db_exec(sqlite3 *db, const char *query, int *num_changes) -{ - int ret; - sqlite3_stmt *stmt = NULL; - - if (db == NULL || query == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL); - if (ret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", ret, - sqlite3_errmsg(db)); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - if (stmt != NULL) { - ret = sqlite3_step(stmt); - if (ret == SQLITE_OK || ret == SQLITE_DONE) { - if (num_changes != NULL) - *num_changes = sqlite3_changes(db); - - sqlite3_finalize(stmt); - } else { - /* LCOV_EXCL_START */ - ERR("sqlite3_step failed [%d][%s]", ret, - sqlite3_errmsg(db)); - sqlite3_finalize(stmt); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - } else { - return BADGE_ERROR_FROM_DB; - } - - return BADGE_ERROR_NONE; -} diff --git a/src/badge_error.c b/src/badge_error.c deleted file mode 100644 index 7ffe35e..0000000 --- a/src/badge_error.c +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge_error.h" - -static const GDBusErrorEntry dbus_error_entries[] = { - {BADGE_ERROR_INVALID_PARAMETER, "org.freedesktop.Badge.Error.INVALID_PARAMETER"}, - {BADGE_ERROR_OUT_OF_MEMORY, "org.freedesktop.Badge.Error.OUT_OF_MEMORY"}, - {BADGE_ERROR_IO_ERROR, "org.freedesktop.Badge.Error.IO_ERROR"}, - {BADGE_ERROR_PERMISSION_DENIED, "org.freedesktop.Badge.Error.PERMISSION_DENIED"}, - {BADGE_ERROR_FROM_DB, "org.freedesktop.Badge.Error.FROM_DB"}, - {BADGE_ERROR_ALREADY_EXIST, "org.freedesktop.Badge.Error.ALREADY_EXIST"}, - {BADGE_ERROR_FROM_DBUS, "org.freedesktop.Badge.Error.FROM_DBUS"}, - {BADGE_ERROR_NOT_EXIST, "org.freedesktop.Badge.Error.NOT_EXIST"}, - {BADGE_ERROR_SERVICE_NOT_READY, "org.freedesktop.Badge.Error.SERVICE_NOT_READY"}, - {BADGE_ERROR_INVALID_PACKAGE, "org.freedesktop.Badge.Error.INVALID_PACKAGE"}, -}; - -#define BADGE_ERROR_QUARK "badge-error-quark" - -EXPORT_API GQuark badge_error_quark(void) -{ - static volatile gsize quark_volatile = 0; - static char *domain_name = NULL; - - /* This is for preventing crash when notification api is used in ui-gadget */ - /* ui-gadget libraries can be unloaded when it is needed and the static string */ - /* parameter to g_dbus_error_register_error_domain may cause crash. */ - GQuark quark = g_quark_try_string(BADGE_ERROR_QUARK); - - if (quark == 0) { - if (domain_name == NULL) - domain_name = strdup(BADGE_ERROR_QUARK); - } else { - domain_name = BADGE_ERROR_QUARK; - } - - g_dbus_error_register_error_domain(domain_name, - &quark_volatile, - dbus_error_entries, - G_N_ELEMENTS(dbus_error_entries)); - return (GQuark) quark_volatile; -} - diff --git a/src/badge_internal.c b/src/badge_internal.c deleted file mode 100644 index b9c77e4..0000000 --- a/src/badge_internal.c +++ /dev/null @@ -1,1689 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge_log.h" -#include "badge_error.h" -#include "badge_internal.h" -#include "badge_ipc.h" -#include "badge_db.h" -#include "badge_private.h" -#include "badge_setting_service.h" - -#define BADGE_PKGNAME_LEN 512 - -#define BADGE_CHANGED_NOTI "badge_changed" - -struct _badge_h { - char *pkgname; - char *writable_pkgs; -}; - -struct _badge_cb_data { - badge_change_cb callback; - void *data; -}; - -static GHashTable *_badge_cb_hash = NULL; - -static inline unsigned long _get_max_len(void) -{ - unsigned long max = 0; - long path_max_len = 4096; - -#ifdef _PC_PATH_MAX - max = (pathconf("/", _PC_PATH_MAX) < 1 ? path_max_len - : pathconf("/", _PC_PATH_MAX)); -#else /* _PC_PATH_MAX */ - max = path_max_len; -#endif /* _PC_PATH_MAX */ - return max; -} - -char *_badge_get_pkgname_by_pid(void) -{ - char *pkgname = NULL; - int pid = 0; - int ret = AUL_R_OK; - int fd = 0; - unsigned long max = 0; - - pid = getpid(); - max = _get_max_len(); - pkgname = malloc(max); - if (!pkgname) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc memory"); - return NULL; - /* LCOV_EXCL_STOP */ - } - memset(pkgname, 0x00, max); - - ret = aul_app_get_pkgname_bypid(pid, pkgname, max); - if (ret != AUL_R_OK) { - fd = open("/proc/self/cmdline", O_RDONLY); - if (fd < 0) { - /* LCOV_EXCL_START */ - free(pkgname); - return NULL; - /* LCOV_EXCL_STOP */ - } - - ret = read(fd, pkgname, max - 1); - if (ret <= 0) { - /* LCOV_EXCL_START */ - close(fd); - free(pkgname); - return NULL; - /* LCOV_EXCL_STOP */ - } - - close(fd); - } - - if (pkgname[0] == '\0') { - /* LCOV_EXCL_START */ - free(pkgname); - return NULL; - /* LCOV_EXCL_STOP */ - } else { - return pkgname; - } -} - -static int _badge_check_data_inserted(const char *pkgname, - sqlite3 *db, uid_t uid) -{ - sqlite3_stmt *stmt = NULL; - int count = 0; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - int sqlret; - - if (!pkgname || !db) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \ - "pkgname = %Q AND uid = %d", - BADGE_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - return BADGE_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto free_and_return; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - count = sqlite3_column_int(stmt, 0); - else - count = 0; - - DBG("[%s], DB search result[%d]", sqlbuf, count); - - if (count > 0) - result = BADGE_ERROR_ALREADY_EXIST; - else - result = BADGE_ERROR_NOT_EXIST; - -free_and_return: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - return result; -} - -static int _badge_check_option_inserted(const char *pkgname, - sqlite3 *db, uid_t uid) -{ - sqlite3_stmt *stmt = NULL; - int count = 0; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - int sqlret; - - if (!pkgname || !db) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \ - "pkgname = %Q AND uid = %d", - BADGE_OPTION_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - return BADGE_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto free_and_return; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - count = sqlite3_column_int(stmt, 0); - else - count = 0; - - DBG("[%s], DB search result[%d]", sqlbuf, count); - - if (count > 0) - result = BADGE_ERROR_ALREADY_EXIST; - else - result = BADGE_ERROR_NOT_EXIST; - -free_and_return: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - return result; -} - -static int _is_same_certinfo(const char *caller, const char *pkgname) -{ - int ret = PACKAGE_MANAGER_ERROR_NONE; - package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH; - - if (!caller || !pkgname) - return 0; - - ret = package_manager_compare_package_cert_info(pkgname, caller, &compare_result); - if (ret == PACKAGE_MANAGER_ERROR_NONE && - compare_result == PACKAGE_MANAGER_COMPARE_MATCH) - return 1; - - return 0; -} - -static bool __check_label(pid_t pid) -{ -#define SMACK_LABEL_LEN 255 -#define COMPARE_LABEL_COUNT 3 - - bool ret = false; - int i; - ssize_t len; - char *label = NULL; - char check_label[COMPARE_LABEL_COUNT][SMACK_LABEL_LEN+1] = { "System", "System::Privileged", "User"}; - - len = smack_new_label_from_process(pid, &label); - if (len < 0 || label == NULL) - goto out; - - for (i = 0; i < COMPARE_LABEL_COUNT; i++) { - if (g_strcmp0(label, check_label[i]) == 0) { - ret = true; - goto out; - } - } - -out: - if (label) - free(label); - - return ret; -} - -static int _badge_check_writable(const char *caller, - const char *pkgname, sqlite3 *db, uid_t uid, pid_t pid) -{ - sqlite3_stmt *stmt = NULL; - int count = 0; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - int sqlret; - - if (!db || !caller || !pkgname) - return BADGE_ERROR_INVALID_PARAMETER; - - if (g_strcmp0(caller, pkgname) == 0) - return BADGE_ERROR_NONE; - - if (__check_label(pid) == true) - return BADGE_ERROR_NONE; - - /* LCOV_EXCL_START */ - if (_is_same_certinfo(caller, pkgname) == 1) - return BADGE_ERROR_NONE; - - sqlbuf = sqlite3_mprintf("SELECT COUNT(*) FROM %q WHERE " \ - "pkgname = %Q AND writable_pkgs LIKE '%%%q%%'" \ - "AND uid = %d", - BADGE_TABLE_NAME, - pkgname, caller, uid); - if (!sqlbuf) { - ERR("Failed to alloc query"); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto free_and_return; - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - count = sqlite3_column_int(stmt, 0); - else - count = 0; - - DBG("[%s], DB search result[%d]", sqlbuf, count); - - if (count <= 0) - result = BADGE_ERROR_PERMISSION_DENIED; - -free_and_return: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - return result; - /* LCOV_EXCL_STOP */ -} - -int _badge_is_existing(const char *pkgname, bool *existing, uid_t uid) -{ - sqlite3 *db = NULL; - int sqlret; - int result = BADGE_ERROR_NONE; - - if (!pkgname || !existing) { - /* LCOV_EXCL_START */ - ERR("pkgname : %s, existing : %p", pkgname, existing); - return BADGE_ERROR_INVALID_PARAMETER; - /* LCOV_EXCL_STOP */ - } - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - if (sqlret == SQLITE_PERM) - return BADGE_ERROR_PERMISSION_DENIED; - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - result = _badge_check_data_inserted(pkgname, db, uid); - if (result == BADGE_ERROR_ALREADY_EXIST) { - *existing = TRUE; - result = BADGE_ERROR_NONE; - } else if (result == BADGE_ERROR_NOT_EXIST) { - *existing = FALSE; - result = BADGE_ERROR_NONE; - } - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_get_list(GList **badge_list, uid_t uid) -{ - sqlite3 *db = NULL; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - sqlite3_stmt *stmt = NULL; - int sqlret; - const char *pkg; - unsigned int badge_count; - badge_info_s *badge_info; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - sqlbuf = sqlite3_mprintf("SELECT pkgname, badge FROM %q WHERE uid = %d", - BADGE_TABLE_NAME, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto free_and_return; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto free_and_return; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_DONE) { - INFO("badge db has no data"); - result = BADGE_ERROR_NOT_EXIST; - goto free_and_return; - } else if (sqlret != SQLITE_ROW) { - ERR("Failed to sqlite3_step [%d]", sqlret); - result = BADGE_ERROR_FROM_DB; - goto free_and_return; - } - - do { - pkg = (const char *)sqlite3_column_text(stmt, 0); - badge_count = (unsigned int)sqlite3_column_int(stmt, 1); - if (pkg) { - badge_info = (badge_info_s *)calloc(sizeof(badge_info_s), 1); - if (badge_info == NULL) { - /* LCOV_EXCL_START */ - ERR("alloc badge_info failed"); - result = BADGE_ERROR_OUT_OF_MEMORY; - break; - /* LCOV_EXCL_STOP */ - } - badge_info->pkg = strdup(pkg); - badge_info->badge_count = badge_count; - *badge_list = g_list_append(*badge_list, badge_info); - } else { - /* LCOV_EXCL_START */ - ERR("db has invaild data"); - result = BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - } while (sqlite3_step(stmt) == SQLITE_ROW); - -free_and_return: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_insert(badge_h *badge, uid_t uid) -{ - sqlite3 *db = NULL; - int sqlret; - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - bool is_existed = false; - - if (!badge || !badge->pkgname || !badge->writable_pkgs) - return BADGE_ERROR_INVALID_PARAMETER; - - ret = badge_setting_is_existed_appid(badge->pkgname, &is_existed, uid); - if (ret == BADGE_ERROR_NONE && is_existed == false) { - result = BADGE_ERROR_INVALID_PACKAGE; - goto return_close_db; - } else if (ret != BADGE_ERROR_NONE) { - ERR("Failed to check existed appid [%d]", ret); - result = ret; - goto return_close_db; - } - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%s][%d]", BADGE_DB_PATH, sqlret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - /* Check pkgname & id */ - ret = _badge_check_data_inserted(badge->pkgname, db, uid); - if (ret != BADGE_ERROR_NOT_EXIST) { - /* LCOV_EXCL_START */ - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - sqlbuf = sqlite3_mprintf("INSERT INTO %q " \ - "(pkgname, writable_pkgs, uid) VALUES (%Q, %Q, %d);", - BADGE_TABLE_NAME, - badge->pkgname, badge->writable_pkgs, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to insert badge[%s], err[%d]", - badge->pkgname, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - /* inserting badge options */ - ret = _badge_check_option_inserted(badge->pkgname, db, uid); - if (ret != BADGE_ERROR_NOT_EXIST) { - result = ret; - goto return_close_db; - } - - sqlite3_free(sqlbuf); - - sqlbuf = sqlite3_mprintf("INSERT INTO %q " \ - "(pkgname, uid) VALUES (%Q, %d);", - BADGE_OPTION_TABLE_NAME, - badge->pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to insert badge option[%s], err[%d]", - badge->pkgname, sqlret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_remove(const char *caller, const char *pkgname, uid_t uid, pid_t pid) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - int sqlret; - char *sqlbuf = NULL; - - if (!caller || !pkgname) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - ret = _badge_check_data_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - ret = _badge_check_writable(caller, pkgname, db, uid, pid); - if (ret != BADGE_ERROR_NONE) { - result = ret; - goto return_close_db; - } - - sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d", - BADGE_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - ERR("Failed to remove badge[%s], err[%d]", - pkgname, ret); - result = ret; - goto return_close_db; - } - - /* treating option table */ - ret = _badge_check_option_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - sqlite3_free(sqlbuf); - - sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d", - BADGE_OPTION_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to remove badge option[%s], err[%d]", - pkgname, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -static int _badge_remove_by_appid(const char *appid, uid_t uid, sqlite3 *db) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - char *sqlbuf = NULL; - - ret = _badge_check_data_inserted(appid, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d", - BADGE_TABLE_NAME, appid, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to remove badge[%s], err[%d]", appid, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - /* treating option table */ - ret = _badge_check_option_inserted(appid, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - sqlite3_free(sqlbuf); - - sqlbuf = sqlite3_mprintf("DELETE FROM %q WHERE pkgname = %Q AND uid = %d", - BADGE_OPTION_TABLE_NAME, appid, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to remove badge option[%s], err[%d]", - appid, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - return result; -} - -static bool _get_table_field_data_string(char **table, char **buf, int ucs2, int index) -{ - bool ret = false; - int sLen = 0; - char *pTemp; - - if (table == NULL || buf == NULL || index < 0) { - /* LCOV_EXCL_START */ - ERR("table[%p], buf[%p], index[%d]", table, buf, index); - return false; - /* LCOV_EXCL_STOP */ - } - - pTemp = table[index]; - if (pTemp == NULL) { - *buf = NULL; /* LCOV_EXCL_LINE */ - } else { - sLen = strlen(pTemp); - if (sLen) { - *buf = (char *)malloc(sLen + 1); - if (*buf == NULL) { - ERR("malloc is failed"); /* LCOV_EXCL_LINE */ - goto out; - } - memset(*buf, 0, sLen + 1); - strncpy(*buf, pTemp, sLen + 1); - } else { - *buf = NULL; /* LCOV_EXCL_LINE */ - } - } - - ret = true; - -out: - return ret; -} - -int _badge_remove_by_pkgname(const char *pkgname, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - int row_count = 0; - int col_count = 0; - int col_index = 0; - int index; - char *sql_query = NULL; - char **query_result = NULL; - char *appid = NULL; - sqlite3 *db = NULL; - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - } - - sql_query = sqlite3_mprintf("SELECT appid FROM %s WHERE pkgname = %Q" \ - "AND (uid = %d OR uid = %d) ORDER BY uid DESC;", - BADGE_SETTING_DB_TABLE, pkgname, uid, - tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)); - if (!sql_query) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL); - if (sql_ret != SQLITE_OK && sql_ret != -1) { - /* LCOV_EXCL_START */ - ERR("sqlite3_get_table failed [%d][%s]", sql_ret, - sqlite3_errmsg(db)); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - if (!row_count) { - DBG("No setting found for [%s]", pkgname); - ret = BADGE_ERROR_NOT_EXIST; - goto out; - } - - col_index = col_count; - - for (index = 0; index < row_count; index++) { - _get_table_field_data_string(query_result, &appid, 1, col_index++); - if (appid) { - _badge_remove_by_appid(appid, uid, db); - free(appid); - appid = NULL; - } - } - -out: - if (query_result) - sqlite3_free_table(query_result); - if (sql_query) - sqlite3_free(sql_query); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -int _badge_set_count(const char *caller, const char *pkgname, - unsigned int count, uid_t uid, pid_t pid) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - int sqlret; - - if (!caller || !pkgname) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - ret = _badge_check_data_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - ret = _badge_check_writable(caller, pkgname, db, uid, pid); - if (ret != BADGE_ERROR_NONE) { - result = ret; - goto return_close_db; - } - - sqlbuf = sqlite3_mprintf("UPDATE %q SET badge = %d " \ - "WHERE pkgname = %Q AND uid = %d", - BADGE_TABLE_NAME, count, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to set badge[%s] count[%d], err[%d]", - pkgname, count, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_get_count(const char *pkgname, unsigned int *count, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - sqlite3_stmt *stmt = NULL; - int sqlret; - - if (!pkgname || !count) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - if (sqlret == SQLITE_PERM) - return BADGE_ERROR_PERMISSION_DENIED; - else - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - ret = _badge_check_data_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - sqlbuf = sqlite3_mprintf("SELECT badge FROM %q " \ - "WHERE pkgname = %Q AND uid = %d", - BADGE_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - *count = (unsigned int)sqlite3_column_int(stmt, 0); - else - *count = (unsigned int)0; - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_set_display(const char *pkgname, unsigned int is_display, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - int sqlret; - - if (!pkgname) - return BADGE_ERROR_INVALID_PARAMETER; - - if (is_display != 0 && is_display != 1) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - ret = _badge_check_data_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - result = ret; - goto return_close_db; - } - - ret = _badge_check_option_inserted(pkgname, db, uid); - if (ret == BADGE_ERROR_ALREADY_EXIST) { - sqlbuf = sqlite3_mprintf("UPDATE %q SET display = %d " \ - "WHERE pkgname = %Q AND uid = %d", - BADGE_OPTION_TABLE_NAME, is_display, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to set badge[%s] option[%d], err[%d]", - pkgname, is_display, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - } else if (ret == BADGE_ERROR_NOT_EXIST) { - sqlbuf = sqlite3_mprintf("INSERT INTO %q " \ - "(pkgname, display, uid) VALUES (%Q, %d, %d);", - BADGE_OPTION_TABLE_NAME, - pkgname, is_display, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Failed to set badge[%s] option[%d], err[%d]", - pkgname, is_display, ret); - result = ret; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - } else { - result = ret; - goto return_close_db; - } - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -int _badge_get_display(const char *pkgname, unsigned int *is_display, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int result = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - sqlite3_stmt *stmt = NULL; - int sqlret; - - if (!pkgname || !is_display) - return BADGE_ERROR_INVALID_PARAMETER; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - if (sqlret == SQLITE_PERM) - return BADGE_ERROR_PERMISSION_DENIED; - else - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - ret = _badge_check_option_inserted(pkgname, db, uid); - if (ret != BADGE_ERROR_ALREADY_EXIST) { - if (ret == BADGE_ERROR_NOT_EXIST) - *is_display = 1; - - result = ret; - goto return_close_db; - } - - sqlbuf = sqlite3_mprintf("SELECT display FROM %q " \ - "WHERE pkgname = %Q AND uid = %d", - BADGE_OPTION_TABLE_NAME, pkgname, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - result = BADGE_ERROR_OUT_OF_MEMORY; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("Failed to prepare [%d][%s]", sqlret, sqlite3_errmsg(db)); - result = BADGE_ERROR_FROM_DB; - goto return_close_db; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - *is_display = (unsigned int)sqlite3_column_int(stmt, 0); - else - *is_display = (unsigned int)1; - -return_close_db: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (stmt) - sqlite3_finalize(stmt); - - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); /* LCOV_EXCL_LINE */ - - return result; -} - -void badge_changed_cb_call(unsigned int action, const char *pkgname, - unsigned int count, uid_t uid) -{ - GList *badge_cb_list = NULL; - struct _badge_cb_data *bd = NULL; - - DBG("call badge_change_cb"); - - if (_badge_cb_hash == NULL) - return; - - badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid)); - - if (badge_cb_list == NULL) { - ERR("invalid data"); - return; - } - - badge_cb_list = g_list_first(badge_cb_list); - - for (; badge_cb_list != NULL; badge_cb_list = badge_cb_list->next) { - bd = badge_cb_list->data; - - if (bd != NULL && bd->callback != NULL) { - DBG("call badge_change_cb : action %d, pkgname %s, count %d", - action, pkgname, count); - bd->callback(action, pkgname, count, bd->data); - } - } -} - -static int _badge_changed_monitor_init(uid_t uid) -{ - return badge_ipc_monitor_init(uid); -} - -static void _badge_chanaged_monitor_fini(void) -{ - badge_ipc_monitor_fini(); -} - -static gint _badge_data_compare(gconstpointer a, gconstpointer b) -{ - const struct _badge_cb_data *bd = NULL; - - if (!a) - return -1; - bd = (struct _badge_cb_data *)a; - - if (bd->callback == b) - return 0; - - return 1; -} - -static struct _badge_cb_data *__malloc_badge_cb_data(badge_change_cb callback, void *data) -{ - struct _badge_cb_data *bd = NULL; - - bd = (struct _badge_cb_data *)malloc(sizeof(struct _badge_cb_data)); - if (bd == NULL) { - /* LCOV_EXCL_START */ - ERR("Failed malloc badge_cb_data"); - return NULL; - /* LCOV_EXCL_STOP */ - } - - bd->callback = callback; - bd->data = data; - - return bd; -} - -int _badge_free(badge_h *badge) -{ - if (!badge) - return BADGE_ERROR_INVALID_PARAMETER; - - if (badge->pkgname) - free(badge->pkgname); - - if (badge->writable_pkgs) - free(badge->writable_pkgs); - - free(badge); - - return BADGE_ERROR_NONE; -} - -badge_h *_badge_new(const char *pkgname, const char *writable_pkgs, - int *err) -{ - badge_h *badge = NULL; - - if (!pkgname || !writable_pkgs) { - ERR("Invalid parameters"); - if (err) - *err = BADGE_ERROR_INVALID_PARAMETER; - return NULL; - } - - badge = (badge_h *)malloc(sizeof(struct _badge_h)); - if (!badge) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc handle"); - if (err) - *err = BADGE_ERROR_OUT_OF_MEMORY; - return NULL; - /* LCOV_EXCL_STOP */ - } - - badge->pkgname = strdup(pkgname); - badge->writable_pkgs = strdup(writable_pkgs); - if (err) - *err = BADGE_ERROR_NONE; - - return badge; -} - -char *_badge_pkgs_new(int *err, const char *pkg1, ...) -{ - char *caller_pkgname = NULL; - char *s = NULL; - char *result = NULL; - char *ptr = NULL; - gsize length; - va_list args; - char *new_pkgs = NULL; - - if (err) - *err = BADGE_ERROR_NONE; - - caller_pkgname = _badge_get_pkgname_by_pid(); - if (!caller_pkgname) { - ERR("Failed to get caller pkgname"); - if (err) - *err = BADGE_ERROR_PERMISSION_DENIED; - return NULL; - } - - if (!pkg1) { - WARN("pkg1 is NULL"); - return caller_pkgname; - } - - length = strlen(pkg1); - va_start(args, pkg1); - s = va_arg(args, char *); - while (s) { - length += strlen(s); - s = va_arg(args, char *); - } - va_end(args); - - if (length <= 0) { - WARN("length is %zu", length); - return caller_pkgname; - } - - result = g_new0(char, length + 1); /* 1 for null terminate */ - if (!result) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc memory"); - if (err) - *err = BADGE_ERROR_OUT_OF_MEMORY; - free(caller_pkgname); - return NULL; - /* LCOV_EXCL_STOP */ - } - - ptr = result; - ptr = g_stpcpy(ptr, pkg1); - va_start(args, pkg1); - s = va_arg(args, char *); - while (s) { - ptr = g_stpcpy(ptr, s); - s = va_arg(args, char *); - } - va_end(args); - - if (g_strstr_len(result, -1, caller_pkgname) == NULL) { - new_pkgs = g_strdup_printf("%s%s", caller_pkgname, result); - if (!new_pkgs) { - ERR("Failed to alloc memory"); - if (err) - *err = BADGE_ERROR_OUT_OF_MEMORY; - - free(result); - free(caller_pkgname); - return NULL; - } - free(result); - result = new_pkgs; - } - - free(caller_pkgname); - - return result; -} - -EXPORT_API -int badge_create_for_uid(const char *pkgname, const char *writable_pkg, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int err = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - return BADGE_ERROR_PERMISSION_DENIED; - } - - err = badge_ipc_request_insert(pkgname, writable_pkg, caller, uid); - - free(caller); - return err; -} - -EXPORT_API -int badge_new_for_uid(const char *writable_app_id, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int err = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - return BADGE_ERROR_PERMISSION_DENIED; - } - - err = badge_ipc_request_insert(caller, writable_app_id, caller, uid); - - free(caller); - return err; -} - -int badge_new_for_for_uid(const char *badge_app_id, const char *writable_app_id, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int err = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - return BADGE_ERROR_PERMISSION_DENIED; - } - - if (badge_app_id == NULL) { - badge_app_id = caller; - } else { - int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE; - package_manager_compare_result_type_e compare_result = - PACKAGE_MANAGER_COMPARE_MISMATCH; - - pkgmgr_ret = package_manager_compare_app_cert_info(badge_app_id, - caller, &compare_result); - - if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE || - compare_result != PACKAGE_MANAGER_COMPARE_MATCH) { - err = BADGE_ERROR_INVALID_PACKAGE; - goto out; - } - } - - err = badge_ipc_request_insert(badge_app_id, writable_app_id, caller, uid); -out: - if (caller) - free(caller); - return err; -} - -EXPORT_API -int badge_new_for(const char *badge_app_id, const char *writable_app_id) -{ - CHECK_BADGE_FEATURE(); - if (writable_app_id == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_new_for_for_uid(badge_app_id, writable_app_id, getuid()); -} - -EXPORT_API -int badge_add_for_uid(const char *badge_app_id, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int err = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - return BADGE_ERROR_PERMISSION_DENIED; - } - - if (badge_app_id == NULL) { - badge_app_id = caller; - } else { - int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE; - package_manager_compare_result_type_e compare_result = PACKAGE_MANAGER_COMPARE_MISMATCH; - - pkgmgr_ret = package_manager_compare_app_cert_info(badge_app_id, caller, &compare_result); - - if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE || compare_result != PACKAGE_MANAGER_COMPARE_MATCH) { - err = BADGE_ERROR_INVALID_PACKAGE; - goto out; - } - } - - err = badge_ipc_request_insert(badge_app_id, caller, caller, uid); - -out: - if (caller) - free(caller); - return err; -} - -EXPORT_API -int badge_remove_for_uid(const char *app_id, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int result = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - result = BADGE_ERROR_PERMISSION_DENIED; - goto out; - } - - result = badge_ipc_request_delete(app_id, caller, uid); - -out: - if (caller) - free(caller); - return result; -} - -EXPORT_API -int badge_is_existing_for_uid(const char *app_id, bool *existing, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - return badge_ipc_request_is_existing(app_id, existing, uid); -} - -EXPORT_API -int badge_foreach_for_uid(badge_foreach_cb callback, void *user_data, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - int result = BADGE_ERROR_NONE; - - result = badge_ipc_request_get_list(callback, user_data, uid); - if (result == BADGE_ERROR_IO_ERROR) - result = BADGE_ERROR_FROM_DB; - return result; -} - -EXPORT_API -int badge_set_count_for_uid(const char *app_id, unsigned int count, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int result = BADGE_ERROR_NONE; - - DBG("app_id %s, count %d", app_id, count); - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - result = BADGE_ERROR_PERMISSION_DENIED; - goto out; - } - - result = badge_ipc_request_set_count(app_id, caller, count, uid); -out: - if (caller) - free(caller); - return result; -} - -EXPORT_API -int badge_get_count_for_uid(const char *app_id, unsigned int *count, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - int result = BADGE_ERROR_NONE; - - result = badge_ipc_request_get_count(app_id, count, uid); - if (result == BADGE_ERROR_IO_ERROR) - result = BADGE_ERROR_FROM_DB; - - return result; -} - -EXPORT_API -int badge_set_display_for_uid(const char *app_id, unsigned int is_display, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - char *caller = NULL; - int result = BADGE_ERROR_NONE; - - caller = _badge_get_pkgname_by_pid(); - if (!caller) { - ERR("Failed to get caller pkgname"); - result = BADGE_ERROR_PERMISSION_DENIED; - goto out; - } - - result = badge_ipc_request_set_display(app_id, caller, is_display, uid); - -out: - if (caller) - free(caller); - return result; -} - -EXPORT_API -int badge_get_display_for_uid(const char *app_id, unsigned int *is_display, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - int result = BADGE_ERROR_NONE; - - result = badge_ipc_request_get_display(app_id, is_display, uid); - if (result == BADGE_ERROR_IO_ERROR) - result = BADGE_ERROR_FROM_DB; - - return result; -} - -EXPORT_API -int badge_register_changed_cb_for_uid(badge_change_cb callback, void *data, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - struct _badge_cb_data *bd = NULL; - GList *badge_cb_list = NULL; - GList *badge_found_list = NULL; - int ret; - - if (_badge_cb_hash == NULL) - _badge_cb_hash = g_hash_table_new(g_direct_hash, g_direct_equal); - - badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid)); - - if (badge_cb_list == NULL) { - bd = __malloc_badge_cb_data(callback, data); - if (!bd) - return BADGE_ERROR_OUT_OF_MEMORY; - - badge_cb_list = g_list_append(badge_cb_list, bd); - g_hash_table_insert(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list); - } else { - badge_found_list = g_list_find_custom(g_list_first(badge_cb_list), (gconstpointer)callback, - (GCompareFunc)_badge_data_compare); - if (badge_found_list) { - bd = g_list_nth_data(badge_found_list, 0); - bd->data = data; - } else { - bd = __malloc_badge_cb_data(callback, data); - if (!bd) - return BADGE_ERROR_OUT_OF_MEMORY; - badge_cb_list = g_list_append(badge_cb_list, bd); - } - } - - ret = _badge_changed_monitor_init(uid); - if (ret == BADGE_ERROR_NONE) { - ret = badge_ipc_init_badge(uid); - if (ret != BADGE_ERROR_NONE && ret != BADGE_ERROR_NOT_EXIST) { - badge_unregister_changed_cb_for_uid(callback, uid); - return BADGE_ERROR_IO_ERROR; - } - } else { - /* LCOV_EXCL_START */ - ERR("badge_ipc_monitor_init err [%d]", ret); - badge_unregister_changed_cb_for_uid(callback, uid); - return ret; - /* LCOV_EXCL_STOP */ - } - return BADGE_ERROR_NONE; -} - -EXPORT_API -int badge_unregister_changed_cb_for_uid(badge_change_cb callback, uid_t uid) -{ - CHECK_BADGE_FEATURE(); - GList *badge_cb_list = NULL; - GList *badge_delete_list = NULL; - struct _badge_cb_data *bd = NULL; - - if (_badge_cb_hash == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - badge_cb_list = (GList *)g_hash_table_lookup(_badge_cb_hash, GUINT_TO_POINTER(uid)); - - if (badge_cb_list == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - badge_delete_list = g_list_find_custom(g_list_first(badge_cb_list), (gconstpointer)callback, - (GCompareFunc)_badge_data_compare); - - if (badge_delete_list) { - bd = g_list_nth_data(badge_delete_list, 0); - badge_cb_list = g_list_delete_link(badge_cb_list, badge_delete_list); - free(bd); - } else { - return BADGE_ERROR_INVALID_PARAMETER; - } - - if (badge_cb_list == NULL) - g_hash_table_steal(_badge_cb_hash, GUINT_TO_POINTER(uid)); - else - g_hash_table_replace(_badge_cb_hash, GUINT_TO_POINTER(uid), badge_cb_list); - - if (g_hash_table_size(_badge_cb_hash) == 0) - _badge_chanaged_monitor_fini(); - - return BADGE_ERROR_NONE; -} - -EXPORT_API -int badge_is_service_ready(void) -{ - CHECK_BADGE_FEATURE(); - return badge_ipc_is_master_ready(); -} - -EXPORT_API -int badge_add_deferred_task( - void (*badge_add_deferred_task)(void *data), void *user_data) -{ - CHECK_BADGE_FEATURE(); - return badge_ipc_add_deferred_task(badge_add_deferred_task, user_data); -} - -EXPORT_API -int badge_del_deferred_task( - void (*badge_add_deferred_task)(void *data)) -{ - CHECK_BADGE_FEATURE(); - return badge_ipc_del_deferred_task(badge_add_deferred_task); -} - -EXPORT_API -int badge_is_existing(const char *app_id, bool *existing) -{ - CHECK_BADGE_FEATURE(); - if (app_id == NULL || existing == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_is_existing_for_uid(app_id, existing, getuid()); -} - -EXPORT_API -int badge_create(const char *pkgname, const char *writable_pkg) -{ - CHECK_BADGE_FEATURE(); - if (pkgname == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - return badge_create_for_uid(pkgname, writable_pkg, getuid()); -} diff --git a/src/badge_ipc.c b/src/badge_ipc.c deleted file mode 100644 index 372753e..0000000 --- a/src/badge_ipc.c +++ /dev/null @@ -1,865 +0,0 @@ -/* - * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge.h" -#include "badge_log.h" -#include "badge_error.h" -#include "badge_internal.h" -#include "badge_ipc.h" -#include "badge_setting.h" - -#define PROVIDER_BUS_NAME "org.tizen.data_provider_service" -#define PROVIDER_OBJECT_PATH "/org/tizen/data_provider_service" -#define PROVIDER_BADGE_INTERFACE_NAME "org.tizen.data_provider_badge_service" - -#define DBUS_SERVICE_DBUS "org.freedesktop.DBus" -#define DBUS_PATH_DBUS "/org/freedesktop/DBus" -#define DBUS_INTERFACE_DBUS "org.freedesktop.DBus" - -typedef struct _task_list task_list; -struct _task_list { - task_list *prev; - task_list *next; - - void (*task_cb)(void *data); - void *data; -}; -static task_list *g_task_list; - -static GDBusConnection *_gdbus_conn = NULL; -static int monitor_id = 0; -static int provider_monitor_id = 0; -static int is_master_started = 0; - -static void _do_deferred_task(void); - -int badge_ipc_is_master_ready(void) -{ - GVariant *result = NULL; - GError *err = NULL; - gboolean name_exist; - - result = g_dbus_connection_call_sync( - _gdbus_conn, - DBUS_SERVICE_DBUS, - DBUS_PATH_DBUS, - DBUS_INTERFACE_DBUS, - "NameHasOwner", - g_variant_new("(s)", PROVIDER_BUS_NAME), - G_VARIANT_TYPE("(b)"), - G_DBUS_CALL_FLAGS_NONE, - -1, - NULL, - &err); - - if (err || (result == NULL)) { - /* LCOV_EXCL_START */ - if (err) { - ERR("No reply. error [%s]", err->message); - g_error_free(err); - } - is_master_started = 0; - /* LCOV_EXCL_STOP */ - } else { - g_variant_get(result, "(b)", &name_exist); - - if (!name_exist) { - /* LCOV_EXCL_START */ - ERR("Name not exist [%s]", PROVIDER_BUS_NAME); - ERR("the master has been stopped"); - is_master_started = 0; - /* LCOV_EXCL_STOP */ - } else { - DBG("the master has been started"); - is_master_started = 1; - } - } - - if (result) - g_variant_unref(result); - - return is_master_started; -} - -int badge_ipc_add_deferred_task( - void (*badge_add_deferred_task)(void *data), - void *user_data) -{ - task_list *list; - task_list *list_new; - - list_new = (task_list *) malloc(sizeof(task_list)); - if (list_new == NULL) - return BADGE_ERROR_OUT_OF_MEMORY; - - list_new->next = NULL; - list_new->prev = NULL; - - list_new->task_cb = badge_add_deferred_task; - list_new->data = user_data; - - if (g_task_list == NULL) { - g_task_list = list_new; - } else { - list = g_task_list; - - while (list->next != NULL) - list = list->next; - - list->next = list_new; - list_new->prev = list; - } - return BADGE_ERROR_NONE; -} - -int badge_ipc_del_deferred_task( - void (*badge_add_deferred_task)(void *data)) -{ - task_list *list_del; - task_list *list_prev; - task_list *list_next; - - list_del = g_task_list; - - if (list_del == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - while (list_del->prev != NULL) - list_del = list_del->prev; - - do { - if (list_del->task_cb == badge_add_deferred_task) { - list_prev = list_del->prev; - list_next = list_del->next; - - if (list_prev == NULL) - g_task_list = list_next; - else - list_prev->next = list_next; - - if (list_next == NULL) { - if (list_prev != NULL) - list_prev->next = NULL; - - } else { - list_next->prev = list_prev; - } - - free(list_del); - return BADGE_ERROR_NONE; - } - list_del = list_del->next; - } while (list_del != NULL); - - return BADGE_ERROR_INVALID_PARAMETER; -} - -/* LCOV_EXCL_START */ -static void _do_deferred_task(void) -{ - task_list *list_do; - task_list *list_temp; - - if (g_task_list == NULL) - return; - - list_do = g_task_list; - g_task_list = NULL; - - while (list_do->prev != NULL) - list_do = list_do->prev; - - while (list_do != NULL) { - if (list_do->task_cb != NULL) { - list_do->task_cb(list_do->data); - DBG("called:%p", list_do->task_cb); - } - list_temp = list_do->next; - free(list_do); - list_do = list_temp; - } -} -/* LCOV_EXCL_STOP */ - -/* - * dbus handler implementation - */ -/* LCOV_EXCL_START */ -static void _insert_badge_notify(GVariant *parameters) -{ - char *pkgname = NULL; - uid_t uid; - - g_variant_get(parameters, "(&si)", &pkgname, &uid); - badge_changed_cb_call(BADGE_ACTION_CREATE, pkgname, 0, uid); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void _delete_badge_notify(GVariant *parameters) -{ - char *pkgname = NULL; - uid_t uid; - - g_variant_get(parameters, "(&si)", &pkgname, &uid); - badge_changed_cb_call(BADGE_ACTION_REMOVE, pkgname, 0, uid); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void _set_badge_count_notify(GVariant *parameters) -{ - char *pkgname = NULL; - int count = 0; - uid_t uid; - - g_variant_get(parameters, "(&sii)", &pkgname, &count, &uid); - badge_changed_cb_call(BADGE_ACTION_UPDATE, pkgname, count, uid); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void _set_disp_option_notify(GVariant *parameters) -{ - char *pkgname = NULL; - int is_display = 0; - uid_t uid; - - g_variant_get(parameters, "(&sii)", &pkgname, &is_display, &uid); - badge_changed_cb_call(BADGE_ACTION_CHANGED_DISPLAY, pkgname, is_display, uid); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void _handle_badge_notify(GDBusConnection *connection, - const gchar *sender_name, - const gchar *object_path, - const gchar *interface_name, - const gchar *signal_name, - GVariant *parameters, - gpointer user_data) -{ - DBG("signal_name: %s", signal_name); - if (g_strcmp0(signal_name, "insert_badge_notify") == 0) - _insert_badge_notify(parameters); - else if (g_strcmp0(signal_name, "delete_badge_notify") == 0) - _delete_badge_notify(parameters); - else if (g_strcmp0(signal_name, "set_badge_count_notify") == 0) - _set_badge_count_notify(parameters); - else if (g_strcmp0(signal_name, "set_disp_option_notify") == 0) - _set_disp_option_notify(parameters); -} -/* LCOV_EXCL_STOP */ - -static int _dbus_init(void) -{ - GError *error = NULL; - - if (_gdbus_conn == NULL) { - _gdbus_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); - if (_gdbus_conn == NULL) { - /* LCOV_EXCL_START */ - if (error != NULL) { - ERR("Failed to get dbus [%s]", error->message); - g_error_free(error); - } - /* LCOV_EXCL_STOP */ - return BADGE_ERROR_IO_ERROR; - } - badge_error_quark(); - } - - return BADGE_ERROR_NONE; -} - -static int _dbus_signal_init(void) -{ - int ret = BADGE_ERROR_NONE; - int id; - - if (monitor_id == 0) { - DBG("get dbus connection success"); - id = g_dbus_connection_signal_subscribe(_gdbus_conn, - PROVIDER_BUS_NAME, - PROVIDER_BADGE_INTERFACE_NAME, /* interface */ - NULL, /* member */ - PROVIDER_OBJECT_PATH, /* path */ - NULL, /* arg0 */ - G_DBUS_SIGNAL_FLAGS_NONE, - _handle_badge_notify, - NULL, - NULL); - - DBG("subscribe id : %d", id); - if (id == 0) { - /* LCOV_EXCL_START */ - ret = BADGE_ERROR_IO_ERROR; - ERR("Failed to _register_noti_dbus_interface"); - /* LCOV_EXCL_STOP */ - } else { - monitor_id = id; - } - } - - return ret; -} - -/* - * implement user request - */ -static int _send_sync_badge(GVariant *body, GDBusMessage **reply, char *cmd) -{ - GError *err = NULL; - GDBusMessage *msg; - int ret = BADGE_ERROR_NONE; - - msg = g_dbus_message_new_method_call( - PROVIDER_BUS_NAME, - PROVIDER_OBJECT_PATH, - PROVIDER_BADGE_INTERFACE_NAME, - cmd); - if (!msg) { - /* LCOV_EXCL_START */ - ERR("Can't allocate new method call"); - if (body) - g_variant_unref(body); - return BADGE_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ - } - - if (body != NULL) - g_dbus_message_set_body(msg, body); - - *reply = g_dbus_connection_send_message_with_reply_sync( - _gdbus_conn, - msg, - G_DBUS_SEND_MESSAGE_FLAGS_NONE, - -1, - NULL, - NULL, - &err); - - g_object_unref(msg); - - if (!*reply) { - /* LCOV_EXCL_START */ - ret = BADGE_ERROR_SERVICE_NOT_READY; - if (err != NULL) { - ERR("No reply. cmd = %s, error = %s", cmd, err->message); - if (err->code == G_DBUS_ERROR_ACCESS_DENIED) - ret = BADGE_ERROR_PERMISSION_DENIED; - g_error_free(err); - } - return ret; - /* LCOV_EXCL_STOP */ - } - - if (g_dbus_message_to_gerror(*reply, &err)) { - ret = err->code; - ERR("_send_sync_badge cmd = %s, error %s", cmd, err->message); - if (err->code == G_DBUS_ERROR_ACCESS_DENIED) - ret = BADGE_ERROR_PERMISSION_DENIED; - g_error_free(err); - return ret; - } - DBG("_send_sync_badge done !!"); - return BADGE_ERROR_NONE; -} - -static int _send_service_register(uid_t uid) -{ - GDBusMessage *reply = NULL; - int result; - - result = _send_sync_badge(g_variant_new("(i)", uid), &reply, "badge_service_register"); - - if (reply) - g_object_unref(reply); - - DBG("_send_service_register dones"); - return result; -} - -static int _ipc_monitor_register(uid_t uid) -{ - DBG("register a service"); - - return _send_service_register(uid); -} - -/* LCOV_EXCL_START */ -static void _on_name_appeared(GDBusConnection *connection, - const gchar *name, - const gchar *name_owner, - gpointer user_data) -{ - DBG("name appeared : %s", name); - is_master_started = 1; - _ipc_monitor_register(GPOINTER_TO_INT(user_data)); - - _do_deferred_task(); -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -static void _on_name_vanished(GDBusConnection *connection, - const gchar *name, - gpointer user_data) -{ - DBG("name vanished : %s", name); - is_master_started = 0; -} -/* LCOV_EXCL_STOP */ - -int badge_ipc_monitor_init(uid_t uid) -{ - DBG("register a service"); - int ret = BADGE_ERROR_NONE; - - ret = _dbus_init(); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Can't init dbus [%d]", ret); - return ret; - /* LCOV_EXCL_STOP */ - } - - ret = _dbus_signal_init(); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Can't init dbus signal [%d]", ret); - return ret; - /* LCOV_EXCL_STOP */ - } - - ret = _ipc_monitor_register(uid); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("Can't init ipc_monitor_register [%d]", ret); - return ret; - /* LCOV_EXCL_STOP */ - } - - if (provider_monitor_id == 0) { - provider_monitor_id = g_bus_watch_name_on_connection( - _gdbus_conn, - PROVIDER_BUS_NAME, - G_BUS_NAME_WATCHER_FLAGS_NONE, - _on_name_appeared, - _on_name_vanished, - GINT_TO_POINTER((int)uid), - NULL); - - if (provider_monitor_id == 0) { - /* LCOV_EXCL_START */ - ERR("watch on name failed"); - g_dbus_connection_signal_unsubscribe(_gdbus_conn, monitor_id); - monitor_id = 0; - return BADGE_ERROR_IO_ERROR; - /* LCOV_EXCL_STOP */ - } - } - - return ret; -} - -int badge_ipc_monitor_fini(void) -{ - if (provider_monitor_id) { - g_bus_unwatch_name(provider_monitor_id); - provider_monitor_id = 0; - } - - if (monitor_id) { - g_dbus_connection_signal_unsubscribe(_gdbus_conn, monitor_id); - monitor_id = 0; - } - return BADGE_ERROR_NONE; -} - -int badge_ipc_request_is_existing(const char *pkgname, bool *existing, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - GVariant *reply_body; - int ret_existing; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - body = g_variant_new("(si)", pkgname, uid); - - result = _send_sync_badge(body, &reply, "get_badge_existing"); - if (result == BADGE_ERROR_NONE) { - reply_body = g_dbus_message_get_body(reply); - g_variant_get(reply_body, "(i)", &ret_existing); - *existing = ret_existing; - } - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_is_existing done [%d]", result); - return result; -} - -int badge_ipc_request_get_list(badge_foreach_cb callback, void *data, uid_t uid) -{ - GDBusMessage *reply = NULL; - int result; - GVariant *reply_body; - GVariant *iter_body; - GVariant *body; - GVariantIter *iter; - badge_info_s badge; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(i)", uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "get_list"); - if (result == BADGE_ERROR_NONE) { - reply_body = g_dbus_message_get_body(reply); - g_variant_get(reply_body, "(a(v))", &iter); - while (g_variant_iter_loop(iter, "(v)", &iter_body)) { - g_variant_get(iter_body, "(&si)", &badge.pkg, &badge.badge_count); - DBG("call calback : %s", badge.pkg); - callback(badge.pkg, badge.badge_count, data); - } - g_variant_iter_free(iter); - } - - if (reply) - g_object_unref(reply); - - return result; -} - -int badge_ipc_request_insert(const char *pkgname, const char *writable_pkg, const char *caller, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(sssi)", pkgname, writable_pkg, caller, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "insert_badge"); - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_insert done [%d]", result); - return result; -} - -int badge_ipc_request_delete(const char *pkgname, const char *caller, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(ssi)", pkgname, caller, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "delete_badge"); - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_delete done [%d]", result); - return result; -} - -int badge_ipc_request_set_count(const char *pkgname, const char *caller, int count, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(ssii)", pkgname, caller, count, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "set_badge_count"); - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_set_count done [%d]", result); - return result; -} - -int badge_ipc_request_get_count(const char *pkgname, unsigned int *count, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - GVariant *reply_body; - int ret_count; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(si)", pkgname, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "get_badge_count"); - if (result == BADGE_ERROR_NONE) { - reply_body = g_dbus_message_get_body(reply); - g_variant_get(reply_body, "(i)", &ret_count); - *count = ret_count; - } - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_get_count done [%d]", result); - return result; -} - -int badge_ipc_request_set_display(const char *pkgname, const char *caller, - unsigned int display_option, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - body = g_variant_new("(ssii)", pkgname, caller, display_option, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "set_disp_option"); - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_set_display done [%d]", result); - return result; -} - -int badge_ipc_request_get_display(const char *pkgname, unsigned int *is_display, uid_t uid) -{ - int result; - GDBusMessage *reply = NULL; - GVariant *body; - GVariant *reply_body; - unsigned int ret_is_display; - - result = _dbus_init(); - if (result != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", result); - return result; - } - - body = g_variant_new("(si)", pkgname, uid); - if (!body) { - ERR("Can't create gvariant. Out of memory."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - result = _send_sync_badge(body, &reply, "get_disp_option"); - if (result == BADGE_ERROR_NONE) { - reply_body = g_dbus_message_get_body(reply); - g_variant_get(reply_body, "(i)", &ret_is_display); - *is_display = ret_is_display; - } - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_request_get_display done [%d]", result); - return result; -} - -int badge_ipc_request_update_setting(badge_setting_h setting, uid_t uid) -{ - int ret; - GDBusMessage *reply = NULL; - GVariant *body = NULL; - - ret = _dbus_init(); - if (ret != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", ret); - return ret; - } - - body = g_variant_new("(ssii)", - setting->pkgname, - setting->appid, - (int)(setting->allow_to_display), - uid); - - ret = _send_sync_badge(body, &reply, "update_badge_setting"); - if (ret != BADGE_ERROR_NONE) - ERR("Failed badge update setting"); - - if (reply) - g_object_unref(reply); - - return ret; -} - -int badge_ipc_request_get_setting_by_appid(badge_setting_h *setting, const char *appid, uid_t uid) -{ - int ret; - GDBusMessage *reply = NULL; - GVariant *body = NULL; - GVariant *reply_body = NULL; - GVariant *setting_body = NULL; - badge_setting_h result_setting; - - ret = _dbus_init(); - if (ret != BADGE_ERROR_NONE) { - ERR("Can't init dbus [%d]", ret); - return ret; - } - - body = g_variant_new("(si)", appid, uid); - - ret = _send_sync_badge(body, &reply, "get_setting_by_appid"); - if (ret == BADGE_ERROR_NONE) { - reply_body = g_dbus_message_get_body(reply); - g_variant_get(reply_body, "(v)", &setting_body); - - result_setting = (struct badge_setting *)malloc(sizeof(struct badge_setting)); - if (result_setting == NULL) { - /* LCOV_EXCL_START */ - ERR("Failed memory allocation."); - g_object_unref(reply); - return BADGE_ERROR_OUT_OF_MEMORY; - /* LCOV_EXCL_STOP */ - } - badge_ipc_make_setting_from_gvariant(result_setting, setting_body); - *setting = result_setting; - g_variant_unref(setting_body); - } - - if (reply) - g_object_ref(reply); - - return ret; -} - -EXPORT_API int badge_ipc_make_setting_from_gvariant(badge_setting_h setting, GVariant *variant) -{ - char *pkgname; - char *appid; - int allow_to_display; - - if (setting == NULL || variant == NULL) { - DBG("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - g_variant_get(variant, "(&s&si)", &pkgname, &appid, &allow_to_display); - - setting->pkgname = strdup(pkgname); - setting->appid = strdup(appid); - setting->allow_to_display = allow_to_display; - - return BADGE_ERROR_NONE; -} - -EXPORT_API GVariant *badge_ipc_make_gvariant_from_setting(badge_setting_h setting) -{ - GVariant *body = NULL; - - body = g_variant_new("(ssi)", - setting->pkgname, - setting->appid, - setting->allow_to_display); - - return body; -} - -int badge_ipc_init_badge(uid_t uid) -{ - int ret; - GDBusMessage *reply = NULL; - GVariant *body; - - body = g_variant_new("(i)", uid); - if (!body) { - ERR("Can't create gvariant."); - return BADGE_ERROR_OUT_OF_MEMORY; - } - - ret = _send_sync_badge(body, &reply, "init_badge"); - - if (reply) - g_object_unref(reply); - - DBG("badge_ipc_init_badge done[%d]", ret); - return ret; -} diff --git a/src/badge_setting.c b/src/badge_setting.c deleted file mode 100644 index 51fa016..0000000 --- a/src/badge_setting.c +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Copyright (c) 2016 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge_log.h" -#include "badge_error.h" -#include "badge_setting.h" -#include "badge_ipc.h" - -EXPORT_API int badge_setting_get_pkgname(badge_setting_h setting, char **pkgname) -{ - if (setting == NULL || pkgname == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - if (setting->pkgname == NULL) { - ERR("setting->pkgname is null"); - return BADGE_ERROR_NOT_EXIST; - } - - *pkgname = strdup(setting->pkgname); - - return BADGE_ERROR_NONE; -} - -EXPORT_API int badge_setting_get_appid(badge_setting_h setting, char **appid) -{ - if (setting == NULL || appid == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - if (setting->appid == NULL) { - ERR("setting->appid is null"); - return BADGE_ERROR_NOT_EXIST; - } - - *appid = strdup(setting->appid); - - return BADGE_ERROR_NONE; -} - -EXPORT_API int badge_setting_set_allow_to_display(badge_setting_h setting, bool value) -{ - if (setting == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - setting->allow_to_display = value; - return BADGE_ERROR_NONE; -} - -EXPORT_API int badge_setting_get_allow_to_display(badge_setting_h setting, bool *value) -{ - if (setting == NULL || value == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - *value = setting->allow_to_display; - return BADGE_ERROR_NONE; -} - -EXPORT_API int badge_setting_update_setting_for_uid(badge_setting_h setting, uid_t uid) -{ - return badge_ipc_request_update_setting(setting, uid); -} - -EXPORT_API int badge_setting_update_setting(badge_setting_h setting) -{ - if (setting == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - return badge_setting_update_setting_for_uid(setting, getuid()); -} - -EXPORT_API int badge_setting_get_setting_by_appid_for_uid(badge_setting_h *setting, const char *appid, uid_t uid) -{ - return badge_ipc_request_get_setting_by_appid(setting, appid, uid); -} - -EXPORT_API int badge_setting_get_setting_by_appid(badge_setting_h *setting, const char *appid) -{ - if (setting == NULL || appid == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - return badge_setting_get_setting_by_appid_for_uid(setting, appid, getuid()); -} - -EXPORT_API int badge_setting_free_setting(badge_setting_h setting) -{ - if (setting == NULL) { - ERR("Invalid Parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - if (setting->pkgname) - free(setting->pkgname); - if (setting->appid) - free(setting->appid); - free(setting); - setting = NULL; - - return BADGE_ERROR_NONE; -} diff --git a/src/badge_setting_service.c b/src/badge_setting_service.c deleted file mode 100644 index 66e7001..0000000 --- a/src/badge_setting_service.c +++ /dev/null @@ -1,933 +0,0 @@ -/* - * Copyright (c) 2016 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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 "badge_setting.h" -#include "badge_setting_service.h" -#include "badge_db.h" -#include "badge_error.h" -#include "badge_log.h" - -#define BADGE_PRIVILEGE "http://tizen.org/privilege/notification" - -#define BAGDE_ALLOW_TO_DISPLAY_BIT 0x1 -#define BAGDE_APP_DISABLE_BIT 0x2 - -#define BAGDE_APP_ENABLE 0x0 -#define BAGDE_APP_DISABLE 0x2 - -#define BAGDE_NOT_ALLOW_TO_DISPLAY 0x0 -#define BAGDE_ALLOW_TO_DISPLAY 0x1 - -typedef struct { - uid_t uid; - sqlite3 *db; -} badge_setting_info; - -static bool _get_table_field_data_int(char **table, int *buf, int index) -{ - if (table == NULL || buf == NULL || index < 0) { - /* LCOV_EXCL_START */ - ERR("table[%p], buf[%p], index[%d]", table, buf, index); - return false; - /* LCOV_EXCL_STOP */ - } - - if (table[index] != NULL) { - *buf = atoi(table[index]); - return true; - } - - /* LCOV_EXCL_START */ - *buf = 0; - return false; - /* LCOV_EXCL_STOP */ -} - -static bool _get_table_field_data_string(char **table, char **buf, int ucs2, int index) -{ - bool ret = false; - int sLen = 0; - char *pTemp; - - if (table == NULL || buf == NULL || index < 0) { - /* LCOV_EXCL_START */ - ERR("table[%p], buf[%p], index[%d]", table, buf, index); - return false; - /* LCOV_EXCL_STOP */ - } - - pTemp = table[index]; - if (pTemp == NULL) { - *buf = NULL; /* LCOV_EXCL_LINE */ - } else { - sLen = strlen(pTemp); - if (sLen) { - *buf = (char *)malloc(sLen + 1); - if (*buf == NULL) { - ERR("malloc is failed"); /* LCOV_EXCL_LINE */ - goto out; - } - memset(*buf, 0, sLen + 1); - strncpy(*buf, pTemp, sLen + 1); - } else { - *buf = NULL; /* LCOV_EXCL_LINE */ - } - } - - ret = true; - -out: - return ret; -} - -EXPORT_API int badge_db_get_setting_by_appid(const char *appid, badge_setting_h *setting, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - int row_count; - int col_count; - int col_index; - char *sql_query = NULL; - char **query_result = NULL; - badge_setting_h result_setting; - sqlite3 *db = NULL; - int atd; - - if (appid == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - sql_query = sqlite3_mprintf("SELECT pkgname, appid, allow_to_display FROM %s " \ - "WHERE appid = %Q AND (uid = %d OR uid = %d) " \ - "ORDER BY uid DESC;", - BADGE_SETTING_DB_TABLE, appid, uid, tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)); - if (!sql_query) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL); - if (sql_ret != SQLITE_OK && sql_ret != -1) { - /* LCOV_EXCL_START */ - ERR("sqlite3_get_table failed [%d][%s]", sql_ret, - sqlite3_errmsg(db)); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - if (!row_count) { - /* LCOV_EXCL_START */ - DBG("No setting found for [%s]", appid); - ret = BADGE_ERROR_NOT_EXIST; - goto out; - /* LCOV_EXCL_STOP */ - } - - result_setting = (struct badge_setting *)malloc(sizeof(struct badge_setting)); - if (result_setting == NULL) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc setting"); - ret = BADGE_ERROR_OUT_OF_MEMORY; - goto out; - /* LCOV_EXCL_STOP */ - } - - col_index = col_count; - - _get_table_field_data_string(query_result, &(result_setting[0].pkgname), 1, col_index++); - _get_table_field_data_string(query_result, &(result_setting[0].appid), 1, col_index++); - if (_get_table_field_data_int(query_result, &atd, col_index++)) { - if (atd & BAGDE_APP_DISABLE_BIT) - result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - else if (atd & BAGDE_ALLOW_TO_DISPLAY_BIT) - result_setting[0].allow_to_display = BAGDE_ALLOW_TO_DISPLAY; - else - result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - } else { - result_setting[0].allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - } - - *setting = result_setting; - -out: - if (query_result) - sqlite3_free_table(query_result); - if (sql_query) - sqlite3_free(sql_query); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -EXPORT_API int badge_db_update_setting(char *pkgname, char *appid, int allow_to_display, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - int sql_ret; - - if (pkgname == NULL || appid == NULL) { - ERR("Invalid package name or app id"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - /* Only the first bit is updated. - (The first bit indicates allow information, and the second bit indicates app disable information.) - */ - sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \ - "WHERE pkgname = %Q AND appid = %Q " \ - "AND uid = %d;", - BADGE_SETTING_DB_TABLE, BAGDE_ALLOW_TO_DISPLAY_BIT, allow_to_display, - pkgname, appid, uid); - - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, NULL); - -out: - if (sqlbuf) - sqlite3_free(sqlbuf); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -EXPORT_API int badge_db_get_allow_to_display_by_appid(char *appid, int *allow_to_display, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - int row_count; - int col_count; - int col_index; - char *sql_query = NULL; - char **query_result = NULL; - sqlite3 *db = NULL; - int atd; - - if (appid == NULL) - return BADGE_ERROR_INVALID_PARAMETER; - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("Failed db util open [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - sql_query = sqlite3_mprintf("SELECT allow_to_display FROM %s WHERE appid = %Q " \ - "AND (uid = %d OR uid = %d) ORDER BY uid DESC;", - BADGE_SETTING_DB_TABLE, appid, uid, - tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)); - if (!sql_query) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - sql_ret = sqlite3_get_table(db, sql_query, &query_result, &row_count, &col_count, NULL); - if (sql_ret != SQLITE_OK && sql_ret != -1) { - /* LCOV_EXCL_START */ - ERR("sqlite3_get_table failed [%d][%s]", sql_ret, - sqlite3_errmsg(db)); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - if (!row_count) { - /* LCOV_EXCL_START */ - DBG("No setting found for [%s]", appid); - ret = BADGE_ERROR_NOT_EXIST; - goto out; - /* LCOV_EXCL_STOP */ - } - - col_index = col_count; - - if (_get_table_field_data_int(query_result, &atd, col_index++)) { - if (atd & BAGDE_APP_DISABLE_BIT) - *allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - else if (atd & BAGDE_ALLOW_TO_DISPLAY_BIT) - *allow_to_display = BAGDE_ALLOW_TO_DISPLAY; - else - *allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - } else { - *allow_to_display = BAGDE_NOT_ALLOW_TO_DISPLAY; - } - -out: - if (query_result) - sqlite3_free_table(query_result); - if (sql_query) - sqlite3_free(sql_query); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -EXPORT_API int badge_db_update_app_disabled(const char *app_id, bool disabled, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - int sql_ret; - int num_changes = 0; - int flag; - - if (app_id == NULL) { - ERR("Invalid app id"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - if (disabled) - flag = BAGDE_APP_DISABLE; - else - flag = BAGDE_APP_ENABLE; - - /* Only the second bit is updated. - (The first bit indicates allow information, and the second bit indicates app disable information.) - */ - sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \ - "WHERE appid = %Q " \ - "AND uid = %d;", - BADGE_SETTING_DB_TABLE, BAGDE_APP_DISABLE_BIT, flag, app_id, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, &num_changes); - if (ret == BADGE_ERROR_NONE && num_changes <= 0) - ret = BADGE_ERROR_NOT_EXIST; - -out: - if (sqlbuf) - sqlite3_free(sqlbuf); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -EXPORT_API int badge_db_update_pkg_disabled(const char *pkg_id, bool disabled, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - int sql_ret; - int num_changes = 0; - int flag; - - if (pkg_id == NULL) { - ERR("Invalid pkg id"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - sql_ret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sql_ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - if (disabled) - flag = BAGDE_APP_DISABLE; - else - flag = BAGDE_APP_ENABLE; - - /* Only the second bit is updated. - (The first bit indicates allow information, and the second bit indicates app disable information.) - */ - sqlbuf = sqlite3_mprintf("UPDATE %s SET allow_to_display = (allow_to_display & ~%d ) | %d " \ - "WHERE pkgname = %Q AND uid = %d;", - BADGE_SETTING_DB_TABLE, BAGDE_APP_DISABLE_BIT, flag, pkg_id, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, sqlbuf, &num_changes); - if (ret == BADGE_ERROR_NONE && num_changes <= 0) - ret = BADGE_ERROR_NOT_EXIST; - -out: - if (sqlbuf) - sqlite3_free(sqlbuf); - if (db) { - sql_ret = db_util_close(db); - if (sql_ret != SQLITE_OK) - WARN("Failed to db_util_close"); - } - - return ret; -} - -EXPORT_API int badge_setting_is_existed_appid(const char *appid, bool *is_existed, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sqlret; - sqlite3 *db = NULL; - sqlite3_stmt *stmt = NULL; - char *sqlbuf = NULL; - int count = 0; - - if (appid == NULL || is_existed == NULL) { - ERR("Invalid parameter"); - return BADGE_ERROR_INVALID_PARAMETER; - } - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - /* LCOV_EXCL_START */ - ERR("Failed to db_util_open [%d]", sqlret); - if (sqlret == SQLITE_PERM) - return BADGE_ERROR_PERMISSION_DENIED; - return BADGE_ERROR_FROM_DB; - /* LCOV_EXCL_STOP */ - } - - sqlbuf = sqlite3_mprintf("SELECT count(*) FROM %q WHERE " \ - "appid = %Q AND uid = %d", - BADGE_SETTING_DB_TABLE, appid, uid); - if (!sqlbuf) { - /* LCOV_EXCL_START */ - ERR("Failed to alloc query"); - ret = BADGE_ERROR_OUT_OF_MEMORY; - goto out; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_prepare_v2(db, sqlbuf, -1, &stmt, NULL); - if (sqlret != SQLITE_OK) { - /* LCOV_EXCL_START */ - ERR("sqlite3_prepare_v2 failed [%d][%s]", sqlret, - sqlite3_errmsg(db)); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - sqlret = sqlite3_step(stmt); - if (sqlret == SQLITE_ROW) - count = sqlite3_column_int(stmt, 0); - - if (count > 0) - *is_existed = true; - else - *is_existed = false; - -out: - if (sqlbuf) - sqlite3_free(sqlbuf); - if (stmt) - sqlite3_finalize(stmt); - if (db) { - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); - } - - return ret; -} - -static bool _is_package_in_setting_table(sqlite3 *db, const char *pkgname, const char* appid, uid_t uid) -{ - int sql_ret; - bool err = true; - char *query = NULL; - sqlite3_stmt *stmt = NULL; - - if (appid != NULL) - query = sqlite3_mprintf("SELECT appid FROM badge_setting " \ - "WHERE uid = %d AND pkgname = %Q AND appid = %Q", - uid, pkgname, appid); - else - query = sqlite3_mprintf("SELECT pkgname FROM badge_setting " \ - "WHERE uid = %d AND pkgname = %Q", - uid, pkgname); - if (query == NULL) { - /* LCOV_EXCL_START */ - ERR("Out of Memory"); - err = false; - goto out; - /* LCOV_EXCL_STOP */ - } - - sql_ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL); - if (sql_ret != SQLITE_OK) { - ERR("sqlite3_prepare_v2 failed [%d][%s]", sql_ret, sqlite3_errmsg(db)); - err = false; - goto out; - } - - sql_ret = sqlite3_step(stmt); - if (sql_ret == SQLITE_DONE) { - INFO("No matched appid[%s] from pkgname[%s]", pkgname, appid); - err = false; - goto out; - } - - if (sql_ret != SQLITE_OK && sql_ret != SQLITE_ROW) { - /* LCOV_EXCL_START */ - ERR("sqlite3_step failed [%d][%s]", sql_ret, - sqlite3_errmsg(db)); - err = false; - goto out; - /* LCOV_EXCL_STOP */ - } - -out: - if (stmt) - sqlite3_finalize(stmt); - if (query) - sqlite3_free(query); - - return err; -} - -static int app_info_callback(const pkgmgrinfo_appinfo_h handle, void *user_data) -{ - int ret; - int pkgmgr_ret; - char *appid = NULL; - char *pkgname = NULL; - char *query = NULL; - badge_setting_info *info = (badge_setting_info *)user_data; - sqlite3 *db = info->db; - - pkgmgr_ret = pkgmgrinfo_appinfo_get_appid(handle, &appid); - if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) { - ERR("pkgmgrinfo_appinfo_get_appid failed [%d]", pkgmgr_ret); - goto out; - } - - pkgmgr_ret = pkgmgrinfo_appinfo_get_pkgname(handle, &pkgname); - if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) { - ERR("pkgmgrinfo_appinfo_get_pkgname failed [%d]", pkgmgr_ret); - goto out; - } - - if (_is_package_in_setting_table(db, pkgname, appid, info->uid) == true) { - INFO("uid[%d] appid[%s] is exist", info->uid, appid); - goto out; - } - - query = sqlite3_mprintf("INSERT INTO badge_setting " \ - "(uid, pkgname, appid) VALUES (%d, %Q, %Q) ", - info->uid, pkgname, appid); - if (query == NULL) { - ERR("Out of memory"); - goto out; - } - - ret = badge_db_exec(db, query, NULL); - if (ret != BADGE_ERROR_NONE) { - ERR("DB Error"); - goto out; - } - - INFO("Insert uid[%d] pkgname[%s] appid[%s]", info->uid, pkgname, appid); - -out: - if (query) - sqlite3_free(query); - - return 0; -} - -static int package_info_callback(const pkgmgrinfo_pkginfo_h package_info, void *user_data) -{ - char *pkgname = NULL; - int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE; - pkgmgrinfo_appinfo_filter_h handle = NULL; - badge_setting_info *info = (badge_setting_info *)user_data; - - pkgmgr_ret = pkgmgrinfo_pkginfo_get_pkgname(package_info, &pkgname); - if (pkgmgr_ret != PACKAGE_MANAGER_ERROR_NONE) { - ERR("package_info_get_package failed [%d]", pkgmgr_ret); - goto out; - } - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_create(&handle); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_appinfo_filter_create failed [%d]", pkgmgr_ret); - goto out; - /* LCOV_EXCL_STOP */ - } - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_PACKAGE, pkgname); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_appinfo_filter_add_string failed [%d]", - pkgmgr_ret); - goto out; - /* LCOV_EXCL_STOP */ - } - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, false); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_appinfo_filter_add_bool failed [%d]", - pkgmgr_ret); - goto out; - /* LCOV_EXCL_STOP */ - } - - pkgmgr_ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(handle, app_info_callback, info, info->uid); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_pkginfo_filter_foreach_appinfo failed [%d]", - pkgmgr_ret); - goto out; - /* LCOV_EXCL_STOP */ - } - -out: - if (handle) - pkgmgrinfo_appinfo_filter_destroy(handle); - - return 0; -} - -EXPORT_API int badge_setting_insert_package_for_uid(const char *pkgname, uid_t uid) -{ - sqlite3 *db; - int ret = BADGE_ERROR_NONE; - int sqlite3_ret = SQLITE_OK; - int pkgmgr_ret = PACKAGE_MANAGER_ERROR_NONE; - badge_setting_info info; - pkgmgrinfo_pkginfo_filter_h handle = NULL; - - sqlite3_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL); - if (sqlite3_ret != SQLITE_OK || db == NULL) { - ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sqlite3_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - - sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL); - - pkgmgr_ret = pkgmgrinfo_pkginfo_filter_create(&handle); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_pkginfo_filter_create failed [%d]", pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - pkgmgr_ret = pkgmgrinfo_pkginfo_filter_add_string(handle, - PMINFO_PKGINFO_PROP_PACKAGE_PRIVILEGE, BADGE_PRIVILEGE); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("Failed to add string to pkginfo_filter[%d]", pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - pkgmgr_ret = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_ID, pkgname); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_pkginfo_filter_add_string failed [%d]", - pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - info.db = db; - info.uid = uid; - pkgmgr_ret = pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo(handle, package_info_callback, &info, uid); - if (pkgmgr_ret != PMINFO_R_OK) { - /* LCOV_EXCL_START */ - ERR("pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo failed [%d]", - pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - -out: - if (handle) - pkgmgrinfo_pkginfo_filter_destroy(handle); - if (db) { - if (ret == BADGE_ERROR_NONE) - sqlite3_exec(db, "END;", NULL, NULL, NULL); - else - sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL); - - if ((sqlite3_ret = db_util_close(db)) != SQLITE_OK) - WARN("db_util_close failed [%d]", sqlite3_ret); - } - - return ret; -} - -EXPORT_API int badge_setting_delete_package_for_uid(const char *pkgname, uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - sqlite3 *db = NULL; - bool is_package_in_setting_table = false; - char *query = NULL; - - sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL); - if (ret != SQLITE_OK || db == NULL) { - /* LCOV_EXCL_START */ - ERR("db_util_open failed [%s][%d]", BADGE_DB_PATH, sql_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - /* LCOV_EXCL_STOP */ - } - - is_package_in_setting_table = _is_package_in_setting_table(db, pkgname, NULL, uid); - if (is_package_in_setting_table == false) { - INFO("[%s] is not exist", pkgname); - goto out; - } - - sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL); - - query = sqlite3_mprintf("DELETE FROM badge_setting " \ - "WHERE uid = %d AND pkgname = %Q ", - uid, pkgname); - if (query == NULL) { - /* LCOV_EXCL_START */ - ERR("Out of memory"); - ret = BADGE_ERROR_OUT_OF_MEMORY; - goto out; - /* LCOV_EXCL_STOP */ - } - - ret = badge_db_exec(db, query, NULL); - if (ret != BADGE_ERROR_NONE) { - /* LCOV_EXCL_START */ - ERR("DB Error"); - goto out; - /* LCOV_EXCL_STOP */ - } - -out: - if (query) - sqlite3_free(query); - if (db) { - if (ret == BADGE_ERROR_NONE) - sqlite3_exec(db, "END;", NULL, NULL, NULL); - else - sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL); - - if ((sql_ret = db_util_close(db)) != SQLITE_OK) - WARN("db_util_close failed [%d]", sql_ret); - } - - return ret; -} - -/* LCOV_EXCL_START */ -EXPORT_API int badge_setting_refresh_setting_table(uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sql_ret; - int pkgmgr_ret; - sqlite3 *db = NULL; - badge_setting_info info; - pkgmgrinfo_appinfo_filter_h filter = NULL; - - sql_ret = sqlite3_open_v2(BADGE_DB_PATH, &db, SQLITE_OPEN_READWRITE, NULL); - if (sql_ret != SQLITE_OK || db == NULL) { - ERR("sqlite3_open_v2 fail [%s][%d]", BADGE_DB_PATH, sql_ret); - return BADGE_ERROR_FROM_DB; - } - - sqlite3_exec(db, "BEGIN immediate;", NULL, NULL, NULL); - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_create(&filter); - if (pkgmgr_ret != PMINFO_R_OK) { - ERR("pkgmgrinfo_appinfo_filter_create failed [%d]", pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_string(filter, - PMINFO_APPINFO_PROP_PRIVILEGE, BADGE_PRIVILEGE); - if (pkgmgr_ret != PMINFO_R_OK) { - ERR("pkgmgrinfo_appinfo_filter_add_string failed [%d]", - pkgmgr_ret); - goto out; - } - - pkgmgr_ret = pkgmgrinfo_appinfo_filter_add_bool(filter, - PMINFO_APPINFO_PROP_APP_NODISPLAY, false); - if (pkgmgr_ret != PMINFO_R_OK) { - ERR("pkgmgrinfo_appinfo_filter_add_bool failed [%d]", - pkgmgr_ret); - goto out; - } - - info.db = db; - info.uid = uid; - pkgmgr_ret = pkgmgrinfo_appinfo_usr_filter_foreach_appinfo(filter, - app_info_callback, &info, uid); - if (pkgmgr_ret != PMINFO_R_OK) { - ERR("pkgmgrinfo_appinfo_usr_filter_foreach_appinfo failed [%d]", - pkgmgr_ret); - ret = BADGE_ERROR_FROM_DB; - goto out; - } - -out: - if (filter) - pkgmgrinfo_appinfo_filter_destroy(filter); - if (db) { - if (ret == BADGE_ERROR_NONE) - sqlite3_exec(db, "END;", NULL, NULL, NULL); - else - sqlite3_exec(db, "ROLLBACK;", NULL, NULL, NULL); - if ((sql_ret = db_util_close(db)) != SQLITE_OK) - WARN("fail to db_util_close [%d]", sql_ret); - } - - return ret; -} -/* LCOV_EXCL_STOP */ - -/* LCOV_EXCL_START */ -EXPORT_API int badge_setting_arrange_tables(uid_t uid) -{ - int ret = BADGE_ERROR_NONE; - int sqlret; - sqlite3 *db = NULL; - char *sqlbuf = NULL; - - sqlret = db_util_open(BADGE_DB_PATH, &db, 0); - if (sqlret != SQLITE_OK || !db) { - ERR("Failed to db_util_open [%d]", sqlret); - if (sqlret == SQLITE_PERM) - return BADGE_ERROR_PERMISSION_DENIED; - return BADGE_ERROR_FROM_DB; - } - - sqlbuf = sqlite3_mprintf("DELETE FROM %Q WHERE pkgname not in " \ - "(SELECT pkgname FROM %Q) AND uid = %d", - BADGE_TABLE_NAME, BADGE_SETTING_DB_TABLE, uid); - if (sqlbuf == NULL) { - ERR("Failed to alloc query"); - ret = BADGE_ERROR_OUT_OF_MEMORY; - goto out; - } - - ret = badge_db_exec(db, sqlbuf, NULL); - if (ret != BADGE_ERROR_NONE) - goto out; - - if (sqlbuf) { - sqlite3_free(sqlbuf); - sqlbuf = NULL; - } - - sqlbuf = sqlite3_mprintf("DELETE FROM %Q WHERE pkgname not in " \ - "(SELECT pkgname FROM %Q) AND uid = %d", - BADGE_OPTION_TABLE_NAME, BADGE_SETTING_DB_TABLE, - uid); - if (sqlbuf == NULL) { - ERR("Failed to alloc query"); - ret = BADGE_ERROR_OUT_OF_MEMORY; - goto out; - } - - ret = badge_db_exec(db, sqlbuf, NULL); - -out: - if (sqlbuf) - sqlite3_free(sqlbuf); - - if (db) { - sqlret = db_util_close(db); - if (sqlret != SQLITE_OK) - WARN("Failed to db_util_close [%d]", sqlret); - } - - return ret; -} -/* LCOV_EXCL_STOP */ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c90fac8..afb82c4 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1 +1,2 @@ ADD_SUBDIRECTORY(unit_tests) +ADD_SUBDIRECTORY(integ_tests) diff --git a/tests/integ_tests/CMakeLists.txt b/tests/integ_tests/CMakeLists.txt new file mode 100644 index 0000000..3eeb833 --- /dev/null +++ b/tests/integ_tests/CMakeLists.txt @@ -0,0 +1,27 @@ +REMOVE_DEFINITIONS("-DDB_PATH") +ADD_DEFINITIONS("-DDB_PATH=\"${DB_PATH}\"") + +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SOURCES) + +ADD_EXECUTABLE(${TARGET_BADGE_INTEGTESTS} + ${SOURCES} +) + +TARGET_LINK_LIBRARIES(${TARGET_BADGE_INTEGTESTS} PUBLIC ${TARGET_BADGE} "-ldl") +SET_TARGET_PROPERTIES(${TARGET_BADGE_INTEGTESTS} PROPERTIES COMPILE_FLAGS "-fPIE") +SET_TARGET_PROPERTIES(${TARGET_BADGE_INTEGTESTS} PROPERTIES LINK_FLAGS "-pie") + +APPLY_PKG_CONFIG(${TARGET_BADGE_INTEGTESTS} PUBLIC + GLIB_2_DEPS + GMOCK_DEPS + SYSTEM_INFO_DEPS + RPC_PORT_DEPS + APP_MANAGER_DEPS + APP_COMMON_DEPS + TIZEN_DATABASE_DEPS + DLOG_DEPS + BUNDLE_DEPS +) + +INSTALL(TARGETS ${TARGET_BADGE_INTEGTESTS} DESTINATION /usr/bin/) diff --git a/tests/integ_tests/src/test_badge.cc b/tests/integ_tests/src/test_badge.cc new file mode 100644 index 0000000..54754c9 --- /dev/null +++ b/tests/integ_tests/src/test_badge.cc @@ -0,0 +1,263 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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 + +namespace { + +bool DbDeleteAll() { + try { + tizen_base::Database db(DB_PATH, SQLITE_OPEN_READWRITE); + db.OneStepExec({ "DELETE FROM badge_data;" }); + db.OneStepExec({ "DELETE FROM badge_option;" }); + db.OneStepExec({ "DELETE FROM badge_setting;" }); + } catch(const tizen_base::DbException& e) { + return false; + } + + return true; +} + +} // namespace + +class BadgeTest : public ::testing::Test { + public: + BadgeTest() { + } + + virtual ~BadgeTest() {} + + static void SetUpTestSuite() { + } + + static void TearDownTestSuite() { + } + + virtual void SetUp() { + DbDeleteAll(); + } + + virtual void TearDown() { + DbDeleteAll(); + } +}; + +TEST_F(BadgeTest, badge_new) { + int ret = badge_new("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_add) { + int ret = badge_add("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_remove) { + int ret = badge_add("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_remove("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_foreach) { + int ret = badge_add("testappid1"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + bool exist = false; + ret = badge_foreach([](const char* app_id, unsigned int count, + void* user_data) { + bool* exist = static_cast(user_data); + *exist = true; + return true; + }, &exist); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_TRUE(exist); +} + +TEST_F(BadgeTest, badge_set_count) { + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_set_count("myappid", 9); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_get_count) { + unsigned int count = 0; + int ret = badge_add("myappid1"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_count("myappid1", 10); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_get_count("myappid1", &count); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_EQ(count, 10); +} + +TEST_F(BadgeTest, badge_set_display) { + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_set_display("myappid", 1); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} + +TEST_F(BadgeTest, badge_get_display) { + unsigned int is_display = 0; + + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_display("myappid", 1); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_get_display("myappid", &is_display); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_EQ(is_display, 1); +} + +TEST_F(BadgeTest, badge_register_changed_cb) { + bool changed = false; + static GMainLoop* loop; + + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + auto* changed = static_cast(user_data); + *changed = true; + g_main_loop_quit(loop); + }, &changed); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); + + EXPECT_TRUE(changed); + g_main_loop_unref(loop); +} + +TEST_F(BadgeTest, badge_register_changed_cb2) { + static GMainLoop* loop; + static bool inserted = false; + static bool deleted = false; + + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_CREATE: + inserted = true; + break; + + case BADGE_ACTION_REMOVE: + deleted = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + inserted = false; + deleted = false; + ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_remove("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); + + EXPECT_TRUE(inserted); + EXPECT_TRUE(deleted); + g_main_loop_unref(loop); +} + +TEST_F(BadgeTest, badge_register_changed_cb3) { + static GMainLoop* loop; + static bool updated = false; + + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_UPDATE: + updated = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + updated = false; + ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_count("myappid", 1); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); + + EXPECT_TRUE(updated); + g_main_loop_unref(loop); +} + +TEST_F(BadgeTest, badge_register_changed_cb4) { + static GMainLoop* loop; + static bool changed_disp = false; + + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_CHANGED_DISPLAY: + changed_disp = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + changed_disp = false; + ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_display("myappid", 1); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); + + EXPECT_TRUE(changed_disp); + g_main_loop_unref(loop); +} + +TEST_F(BadgeTest, badge_unregister_changed_cb) { + auto cb = [](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + }; + + int ret = badge_register_changed_cb(cb, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + ret = badge_unregister_changed_cb(cb); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} diff --git a/tests/mock/package_manager_mock.h b/tests/integ_tests/src/test_main.cc similarity index 60% rename from tests/mock/package_manager_mock.h rename to tests/integ_tests/src/test_main.cc index 4552053..c2eb730 100644 --- a/tests/mock/package_manager_mock.h +++ b/tests/integ_tests/src/test_main.cc @@ -14,20 +14,24 @@ * limitations under the License. */ -#ifndef MOCK_PACKAGE_MANAGER_MOCK_H_ -#define MOCK_PACKAGE_MANAGER_MOCK_H_ - -#include +#include #include -#include "module_mock.h" - -class PackageManagerMock : public virtual ModuleMock { - public: - virtual ~PackageManagerMock() {} +int main(int argc, char** argv) { + int ret = -1; - MOCK_METHOD3(package_manager_compare_app_cert_info, int(const char*, const char*, package_manager_compare_result_type_e*)); -}; + try { + testing::InitGoogleTest(&argc, argv); + } catch(...) { + std::cout << "Exception occurred" << std::endl; + } -#endif // MOCK_PACKAGE_MANAGER_MOCK_H_ + try { + ret = RUN_ALL_TESTS(); + } catch (const ::testing::internal::GoogleTestFailureException& e) { + ret = -1; + std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl; + } + return ret; +} diff --git a/tests/mock/aul_mock.cc b/tests/mock/aul_mock.cc index 15952dd..717bdf4 100644 --- a/tests/mock/aul_mock.cc +++ b/tests/mock/aul_mock.cc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,10 @@ */ #include "aul_mock.h" + #include "mock_hook.h" #include "test_fixture.h" -extern "C" int aul_app_get_pkgname_bypid(int arg0, char* arg1, int arg2) { - return MOCK_HOOK_P3(AulMock, aul_app_get_pkgname_bypid, arg0, arg1, arg2); -} +extern "C" int aul_svc_get_appid_by_alias_appid(const char* arg0, char** arg1) { + return MOCK_HOOK_P2(AulMock, aul_svc_get_appid_by_alias_appid, arg0, arg1); +} \ No newline at end of file diff --git a/tests/mock/aul_mock.h b/tests/mock/aul_mock.h index 46bceef..3f04d07 100644 --- a/tests/mock/aul_mock.h +++ b/tests/mock/aul_mock.h @@ -17,7 +17,7 @@ #ifndef MOCK_AUL_MOCK_H_ #define MOCK_AUL_MOCK_H_ -#include +#include #include #include "module_mock.h" @@ -26,7 +26,7 @@ class AulMock : public virtual ModuleMock { public: virtual ~AulMock() {} - MOCK_METHOD3(aul_app_get_pkgname_bypid, int(int, char*, int)); + MOCK_METHOD2(aul_svc_get_appid_by_alias_appid, int(const char*, char**)); }; #endif // MOCK_AUL_MOCK_H_ diff --git a/tests/mock/gio_mock.cc b/tests/mock/gio_mock.cc deleted file mode 100644 index 67f4fde..0000000 --- a/tests/mock/gio_mock.cc +++ /dev/null @@ -1,88 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. - * - * 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 "gio_mock.h" -#include "mock_hook.h" -#include "test_fixture.h" - -extern "C" GDBusConnection* g_bus_get_sync(GBusType type, - GCancellable* cancellable, GError** error) { - return MOCK_HOOK_P3(GioMock, g_bus_get_sync, type, cancellable, error); -} - -extern "C" GDBusMessage* g_dbus_connection_send_message_with_reply_sync( - GDBusConnection* conn, GDBusMessage* msg, GDBusSendMessageFlags flags, - gint timeout, volatile guint32* out_serial, GCancellable* cancellable, - GError** error) { - return MOCK_HOOK_P7(GioMock, g_dbus_connection_send_message_with_reply_sync, - conn, msg, flags, timeout, out_serial, cancellable, error); -} - -extern "C" GDBusMessage* g_dbus_message_new_method_call(const gchar* arg0, - const gchar* arg1, const gchar* arg2, const gchar* arg3) { - return MOCK_HOOK_P4(GioMock, g_dbus_message_new_method_call, arg0, arg1, arg2, - arg3); -} - -extern "C" void g_dbus_message_set_body(GDBusMessage* arg0, GVariant* arg1) { - return MOCK_HOOK_P2(GioMock, g_dbus_message_set_body, arg0, arg1); -} - -extern "C" GVariant* g_dbus_message_get_body(GDBusMessage* arg0) { - return MOCK_HOOK_P1(GioMock, g_dbus_message_get_body, arg0); -} - -extern "C" guint g_dbus_connection_signal_subscribe(GDBusConnection* arg0, - const gchar* arg1, const gchar* arg2, const gchar* arg3, const gchar* arg4, - const gchar* arg5, GDBusSignalFlags arg6, GDBusSignalCallback arg7, - gpointer arg8, GDestroyNotify arg9) { - return MOCK_HOOK_P10(GioMock, g_dbus_connection_signal_subscribe, - arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); -} - -extern "C" void g_dbus_connection_send_message_with_reply(GDBusConnection* arg0, - GDBusMessage* arg1, GDBusSendMessageFlags arg2, gint arg3, - volatile guint32* arg4, GCancellable* arg5, GAsyncReadyCallback arg6, - gpointer arg7) { - return MOCK_HOOK_P8(GioMock, g_dbus_connection_send_message_with_reply, - arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); -} - -extern "C" gboolean g_dbus_message_to_gerror( - GDBusMessage* arg0, GError** arg1) { - return MOCK_HOOK_P2(GioMock, g_dbus_message_to_gerror, - arg0, arg1); -} - -extern "C" guint g_bus_watch_name_on_connection( - GDBusConnection* arg0, const gchar* arg1, GBusNameWatcherFlags arg2, - GBusNameAppearedCallback arg3, GBusNameVanishedCallback arg4, - gpointer arg5, GDestroyNotify arg6) { - return MOCK_HOOK_P7(GioMock, g_bus_watch_name_on_connection, - arg0, arg1, arg2, arg3, arg4, arg5, arg6); -} - -extern "C" void g_bus_unwatch_name(guint arg0) { - return MOCK_HOOK_P1(GioMock, g_bus_unwatch_name, arg0); -} - -extern "C" void g_dbus_connection_signal_unsubscribe( - GDBusConnection* arg0, guint arg1) { - return MOCK_HOOK_P2(GioMock, g_dbus_connection_signal_unsubscribe, - arg0, arg1); -} diff --git a/tests/mock/gio_mock.h b/tests/mock/gio_mock.h deleted file mode 100644 index 298ce50..0000000 --- a/tests/mock/gio_mock.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. - * - * 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. - */ - -#ifndef MOCK_GIO_MOCK_H_ -#define MOCK_GIO_MOCK_H_ - -#include -#include - -#include "module_mock.h" - -class GioMock : public virtual ModuleMock { - public: - virtual ~GioMock() {} - - MOCK_METHOD3(g_bus_get_sync, - GDBusConnection*(GBusType, GCancellable*, GError**)); - MOCK_METHOD4(g_dbus_message_new_method_call, - GDBusMessage*(const gchar*, const gchar*, const gchar*, const gchar*)); - MOCK_METHOD2(g_dbus_message_set_body, void(GDBusMessage*, GVariant*)); - MOCK_METHOD1(g_dbus_message_get_body, GVariant*(GDBusMessage*)); - MOCK_METHOD7(g_dbus_connection_send_message_with_reply_sync, - GDBusMessage*(GDBusConnection*, GDBusMessage*, GDBusSendMessageFlags, - gint, volatile guint32*, GCancellable*, GError**)); - MOCK_METHOD10(g_dbus_connection_signal_subscribe, - guint(GDBusConnection*, const gchar*, const gchar*, const gchar*, - const gchar*, const gchar*, GDBusSignalFlags, GDBusSignalCallback, - gpointer, GDestroyNotify)); - MOCK_METHOD8(g_dbus_connection_send_message_with_reply, - void(GDBusConnection*, GDBusMessage*, GDBusSendMessageFlags, gint, - volatile guint32*, GCancellable*, GAsyncReadyCallback, gpointer)); - MOCK_METHOD2(g_dbus_message_to_gerror, - gboolean(GDBusMessage*, GError**)); - MOCK_METHOD7(g_bus_watch_name_on_connection, - guint(GDBusConnection*, const gchar*, GBusNameWatcherFlags, - GBusNameAppearedCallback, GBusNameVanishedCallback, gpointer, - GDestroyNotify)); - MOCK_METHOD1(g_bus_unwatch_name, void(guint)); - MOCK_METHOD2(g_dbus_connection_signal_unsubscribe, - void(GDBusConnection*, guint)); -}; - -#endif // MOCK_GIO_MOCK_H_ diff --git a/tests/mock/package_manager_mock.cc b/tests/mock/rpc_port_mock.cc similarity index 63% rename from tests/mock/package_manager_mock.cc rename to tests/mock/rpc_port_mock.cc index f49ea96..a15b1d5 100644 --- a/tests/mock/package_manager_mock.cc +++ b/tests/mock/rpc_port_mock.cc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020 Samsung Electronics Co., Ltd. + * Copyright (c) 2024 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,11 +14,15 @@ * limitations under the License. */ -#include "package_manager_mock.h" +#include "rpc_port_mock.h" + #include "mock_hook.h" #include "test_fixture.h" -extern "C" int package_manager_compare_app_cert_info(const char* arg0, const char* arg1, package_manager_compare_result_type_e* arg2) { - return MOCK_HOOK_P3(PackageManagerMock, package_manager_compare_app_cert_info, arg0, arg1, arg2); +extern "C" int rpc_port_register_proc_info(const char* arg0, bundle* arg1) { + return MOCK_HOOK_P2(RpcPortMock, rpc_port_register_proc_info, arg0, arg1); } +extern "C" int rpc_port_stub_listen(rpc_port_stub_h h) { + return MOCK_HOOK_P1(RpcPortMock, rpc_port_stub_listen, h); +} \ No newline at end of file diff --git a/tests/mock/rpc_port_mock.h b/tests/mock/rpc_port_mock.h new file mode 100644 index 0000000..6c552a9 --- /dev/null +++ b/tests/mock/rpc_port_mock.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2024 Samsung Electronics Co., Ltd. + * + * 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. + */ + +#ifndef MOCK_RPC_PORT_MOCK_H_ +#define MOCK_RPC_PORT_MOCK_H_ + +#include +#include +#include +#include + +#include "module_mock.h" + +class RpcPortMock : public virtual ModuleMock { + public: + virtual ~RpcPortMock() {} + + MOCK_METHOD2(rpc_port_register_proc_info, int(const char*, bundle*)); + MOCK_METHOD1(rpc_port_stub_listen, int(rpc_port_stub_h)); +}; + +#endif // MOCK_RPC_PORT_MOCK_H_ diff --git a/tests/unit_tests/CMakeLists.txt b/tests/unit_tests/CMakeLists.txt index 2c95d9b..91ba5ec 100644 --- a/tests/unit_tests/CMakeLists.txt +++ b/tests/unit_tests/CMakeLists.txt @@ -1,35 +1,39 @@ -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src UNIT_TESTS_SRCS) -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock/ UNIT_TESTS_SRCS) -ADD_EXECUTABLE(${TARGET_BADGE_UNIT_TEST} - ${UNIT_TESTS_SRCS} -) +REMOVE_DEFINITIONS("-DDB_PATH") +ADD_DEFINITIONS("-DDB_PATH=\"badge_test.db\"") + +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../include) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../src) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../../modules/badge) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../mock) + +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/src SOURCES) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../modules/badge/ MOD_SOURCES) +AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../mock MOCK_SOURCES) -TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE_UNIT_TEST} PUBLIC - "${CMAKE_CURRENT_SOURCE_DIR}/../../include" - "${CMAKE_CURRENT_SOURCE_DIR}/../mock" +ADD_EXECUTABLE(${TARGET_BADGE_UNIT_TEST} + ${SOURCES} + ${MOD_SOURCES} + ${MOCK_SOURCES} ) APPLY_PKG_CONFIG(${TARGET_BADGE_UNIT_TEST} PUBLIC - GLIB_DEPS + GLIB_2_DEPS GMOCK_DEPS - BUNDLE_DEPS - GOBJECT_DEPS SYSTEM_INFO_DEPS + ESD_DEPS + RPC_PORT_DEPS + APP_MANAGER_DEPS + PACKAGE_MANAGER_DEPS + APP_COMMON_DEPS + TIZEN_DATABASE_DEPS + DLOG_DEPS + VCONF_DEPS ) -TARGET_LINK_LIBRARIES(${TARGET_BADGE_UNIT_TEST} PUBLIC ${TARGET_BADGE}) +TARGET_LINK_LIBRARIES(${TARGET_BADGE_UNIT_TEST} PUBLIC ${TARGET_BADGE} "-ldl") SET_TARGET_PROPERTIES(${TARGET_BADGE_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE") SET_TARGET_PROPERTIES(${TARGET_BADGE_UNIT_TEST} PROPERTIES LINK_FLAGS "-pie") -SET(TESTDB "badge.db") -SET(TARGET_TESTDB "badge-test-db") -ADD_CUSTOM_COMMAND(OUTPUT ${TESTDB} - COMMAND sqlite3 ${TESTDB} < data/test.sql - COMMENT " Generate test database for ${TARGET_BADGE_UNIT_TEST}" -) -ADD_CUSTOM_TARGET(${TARGET_TESTDB} DEPENDS ${TESTDB}) -ADD_DEPENDENCIES(${TARGET_BADGE_UNIT_TEST} ${TARGET_TESTDB}) - ADD_TEST( NAME ${TARGET_BADGE_UNIT_TEST} COMMAND ${TARGET_BADGE_UNIT_TEST} diff --git a/tests/unit_tests/src/test_badge.cc b/tests/unit_tests/src/test_badge.cc index df3f84e..94e2195 100644 --- a/tests/unit_tests/src/test_badge.cc +++ b/tests/unit_tests/src/test_badge.cc @@ -15,20 +15,16 @@ */ #include +#include #include -#include -#include "badge.h" -#include "badge_db.h" -#include "badge_internal.h" -#include "badge_setting.h" -#include "badge_setting_service.h" - +#include +#include #include -#include "system_info_mock.h" -#include "gio_mock.h" #include "aul_mock.h" -#include "package_manager_mock.h" +#include "badge.h" +#include "rpc_port_mock.h" +#include "system_info_mock.h" #include "test_fixture.h" using ::testing::_; @@ -37,841 +33,334 @@ using ::testing::Return; using ::testing::SetArgPointee; using ::testing::Invoke; +bool DbDeleteAll() { + try { + tizen_base::Database db(DB_PATH, SQLITE_OPEN_READWRITE); + db.OneStepExec({ "DELETE FROM badge_data;" }); + db.OneStepExec({ "DELETE FROM badge_option;" }); + db.OneStepExec({ "DELETE FROM badge_setting;" }); + } catch(const tizen_base::DbException& e) { + return false; + } -typedef enum { - LOG_ID_INVALID = -1, - LOG_ID_MAIN, - LOG_ID_RADIO, - LOG_ID_SYSTEM, - LOG_ID_APPS, - LOG_ID_KMSG, - LOG_ID_SYSLOG, - LOG_ID_MAX -} log_id_t; - -extern "C" int __dlog_print( - log_id_t log_id, int prio, const char* tag, const char* fmt, ...) { - va_list ap; - va_start(ap, fmt); - vprintf(fmt, ap); - va_end(ap); - printf("\n"); - - return 0; + return true; } -extern "C" int __dlog_sec_print( - log_id_t log_id, int prio, const char* tag, const char* fmt, ...) { - va_list ap; - va_start(ap, fmt); - vprintf(fmt, ap); - va_end(ap); - printf("\n"); - - return 0; -} +#undef EXPORT_API +#define EXPORT_API __attribute__((visibility("default"))) +extern "C" EXPORT_API esd::api::IModule* ESD_GET_MODULE(); class Mocks : public ::testing::NiceMock, - public ::testing::NiceMock, - public ::testing::NiceMock, - public ::testing::NiceMock {}; + public ::testing::NiceMock, + public ::testing::NiceMock {}; + +std::unique_ptr module_; class BadgeTest : public TestFixture { public: - BadgeTest() : TestFixture(std::make_unique()) {} + BadgeTest() : TestFixture(std::make_unique()) { + setenv("AUL_APPID", "d::org.tizen.appfw.service.esd", 1); + } + virtual ~BadgeTest() {} - virtual void SetUp() { - pkgid_ = const_cast("mypkgid"); - pkgid2_ = const_cast("pkgname"); - pkgid3_ = const_cast("pkgname2"); - conn_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); - msg_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); - msg2_ = static_cast(g_object_new(G_TYPE_OBJECT, NULL)); + static void SetUpTestSuite() { + auto* mod = ESD_GET_MODULE(); + module_.reset(mod); + } + static void TearDownTestSuite() { + module_->Shutdown(); + module_.reset(); + unlink(DB_PATH); } - virtual void TearDown() { + virtual void SetUp() { + ON_CALL(GetMock(), aul_svc_get_appid_by_alias_appid(_, _)) + .WillByDefault(Return(-1)); + EXPECT_CALL(GetMock(), rpc_port_register_proc_info(_, _)) + .WillOnce(Return(0)); + EXPECT_CALL(GetMock(), rpc_port_stub_listen(_)) + .WillOnce(Return(0)); + module_->Startup(nullptr); } - char* pkgid_ = nullptr; - char* pkgid2_ = nullptr; - char* pkgid3_ = nullptr; - GDBusConnection* conn_ = nullptr; - GDBusMessage* msg_ = nullptr; - GDBusMessage* msg2_ = nullptr; + virtual void TearDown() { + DbDeleteAll(); + } }; TEST_F(BadgeTest, badge_new) { - int ret; bool is_supported = true; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - - EXPECT_CALL(GetMock(), - g_bus_get_sync(_, _, _)). - WillOnce(Return(conn_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - - ret = badge_new("testappid"); - - g_object_unref(conn_); - + int ret = badge_new("testappid"); EXPECT_EQ(ret, BADGE_ERROR_NONE); } TEST_F(BadgeTest, badge_add) { - int ret; bool is_supported = true; - package_manager_compare_result_type_e comp_ret = - PACKAGE_MANAGER_COMPARE_MATCH; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), - Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - - EXPECT_CALL(GetMock(), - package_manager_compare_app_cert_info(_, _, _)). - WillOnce(DoAll(SetArgPointee<2>(comp_ret), - Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - - ret = badge_add("myappid"); - + Return(0))); + int ret = badge_add("testappid"); EXPECT_EQ(ret, BADGE_ERROR_NONE); } TEST_F(BadgeTest, badge_remove) { - int ret; bool is_supported = true; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), - Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); + Return(0))); + int ret = badge_add("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); + ret = badge_remove("testappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); +} - ret = badge_remove("myappid"); +TEST_F(BadgeTest, badge_foreach) { + bool is_supported = true; + EXPECT_CALL(GetMock(), + system_info_get_platform_bool(_, _)). + WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), + Return(0))); + int ret = badge_add("testappid1"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + bool exist = false; + ret = badge_foreach([](const char* app_id, unsigned int count, + void* user_data) { + bool* exist = static_cast(user_data); + *exist = true; + return true; + }, &exist); EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_TRUE(exist); } TEST_F(BadgeTest, badge_set_count) { - int ret; bool is_supported = true; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); ret = badge_set_count("myappid", 9); - EXPECT_EQ(ret, BADGE_ERROR_NONE); } TEST_F(BadgeTest, badge_get_count) { - int ret; bool is_supported = true; unsigned int count = 0; - GVariant* body = g_variant_new("(i)", 3); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); + int ret = badge_add("myappid1"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_count("myappid1", 10); + EXPECT_EQ(ret, BADGE_ERROR_NONE); - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_get_body(_)). - WillOnce(Return(body)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - - ret = badge_get_count("myappid", &count); - - if (body) - g_variant_unref(body); - + ret = badge_get_count("myappid1", &count); EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_EQ(count, 10); } TEST_F(BadgeTest, badge_set_display) { - int ret; bool is_supported = true; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); ret = badge_set_display("myappid", 1); - EXPECT_EQ(ret, BADGE_ERROR_NONE); } TEST_F(BadgeTest, badge_get_display) { - int ret; bool is_supported = true; unsigned int is_display = 0; - GVariant* body = g_variant_new("(i)", 1); EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_get_body(_)). - WillOnce(Return(body)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); + int ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_set_display("myappid", 1); + EXPECT_EQ(ret, BADGE_ERROR_NONE); ret = badge_get_display("myappid", &is_display); - - if (body) - g_variant_unref(body); - EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_EQ(is_display, 1); } -bool _badge_foreach_cb( - const char* app_id, unsigned int count, void* user_data) { - return true; -} - -TEST_F(BadgeTest, badge_foreach) { - int ret; +TEST_F(BadgeTest, badge_register_changed_cb) { bool is_supported = true; - GVariant* body = g_variant_new("(a(v))", NULL); + bool changed = false; + static GMainLoop* loop; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_get_body(_)). - WillOnce(Return(body)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - - ret = badge_foreach(_badge_foreach_cb, NULL); - + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + auto* changed = static_cast(user_data); + *changed = true; + g_main_loop_quit(loop); + }, &changed); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -void _badge_change_cb(unsigned int action, const char* app_id, - unsigned int count, void* user_data) { -} - -guint _signal_subscribe(GDBusConnection* connection, const gchar* sender, - const gchar* interface_name, const gchar* member, - const gchar* object_path, const gchar* arg0, GDBusSignalFlags flags, - GDBusSignalCallback callback, gpointer user_data, - GDestroyNotify user_data_free_func) { + ret = badge_add("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); - GVariant* parameters = g_variant_new("(si)", "pkgname", 1000); - callback(nullptr, "", "", "", "insert_badge_notify", parameters, nullptr); - return 99; + EXPECT_TRUE(changed); + g_main_loop_unref(loop); } -TEST_F(BadgeTest, badge_register_changed_cb) { - int ret; +TEST_F(BadgeTest, badge_register_changed_cb2) { bool is_supported = true; - GDBusMessage* msg3 = static_cast( - g_object_new(G_TYPE_OBJECT, NULL)); - GDBusMessage* msg4 = static_cast( - g_object_new(G_TYPE_OBJECT, NULL)); + static GMainLoop* loop; + static bool inserted = false; + static bool deleted = false; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - EXPECT_CALL(GetMock(), - g_dbus_connection_signal_subscribe( - _, _, _, _, _, _, _, _, _, _)). - WillOnce(Invoke(_signal_subscribe)); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg3)). - WillOnce(Return(msg4)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillRepeatedly(Return(FALSE)); - - EXPECT_CALL(GetMock(), - g_bus_watch_name_on_connection( - _, _, _, _, _, _, _)). - WillOnce(Return(88)); - - ret = badge_register_changed_cb(_badge_change_cb, NULL); - + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_CREATE: + inserted = true; + break; + + case BADGE_ACTION_REMOVE: + deleted = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + inserted = false; + deleted = false; + ret = badge_add("myappid"); EXPECT_EQ(ret, BADGE_ERROR_NONE); + ret = badge_remove("myappid"); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + g_main_loop_run(loop); + + EXPECT_TRUE(inserted); + EXPECT_TRUE(deleted); + g_main_loop_unref(loop); } -TEST_F(BadgeTest, badge_unregister_changed_cb) { - int ret; +TEST_F(BadgeTest, badge_register_changed_cb3) { bool is_supported = true; + static GMainLoop* loop; + static bool updated = false; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), Return(0))); - - EXPECT_CALL(GetMock(), - g_bus_unwatch_name(_)). - Times(1); - - EXPECT_CALL(GetMock(), - g_dbus_connection_signal_unsubscribe(_, _)). - Times(1); - - ret = badge_unregister_changed_cb(_badge_change_cb); - - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -extern "C" const char* tzplatform_mkpath( - enum tzplatform_variable id, const char* path) { - return "badge.db"; -} - -TEST_F(BadgeTest, badge_db_is_existing) { - bool existing; - badge_db_init(); - int ret = badge_db_is_existing("test", &existing, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_insert) { - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - int ret = badge_db_insert(pkgid3_, "writable_pkg", "caller", 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_get_list) { - GList* list = nullptr; - int ret = badge_db_get_list(&list, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_delete) { - int ret = badge_db_delete(pkgid2_, "writable_pkgs", 1000, getpid()); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_delete_by_pkgname) { - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - int ret = badge_db_insert(pkgid2_, "writable_pkg", "caller", 1000); - ret = badge_db_delete_by_pkgname(pkgid2_, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_set_count) { - int ret = badge_db_set_count(pkgid3_, "caller", 2, 1000, getpid()); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_get_count) { - unsigned int cnt; - int ret = badge_db_get_count(pkgid3_, &cnt, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_set_display_option) { - int ret = badge_db_set_display_option(pkgid3_, 1, 1000); + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_UPDATE: + updated = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + updated = false; + ret = badge_add("myappid"); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_get_display_option) { - unsigned int is_display; - int ret = badge_db_get_display_option(pkgid3_, &is_display, 1000); + ret = badge_set_count("myappid", 1); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} + g_main_loop_run(loop); -TEST_F(BadgeTest, badge_create_for_uid) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillOnce(DoAll( - SetArgPointee<1>(true), - Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - int ret = badge_create_for_uid(pkgid3_, "writable_pkg", 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_new_for) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillRepeatedly(DoAll( - SetArgPointee<1>(true), - Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - int ret = badge_new_for(nullptr, "writable_pkg"); - EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_TRUE(updated); + g_main_loop_unref(loop); } -extern "C" GVariant* g_dbus_connection_call_sync( - GDBusConnection* connection, const gchar* bus_name, - const gchar* object_path, const gchar* interface_name, - const gchar* method_name, GVariant* parameters, - const GVariantType* reply_type, GDBusCallFlags flags, - gint timeout_msec, GCancellable* cancellable, GError** error) { - return g_variant_new("(b)", 1); -} - -TEST_F(BadgeTest, badge_is_service_ready) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillOnce(DoAll( - SetArgPointee<1>(true), - Return(0))); - - int ret = badge_is_service_ready(); - EXPECT_EQ(ret, 1); -} - -void _deferred_task(void* data) { -} - -TEST_F(BadgeTest, badge_add_deferred_task) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillOnce(DoAll( - SetArgPointee<1>(true), - Return(0))); - int ret = badge_add_deferred_task(_deferred_task, nullptr); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} +TEST_F(BadgeTest, badge_register_changed_cb4) { + bool is_supported = true; + static GMainLoop* loop; + static bool changed_disp = false; -TEST_F(BadgeTest, badge_del_deferred_task) { EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). - WillOnce(DoAll( - SetArgPointee<1>(true), - Return(0))); - int ret = badge_del_deferred_task(_deferred_task); + WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), + Return(0))); + loop = g_main_loop_new(nullptr, FALSE); + int ret = badge_register_changed_cb([](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + switch (action) { + case BADGE_ACTION_CHANGED_DISPLAY: + changed_disp = true; + g_main_loop_quit(loop); + break; + + default: + break; + } + }, nullptr); + EXPECT_EQ(ret, BADGE_ERROR_NONE); + + changed_disp = false; + ret = badge_add("myappid"); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_is_existing) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillRepeatedly(DoAll( - SetArgPointee<1>(true), - Return(0))); - - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - bool existing; - int ret = badge_is_existing(pkgid3_, &existing); + ret = badge_set_display("myappid", 1); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} + g_main_loop_run(loop); -TEST_F(BadgeTest, badge_create) { - EXPECT_CALL(GetMock(), - system_info_get_platform_bool(_, _)). - WillRepeatedly(DoAll( - SetArgPointee<1>(true), - Return(0))); - - EXPECT_CALL(GetMock(), - aul_app_get_pkgname_bypid(_, _, _)). - WillOnce(DoAll(SetArgPointee<1>(*pkgid_), - Return(0))); - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillOnce(Return(msg_)); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillOnce(Return(msg2_)); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillOnce(Return(FALSE)); - int ret = badge_create("pkgname3", "writable"); - EXPECT_EQ(ret, BADGE_ERROR_NONE); + EXPECT_TRUE(changed_disp); + g_main_loop_unref(loop); } -TEST_F(BadgeTest, badge_setting_positive) { - badge_setting_h setting; +TEST_F(BadgeTest, badge_unregister_changed_cb) { + bool is_supported = true; EXPECT_CALL(GetMock(), system_info_get_platform_bool(_, _)). - WillRepeatedly(DoAll(SetArgPointee<1>(true), - Return(0))); - EXPECT_CALL(GetMock(), - g_dbus_message_new_method_call(_, _, _, _)). - WillRepeatedly( - Invoke([&](const gchar* bus_name, const gchar* obj_path, - const gchar* interface_name, const gchar* method_name) - -> GDBusMessage* { - GDBusMessage* msg = - (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr); - return msg; - })); - - EXPECT_CALL(GetMock(), - g_dbus_connection_send_message_with_reply_sync( - _, _, _, _, _, _, _)). - WillRepeatedly( - Invoke([&](GDBusConnection* con, GDBusMessage* mesg, - GDBusSendMessageFlags flags, gint timeout, volatile guint32* out_serial, - GCancellable* cancelable, GError** error) - -> GDBusMessage* { - GDBusMessage* msg = - (GDBusMessage*)g_object_new(G_TYPE_OBJECT, nullptr); - return msg; - })); - - EXPECT_CALL(GetMock(), - g_dbus_message_get_body(_)). - WillRepeatedly( - Invoke([&](GDBusMessage* message) - -> GVariant* { - GVariant* reply = g_variant_new("(v)", - g_variant_new("(ssi)", pkgid2_, "appid", 1)); - return reply; - })); - - EXPECT_CALL(GetMock(), - g_dbus_message_to_gerror(_, _)). - WillRepeatedly(Return(FALSE)); - - int ret = badge_setting_get_setting_by_appid(&setting, "appid"); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - char* pkgname; - ret = badge_setting_get_pkgname(setting, &pkgname); - if (pkgname) - free(pkgname); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - char* appid; - ret = badge_setting_get_appid(setting, &appid); - if (appid) - free(appid); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - ret = badge_setting_set_allow_to_display(setting, true); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - bool allow; - ret = badge_setting_get_allow_to_display(setting, &allow); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - ret = badge_setting_update_setting(setting); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - - ret = badge_setting_free_setting(setting); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_setting_negative) { - int ret = badge_setting_get_setting_by_appid(nullptr, nullptr); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - char* pkgname; - ret = badge_setting_get_pkgname(nullptr, &pkgname); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - char* appid; - ret = badge_setting_get_appid(nullptr, &appid); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - ret = badge_setting_set_allow_to_display(nullptr, true); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - bool allow; - ret = badge_setting_get_allow_to_display(nullptr, &allow); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - ret = badge_setting_update_setting(nullptr); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); - - ret = badge_setting_free_setting(nullptr); - EXPECT_EQ(ret, BADGE_ERROR_INVALID_PARAMETER); -} - -TEST_F(BadgeTest, badge_db_get_setting_by_appid) { - badge_setting_h setting; - int ret = badge_db_get_setting_by_appid(pkgid3_, &setting, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); - badge_setting_free_setting(setting); -} - -TEST_F(BadgeTest, badge_db_update_setting) { - int ret = badge_db_update_setting(pkgid3_, pkgid3_, 1, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_get_allow_to_display_by_appid) { - int allow_to_display; - int ret = badge_db_get_allow_to_display_by_appid( - pkgid3_, &allow_to_display, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_update_app_disabled) { - int ret = badge_db_update_app_disabled( - pkgid3_, true, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -TEST_F(BadgeTest, badge_db_update_pkg_disabled) { - int ret = badge_db_update_pkg_disabled( - pkgid3_, true, 1000); - EXPECT_EQ(ret, BADGE_ERROR_NONE); -} - -extern "C" int pkgmgrinfo_pkginfo_filter_create( - pkgmgrinfo_pkginfo_filter_h* handle) { - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_pkginfo_filter_add_string( - pkgmgrinfo_pkginfo_filter_h handle, const char* property, - const char* value) { - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_filter_add_bool( - pkgmgrinfo_appinfo_filter_h handle, - const char* property, const bool value) { - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_pkginfo_get_pkgname( - pkgmgrinfo_pkginfo_h handle, char** pkg_name) { - *pkg_name = const_cast("pkgname"); - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_filter_create( - pkgmgrinfo_appinfo_filter_h* handle) { - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_filter_add_string( - pkgmgrinfo_appinfo_filter_h handle, const char* property, - const char* value) { - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_pkginfo_usr_filter_foreach_pkginfo( - pkgmgrinfo_pkginfo_filter_h handle, - pkgmgrinfo_pkg_list_cb pkg_cb, void* user_data, uid_t uid) { - pkg_cb(nullptr, user_data); - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_usr_filter_foreach_appinfo( - pkgmgrinfo_appinfo_filter_h handle, - pkgmgrinfo_app_list_cb app_cb, void* user_data, uid_t uid) { - - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_get_appid( - pkgmgrinfo_appinfo_h handle, char** appid) { - *appid = const_cast("pkgname"); - return PMINFO_R_OK; -} - -extern "C" int pkgmgrinfo_appinfo_get_pkgname( - pkgmgrinfo_appinfo_h handle, char** pkg_name) { - *pkg_name = const_cast("pkgname"); - return PMINFO_R_OK; -} + WillRepeatedly(DoAll(SetArgPointee<1>(is_supported), + Return(0))); + auto cb = [](unsigned int action, + const char* app_id, unsigned int count, void* user_data) { + }; -TEST_F(BadgeTest, badge_setting_insert_package_for_uid) { - int ret = badge_setting_insert_package_for_uid(pkgid2_, 1000); + int ret = badge_register_changed_cb(cb, nullptr); EXPECT_EQ(ret, BADGE_ERROR_NONE); -} -TEST_F(BadgeTest, badge_setting_delete_package_for_uid) { - int ret = badge_setting_delete_package_for_uid(pkgid2_, 1000); + ret = badge_unregister_changed_cb(cb); EXPECT_EQ(ret, BADGE_ERROR_NONE); } diff --git a/tests/unit_tests/src/test_main.cc b/tests/unit_tests/src/test_main.cc index c2eb730..a4631b3 100644 --- a/tests/unit_tests/src/test_main.cc +++ b/tests/unit_tests/src/test_main.cc @@ -17,6 +17,23 @@ #include #include +//#define LOG_INTERNAL + +#ifdef LOG_INTERNAL +#include + +extern "C" int __dlog_print(log_id_t log_id, int prio, const char *tag, const char *fmt, ...) { + printf("%s:", tag); + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + printf("\n"); + + return 0; +} +#endif + int main(int argc, char** argv) { int ret = -1; diff --git a/tidl/badge.tidl b/tidl/badge.tidl new file mode 100755 index 0000000..9f1808a --- /dev/null +++ b/tidl/badge.tidl @@ -0,0 +1,29 @@ +protocol 2 + +struct BadgeInfo { + enum Action { + Create = 0, + Remove, + Update, + ChangedDisplay, + ServiceReady + } + + string PkgName; + int Count; +} + +[privilege = "http://tizen.org/privilege/notification"] +interface Badge { + void ChangedCb(BadgeInfo.Action action, string appid, int count) delegate; + + array GetList(); + bool Insert(string appid, string writable_pkg, string caller); + bool Delete(string appid, string caller); + bool SetCount(string appid, string caller, int count); + int GetCount(string appid); + bool SetDisplayOption(string appid, string caller, bool isDisplay); + bool GetDisplayOption(string appid); + bool Register(ChangedCb cb); + bool Unregister(); +} diff --git a/tidl/prebuild.sh b/tidl/prebuild.sh new file mode 100755 index 0000000..2a4795d --- /dev/null +++ b/tidl/prebuild.sh @@ -0,0 +1,3 @@ +#!/bin/bash +tidlc -p -l C++ -i ./badge.tidl -o badge_proxy +tidlc -s -l C++ -i ./badge.tidl -o badge_stub diff --git a/tool/CMakeLists.txt b/tool/CMakeLists.txt deleted file mode 100644 index 7b9dae5..0000000 --- a/tool/CMakeLists.txt +++ /dev/null @@ -1,29 +0,0 @@ -AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ BADGE_INIT_SRCS) -ADD_EXECUTABLE(${TARGET_BADGE_INIT} - ${BADGE_INIT_SRCS} -) - -TARGET_INCLUDE_DIRECTORIES(${TARGET_BADGE_INIT} PUBLIC - "${CMAKE_CURRENT_SOURCE_DIR}/../include" -) - -APPLY_PKG_CONFIG(${TARGET_BADGE_INIT} PUBLIC - AUL_DEP - DLOG_DEPS - VCONF_DEPS - PKGMGR_DEPS - SYSTEM_INFO_DEPS - DB_UTIL_DEPS - PLATFORM_CONFIG_DEPS - PKGMGR_INFO_DEPS - SMACK_DEPS - GLIB_DEPS - GIO_DEPS -) - - -TARGET_LINK_LIBRARIES(${TARGET_BADGE_INIT} PUBLIC ${TARGET_BADGE}) -SET_TARGET_PROPERTIES(${TARGET_BADGE_INIT} PROPERTIES COMPILE_FLAGS "-fPIE") -SET_TARGET_PROPERTIES(${TARGET_BADGE_INIT} PROPERTIES LINK_FLAGS "-pie") - -INSTALL(TARGETS badge_init DESTINATION bin) \ No newline at end of file diff --git a/tool/badge_init.c b/tool/badge_init.c deleted file mode 100644 index a6cf681..0000000 --- a/tool/badge_init.c +++ /dev/null @@ -1,70 +0,0 @@ -/* - * Copyright (c) 2016 - 2017 Samsung Electronics Co., Ltd. All rights reserved. - * - * 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. - * - */ - -#define _GNU_SOURCE - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#define OWNER_ROOT 0 - -#ifdef _E -#undef _E -#endif -#define _E(fmt, arg...) fprintf(stderr, "[BADGE_INIT][E][%s,%d] "fmt"\n", \ - __func__, __LINE__, ##arg) - -static int __is_authorized(void) -{ - uid_t uid = getuid(); - - if ((uid_t)OWNER_ROOT == uid) - return 1; - else - return 0; -} - -int main(int argc, char *argv[]) -{ - int ret; - uid_t uid = OWNER_ROOT; - - if (!__is_authorized()) { - _E("You are not an authorized user!"); - return -1; - } - - if (argc > 2) - uid = (uid_t)atoi(argv[2]); - - ret = badge_setting_refresh_setting_table(uid); - if (ret != BADGE_ERROR_NONE) - _E("badge setting table refresh fail."); - - return ret; -} -- 2.7.4