diff --git a/common/utils/include/bundle_memory_guard.h b/common/utils/include/bundle_memory_guard.h index 6bc57dab1d4958f96ae1f430039b48891d30aed4..83a4e685533a1fdd8e0a56efe2c9f2b6023d8e23 100644 --- a/common/utils/include/bundle_memory_guard.h +++ b/common/utils/include/bundle_memory_guard.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -21,6 +21,8 @@ class BundleMemoryGuard final { public: BundleMemoryGuard(); ~BundleMemoryGuard(); + static void SetBundleMemoryGuard(); + static void ClearBundleMemoryGuard(); }; } // AppExecFwk } // OHOS diff --git a/common/utils/src/bundle_memory_guard.cpp b/common/utils/src/bundle_memory_guard.cpp index 833558dd12f64018fc1d30fbbbed885390e73743..177333a236370b4260ea71b7ebb7ea2476f03f60 100644 --- a/common/utils/src/bundle_memory_guard.cpp +++ b/common/utils/src/bundle_memory_guard.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -37,5 +37,23 @@ BundleMemoryGuard::~BundleMemoryGuard() APP_LOGD("flush cache, result: %{public}d", err); #endif } + +void BundleMemoryGuard::SetBundleMemoryGuard() +{ +#ifdef CONFIG_USE_JEMALLOC_DFX_INTF + // 0 indicates success + int32_t thread_cache_ret = mallopt(M_SET_THREAD_CACHE, M_THREAD_CACHE_DISABLE); + int32_t delay_free_ret = mallopt(M_DELAYED_FREE, M_DELAYED_FREE_DISABLE); + APP_LOGD("disable tcache and delay free, result:%{public}d, %{public}d", thread_cache_ret, delay_free_ret); +#endif +} + +void BundleMemoryGuard::ClearBundleMemoryGuard() +{ +#ifdef CONFIG_USE_JEMALLOC_DFX_INTF + int32_t flush_ret = mallopt(M_FLUSH_THREAD_CACHE, 0); + APP_LOGD("flush cache, result: %{public}d", flush_ret); +#endif +} } // AppExecFwk } // OHOS diff --git a/interfaces/inner_api/appexecfwk_base/include/appexecfwk_errors.h b/interfaces/inner_api/appexecfwk_base/include/appexecfwk_errors.h index 62f8bae1aaf6b5444167845599a8c7a98649397c..8785c64173dcb280b3fc74c47d7a57aafbc05778 100644 --- a/interfaces/inner_api/appexecfwk_base/include/appexecfwk_errors.h +++ b/interfaces/inner_api/appexecfwk_base/include/appexecfwk_errors.h @@ -626,6 +626,9 @@ enum { // ark startup cache ERR_APPEXECFWK_ARK_STARTUP_CACHE_ONLY_ALLOW_CREATE_APP_OR_ATOMIC = 8522591, ERR_APPEXECFWK_ARK_STARTUP_CACHE_ONLY_ALLOW_CREATE_IN_WHITE_LIST = 8522592, + + //IDL + ERR_APPEXECFWK_IDL_GET_RESULT_ERROR = 8522610, }; // Error code for Hidump diff --git a/interfaces/inner_api/appexecfwk_core/BUILD.gn b/interfaces/inner_api/appexecfwk_core/BUILD.gn index 161b580d852c8b5bdadd63dead08560d97a13fd7..162121d99f1a57548f1f2f826bff20363a5acaa8 100644 --- a/interfaces/inner_api/appexecfwk_core/BUILD.gn +++ b/interfaces/inner_api/appexecfwk_core/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2024 Huawei Device Co., Ltd. +# Copyright (c) 2021-2025 Huawei Device 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 @@ -11,9 +11,19 @@ # See the License for the specific language governing permissions and # limitations under the License. +import("//build/config/components/idl_tool/idl.gni") import("//build/ohos.gni") import("../../../appexecfwk.gni") +idl_gen_interface("overlay_manager_interface") { + sources = [ "IOverlayManager.idl" ] + # log_domainid = "0xD001120" + # log_tag = "BMS" + subsystem_name = "bundlemanager" + part_name = "bundle_framework" + hitrace = "HITRACE_TAG_APP" +} + config("bundlemgr_sdk_config") { include_dirs = [ "include", @@ -32,6 +42,7 @@ config("bundlemgr_sdk_config") { config("appexecfwk_core_config") { include_dirs = [ "${common_path}/log/include", + "${target_gen_dir}", "include", ] } @@ -114,7 +125,7 @@ ohos_shared_library("appexecfwk_core") { "hilog:libhilog", "hitrace:hitrace_meter", "ipc:ipc_core", - "safwk:api_cache_manager" + "safwk:api_cache_manager", ] public_external_deps = [ @@ -157,10 +168,14 @@ ohos_shared_library("appexecfwk_core") { if (bundle_framework_overlay_install) { defines += [ "BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION" ] - sources += [ - "src/overlay/overlay_manager_host.cpp", - "src/overlay/overlay_manager_proxy.cpp", - ] + sources += [ "src/overlay/overlay_manager_client.cpp" ] + output_values = get_target_outputs(":overlay_manager_interface") + sources += filter_include(output_values, + [ + "*overlay_manager_proxy.cpp", + "*overlay_manager_stub.cpp", + ]) + deps += [ ":overlay_manager_interface" ] } if (bundle_framework_bundle_resource) { @@ -223,6 +238,7 @@ ohos_shared_library("bundlemgr_mini") { cflags += [ "-DBINDER_IPC_32BIT" ] } deps = [ + ":overlay_manager_interface", "${base_path}:appexecfwk_base", "${common_path}:libappexecfwk_common", ] @@ -249,3 +265,73 @@ ohos_shared_library("bundlemgr_mini") { ] part_name = "bundle_framework" } +ohos_source_set("overlay_manager_proxy") { + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } + configs = [ ":appexecfwk_core_config" ] + cflags = [ + "-Os", + "-fstack-protector-strong", + ] + cflags_cc = [ + "-Os", + "-fstack-protector-strong", + ] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + output_values = get_target_outputs(":overlay_manager_interface") + sources = filter_include(output_values, [ "*overlay_manager_proxy.cpp" ]) + deps = [ + ":overlay_manager_interface", + "${base_path}:appexecfwk_base", + ] + external_deps = [ + "hilog:libhilog", + "hitrace:hitrace_meter", + ] + subsystem_name = "bundlemanager" + part_name = "bundle_framework" +} + +ohos_source_set("overlay_manager_stub") { + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } + configs = [ ":appexecfwk_core_config" ] + cflags = [ + "-Os", + "-fstack-protector-strong", + ] + + cflags_cc = [ + "-Os", + "-fstack-protector-strong", + ] + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + output_values = get_target_outputs(":overlay_manager_interface") + sources = filter_include(output_values, [ "*overlay_manager_stub.cpp" ]) + deps = [ + ":overlay_manager_interface", + "${base_path}:appexecfwk_base", + ] + external_deps = [ + "hilog:libhilog", + "hitrace:hitrace_meter", + ] + subsystem_name = "bundlemanager" + part_name = "bundle_framework" +} diff --git a/interfaces/inner_api/appexecfwk_core/IOverlayManager.idl b/interfaces/inner_api/appexecfwk_core/IOverlayManager.idl new file mode 100644 index 0000000000000000000000000000000000000000..12c3e1637b1472304abb44af9ef68fac80f0fb4d --- /dev/null +++ b/interfaces/inner_api/appexecfwk_core/IOverlayManager.idl @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2025 Huawei Device 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. + */ + +package OHOS.AppExecFwk; +interface_token ohos.bundleManager.OverlayManager; +sequenceable Overlay.OverlayBundleInfo..OHOS.AppExecFwk.OverlayBundleInfo; +sequenceable Overlay.OverlayModuleInfo..OHOS.AppExecFwk.OverlayModuleInfo; +option_stub_hooks on; + interface OHOS.AppExecFwk.IOverlayManager { + [ipccode 0] void GetAllOverlayModuleInfo([in] String bundleName, [in] int userId, [out] OverlayModuleInfo[] overlayModuleInfos, + [out] int funcResult); + [ipccode 1] void GetOverlayModuleInfo([in] String bundleName, [in] String moduleName, [in] int userId, + [out] OverlayModuleInfo overlayModuleInfo, [out] int funcResult); + [ipccode 2] void GetOverlayModuleInfo([in] String moduleName, [in] int userId, + [out] OverlayModuleInfo overlayModuleInfo, [out] int funcResult); + [ipccode 3] void GetTargetOverlayModuleInfo([in] String targetModuleName, [in] int userId, + [out] OverlayModuleInfo[] overlayModuleInfos, [out] int funcResult); + [ipccode 4] void GetOverlayModuleInfoByBundleName([in] String bundleName, [in] String moduleName, [in] int userId, + [out] OverlayModuleInfo[] overlayModuleInfos, [out] int funcResult); + [ipccode 5] void GetOverlayBundleInfoForTarget([in] String targetBundleName, [in] int userId, + [out] OverlayBundleInfo[] overlayBundleInfos, [out] int funcResult); + [ipccode 6] void GetOverlayModuleInfoForTarget([in] String targetBundleName, [in] String targetModuleName, + [in] int userId,[out] OverlayModuleInfo[] overlayModuleInfos, [out] int funcResult); + [ipccode 7] void SetOverlayEnabled([in] String bundleName, [in] String moduleName, [in] boolean isEnabled, + [in] int userId, [out] int funcResult); + [ipccode 8] void SetOverlayEnabledForSelf([in] String moduleName, [in] boolean isEnabled, [in] int userId, + [out] int funcResult); + } \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/bundlemgr/bundle_mgr_interface.h b/interfaces/inner_api/appexecfwk_core/include/bundlemgr/bundle_mgr_interface.h index 9fb263296e76bcf59a64078ea3bddc39e7503ab8..3a7d8d04e84a933619063d66e74c90a43b43a74f 100644 --- a/interfaces/inner_api/appexecfwk_core/include/bundlemgr/bundle_mgr_interface.h +++ b/interfaces/inner_api/appexecfwk_core/include/bundlemgr/bundle_mgr_interface.h @@ -39,7 +39,7 @@ #include "bundle_resource_interface.h" #include "default_app_interface.h" #include "extend_resource_manager_interface.h" -#include "overlay_manager_interface.h" +#include "ioverlay_manager.h" #include "plugin/plugin_bundle_info.h" #include "quick_fix_manager_interface.h" #include "verify_manager_interface.h" diff --git a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_client.h b/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_client.h new file mode 100644 index 0000000000000000000000000000000000000000..0483ecff3e67fd58b0383017424af02f946a04f1 --- /dev/null +++ b/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_client.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2025 Huawei Device 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 FOUNDATION_APPEXECFWK_INTERFACES_INNERAPI_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_CLIENT_H +#define FOUNDATION_APPEXECFWK_INTERFACES_INNERAPI_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_CLIENT_H + +#include + +#include "bundle_constants.h" +#include "ioverlay_manager.h" +#include "overlay/overlay_bundle_info.h" +#include "overlay/overlay_module_info.h" + +namespace OHOS { +namespace AppExecFwk { +class OverlayManagerClient { +public: + static OverlayManagerClient &GetInstance(); + + ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, + std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, + OverlayModuleInfo &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetOverlayModuleInfo(const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, + int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, + std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetOverlayModuleInfoByBundleName(const std::string &bundleName, const std::string &moduleName, + std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, + std::vector &overlayBundleInfos, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode GetOverlayModuleInfoForTarget(const std::string &targetBundleName, + const std::string &targetModuleName, std::vector &overlayModuleInfos, + int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, + bool isEnabled, int32_t userId = Constants::UNSPECIFIED_USERID); + + ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, + int32_t userId = Constants::UNSPECIFIED_USERID); + +private: + OverlayManagerClient() = default; + ~OverlayManagerClient() = default; + DISALLOW_COPY_AND_MOVE(OverlayManagerClient); + sptr GetOverlayManagerProxy(); + void ResetOverlayManagerProxy(const wptr& remote); + class OverlayManagerDeathRecipient : public IRemoteObject::DeathRecipient { + public: + OverlayManagerDeathRecipient() = default; + ~OverlayManagerDeathRecipient() override = default; + void OnRemoteDied(const wptr& remote) override; + + private: + DISALLOW_COPY_AND_MOVE(OverlayManagerDeathRecipient); + }; + std::mutex mutex_; + sptr overlayManagerProxy_; + sptr deathRecipient_; +}; +} // AppExecFwk +} // OHOS +#endif // FOUNDATION_APPEXECFWK_INTERFACES_INNERAPI_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_CLIENT_H \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_host.h b/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_host.h deleted file mode 100644 index c838aa3ecd633337f0c9771715af4b29bf3516a0..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_host.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device 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 FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_HOST_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_HOST_H - -#include "overlay_manager_interface.h" -#include "iremote_stub.h" -#include "nocopyable.h" - -namespace OHOS { -namespace AppExecFwk { -class OverlayManagerHost : public IRemoteStub { -public: - OverlayManagerHost(); - virtual ~OverlayManagerHost(); - - int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; - -private: - ErrCode HandleGetAllOverlayModuleInfo(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetOverlayModuleInfoByName(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetOverlayModuleInfo(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetTargetOverlayModuleInfo(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetOverlayModuleInfoByBundleName(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetOverlayBundleInfoForTarget(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleGetOverlayModuleInfoForTarget(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleSetOverlayEnabled(MessageParcel &data, MessageParcel &reply); - - ErrCode HandleSetOverlayEnabledForSelf(MessageParcel &data, MessageParcel &reply); - - template - bool WriteParcelableVector(std::vector &parcelableVector, MessageParcel &reply); - - DISALLOW_COPY_AND_MOVE(OverlayManagerHost); -}; -} // AppExecFwk -} // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_HOST_H diff --git a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_interface.h b/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_interface.h deleted file mode 100644 index e9494bbffbb3a7b448e2ee3539dda13ad06bdc51..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_interface.h +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device 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 FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_INTERFACE_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_INTERFACE_H - -#include "appexecfwk_errors.h" -#include "bundle_info.h" -#include "iremote_broker.h" - -#include -#include - -namespace OHOS { -namespace AppExecFwk { -class IOverlayManager : public IRemoteBroker { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.bundleManager.OverlayManager"); - - virtual ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetOverlayModuleInfoByBundleName(const std::string &bundleName, const std::string &moduleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } - - virtual ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) - { - return ERR_BUNDLEMANAGER_OVERLAY_INSTALLATION_FAILED_INTERNAL_ERROR; - } -}; -} // AppExecFwk -} // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_INTERFACE_H \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_proxy.h b/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_proxy.h deleted file mode 100644 index a3e8bc195559bab4f319109ec74ec0b7bb0ee219..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/include/overlay/overlay_manager_proxy.h +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright (c) 2023 Huawei Device 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 FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_PROXY_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_PROXY_H - -#include "bundle_framework_core_ipc_interface_code.h" -#include "overlay_manager_interface.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace AppExecFwk { -class OverlayManagerProxy : public IRemoteProxy { -public: - explicit OverlayManagerProxy(const sptr &object); - virtual ~OverlayManagerProxy(); - - virtual ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetOverlayModuleInfoByBundleName(const std::string &bundleName, const std::string &moduleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, - bool isEnabled, int32_t userId = Constants::UNSPECIFIED_USERID) override; - - virtual ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - -private: - template - ErrCode GetParcelableInfo(OverlayManagerInterfaceCode code, MessageParcel &data, T &parcelableInfo); - - template - ErrCode GetParcelableInfosWithErrCode(OverlayManagerInterfaceCode code, MessageParcel &data, - std::vector &parcelableInfos); - - bool SendTransactCmd(OverlayManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply); - - static inline BrokerDelegator delegator_; -}; -} // AppExecFwk -} // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_OVERLAY_MANAGER_PROXY_H diff --git a/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_client.cpp b/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_client.cpp new file mode 100644 index 0000000000000000000000000000000000000000..de3202f453d7731219e9243e2ed679b62a01f228 --- /dev/null +++ b/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_client.cpp @@ -0,0 +1,310 @@ +/* + * Copyright (c) 2025 Huawei Device 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 "overlay_manager_client.h" + +#include "app_log_wrapper.h" +#include "bundle_mgr_proxy.h" +#include "bundle_mgr_service_death_recipient.h" +#include "iservice_registry.h" +#include "overlay_manager_proxy.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace AppExecFwk { + +OverlayManagerClient &OverlayManagerClient::GetInstance() +{ + static OverlayManagerClient instance; + return instance; +} + +ErrCode OverlayManagerClient::GetAllOverlayModuleInfo(const std::string &bundleName, + std::vector &overlayModuleInfos, int32_t userId) +{ + APP_LOGD("begin to call GetAllOverlayModuleInfo"); + if (bundleName.empty()) { + APP_LOGE("GetAllOverlayModuleInfo failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetAllOverlayModuleInfo(bundleName, userId, overlayModuleInfos, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetAllOverlayModuleInfo end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetOverlayModuleInfo(const std::string &bundleName, + const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, int32_t userId) +{ + APP_LOGD("begin to call GetOverlayModuleInfo"); + if (bundleName.empty() || moduleName.empty()) { + APP_LOGE("GetOverlayModuleInfo failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + ErrCode funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetOverlayModuleInfo(bundleName, moduleName, userId, overlayModuleInfo, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetOverlayModuleInfo end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetOverlayModuleInfo(const std::string &moduleName, + OverlayModuleInfo &overlayModuleInfo, int32_t userId) +{ + APP_LOGD("begin to call GetOverlayModuleInfo"); + if (moduleName.empty()) { + APP_LOGE("GetOverlayModuleInfo failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetOverlayModuleInfo(moduleName, userId, overlayModuleInfo, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetOverlayModuleInfo end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetTargetOverlayModuleInfo(const std::string &targetModuleName, + std::vector &overlayModuleInfos, int32_t userId) +{ + APP_LOGD("begin to call GetTargetOverlayModuleInfo"); + if (targetModuleName.empty()) { + APP_LOGE("GetTargetOverlayModuleInfo failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetTargetOverlayModuleInfo(targetModuleName, userId, overlayModuleInfos, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetTargetOverlayModuleInfo end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetOverlayModuleInfoByBundleName(const std::string &bundleName, + const std::string &moduleName, std::vector &overlayModuleInfos, int32_t userId) +{ + APP_LOGD("begin to call GetOverlayModuleInfoByBundleName"); + if (bundleName.empty()) { + APP_LOGE("GetOverlayModuleInfoByBundleName failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetOverlayModuleInfoByBundleName(bundleName, moduleName, userId, + overlayModuleInfos, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetOverlayModuleInfoByBundleName end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetOverlayBundleInfoForTarget(const std::string &targetBundleName, + std::vector &overlayBundleInfos, int32_t userId) +{ + APP_LOGD("begin to call GetOverlayBundleInfoForTarget"); + if (targetBundleName.empty()) { + APP_LOGE("GetOverlayBundleInfoForTarget failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetOverlayBundleInfoForTarget(targetBundleName, userId, overlayBundleInfos, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetOverlayBundleInfoForTarget end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::GetOverlayModuleInfoForTarget(const std::string &targetBundleName, + const std::string &targetModuleName, std::vector &overlayModuleInfos, int32_t userId) +{ + APP_LOGD("begin to call GetOverlayModuleInfoForTarget"); + if (targetBundleName.empty()) { + APP_LOGE("GetOverlayModuleInfoForTarget failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->GetOverlayModuleInfoForTarget(targetBundleName, targetModuleName, + userId, overlayModuleInfos, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("GetOverlayModuleInfoForTarget end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::SetOverlayEnabled(const std::string& bundleName, const std::string& moduleName, + bool isEnabled, int32_t userId) +{ + APP_LOGD("begin to call SetOverlayEnabled"); + if (bundleName.empty() || moduleName.empty()) { + APP_LOGE("SetOverlayEnabled failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + } + + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->SetOverlayEnabled(bundleName, moduleName, isEnabled, userId, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("SetOverlayEnabled end, errCode is %{public}d", funcResult); + return funcResult; +} + +ErrCode OverlayManagerClient::SetOverlayEnabledForSelf(const std::string& moduleName, bool isEnabled, int32_t userId) +{ + APP_LOGD("begin to call SetOverlayEnabledForSelf"); + if (moduleName.empty()) { + APP_LOGE("SetOverlayEnabledForSelf failed due to params error"); + return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + } + auto proxy = GetOverlayManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get overlay manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; + } + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode proxyRet = proxy->SetOverlayEnabledForSelf(moduleName, isEnabled, userId, funcResult); + if (proxyRet != ERR_OK) { + APP_LOGE("proxy fail"); + return ERR_APPEXECFWK_PARCEL_ERROR; + } + APP_LOGD("SetOverlayEnabledForSelf end, errCode is %{public}d", funcResult); + return funcResult; +} + +void OverlayManagerClient::ResetOverlayManagerProxy(const wptr &remote) +{ + std::lock_guard lock(mutex_); + if (overlayManagerProxy_ == nullptr) { + APP_LOGE("Proxy is nullptr"); + return ; + } + auto serviceRemote = overlayManagerProxy_->AsObject(); + if ((serviceRemote != nullptr) && (serviceRemote == remote.promote())) { + serviceRemote->RemoveDeathRecipient(deathRecipient_); + } + overlayManagerProxy_ = nullptr; + deathRecipient_ = nullptr; +} + +void OverlayManagerClient::OverlayManagerDeathRecipient::OnRemoteDied(const wptr &remote) +{ + if (remote == nullptr) { + APP_LOGE("remote is nullptr"); + return; + } + OverlayManagerClient::GetInstance().ResetOverlayManagerProxy(remote); +} + +sptr OverlayManagerClient::GetOverlayManagerProxy() +{ + std::lock_guard lock(mutex_); + if (overlayManagerProxy_ != nullptr) { + return overlayManagerProxy_; + } + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (systemAbilityManager == nullptr) { + APP_LOGE("failed to get system ability manager"); + return nullptr; + } + + sptr remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + if (remoteObject == nullptr) { + APP_LOGE_NOFUNC("get bms sa failed"); + return nullptr; + } + auto bundleMgr = iface_cast(remoteObject); + if (bundleMgr == nullptr) { + APP_LOGE_NOFUNC("get bms sa failed"); + return nullptr; + } + overlayManagerProxy_ = bundleMgr->GetOverlayManagerProxy(); + if ((overlayManagerProxy_ == nullptr) || (overlayManagerProxy_->AsObject() == nullptr)) { + APP_LOGE("failed to get overlay manager proxy"); + return nullptr; + } + deathRecipient_ = new (std::nothrow) OverlayManagerDeathRecipient(); + if (deathRecipient_ == nullptr) { + APP_LOGE("failed to create OverlayManager death recipient"); + return nullptr; + } + if ((overlayManagerProxy_->AsObject()->IsProxyObject()) && + (!overlayManagerProxy_->AsObject()->AddDeathRecipient(deathRecipient_))) { + APP_LOGE("Failed to add death recipient"); + overlayManagerProxy_ = nullptr; + deathRecipient_ = nullptr; + return nullptr; + } + return overlayManagerProxy_; +} +} +} \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_host.cpp b/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_host.cpp deleted file mode 100644 index a2fa33663be08ce177da33cbc23f9bccb393f596..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_host.cpp +++ /dev/null @@ -1,292 +0,0 @@ -/* - * Copyright (c) 2022-2025 Huawei Device 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 "overlay_manager_host.h" - -#include "app_log_wrapper.h" -#include "appexecfwk_errors.h" -#include "bundle_framework_core_ipc_interface_code.h" -#include "bundle_memory_guard.h" -#include "hitrace_meter.h" -#include "ipc_types.h" - -namespace OHOS { -namespace AppExecFwk { -OverlayManagerHost::OverlayManagerHost() -{ - APP_LOGD("create OverlayManagerHost"); -} - -OverlayManagerHost::~OverlayManagerHost() -{ - APP_LOGD("destroy OverlayManagerHost"); -} - -int OverlayManagerHost::OnRemoteRequest(uint32_t code, MessageParcel& data, - MessageParcel& reply, MessageOption& option) -{ - BundleMemoryGuard memoryGuard; - APP_LOGD("bundle mgr host onReceived message, the message code is %{public}u", code); - std::u16string descriptor = OverlayManagerHost::GetDescriptor(); - std::u16string remoteDescriptor = data.ReadInterfaceToken(); - if (descriptor != remoteDescriptor) { - APP_LOGE("fail to write reply message in bundle mgr host due to the reply is nullptr"); - return OBJECT_NULL; - } - - ErrCode errCode = ERR_OK; - switch (code) { - case static_cast(OverlayManagerInterfaceCode::GET_ALL_OVERLAY_MODULE_INFO): - errCode = this->HandleGetAllOverlayModuleInfo(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_NAME): - errCode = this->HandleGetOverlayModuleInfoByName(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO): - errCode = this->HandleGetOverlayModuleInfo(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_TARGET_OVERLAY_MODULE_INFOS): - errCode = this->HandleGetTargetOverlayModuleInfo(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME): - errCode = this->HandleGetOverlayModuleInfoByBundleName(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_BUNDLE_INFO_FOR_TARGET): - errCode = this->HandleGetOverlayBundleInfoForTarget(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_FOR_TARGET): - errCode = this->HandleGetOverlayModuleInfoForTarget(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED): - errCode = this->HandleSetOverlayEnabled(data, reply); - break; - case static_cast(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED_FOR_SELF): - errCode = this->HandleSetOverlayEnabledForSelf(data, reply); - break; - default : - APP_LOGW("overlayMgr host receives unknown code %{public}u", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - APP_LOGD("overlayMgr host finish to process message"); - return (errCode == ERR_OK) ? NO_ERROR : UNKNOWN_ERROR; -} - -ErrCode OverlayManagerHost::HandleGetAllOverlayModuleInfo(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - APP_LOGD("bundleName %{public}s, userId %{public}d", bundleName.c_str(), userId); - - std::vector infos; - auto res = GetAllOverlayModuleInfo(bundleName, infos, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (res == ERR_OK) { - if (!WriteParcelableVector(infos, reply)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetOverlayModuleInfoByName(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - std::string moduleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - APP_LOGD("bundleName %{public}s, moduleName %{public}s, userId %{public}d", bundleName.c_str(), - moduleName.c_str(), userId); - - OverlayModuleInfo info; - auto res = GetOverlayModuleInfo(bundleName, moduleName, info, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (res == ERR_OK) { - if (!reply.WriteParcelable(&info)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetOverlayModuleInfo(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string moduleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - APP_LOGD("moduleName %{public}s, userId %{public}d", moduleName.c_str(), userId); - - OverlayModuleInfo info; - auto res = GetOverlayModuleInfo(moduleName, info, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (res == ERR_OK) { - if (!reply.WriteParcelable(&info)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetTargetOverlayModuleInfo(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string targetModuleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - - std::vector overlayModuleInfos; - auto res = GetTargetOverlayModuleInfo(targetModuleName, overlayModuleInfos, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (res == ERR_OK) { - if (!WriteParcelableVector(overlayModuleInfos, reply)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetOverlayModuleInfoByBundleName(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - std::string moduleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - APP_LOGD("bundleName %{public}s, userId %{public}d", bundleName.c_str(), userId); - - std::vector infos; - auto res = GetOverlayModuleInfoByBundleName(bundleName, moduleName, infos, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (res == ERR_OK) { - if (!WriteParcelableVector(infos, reply)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetOverlayBundleInfoForTarget(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string targetBundleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - - std::vector overlayBundleInfo; - auto res = GetOverlayBundleInfoForTarget(targetBundleName, overlayBundleInfo, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (res == ERR_OK) { - if (!WriteParcelableVector(overlayBundleInfo, reply)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleGetOverlayModuleInfoForTarget(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string targetBundleName = data.ReadString(); - std::string targetModuleName = data.ReadString(); - int32_t userId = data.ReadInt32(); - - std::vector overlayModuleInfo; - auto res = GetOverlayModuleInfoForTarget(targetBundleName, targetModuleName, overlayModuleInfo, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (res == ERR_OK) { - if (!WriteParcelableVector(overlayModuleInfo, reply)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleSetOverlayEnabled(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - std::string moduleName = data.ReadString(); - bool isEnabled = data.ReadBool(); - int32_t userId = data.ReadInt32(); - - auto res = SetOverlayEnabled(bundleName, moduleName, isEnabled, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - return ERR_OK; -} - -ErrCode OverlayManagerHost::HandleSetOverlayEnabledForSelf(MessageParcel &data, MessageParcel &reply) -{ - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string moduleName = data.ReadString(); - bool isEnabled = data.ReadBool(); - int32_t userId = data.ReadInt32(); - - auto res = SetOverlayEnabledForSelf(moduleName, isEnabled, userId); - if (!reply.WriteInt32(res)) { - APP_LOGE("write failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - return ERR_OK; -} - -template -bool OverlayManagerHost::WriteParcelableVector(std::vector &parcelableVector, MessageParcel &reply) -{ - if (!reply.WriteInt32(parcelableVector.size())) { - APP_LOGE("write ParcelableVector failed"); - return false; - } - - for (auto &parcelable : parcelableVector) { - if (!reply.WriteParcelable(&parcelable)) { - APP_LOGE("write ParcelableVector failed"); - return false; - } - } - return true; -} -} // AppExecFwk -} // namespace OHOS diff --git a/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_proxy.cpp b/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_proxy.cpp deleted file mode 100644 index f3c1dfe261d3528744dad24f69adca0a490dc356..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/src/overlay/overlay_manager_proxy.cpp +++ /dev/null @@ -1,409 +0,0 @@ -/* - * Copyright (c) 2023-2025 Huawei Device 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 "overlay_manager_proxy.h" - -#include "app_log_wrapper.h" -#include "appexecfwk_errors.h" -#include "hitrace_meter.h" -#include "ipc_types.h" -#include "parcel_macro.h" - -namespace OHOS { -namespace AppExecFwk { -OverlayManagerProxy::OverlayManagerProxy(const sptr &object) : IRemoteProxy(object) -{ - APP_LOGD("create OverlayManagerProxy"); -} - -OverlayManagerProxy::~OverlayManagerProxy() -{ - APP_LOGD("destroy OverlayManagerProxy"); -} - -ErrCode OverlayManagerProxy::GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId) -{ - APP_LOGD("begin to call GetAllOverlayModuleInfo"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (bundleName.empty()) { - APP_LOGE("GetAllOverlayModuleInfo failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(bundleName)) { - APP_LOGE("write bundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetAllOverlayModuleInfo due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode::GET_ALL_OVERLAY_MODULE_INFO, data, overlayModuleInfo); -} - -ErrCode OverlayManagerProxy::GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) -{ - APP_LOGD("begin to call GetOverlayModuleInfo"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (bundleName.empty() || moduleName.empty()) { - APP_LOGE("GetOverlayModuleInfo failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(bundleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(moduleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetOverlayModuleInfo due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfo(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_NAME, data, overlayModuleInfo); -} - -ErrCode OverlayManagerProxy::GetOverlayModuleInfo(const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) -{ - APP_LOGD("begin to call GetOverlayModuleInfo"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (moduleName.empty()) { - APP_LOGE("GetOverlayModuleInfo failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(moduleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetOverlayModuleInfo due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfo(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO, data, overlayModuleInfo); -} - -ErrCode OverlayManagerProxy::GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId) -{ - APP_LOGD("begin to call GetTargetOverlayModuleInfo"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (targetModuleName.empty()) { - APP_LOGE("GetTargetOverlayModuleInfo failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (!data.WriteString(targetModuleName)) { - APP_LOGE("write targetModuleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetTargetOverlayModuleInfo due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode::GET_TARGET_OVERLAY_MODULE_INFOS, data, overlayModuleInfos); -} - -ErrCode OverlayManagerProxy::GetOverlayModuleInfoByBundleName(const std::string &bundleName, - const std::string &moduleName, std::vector &overlayModuleInfos, int32_t userId) -{ - APP_LOGD("begin to call GetOverlayModuleInfoByBundleName"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (bundleName.empty()) { - APP_LOGE("GetOverlayModuleInfoByBundleName failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(bundleName)) { - APP_LOGE("write bundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(moduleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetOverlayModuleInfoByBundleName due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME, data, overlayModuleInfos); -} - -ErrCode OverlayManagerProxy::GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, - int32_t userId) -{ - APP_LOGD("begin to call GetOverlayModuleInfoForTarget"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (targetBundleName.empty()) { - APP_LOGE("GetOverlayModuleInfoForTarget failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(targetBundleName)) { - APP_LOGE("write targetBundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(targetModuleName)) { - APP_LOGE("write targetModuleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetOverlayModuleInfoForTarget due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_FOR_TARGET, data, overlayModuleInfo); -} - -ErrCode OverlayManagerProxy::SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId) -{ - APP_LOGD("begin to call SetOverlayEnabledForSelf"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (moduleName.empty()) { - APP_LOGE("SetOverlayEnabledForSelf failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(moduleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteBool(isEnabled)) { - APP_LOGE("failed to SetOverlayEnabledForSelf due to write isEnabled fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to SetOverlayEnabledForSelf due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - MessageParcel reply; - if (!SendTransactCmd(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED_FOR_SELF, data, reply)) { - APP_LOGE("SendTransactCmd failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - auto res = reply.ReadInt32(); - if (res != ERR_OK) { - APP_LOGE("SetOverlayEnabledForSelf failed %{public}d", res); - } - return res; -} - -ErrCode OverlayManagerProxy::SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, - bool isEnabled, int32_t userId) -{ - APP_LOGD("begin to call SetOverlayEnabled"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - if (bundleName.empty() || moduleName.empty()) { - APP_LOGE("SetOverlayEnabled failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(bundleName)) { - APP_LOGE("write bundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(moduleName)) { - APP_LOGE("write moduleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteBool(isEnabled)) { - APP_LOGE("failed to SetOverlayEnabled due to write isEnabled fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to SetOverlayEnabled due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - MessageParcel reply; - if (!SendTransactCmd(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED, data, reply)) { - APP_LOGE("SendTransactCmd failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - auto res = reply.ReadInt32(); - if (res != ERR_OK) { - APP_LOGE("failed SetOverlayEnabled %{public}d", res); - } - return res; -} - -ErrCode OverlayManagerProxy::GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId) -{ - APP_LOGD("begin to call GetOverlayBundleInfoForTarget"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - - if (targetBundleName.empty()) { - APP_LOGE("GetOverlayBundleInfoForTarget failed due to params error"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; - } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - APP_LOGE("WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(targetBundleName)) { - APP_LOGE("write targetBundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - if (!data.WriteInt32(userId)) { - APP_LOGE("failed to GetOverlayBundleInfoForTarget due to write userId fail"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - return GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode::GET_OVERLAY_BUNDLE_INFO_FOR_TARGET, data, overlayBundleInfo); -} - -template -ErrCode OverlayManagerProxy::GetParcelableInfo( - OverlayManagerInterfaceCode code, MessageParcel &data, T &parcelableInfo) -{ - MessageParcel reply; - if (!SendTransactCmd(code, data, reply)) { - APP_LOGE("SendTransactCmd failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - ErrCode res = reply.ReadInt32(); - if (res != ERR_OK) { - APP_LOGE("GetParcelableInfo failed due to %{public}d", res); - return res; - } - - std::unique_ptr info(reply.ReadParcelable()); - if (info == nullptr) { - APP_LOGE("readParcelableInfo failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - parcelableInfo = *info; - APP_LOGD("get parcelable info success"); - return ERR_OK; -} - -template -ErrCode OverlayManagerProxy::GetParcelableInfosWithErrCode( - OverlayManagerInterfaceCode code, MessageParcel &data, std::vector &parcelableInfos) -{ - MessageParcel reply; - if (!SendTransactCmd(code, data, reply)) { - APP_LOGE("SendTransactCmd failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - ErrCode res = reply.ReadInt32(); - if (res == ERR_OK) { - int32_t infoSize = reply.ReadInt32(); - CONTAINER_SECURITY_VERIFY(reply, infoSize, &parcelableInfos); - for (int32_t i = 0; i < infoSize; i++) { - std::unique_ptr info(reply.ReadParcelable()); - if (info == nullptr) { - APP_LOGE("Read Parcelable infos failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - parcelableInfos.emplace_back(*info); - } - APP_LOGD("get parcelable infos success"); - } - APP_LOGD("GetParcelableInfosWithErrCode ErrCode : %{public}d", res); - return res; -} - -bool OverlayManagerProxy::SendTransactCmd(OverlayManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply) -{ - MessageOption option(MessageOption::TF_SYNC); - - sptr remote = Remote(); - if (remote == nullptr) { - APP_LOGE("fail send transact cmd %{public}hhu due to remote object", code); - return false; - } - int32_t result = remote->SendRequest(static_cast(code), data, reply, option); - if (result != NO_ERROR) { - APP_LOGE("receive error code %{public}d in transact cmd %{public}hhu", result, code); - return false; - } - return true; -} -} // AppExecFwk -} // OHOS \ No newline at end of file diff --git a/interfaces/kits/js/overlay/js_app_overlay.cpp b/interfaces/kits/js/overlay/js_app_overlay.cpp index 094102c2e73f282af5bdf693a662640362772d50..97040aeb91fd7245d5a1bd4fc71bcac8108a2048 100644 --- a/interfaces/kits/js/overlay/js_app_overlay.cpp +++ b/interfaces/kits/js/overlay/js_app_overlay.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -26,6 +26,7 @@ #include "ipc_skeleton.h" #include "napi_arg.h" #include "napi_constants.h" +#include "overlay_manager_client.h" namespace OHOS { namespace AppExecFwk { @@ -43,34 +44,14 @@ const std::string GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME = "GetOverlayModuleInfo const std::string GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME = "GetTargetOverlayModuleInfosByBundleName"; } // namespace -static OHOS::sptr GetOverlayMgrProxy() -{ - auto bundleMgr = CommonFunc::GetBundleMgr(); - if (bundleMgr == nullptr) { - APP_LOGE("CommonFunc::GetBundleMgr failed"); - return nullptr; - } - auto overlayMgrProxy = bundleMgr->GetOverlayManagerProxy(); - if (overlayMgrProxy == nullptr) { - APP_LOGE("GetOverlayManagerProxy failed"); - return nullptr; - } - return overlayMgrProxy; -} - - static ErrCode InnerSetOverlayEnabledExec(napi_env, OverlayCallbackInfo *callback) { - auto overlayMgrProxy = GetOverlayMgrProxy(); - if (overlayMgrProxy == nullptr) { - APP_LOGE("overlayMgrProxy is null"); - return ERROR_SYSTEM_ABILITY_NOT_FOUND; - } ErrCode ret = ERR_OK; if (callback->option == OverlayOption::OPTION_SET_OVERLAY_ENABLED_BY_BUNDLE) { - ret = overlayMgrProxy->SetOverlayEnabled(callback->bundleName, callback->moduleName, callback->isEnabled); + ret = OverlayManagerClient::GetInstance().SetOverlayEnabled(callback->bundleName, callback->moduleName, + callback->isEnabled); } else { - ret = overlayMgrProxy->SetOverlayEnabledForSelf(callback->moduleName, callback->isEnabled); + ret = OverlayManagerClient::GetInstance().SetOverlayEnabledForSelf(callback->moduleName, callback->isEnabled); } return CommonFunc::ConvertErrCode(ret); } @@ -225,24 +206,18 @@ static ErrCode InnerGetOverlayModuleInfoExec(napi_env, OverlayCallbackInfo *over return ERROR_BUNDLE_SERVICE_EXCEPTION; } - auto overlayMgrProxy = GetOverlayMgrProxy(); - if (overlayMgrProxy == nullptr) { - APP_LOGE("overlayMgrProxy is null"); - return ERROR_SYSTEM_ABILITY_NOT_FOUND; - } - ErrCode ret = ERR_OK; if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO) { - ret = overlayMgrProxy->GetOverlayModuleInfo(overlayCbInfo->moduleName, + ret = OverlayManagerClient::GetInstance().GetOverlayModuleInfo(overlayCbInfo->moduleName, overlayCbInfo->overlayModuleInfo); } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_TARGET_MODULE_INFO) { - ret = overlayMgrProxy->GetTargetOverlayModuleInfo(overlayCbInfo->targetModuleName, + ret = OverlayManagerClient::GetInstance().GetTargetOverlayModuleInfo(overlayCbInfo->targetModuleName, overlayCbInfo->infoVec); } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME) { - ret = overlayMgrProxy->GetOverlayModuleInfoByBundleName(overlayCbInfo->bundleName, overlayCbInfo->moduleName, - overlayCbInfo->infoVec); + ret = OverlayManagerClient::GetInstance().GetOverlayModuleInfoByBundleName(overlayCbInfo->bundleName, + overlayCbInfo->moduleName, overlayCbInfo->infoVec); } else if (overlayCbInfo->option == OverlayOption::OPTION_GET_TARGET_OVERLAY_MODULE_INFOS_BY_BUNDLE_NAME) { - ret = overlayMgrProxy->GetOverlayModuleInfoForTarget(overlayCbInfo->targetBundleName, + ret = OverlayManagerClient::GetInstance().GetOverlayModuleInfoForTarget(overlayCbInfo->targetBundleName, overlayCbInfo->moduleName, overlayCbInfo->infoVec); } else { APP_LOGE("invalid overlay option"); diff --git a/services/bundlemgr/include/overlay/bundle_overlay_manager_host_impl.h b/services/bundlemgr/include/overlay/bundle_overlay_manager_host_impl.h index e6697e51704460aee7ff6d35a6ebb52e8a4c5f0a..4d754c138c4316f058d2e10ca8a302c9843c6744 100644 --- a/services/bundlemgr/include/overlay/bundle_overlay_manager_host_impl.h +++ b/services/bundlemgr/include/overlay/bundle_overlay_manager_host_impl.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -18,34 +18,36 @@ #include -#include "overlay_manager_host.h" +#include "overlay_manager_stub.h" namespace OHOS { namespace AppExecFwk { -class OverlayManagerHostImpl : public OverlayManagerHost { +class OverlayManagerHostImpl : public OverlayManagerStub { public: OverlayManagerHostImpl(); virtual ~OverlayManagerHostImpl(); - virtual ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; + virtual ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, int32_t userId, + std::vector &overlayModuleInfo, int32_t &funcResult) override; + virtual ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, int32_t userId, + OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) override; + virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, int32_t userId, + OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) override; + virtual ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, int32_t userId, + std::vector &overlayModuleInfos, int32_t &funcResult) override; virtual ErrCode GetOverlayModuleInfoByBundleName(const std::string &bundleName, const std::string &moduleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, std::vector &overlayModuleInfos, int32_t &funcResult) override; + virtual ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, int32_t userId, + std::vector &overlayBundleInfo, int32_t &funcResult) override; virtual ErrCode GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) override; + const std::string &targetModuleName, int32_t userId, std::vector &overlayModuleInfo, + int32_t& funcResult) override; + virtual ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, int32_t userId, + int32_t& funcResult) override; virtual ErrCode SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, int32_t &funcResult) override; + virtual int32_t CallbackEnter([[maybe_unused]] uint32_t code) override; + virtual int32_t CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) override; }; } // AppExecFwk } // OHOS diff --git a/services/bundlemgr/src/overlay/bundle_overlay_manager_host_impl.cpp b/services/bundlemgr/src/overlay/bundle_overlay_manager_host_impl.cpp index 2ac2e75d5fd306ffde88e8ebbef57e3ffaf93bd6..ae73fa3d30ca6690a08c0f2f5f9e69af1f01e965 100644 --- a/services/bundlemgr/src/overlay/bundle_overlay_manager_host_impl.cpp +++ b/services/bundlemgr/src/overlay/bundle_overlay_manager_host_impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -15,6 +15,7 @@ #include "bundle_overlay_manager_host_impl.h" +#include "bundle_memory_guard.h" #include "bundle_permission_mgr.h" #include "bundle_overlay_data_manager.h" #include "bundle_overlay_manager.h" @@ -45,19 +46,21 @@ OverlayManagerHostImpl::~OverlayManagerHostImpl() APP_LOGI("destory"); } -ErrCode OverlayManagerHostImpl::GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId) +ErrCode OverlayManagerHostImpl::GetAllOverlayModuleInfo(const std::string &bundleName, int32_t userId, + std::vector &overlayModuleInfo, int32_t& funcResult) { APP_LOGD("start to get all overlay moduleInfo of bundle %{public}s", bundleName.c_str()); int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_GET_ALL_OVERLAY_MODULE_INFO); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (bundleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (!BundlePermissionMgr::CheckUserFromShell(userId)) { LOG_E(BMS_TAG_INSTALLER, "check shell user fail"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -66,13 +69,15 @@ ErrCode OverlayManagerHostImpl::GetAllOverlayModuleInfo(const std::string &bundl if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) { APP_LOGE("no permission to query overlay info of targetBundleName %{public}s", bundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } - return BundleOverlayManager::GetInstance()->GetAllOverlayModuleInfo(bundleName, overlayModuleInfo, userId); + funcResult = BundleOverlayManager::GetInstance()->GetAllOverlayModuleInfo(bundleName, overlayModuleInfo, userId); + return ERR_OK; } ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) + int32_t userId, OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) { APP_LOGD("start to get overlay moduleInfo of bundle %{public}s and module %{public}s", bundleName.c_str(), moduleName.c_str()); @@ -80,11 +85,13 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &bundleNa ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (!BundlePermissionMgr::CheckUserFromShell(userId)) { LOG_E(BMS_TAG_INSTALLER, "check shell user fail"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (bundleName.empty() || moduleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -93,25 +100,29 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &bundleNa if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) { APP_LOGE("no permission to query overlay info of targetBundleName %{public}s", bundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } - return BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, + funcResult = BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, userId); + return ERR_OK; } -ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) +ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &moduleName, int32_t userId, + OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) { APP_LOGD("start to get overlay moduleInfo of module %{public}s", moduleName.c_str()); int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_GET_OVERLAY_MODULE_INFO_NO_BUNDLENAME); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (moduleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (!BundlePermissionMgr::CheckUserFromShell(userId)) { LOG_E(BMS_TAG_INSTALLER, "check shell user fail"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -121,22 +132,25 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfo(const std::string &moduleNa std::string callingBundleName = OverlayDataMgr::GetInstance()->GetCallingBundleName(); if (callingBundleName.empty()) { APP_LOGE("GetCallingBundleName failed"); - return ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + funcResult = ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + return ERR_OK; } APP_LOGD("get overlay moduleInfo of bundle %{public}s", callingBundleName.c_str()); - return BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(callingBundleName, moduleName, overlayModuleInfo, - userId); + funcResult = BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(callingBundleName, moduleName, + overlayModuleInfo, userId); + return ERR_OK; } -ErrCode OverlayManagerHostImpl::GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId) +ErrCode OverlayManagerHostImpl::GetTargetOverlayModuleInfo(const std::string &targetModuleName, int32_t userId, + std::vector &overlayModuleInfos, int32_t &funcResult) { APP_LOGD("start to get target overlay moduleInfo of target module %{public}s", targetModuleName.c_str()); int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_GET_TARGET_OVERLAY_MODULE_INFO); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (targetModuleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -146,15 +160,18 @@ ErrCode OverlayManagerHostImpl::GetTargetOverlayModuleInfo(const std::string &ta std::string callingBundleName = OverlayDataMgr::GetInstance()->GetCallingBundleName(); if (callingBundleName.empty()) { APP_LOGE("GetCallingBundleName failed"); - return ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + funcResult = ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + return ERR_OK; } APP_LOGD("get target overlay moduleInfo of bundle %{public}s", callingBundleName.c_str()); - return BundleOverlayManager::GetInstance()->GetOverlayModuleInfoForTarget(callingBundleName, targetModuleName, - overlayModuleInfos, userId); + funcResult = BundleOverlayManager::GetInstance()->GetOverlayModuleInfoForTarget(callingBundleName, + targetModuleName, overlayModuleInfos, userId); + return ERR_OK; } ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoByBundleName(const std::string &bundleName, - const std::string &moduleName, std::vector &overlayModuleInfos, int32_t userId) + const std::string &moduleName, int32_t userId, std::vector &overlayModuleInfos, + int32_t &funcResult) { APP_LOGD("start to get overlay moduleInfo of bundle %{public}s and module %{public}s", bundleName.c_str(), moduleName.c_str()); @@ -162,7 +179,8 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoByBundleName(const std::stri ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (bundleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -171,42 +189,48 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoByBundleName(const std::stri if (!BundlePermissionMgr::IsSystemApp()) { APP_LOGE("non-system app is not allowed to call this function"); - return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + funcResult = ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + return ERR_OK; } if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED) && !BundlePermissionMgr::IsBundleSelfCalling(bundleName)) { APP_LOGE("no permission to query overlay info of bundleName %{public}s", bundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (moduleName.empty()) { APP_LOGD("moduleName is empty, then to query all overlay module info in specified bundle"); - return BundleOverlayManager::GetInstance()->GetAllOverlayModuleInfo(bundleName, overlayModuleInfos, userId); + funcResult = BundleOverlayManager::GetInstance()->GetAllOverlayModuleInfo(bundleName, overlayModuleInfos, + userId); + return ERR_OK; } OverlayModuleInfo overlayModuleInfo; - ErrCode res = BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, + funcResult = BundleOverlayManager::GetInstance()->GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, userId); - if (res != ERR_OK) { - APP_LOGE("GetOverlayModuleInfo failed due to errcode %{public}d", res); - return res; + if (funcResult != ERR_OK) { + APP_LOGE("GetOverlayModuleInfo failed due to errcode %{public}d", funcResult); + return ERR_OK; } overlayModuleInfos.emplace_back(overlayModuleInfo); return ERR_OK; } -ErrCode OverlayManagerHostImpl::GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId) +ErrCode OverlayManagerHostImpl::GetOverlayBundleInfoForTarget(const std::string &targetBundleName, int32_t userId, + std::vector &overlayBundleInfo, int32_t &funcResult) { APP_LOGD("start to get target overlay bundleInfo of bundle %{public}s", targetBundleName.c_str()); int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_GET_OVERLAY_BUNDLE_INFOFOR_TARGET); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (!BundlePermissionMgr::CheckUserFromShell(userId)) { LOG_E(BMS_TAG_INSTALLER, "check shell user fail"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (targetBundleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -215,14 +239,17 @@ ErrCode OverlayManagerHostImpl::GetOverlayBundleInfoForTarget(const std::string if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) { APP_LOGE("no permission to query overlay info of targetBundleName %{public}s", targetBundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } - return BundleOverlayManager::GetInstance()-> + funcResult = BundleOverlayManager::GetInstance()-> GetOverlayBundleInfoForTarget(targetBundleName, overlayBundleInfo, userId); + return ERR_OK; } ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, int32_t userId) + const std::string &targetModuleName, int32_t userId, std::vector &overlayModuleInfo, + int32_t &funcResult) { APP_LOGD("start to get target overlay moduleInfo of target bundle %{public}s and target module %{public}s", targetBundleName.c_str(), targetModuleName.c_str()); @@ -230,11 +257,13 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoForTarget(const std::string ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (!BundlePermissionMgr::CheckUserFromShell(userId)) { LOG_E(BMS_TAG_INSTALLER, "check shell user fail"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } if (targetBundleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -243,26 +272,30 @@ ErrCode OverlayManagerHostImpl::GetOverlayModuleInfoForTarget(const std::string if (!BundlePermissionMgr::IsSystemApp()) { APP_LOGE("non-system app is not allowed to call this function"); - return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + funcResult = ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + return ERR_OK; } if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED) && !BundlePermissionMgr::IsBundleSelfCalling(targetBundleName)) { APP_LOGE("no permission to query overlay info of targetBundleName %{public}s", targetBundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } - return BundleOverlayManager::GetInstance()->GetOverlayModuleInfoForTarget(targetBundleName, targetModuleName, - overlayModuleInfo, userId); + funcResult = BundleOverlayManager::GetInstance()->GetOverlayModuleInfoForTarget(targetBundleName, + targetModuleName, overlayModuleInfo, userId); + return ERR_OK; } ErrCode OverlayManagerHostImpl::SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId) + int32_t userId, int32_t &funcResult) { int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_SET_OVERLAY_ENABLED_FOR_SELF); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (moduleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -271,21 +304,25 @@ ErrCode OverlayManagerHostImpl::SetOverlayEnabledForSelf(const std::string &modu std::string callingBundleName = OverlayDataMgr::GetInstance()->GetCallingBundleName(); if (callingBundleName.empty()) { APP_LOGE("GetCallingBundleName failed"); - return ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + funcResult = ERR_BUNDLE_MANAGER_INTERNAL_ERROR; + return ERR_OK; } APP_LOGD("set overlay enable %{public}d for bundle %{public}s", isEnabled, callingBundleName.c_str()); - return BundleOverlayManager::GetInstance()->SetOverlayEnabled(callingBundleName, moduleName, isEnabled, userId); + funcResult = BundleOverlayManager::GetInstance()->SetOverlayEnabled(callingBundleName, moduleName, isEnabled, + userId); + return ERR_OK; } ErrCode OverlayManagerHostImpl::SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, - bool isEnabled, int32_t userId) + bool isEnabled, int32_t userId, int32_t &funcResult) { APP_LOGD("start"); int32_t timerId = XCollieHelper::SetRecoveryTimer(FUNCTION_SET_OVERLAY_ENABLED); ScopeGuard cancelTimerIdGuard([timerId] { XCollieHelper::CancelTimer(timerId); }); if (bundleName.empty() || moduleName.empty()) { APP_LOGE("invalid param"); - return ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR; + return ERR_OK; } if (userId == Constants::UNSPECIFIED_USERID) { userId = BundleUtil::GetUserIdByCallingUid(); @@ -294,14 +331,29 @@ ErrCode OverlayManagerHostImpl::SetOverlayEnabled(const std::string &bundleName, if (!BundlePermissionMgr::IsSystemApp()) { APP_LOGE("non-system app is not allowed to call this function"); - return ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + funcResult = ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED; + return ERR_OK; } if (!BundlePermissionMgr::VerifyCallingPermissionForAll(Constants::PERMISSION_CHANGE_OVERLAY_ENABLED_STATE) && !BundlePermissionMgr::IsBundleSelfCalling(bundleName)) { APP_LOGE("no permission to query overlay info of bundleName %{public}s", bundleName.c_str()); - return ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED; + return ERR_OK; } - return BundleOverlayManager::GetInstance()->SetOverlayEnabled(bundleName, moduleName, isEnabled, userId); + funcResult = BundleOverlayManager::GetInstance()->SetOverlayEnabled(bundleName, moduleName, isEnabled, userId); + return ERR_OK; +} + +int32_t OverlayManagerHostImpl::CallbackEnter([[maybe_unused]] uint32_t code) +{ + BundleMemoryGuard::SetBundleMemoryGuard(); + return ERR_NONE; +} + +int32_t OverlayManagerHostImpl::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) +{ + BundleMemoryGuard::ClearBundleMemoryGuard(); + return ERR_NONE; } } // AppExecFwk } // OHOS diff --git a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/BUILD.gn b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/BUILD.gn index c9f8fa444554c04fe3a34bc0f02408a679504cff..ba6adc507871193e59d03e257a03f266851f5b6a 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/BUILD.gn +++ b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/BUILD.gn @@ -249,12 +249,8 @@ ohos_unittest("BmsBundleOverlayIpcTest") { use_exceptions = true module_out_path = module_output_path include_dirs = [ "${services_path}/bundlemgr/test/mock/include/parameter" ] - sources = [ - "${core_path}/src/overlay/overlay_manager_host.cpp", - "${core_path}/src/overlay/overlay_manager_proxy.cpp", - ] - sources += bundle_mgr_source + sources = bundle_mgr_source sources -= [ "${services_path}/bundlemgr/src/bms_param.cpp" ] sources += [ "${services_path}/bundlemgr/test/mock/src/bms_param.cpp" ] sources -= [ "${services_path}/bundlemgr/src/system_ability_helper.cpp" ] @@ -294,6 +290,8 @@ ohos_unittest("BmsBundleOverlayIpcTest") { deps = [ "${common_path}:libappexecfwk_common", "${core_path}:appexecfwk_core", + "${core_path}:overlay_manager_proxy", + "${core_path}:overlay_manager_stub", ] deps += bundle_install_deps diff --git a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_get_overlay_module_info_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_get_overlay_module_info_test.cpp index e2c3a52bcbdb78184a9c4fbdfec6622e86c46e2e..29b703d23d0c8f0d2d203752e84c8f4ef56a0831 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_get_overlay_module_info_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_get_overlay_module_info_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -234,8 +234,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0100, Funct EXPECT_NE(hostImpl, nullptr); std::vector vec; - auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, vec); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, UNSPECIFIED_USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + EXPECT_EQ(res, ERR_OK); } /** @@ -253,9 +255,11 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0200, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::vector vec; - auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, vec, TEST_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + EXPECT_EQ(res, ERR_OK); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -274,9 +278,11 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0300, Funct AddNonOverlayInnerBundleInfo(); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::vector vec; - auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, vec, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); + auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); + EXPECT_EQ(res, ERR_OK); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -296,7 +302,9 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0400, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector vec; - auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, vec, USERID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_OK); EXPECT_EQ(res, ERR_OK); EXPECT_EQ(vec.size(), OVERLAY_MODULE_INFO_SIZE); @@ -318,8 +326,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0500, Funct EXPECT_NE(hostImpl, nullptr); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); } /** @@ -338,8 +348,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0600, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, TEST_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, TEST_USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -359,8 +371,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0700, Funct AddNonOverlayInnerBundleInfo(); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -380,8 +394,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0800, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -401,8 +417,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_0900, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -422,8 +440,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1000, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -443,8 +463,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1100, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckOverlayModuleInfo(overlayModuleInfo); RemoveBundleInfo(TEST_BUNDLE_NAME); @@ -464,8 +486,9 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1200, Funct EXPECT_NE(hostImpl, nullptr); std::vector overlayBundleInfo; - auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, overlayBundleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, USERID, overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); } /** @@ -484,8 +507,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1300, Funct AddOverlayBundleInfo(); std::vector overlayBundleInfo; - auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, overlayBundleInfo, TEST_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, TEST_USERID, + overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); RemoveBundleInfo(TEST_TARGET_BUNDLE_NAME); } @@ -505,8 +530,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1400, Funct AddOverlayBundleInfo(); std::vector overlayBundleInfo; - auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, overlayBundleInfo, USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, USERID, + overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_OK); EXPECT_EQ(overlayBundleInfo.size(), OVERLAY_MODULE_INFO_SIZE); CheckOverlayBundleInfo(overlayBundleInfo[0]); @@ -529,8 +556,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1500, Funct AddNonOverlayInnerBundleInfo(); std::vector overlayBundleInfo; - auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, overlayBundleInfo, USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, USERID, + overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_OK); EXPECT_EQ(overlayBundleInfo.size(), DEFAULT_OVERLAY_MODULE_INFO_SIZE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -549,8 +578,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1600, Funct EXPECT_NE(hostImpl, nullptr); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); } /** @@ -569,8 +600,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1700, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_EXTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_IS_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_IS_OVERLAY_BUNDLE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -590,9 +623,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1800, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, - TEST_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, + TEST_USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -612,9 +646,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_1900, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, overlayModuleInfo, - USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_NOT_EXISTED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, + USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_NOT_EXISTED); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -634,8 +669,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2000, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_IS_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_IS_OVERLAY_MODULE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -655,9 +692,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2100, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, overlayModuleInfo, - USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, + USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_OK); EXPECT_EQ(overlayModuleInfo.size(), DEFAULT_OVERLAY_MODULE_INFO_SIZE); RemoveBundleInfo(TEST_BUNDLE_NAME); } @@ -678,9 +716,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2200, Funct AddOverlayInnerBundleInfo(OverlayType::OVERLAY_INTERNAL_BUNDLE); std::vector overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TARGET_MODULE_NAME, overlayModuleInfo, - USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_BUNDLE_NAME, TARGET_MODULE_NAME, USERID, + overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_OK); EXPECT_EQ(overlayModuleInfo.size(), OVERLAY_MODULE_INFO_SIZE); CheckOverlayModuleInfo(overlayModuleInfo[0]); @@ -699,8 +738,9 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2300, Funct EXPECT_NE(hostImpl, nullptr); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo("", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo("", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } /** @@ -715,11 +755,13 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2400, Funct EXPECT_NE(hostImpl, nullptr); OverlayModuleInfo overlayModuleInfo; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, overlayModuleInfo, UNSPECIFIED_USERID); - EXPECT_NE(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, UNSPECIFIED_USERID, + overlayModuleInfo, funcResult); + EXPECT_NE(funcResult, ERR_OK); - res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, overlayModuleInfo, USERID); - EXPECT_NE(res, ERR_OK); + res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, USERID, overlayModuleInfo, funcResult); + EXPECT_NE(funcResult, ERR_OK); } /** @@ -734,8 +776,10 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2500, Funct EXPECT_NE(hostImpl, nullptr); std::vector overlayModuleInfos; - auto res = hostImpl->GetTargetOverlayModuleInfo(TARGET_MODULE_NAME, overlayModuleInfos, UNSPECIFIED_USERID); - EXPECT_NE(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetTargetOverlayModuleInfo(TARGET_MODULE_NAME, UNSPECIFIED_USERID, + overlayModuleInfos, funcResult); + EXPECT_NE(funcResult, ERR_OK); } /** @@ -749,7 +793,9 @@ HWTEST_F(BmsBundleGetOverlayModuleInfoTest, GetOverlayModuleInfoTest_2600, Funct auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabledForSelf(TARGET_MODULE_NAME, false, UNSPECIFIED_USERID); - EXPECT_NE(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabledForSelf(TARGET_MODULE_NAME, false, UNSPECIFIED_USERID, + funcResult); + EXPECT_NE(funcResult, ERR_OK); } } // OHOS diff --git a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_checker_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_checker_test.cpp index dd117550bb48d8187e4ff71ab0804733dec1af5c..c6036dc0e78f81498bd4a98f108d2f6c0f36fb24 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_checker_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_checker_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -2057,12 +2057,13 @@ HWTEST_F(BmsBundleOverlayCheckerTest, OverlayManagerHostImpl_0100, Function | Sm { OverlayManagerHostImpl overlayManagerHostImpl; std::vector overlayModuleInfo; - ErrCode res = overlayManagerHostImpl.GetAllOverlayModuleInfo("", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode res = overlayManagerHostImpl.GetAllOverlayModuleInfo("", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetAllOverlayModuleInfo( - "bundleName", overlayModuleInfo, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + "bundleName", Constants::UNSPECIFIED_USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); } /** @@ -2076,21 +2077,22 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0200, Function | Smal { OverlayManagerHostImpl overlayManagerHostImpl; OverlayModuleInfo overlayModuleInfo; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; ErrCode res = overlayManagerHostImpl.GetOverlayModuleInfo( - "", "moduleName", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + "", "moduleName", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayModuleInfo( - "bundleName", "", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + "bundleName", "", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayModuleInfo( - "", "", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + "", "", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayModuleInfo( - "bundleName", "moduleName", overlayModuleInfo, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + "bundleName", "moduleName", Constants::UNSPECIFIED_USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); } /** @@ -2104,13 +2106,14 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0300, Function | Smal { OverlayManagerHostImpl overlayManagerHostImpl; std::vector overlayBundleInfo; - ErrCode res = overlayManagerHostImpl.GetOverlayBundleInfoForTarget( - "", overlayBundleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode res = + overlayManagerHostImpl.GetOverlayBundleInfoForTarget("", USERID, overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayBundleInfoForTarget( - "targetBundleName", overlayBundleInfo, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); + "targetBundleName", Constants::UNSPECIFIED_USERID, overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); } /** @@ -2124,21 +2127,22 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0400, Function | Smal { OverlayManagerHostImpl overlayManagerHostImpl; std::vector overlayModuleInfo; - ErrCode res = overlayManagerHostImpl.GetOverlayModuleInfoForTarget( - "", "targetModuleName", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode res = overlayManagerHostImpl.GetOverlayModuleInfoForTarget("", "targetModuleName", + USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayModuleInfoForTarget( - "targetBundleName", "", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); + "targetBundleName", "", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); res = overlayManagerHostImpl.GetOverlayModuleInfoForTarget( - "", "", overlayModuleInfo, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + "", "", USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); res = overlayManagerHostImpl.GetOverlayModuleInfoForTarget( - "targetBundleName", "targetModuleName", overlayModuleInfo, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); + "targetBundleName", "targetModuleName", Constants::UNSPECIFIED_USERID, overlayModuleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED); } /** @@ -2152,21 +2156,22 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0500, Function | Smal { OverlayManagerHostImpl overlayManagerHostImpl; bool isEnabled = false; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; ErrCode res = overlayManagerHostImpl.SetOverlayEnabled( - "", "moduleName", isEnabled, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + "", "moduleName", isEnabled, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); res = overlayManagerHostImpl.SetOverlayEnabled( - "bundleName", "", isEnabled, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + "bundleName", "", isEnabled, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); res = overlayManagerHostImpl.SetOverlayEnabled( - "", "", isEnabled, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + "", "", isEnabled, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); res = overlayManagerHostImpl.SetOverlayEnabled( - "bundleName", "moduleName", isEnabled, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + "bundleName", "moduleName", isEnabled, Constants::UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); } /** @@ -2179,10 +2184,11 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0500, Function | Smal HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0800, Function | SmallTest | Level0) { OverlayManagerHostImpl overlayManagerHostImpl; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::vector overlayBundleInfo; - ErrCode res = overlayManagerHostImpl.GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, - overlayBundleInfo, Constants::INVALID_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + ErrCode res = overlayManagerHostImpl.GetOverlayBundleInfoForTarget(TEST_BUNDLE_NAME, Constants::INVALID_USERID, + overlayBundleInfo, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } /** @@ -2197,14 +2203,15 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0900, Function | Smal { OverlayManagerHostImpl overlayManagerHostImpl; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::vector overlayModuleInfos; - auto errCode = overlayManagerHostImpl.GetTargetOverlayModuleInfo("", overlayModuleInfos, - USERID); - EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + auto errCode = overlayManagerHostImpl.GetTargetOverlayModuleInfo("", USERID, overlayModuleInfos, + funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); - errCode = overlayManagerHostImpl.GetTargetOverlayModuleInfo(TEST_BUNDLE_NAME, overlayModuleInfos, - Constants::UNSPECIFIED_USERID); - EXPECT_EQ(errCode, ERR_BUNDLE_MANAGER_INTERNAL_ERROR); + errCode = overlayManagerHostImpl.GetTargetOverlayModuleInfo(TEST_BUNDLE_NAME, Constants::UNSPECIFIED_USERID, + overlayModuleInfos, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLE_MANAGER_INTERNAL_ERROR); } /** @@ -2218,19 +2225,20 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_0900, Function | Smal HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_1000, Function | SmallTest | Level0) { OverlayManagerHostImpl overlayManagerHostImpl; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::vector overlayModuleInfos; auto errCode = overlayManagerHostImpl.GetOverlayModuleInfoByBundleName("", TEST_MODULE_NAME, - overlayModuleInfos, USERID); - EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); + USERID, overlayModuleInfos, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); errCode = overlayManagerHostImpl.GetOverlayModuleInfoByBundleName(TEST_BUNDLE_NAME, "", - overlayModuleInfos, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + Constants::UNSPECIFIED_USERID, overlayModuleInfos, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); errCode = overlayManagerHostImpl.GetOverlayModuleInfoByBundleName(TEST_BUNDLE_NAME, TEST_MODULE_NAME, - overlayModuleInfos, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + Constants::UNSPECIFIED_USERID, overlayModuleInfos, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); } /** @@ -2244,15 +2252,16 @@ HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_1000, Function | Smal HWTEST_F(BmsBundleOverlayCheckerTest, GetOverlayModuleInfo_1100, Function | SmallTest | Level0) { OverlayManagerHostImpl overlayManagerHostImpl; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; bool isEnabled = false; auto errCode = overlayManagerHostImpl.SetOverlayEnabledForSelf("", - isEnabled, USERID); - EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + isEnabled, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); errCode = overlayManagerHostImpl.SetOverlayEnabledForSelf(TEST_MODULE_NAME, - isEnabled, Constants::UNSPECIFIED_USERID); - EXPECT_EQ(errCode, ERR_BUNDLE_MANAGER_INTERNAL_ERROR); + isEnabled, Constants::UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLE_MANAGER_INTERNAL_ERROR); } /** diff --git a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_ipc_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_ipc_test.cpp index c1c2ef1c4b58d91d2884d42c3d183621d3ac736f..ea5f181eee3ffa873b62defa32c2ce881762137a 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_ipc_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_overlay_ipc_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023-2024 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -19,10 +19,13 @@ #define private public #include "bundle_framework_core_ipc_interface_code.h" #include "overlay_manager_proxy.h" -#include "overlay_manager_host.h" +#include "overlay_manager_stub.h" #undef private #include "bundle_overlay_manager_host_impl.h" +#include "bundle_memory_guard.h" #include "bundle_mgr_service.h" +#include "overlay_manager_client.h" + using namespace testing::ext; using namespace OHOS::AppExecFwk; @@ -39,42 +42,44 @@ const std::u16string TEST_HOST_DESCRIPTOR = u"ohos.bundleManager.OverlayManager. const int32_t TEST_PRIORITY = 50; const int32_t TEST_STATE = 0; const int32_t TEST_USER_ID = 100; +const int32_t UNSPECIFIED_USERID = -2; const int32_t TEST_CODE = 100; const int32_t OVERLAY_INFO_SIZE = 1; } // namespace -class OverlayManagerHostMock : public OverlayManagerHost { +class OverlayManagerHostMock : public OverlayManagerStub { public: OverlayManagerHostMock() = default; virtual ~OverlayManagerHostMock() = default; virtual ErrCode GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, std::vector &overlayModuleInfo, int32_t &funcResult) override; virtual ErrCode GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; - virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) override; + virtual ErrCode GetOverlayModuleInfo(const std::string &moduleName, + int32_t userId, OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) override; virtual ErrCode GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, std::vector &overlayModuleInfos, int32_t &funcResult) override; virtual ErrCode GetOverlayModuleInfoByBundleName(const std::string &bundleName, const std::string &moduleName, - std::vector &overlayModuleInfos, int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, std::vector &overlayModuleInfos, int32_t &funcResult) override; virtual ErrCode GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, std::vector &overlayBundleInfo, int32_t &funcResult) override; virtual ErrCode GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, - int32_t userId = Constants::UNSPECIFIED_USERID) override; + const std::string &targetModuleName, int32_t userId, std::vector &overlayModuleInfo, + int32_t &funcResult) override; virtual ErrCode SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) override; + int32_t userId, int32_t &funcResult) override; virtual ErrCode SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId = Constants::UNSPECIFIED_USERID) override; - + int32_t userId, int32_t &funcResult) override; + virtual int32_t CallbackEnter([[maybe_unused]] uint32_t code) override; + virtual int32_t CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) override; private: OverlayModuleInfo CreateOverlayModuleInfo(); OverlayBundleInfo CreateOverlayBundleInfo(); }; ErrCode OverlayManagerHostMock::GetAllOverlayModuleInfo(const std::string &bundleName, - std::vector &overlayModuleInfo, int32_t userId) + int32_t userId, std::vector &overlayModuleInfo, int32_t &funcResult) { OverlayModuleInfo moduleInfo = CreateOverlayModuleInfo(); overlayModuleInfo.emplace_back(moduleInfo); @@ -82,21 +87,21 @@ ErrCode OverlayManagerHostMock::GetAllOverlayModuleInfo(const std::string &bundl } ErrCode OverlayManagerHostMock::GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) + int32_t userId, OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) { overlayModuleInfo = CreateOverlayModuleInfo(); return ERR_OK; } ErrCode OverlayManagerHostMock::GetOverlayModuleInfo(const std::string &moduleName, - OverlayModuleInfo &overlayModuleInfo, int32_t userId) + int32_t userId, OverlayModuleInfo &overlayModuleInfo, int32_t &funcResult) { overlayModuleInfo = CreateOverlayModuleInfo(); return ERR_OK; } ErrCode OverlayManagerHostMock::GetTargetOverlayModuleInfo(const std::string &targetModuleName, - std::vector &overlayModuleInfos, int32_t userId) + int32_t userId, std::vector &overlayModuleInfos, int32_t &funcResult) { OverlayModuleInfo moduleInfo = CreateOverlayModuleInfo(); overlayModuleInfos.emplace_back(moduleInfo); @@ -104,7 +109,8 @@ ErrCode OverlayManagerHostMock::GetTargetOverlayModuleInfo(const std::string &ta } ErrCode OverlayManagerHostMock::GetOverlayModuleInfoByBundleName(const std::string &bundleName, - const std::string &moduleName, std::vector &overlayModuleInfos, int32_t userId) + const std::string &moduleName, int32_t userId, std::vector &overlayModuleInfos, + int32_t &funcResult) { OverlayModuleInfo moduleInfo = CreateOverlayModuleInfo(); overlayModuleInfos.emplace_back(moduleInfo); @@ -112,7 +118,7 @@ ErrCode OverlayManagerHostMock::GetOverlayModuleInfoByBundleName(const std::stri } ErrCode OverlayManagerHostMock::GetOverlayBundleInfoForTarget(const std::string &targetBundleName, - std::vector &overlayBundleInfo, int32_t userId) + int32_t userId, std::vector &overlayBundleInfo, int32_t &funcResult) { OverlayBundleInfo bundleInfo = CreateOverlayBundleInfo(); overlayBundleInfo.emplace_back(bundleInfo); @@ -120,7 +126,8 @@ ErrCode OverlayManagerHostMock::GetOverlayBundleInfoForTarget(const std::string } ErrCode OverlayManagerHostMock::GetOverlayModuleInfoForTarget(const std::string &targetBundleName, - const std::string &targetModuleName, std::vector &overlayModuleInfo, int32_t userId) + const std::string &targetModuleName, int32_t userId, std::vector &overlayModuleInfo, + int32_t &funcResult) { OverlayModuleInfo moduleInfo = CreateOverlayModuleInfo(); overlayModuleInfo.emplace_back(moduleInfo); @@ -128,13 +135,13 @@ ErrCode OverlayManagerHostMock::GetOverlayModuleInfoForTarget(const std::string } ErrCode OverlayManagerHostMock::SetOverlayEnabled(const std::string &bundleName, const std::string &moduleName, - bool isEnabled, int32_t userId) + bool isEnabled, int32_t userId, int32_t &funcResult) { return ERR_OK; } ErrCode OverlayManagerHostMock::SetOverlayEnabledForSelf(const std::string &moduleName, bool isEnabled, - int32_t userId) + int32_t userId, int32_t &funcResult) { return ERR_OK; } @@ -161,6 +168,17 @@ OverlayBundleInfo OverlayManagerHostMock::CreateOverlayBundleInfo() return overlayBundleInfo; } +int32_t OverlayManagerHostMock::CallbackEnter([[maybe_unused]] uint32_t code) +{ + BundleMemoryGuard::SetBundleMemoryGuard(); + return ERR_NONE; +} + +int32_t OverlayManagerHostMock::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) +{ + BundleMemoryGuard::ClearBundleMemoryGuard(); + return ERR_NONE; +} class BmsBundleOverlayIpcTest : public testing::Test { public: BmsBundleOverlayIpcTest(); @@ -259,8 +277,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0100, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, overlayModuleInfos, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_USER_ID, overlayModuleInfos, + funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -276,9 +296,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0200, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); OverlayModuleInfo overlayModuleInfo; - auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, overlayModuleInfo, - TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, TEST_USER_ID, + overlayModuleInfo, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -294,9 +315,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0300, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayBundleInfos; - auto errCode = overlayProxy->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, overlayBundleInfos, - TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, TEST_USER_ID, + overlayBundleInfos, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -312,9 +334,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0400, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayModuleInfos; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; auto errCode = overlayProxy->GetOverlayModuleInfoForTarget(TEST_TARGET_BUNDLE_NAME, TEST_TARGET_MODULE_NAME, - overlayModuleInfos, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + TEST_USER_ID, overlayModuleInfos, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -328,11 +351,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0400, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0500, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetAllOverlayModuleInfo("", overlayModuleInfos, TEST_USER_ID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = OverlayManagerClient::GetInstance().GetAllOverlayModuleInfo("", overlayModuleInfos, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -347,11 +368,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0500, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0600, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - OverlayModuleInfo overlayModuleInfo; - auto errCode = overlayProxy->GetOverlayModuleInfo("", TEST_MODULE_NAME, overlayModuleInfo, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().GetOverlayModuleInfo("", TEST_MODULE_NAME, overlayModuleInfo, + TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -366,11 +385,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0600, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0700, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - OverlayModuleInfo overlayModuleInfo; - auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_BUNDLE_NAME, "", overlayModuleInfo, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().GetOverlayModuleInfo(TEST_BUNDLE_NAME, "", overlayModuleInfo, + TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -385,11 +402,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0700, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0800, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - std::vector overlayBundleInfos; - auto errCode = overlayProxy->GetOverlayBundleInfoForTarget("", overlayBundleInfos, TEST_USER_ID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = OverlayManagerClient::GetInstance().GetOverlayBundleInfoForTarget("", + overlayBundleInfos, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -404,12 +420,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0800, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0900, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetOverlayModuleInfoForTarget("", TEST_TARGET_MODULE_NAME, overlayModuleInfos, - TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().GetOverlayModuleInfoForTarget("", TEST_TARGET_MODULE_NAME, + overlayModuleInfos, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -428,9 +441,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1000, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetOverlayModuleInfoForTarget(TEST_TARGET_BUNDLE_NAME, "", overlayModuleInfos, - TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetOverlayModuleInfoForTarget(TEST_TARGET_BUNDLE_NAME, "", TEST_USER_ID, + overlayModuleInfos, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -449,9 +463,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1100, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_ALL_OVERLAY_MODULE_INFO), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_ALL_OVERLAY_MODULE_INFO), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -478,9 +492,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1200, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_MODULE_INFO), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -505,9 +519,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1300, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_BUNDLE_INFO_FOR_TARGET), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_BUNDLE_INFO_FOR_TARGET), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -534,9 +548,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1400, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_FOR_TARGET), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_MODULE_INFO_FOR_TARGET), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -566,8 +580,8 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1500, Function | SmallTest | Le MessageOption option; data.WriteInterfaceToken(TEST_HOST_DESCRIPTOR); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_FOR_TARGET), data, reply, option); - EXPECT_EQ(ret, OBJECT_NULL); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_MODULE_INFO_FOR_TARGET), data, reply, option); + EXPECT_EQ(ret, ERR_TRANSACTION_FAILED); } /** @@ -587,7 +601,7 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1600, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest(TEST_CODE, data, reply, option); EXPECT_NE(ret, ERR_OK); } @@ -604,9 +618,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1700, Function | SmallTest | Le auto overlayProxy = GetOverlayProxy(); EXPECT_NE(overlayProxy, nullptr); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; auto errCode = overlayProxy->SetOverlayEnabled(TEST_TARGET_BUNDLE_NAME, TEST_TARGET_MODULE_NAME, - true, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + true, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -621,9 +636,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1800, Function | SmallTest | Le auto overlayProxy = GetOverlayProxy(); EXPECT_NE(overlayProxy, nullptr); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; auto errCode = overlayProxy->SetOverlayEnabled(TEST_TARGET_BUNDLE_NAME, TEST_TARGET_MODULE_NAME, - false, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + false, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -636,10 +652,7 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1800, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1900, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - - auto errCode = overlayProxy->SetOverlayEnabled("", TEST_TARGET_MODULE_NAME, + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabled("", TEST_TARGET_MODULE_NAME, true, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } @@ -654,10 +667,7 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_1900, Function | SmallTest | Le */ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2000, Function | SmallTest | Level0) { - auto overlayProxy = GetOverlayProxy(); - EXPECT_NE(overlayProxy, nullptr); - - auto errCode = overlayProxy->SetOverlayEnabled(TEST_TARGET_BUNDLE_NAME, "", + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabled(TEST_TARGET_BUNDLE_NAME, "", true, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } @@ -678,9 +688,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2200, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_SET_OVERLAY_ENABLED), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); EXPECT_EQ(ret, ERR_OK); @@ -700,8 +710,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2400, Function | SmallTest | Le EXPECT_NE(hostImpl, nullptr); std::vector vec; - auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, vec); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetAllOverlayModuleInfo(TEST_BUNDLE_NAME, UNSPECIFIED_USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -718,8 +729,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2500, Function | SmallTest | Le EXPECT_NE(hostImpl, nullptr); OverlayModuleInfo info; - auto res = hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, info); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = + hostImpl->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, UNSPECIFIED_USERID, info, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -736,8 +749,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2600, Function | SmallTest | Le EXPECT_NE(hostImpl, nullptr); std::vector vec; - auto res = hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, vec); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res =hostImpl->GetOverlayBundleInfoForTarget(TEST_TARGET_BUNDLE_NAME, UNSPECIFIED_USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -754,8 +768,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2700, Function | SmallTest | Le EXPECT_NE(hostImpl, nullptr); std::vector vec; - auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_TARGET_BUNDLE_NAME, TEST_TARGET_MODULE_NAME, vec); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->GetOverlayModuleInfoForTarget(TEST_TARGET_BUNDLE_NAME, TEST_TARGET_MODULE_NAME, + UNSPECIFIED_USERID, vec, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -771,8 +787,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2800, Function | SmallTest | Le auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -788,8 +805,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_2900, Function | SmallTest | Le auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, false); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, false, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED); } /** @@ -808,9 +826,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3000, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_NAME), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_MODULE_INFO), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -835,9 +853,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3100, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_TARGET_OVERLAY_MODULE_INFOS), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_GET_TARGET_OVERLAY_MODULE_INFO), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); @@ -864,9 +882,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3200, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME), + static_cast(IOverlayManagerIpcCode::COMMAND_GET_OVERLAY_MODULE_INFO_BY_BUNDLE_NAME), data, reply, option); EXPECT_EQ(ret, ERR_OK); @@ -894,9 +912,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3300, Function | SmallTest | Le MessageParcel data; MessageParcel reply; MessageOption option; - data.WriteInterfaceToken(OverlayManagerHost::GetDescriptor()); + data.WriteInterfaceToken(OverlayManagerStub::GetDescriptor()); auto ret = overlayHost->OnRemoteRequest( - static_cast(OverlayManagerInterfaceCode::SET_OVERLAY_ENABLED_FOR_SELF), data, reply, option); + static_cast(IOverlayManagerIpcCode::COMMAND_SET_OVERLAY_ENABLED_FOR_SELF), data, reply, option); EXPECT_EQ(ret, ERR_OK); ret = reply.ReadInt32(); EXPECT_EQ(ret, ERR_OK); @@ -916,13 +934,13 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3400, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetTargetOverlayModuleInfo("", overlayModuleInfos, - TEST_USER_ID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = OverlayManagerClient::GetInstance().GetTargetOverlayModuleInfo("", overlayModuleInfos, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); - errCode = overlayProxy->GetTargetOverlayModuleInfo(TEST_TARGET_BUNDLE_NAME, overlayModuleInfos, - TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + errCode = overlayProxy->GetTargetOverlayModuleInfo(TEST_TARGET_BUNDLE_NAME, TEST_USER_ID, + overlayModuleInfos, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -939,13 +957,14 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3500, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); std::vector overlayModuleInfos; - auto errCode = overlayProxy->GetOverlayModuleInfoByBundleName("", TEST_MODULE_NAME, + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = OverlayManagerClient::GetInstance().GetOverlayModuleInfoByBundleName("", TEST_MODULE_NAME, overlayModuleInfos, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); errCode = overlayProxy->GetOverlayModuleInfoByBundleName(TEST_BUNDLE_NAME, TEST_MODULE_NAME, - overlayModuleInfos, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + TEST_USER_ID, overlayModuleInfos, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -962,13 +981,14 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3600, Function | SmallTest | Le EXPECT_NE(overlayProxy, nullptr); bool isEnabled = false; - auto errCode = overlayProxy->SetOverlayEnabledForSelf("", + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabledForSelf("", isEnabled, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); errCode = overlayProxy->SetOverlayEnabledForSelf(TEST_MODULE_NAME, - isEnabled, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + isEnabled, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -981,8 +1001,10 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3700, Function | SmallTest | Le auto overlayProxy = GetOverlayProxy(); ASSERT_NE(overlayProxy, nullptr); OverlayModuleInfo info; - auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, info, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_BUNDLE_NAME, TEST_MODULE_NAME, TEST_USER_ID, info, + funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -1000,7 +1022,7 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_3800, Function | SmallTest | Le ASSERT_NE(overlayProxy, nullptr); OverlayModuleInfo overlayModuleInfo; - auto errCode = overlayProxy->GetOverlayModuleInfo("", overlayModuleInfo, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().GetOverlayModuleInfo("", overlayModuleInfo, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR); } @@ -1017,8 +1039,9 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_0390, Function | SmallTest | Le ASSERT_NE(overlayProxy, nullptr); OverlayModuleInfo overlayModuleInfo; - auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_MODULE_NAME, overlayModuleInfo, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto errCode = overlayProxy->GetOverlayModuleInfo(TEST_MODULE_NAME, TEST_USER_ID, overlayModuleInfo, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); } /** @@ -1034,12 +1057,13 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_4000, Function | SmallTest | Le ASSERT_NE(overlayProxy, nullptr); MessageParcel reply; bool isEnabled = false; - auto errCode = overlayProxy->SetOverlayEnabledForSelf("", isEnabled, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabledForSelf("", isEnabled, TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); std::string moduleName = TEST_MODULE_NAME; - errCode = overlayProxy->SetOverlayEnabledForSelf(moduleName, isEnabled, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + errCode = overlayProxy->SetOverlayEnabledForSelf(moduleName, isEnabled, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); auto res = reply.ReadInt32(); EXPECT_EQ(res, ERR_OK); } @@ -1057,13 +1081,15 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_4010, Function | SmallTest | Le ASSERT_NE(overlayProxy, nullptr); bool isEnabled = false; MessageParcel reply; - auto errCode = overlayProxy->SetOverlayEnabled("", TEST_TARGET_BUNDLE_NAME, isEnabled, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabled("", TEST_TARGET_BUNDLE_NAME, isEnabled, + TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); std::string moduleName = TEST_TARGET_MODULE_NAME; std::string bundleName = TEST_TARGET_BUNDLE_NAME; - errCode = overlayProxy->SetOverlayEnabled(bundleName, moduleName, isEnabled, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + errCode = overlayProxy->SetOverlayEnabled(bundleName, moduleName, isEnabled, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); auto res = reply.ReadInt32(); EXPECT_EQ(res, ERR_OK); } @@ -1081,13 +1107,15 @@ HWTEST_F(BmsBundleOverlayIpcTest, OverlayIpcTest_4020, Function | SmallTest | Le ASSERT_NE(overlayProxy, nullptr); bool isEnabled = false; MessageParcel reply; - auto errCode = overlayProxy->SetOverlayEnabled("", TEST_TARGET_BUNDLE_NAME, isEnabled, TEST_USER_ID); + auto errCode = OverlayManagerClient::GetInstance().SetOverlayEnabled("", TEST_TARGET_BUNDLE_NAME, isEnabled, + TEST_USER_ID); EXPECT_EQ(errCode, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); std::string bundleName = TEST_TARGET_BUNDLE_NAME; std::string moduleName = TEST_TARGET_MODULE_NAME; - errCode = overlayProxy->SetOverlayEnabled(bundleName, moduleName, isEnabled, TEST_USER_ID); - EXPECT_EQ(errCode, ERR_APPEXECFWK_PARCEL_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + errCode = overlayProxy->SetOverlayEnabled(bundleName, moduleName, isEnabled, TEST_USER_ID, funcResult); + EXPECT_EQ(errCode, ERR_INVALID_DATA); auto res = reply.ReadInt32(); EXPECT_EQ(res, ERR_OK); } diff --git a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_set_overlay_enabled_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_set_overlay_enabled_test.cpp index 98c7f8c12f707a09145f81b9250fa2dcbce9ecc7..dbe9368c30941e67808725af970657b4cc3d8386 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_set_overlay_enabled_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_overlay_test/bms_bundle_set_overlay_enabled_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -35,6 +35,7 @@ const std::string TEST_MODULE_NAME_THIRD = "testModuleNameThird"; const std::string TARGET_MODULE_NAME = "targetModuleName"; const std::string TEST_BUNDLE_NAME = "testBundleName"; const int32_t DEFAULT_TARGET_PRIORITY_SECOND = 1; +const int32_t UNSPECIFIED_USERID = -2; const int32_t USERID = 100; const int32_t TEST_USERID = 101; const int32_t WAIT_TIME = 5; // init mocked bms @@ -191,8 +192,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0100, Function | auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled("", TEST_MODULE_NAME, true); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled("", TEST_MODULE_NAME, true, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } /** @@ -208,8 +210,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0200, Function | auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled("", TEST_MODULE_NAME, false); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled("", TEST_MODULE_NAME, UNSPECIFIED_USERID, false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } /** @@ -225,8 +228,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0300, Function | auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, "", true); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, "", true, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } /** @@ -242,8 +246,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0400, Function | auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, "", false); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, "", false, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } /** @@ -258,8 +263,10 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_500, Function | S // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, Constants::INVALID_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = + hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, Constants::INVALID_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR); } /** @@ -274,8 +281,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0600, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, UNSPECIFIED_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE); } /** @@ -294,8 +302,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0700, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, TEST_USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, TEST_USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID); RemoveBundleInfo(); } @@ -315,8 +324,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0800, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE); RemoveBundleInfo(); } @@ -336,8 +346,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_0900, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, true, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME_THIRD, true, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE); RemoveBundleInfo(); } @@ -357,8 +368,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_1000, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, true, USERID); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME_SECOND, true, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE); RemoveBundleInfo(); } @@ -378,8 +390,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_1100, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, true, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckEnabledState(OVERLAY_ENABLE); RemoveBundleInfo(); @@ -401,8 +414,9 @@ HWTEST_F(BmsBundleSetOverlayEnabledTest, SetOverlayEnabledTest_1200, Function | // get OverlayManagerHostImpl instance auto hostImpl = std::make_shared(); EXPECT_NE(hostImpl, nullptr); - auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, false, USERID); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + auto res = hostImpl->SetOverlayEnabled(TEST_BUNDLE_NAME, TEST_MODULE_NAME, false, USERID, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckEnabledState(OVERLAY_DISABLED); RemoveBundleInfo(); diff --git a/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/BUILD.gn b/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/BUILD.gn index c4f8b98295df09cfe8a092674d84c6ae89959df7..a42f3256c65e50c0318e363dd3fa11d1557a9664 100644 --- a/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/BUILD.gn +++ b/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2023 Huawei Device Co., Ltd. +# Copyright (c) 2023-2025 Huawei Device 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 @@ -16,6 +16,7 @@ import("//build/config/features.gni") import("//build/ohos.gni") import("//build/test.gni") import("../../../../appexecfwk.gni") +import("../../../../services/bundlemgr/appexecfwk_bundlemgr.gni") module_output_path = fuzz_test_path ##############################fuzztest########################################## @@ -31,15 +32,130 @@ ohos_fuzztest("OverlayManagerHostFuzzTest") { "-fno-omit-frame-pointer", ] sources = [ "overlaymanagerhost_fuzzer.cpp" ] + use_exceptions = true + include_dirs = [] + sources += bundle_mgr_source + sources += [ + "${services_path}/bundlemgr/src/aot/aot_executor.cpp", + "${services_path}/bundlemgr/src/installd/installd_host_impl.cpp", + "${services_path}/bundlemgr/src/installd/installd_operator.cpp", + "${services_path}/bundlemgr/src/installd/installd_permission_mgr.cpp", + "${services_path}/bundlemgr/src/installd/installd_service.cpp", + ] + + defines = [] + sources += bundle_install_sources + if (bundle_framework_overlay_install) { + include_dirs += [ "${services_path}/bundlemgr/include/overlay" ] + sources += overlay_installation + defines += [ "BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION" ] + } + configs = [ "${services_path}/bundlemgr/test:bundlemgr_test_config" ] deps = [ "${base_path}:appexecfwk_base", "${common_path}:libappexecfwk_common", "${core_path}:appexecfwk_core", + "${core_path}:overlay_manager_stub", ] + deps += bundle_install_deps + external_deps = [ "ability_base:want", "c_utils:utils", + "access_token:el5_filekey_manager_sdk", + "access_token:libprivacy_sdk", + "access_token:libtokenid_sdk", + "appspawn:hnpapi", + "appverify:libhapverify", + "bounds_checking_function:libsec_shared", + "common_event_service:cesfwk_innerkits", + "eventhandler:libeventhandler", + "hilog:libhilog", + "hitrace:hitrace_meter", + "init:libbegetutil", "ipc:ipc_core", + "ipc:ipc_single", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "selinux_adapter:librestorecon", ] + + external_deps += [ + "ability_runtime:ability_manager", + "ability_runtime:app_manager", + "battery_manager:batterysrv_client", + "display_manager:displaymgr", + "ffrt:libffrt", + "power_manager:powermgr_client", + "syscap_codec:syscap_interface_shared", + ] + if (device_usage_statistics_enabled) { + external_deps += [ "device_usage_statistics:usagestatsinner" ] + defines += [ "DEVICE_USAGE_STATISTICS_ENABLED" ] + } + + external_deps += bundle_install_external_deps + + if (code_signature_enable) { + sources += [ + "${services_path}/bundlemgr/src/aot/aot_sign_data_cache_mgr.cpp", + "${services_path}/bundlemgr/src/code_sign_helper.cpp", + ] + include_dirs += [ "${services_path}/bundlemgr/include" ] + external_deps += [ + "bounds_checking_function:libsec_shared", + "code_signature:libcode_sign_utils", + "ets_runtime:libcompiler_service", + ] + defines += [ "CODE_SIGNATURE_ENABLE" ] + } + + if (bundle_framework_power_mgr_enable) { + external_deps += aot_external_deps + } + + if (configpolicy_enable) { + external_deps += [ "config_policy:configpolicy_util" ] + defines += [ "CONFIG_POLOCY_ENABLE" ] + } + + if (build_selinux) { + external_deps += [ "selinux_adapter:libhap_restorecon" ] + } + + if (storage_service_enable) { + external_deps += [ "storage_service:storage_manager_sa_proxy" ] + defines += [ "STORAGE_SERVICE_ENABLE" ] + } + configs += [ "../../../../services/bundlemgr:rdb_config" ] + external_deps += [ "relational_store:native_rdb" ] + sources += [ + "${services_path}/bundlemgr/src/bundle_data_storage_rdb.cpp", + "${services_path}/bundlemgr/src/preinstall_data_storage_rdb.cpp", + "${services_path}/bundlemgr/src/rdb/bms_rdb_open_callback.cpp", + "${services_path}/bundlemgr/src/rdb/rdb_data_manager.cpp", + ] + if (bundle_framework_app_control) { + defines += [ "BUNDLE_FRAMEWORK_APP_CONTROL" ] + sources += [ + "${services_path}/bundlemgr/src/app_control/app_control_manager.cpp", + "${services_path}/bundlemgr/src/app_control/app_control_manager_host_impl.cpp", + "${services_path}/bundlemgr/src/app_control/app_control_manager_rdb.cpp", + "${services_path}/bundlemgr/src/app_control/app_jump_interceptor_event_subscriber.cpp", + "${services_path}/bundlemgr/src/app_control/app_jump_interceptor_manager_rdb.cpp", + ] + include_dirs += [ "${services_path}/bundlemgr/include/app_control" ] + } + if (udmf_enabled) { + defines += [ "BUNDLE_FRAMEWORK_UDMF_ENABLED" ] + external_deps += [ "udmf:utd_client" ] + } + + if (user_auth_framework_impl_enabled) { + external_deps += [ "user_auth_framework:userauth_client" ] + defines += [ "BMS_USER_AUTH_FRAMEWORK_ENABLED" ] + include_dirs += [ "${services_path}/bundlemgr/include/user_auth" ] + sources += user_auth + } } diff --git a/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/overlaymanagerhost_fuzzer.cpp b/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/overlaymanagerhost_fuzzer.cpp index fb6d3ba43374ae2928b78bd70ac9a776af45d365..67f0d10b7fce5bfbdf85d0fc475b0fedd703b58c 100644 --- a/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/overlaymanagerhost_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/overlaymanagerhost_fuzzer/overlaymanagerhost_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -18,7 +18,7 @@ #include #include -#include "overlay_manager_host.h" +#include "bundle_overlay_manager_host_impl.h" #include "securec.h" using namespace OHOS::AppExecFwk; @@ -30,14 +30,14 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) { for (uint32_t code = 0; code <= CODE_MAX; code++) { MessageParcel datas; - std::u16string descriptor = OverlayManagerHost::GetDescriptor(); + std::u16string descriptor = OverlayManagerStub::GetDescriptor(); datas.WriteInterfaceToken(descriptor); datas.WriteBuffer(data, size); datas.RewindRead(0); MessageParcel reply; MessageOption option; - OverlayManagerHost overlayManagerHost; - overlayManagerHost.OnRemoteRequest(code, datas, reply, option); + OverlayManagerHostImpl overlayManagerHostImpl; + overlayManagerHostImpl.OnRemoteRequest(code, datas, reply, option); } return true; } diff --git a/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/BUILD.gn b/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/BUILD.gn index 81c8b052770b7341a857a7accd49ebeb9dbdd18f..7e1981b7639551db808b613214f861fb0cfa7ba1 100644 --- a/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/BUILD.gn +++ b/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/BUILD.gn @@ -48,7 +48,10 @@ ohos_fuzztest("OverlayMgrHostImplFuzzTest") { "-fno-omit-frame-pointer", ] - deps = [ "${core_path}:appexecfwk_core" ] + deps = [ + "${core_path}:appexecfwk_core", + "${core_path}:overlay_manager_stub", + ] deps += bundle_install_deps external_deps = [ diff --git a/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/overlaymgrhostimpl_fuzzer.cpp b/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/overlaymgrhostimpl_fuzzer.cpp index 17af9a7eff52f2fc1456836dc0f7e91006aee570..50a922354195a61b6f17fea9dadaf74e5e8a630a 100644 --- a/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/overlaymgrhostimpl_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/overlaymgrhostimpl_fuzzer/overlaymgrhostimpl_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-2025 Huawei Device 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 @@ -18,6 +18,7 @@ #include "bundle_overlay_manager_host_impl.h" #include "securec.h" +#include "appexecfwk_errors.h" using namespace OHOS::AppExecFwk; namespace OHOS { @@ -29,22 +30,24 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) { OverlayManagerHostImpl overlayManagerHostImpl; std::vector overlayModuleInfos; + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; std::string bundleName(data, size); - overlayManagerHostImpl.GetAllOverlayModuleInfo(bundleName, overlayModuleInfos, USERID); + overlayManagerHostImpl.GetAllOverlayModuleInfo(bundleName, USERID, overlayModuleInfos, funcResult); OverlayModuleInfo overlayModuleInfo; std::string moduleName(data, size); - overlayManagerHostImpl.GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, USERID); - overlayManagerHostImpl.GetOverlayModuleInfo(moduleName, overlayModuleInfo, USERID); + overlayManagerHostImpl.GetOverlayModuleInfo(bundleName, moduleName, USERID, overlayModuleInfo, funcResult); + overlayManagerHostImpl.GetOverlayModuleInfo(moduleName, USERID, overlayModuleInfo, funcResult); std::string targetModuleName(data, size); - overlayManagerHostImpl.GetTargetOverlayModuleInfo(targetModuleName, overlayModuleInfos, USERID); - overlayManagerHostImpl.GetOverlayModuleInfoByBundleName(bundleName, moduleName, overlayModuleInfos, USERID); + overlayManagerHostImpl.GetTargetOverlayModuleInfo(targetModuleName, USERID, overlayModuleInfos, funcResult); + overlayManagerHostImpl.GetOverlayModuleInfoByBundleName(bundleName, moduleName, + USERID, overlayModuleInfos, funcResult); std::string targetBundleName(data, size); std::vector overlayBundleInfos; - overlayManagerHostImpl.GetOverlayBundleInfoForTarget(targetBundleName, overlayBundleInfos, USERID); + overlayManagerHostImpl.GetOverlayBundleInfoForTarget(targetBundleName, USERID, overlayBundleInfos, funcResult); overlayManagerHostImpl.GetOverlayModuleInfoForTarget(targetBundleName, - targetModuleName, overlayModuleInfos, USERID); - overlayManagerHostImpl.SetOverlayEnabledForSelf(moduleName, true, USERID); - overlayManagerHostImpl.SetOverlayEnabled(bundleName, moduleName, true, USERID); + targetModuleName, USERID, overlayModuleInfos, funcResult); + overlayManagerHostImpl.SetOverlayEnabledForSelf(moduleName, true, USERID, funcResult); + overlayManagerHostImpl.SetOverlayEnabled(bundleName, moduleName, true, USERID, funcResult); return true; } } diff --git a/test/systemtest/common/bms/bms_overlay_install_test/bms_overlay_internal_install_test.cpp b/test/systemtest/common/bms/bms_overlay_install_test/bms_overlay_internal_install_test.cpp index 4cc6979bf01a4fcfc3dbf519fecbda1b5b996aed..9b19ef283ea640a2d71d3c4bf91df70e86439166 100755 --- a/test/systemtest/common/bms/bms_overlay_install_test/bms_overlay_internal_install_test.cpp +++ b/test/systemtest/common/bms/bms_overlay_install_test/bms_overlay_internal_install_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device 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 @@ -25,6 +25,7 @@ #include "common_event_support.h" #include "common_tool.h" #include "iservice_registry.h" +#include "overlay_manager_client.h" #include "system_ability_definition.h" #include "status_receiver_host.h" @@ -248,10 +249,8 @@ ErrCode BmsOverlayInternalInstallTest::UninstallBundle(const std::string &bundle ErrCode BmsOverlayInternalInstallTest::GetOverlayModuleInfo(const std::string &bundleName, const std::string &moduleName, OverlayModuleInfo &overlayModuleInfo) { - sptr overlayProxy = GetOverlayManagerProxy(); - EXPECT_NE(overlayProxy, nullptr); - - auto ret = overlayProxy->GetOverlayModuleInfo(bundleName, moduleName, overlayModuleInfo, USERID); + auto ret = OverlayManagerClient::GetInstance().GetOverlayModuleInfo(bundleName, moduleName, + overlayModuleInfo, USERID); return ret; } @@ -259,10 +258,8 @@ ErrCode BmsOverlayInternalInstallTest::GetOverlayModuleInfoForTarget(const std:: const std::string &moduleName, std::vector &overlayModuleInfos) { - sptr overlayProxy = GetOverlayManagerProxy(); - EXPECT_NE(overlayProxy, nullptr); - - auto ret = overlayProxy->GetOverlayModuleInfoForTarget(targetBundleName, moduleName, overlayModuleInfos, USERID); + auto ret = OverlayManagerClient::GetInstance().GetOverlayModuleInfoForTarget(targetBundleName, + moduleName, overlayModuleInfos, USERID); return ret; }