diff --git a/interfaces/inner_api/appexecfwk_core/BUILD.gn b/interfaces/inner_api/appexecfwk_core/BUILD.gn index b97c6af2fcb594636f86725e80b19f339fbdaff4..f4de519eb86bc0da1a8cfa3c980694a91c48e0ba 100644 --- a/interfaces/inner_api/appexecfwk_core/BUILD.gn +++ b/interfaces/inner_api/appexecfwk_core/BUILD.gn @@ -48,6 +48,16 @@ idl_gen_interface("bundle_mgr_ext_interface") { hitrace = "HITRACE_TAG_APP" } +idl_gen_interface("quick_fix_manager_interface") { + sources = [ "IQuickFixManager.idl" ] + # log_domainid = "0xD001120" + # log_tag = "BMS" + subsystem_name = "bundlemanager" + part_name = "bundle_framework" + hitrace = "HITRACE_TAG_APP" +} +gen_parent_dir = get_path_info(target_gen_dir, "dir") + config("bundlemgr_sdk_config") { include_dirs = [ "include", @@ -60,6 +70,7 @@ config("bundlemgr_sdk_config") { "include/quick_fix", "include/verify", "include/bundlemgr_ext", + "${gen_parent_dir}", "${target_gen_dir}", ] } @@ -192,12 +203,15 @@ ohos_shared_library("appexecfwk_core") { defines += [ "BUNDLE_FRAMEWORK_QUICK_FIX" ] } sources += [ - "src/quick_fix/quick_fix_manager_host.cpp", - "src/quick_fix/quick_fix_manager_proxy.cpp", + "src/quick_fix/quick_fix_manager_client.cpp", "src/quick_fix/quick_fix_result_info.cpp", "src/quick_fix/quick_fix_status_callback_host.cpp", "src/quick_fix/quick_fix_status_callback_proxy.cpp", ] + deps += [ + ":quick_fix_manager_proxy", + ":quick_fix_manager_stub", + ] if (bundle_framework_overlay_install) { defines += [ "BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION" ] @@ -271,6 +285,7 @@ ohos_shared_library("bundlemgr_mini") { deps = [ ":bundle_mgr_ext_interface", ":overlay_manager_interface", + ":quick_fix_manager_interface", ":verify_manager_interface", "${base_path}:appexecfwk_base", "${common_path}:libappexecfwk_common", @@ -515,4 +530,82 @@ ohos_source_set("bundle_mgr_ext_stub") { ] subsystem_name = "bundlemanager" part_name = "bundle_framework" -} \ No newline at end of file +} + +ohos_source_set("quick_fix_manager_proxy") { + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } + cflags = [ + "-Os", + "-fstack-protector-strong", + ] + + cflags_cc = [ + "-Os", + "-fstack-protector-strong", + ] + + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + include_dirs = [ "include/quick_fix" ] + output_values = get_target_outputs(":quick_fix_manager_interface") + sources = filter_include(output_values, [ "*quick_fix_manager_proxy.cpp" ]) + deps = [ + ":quick_fix_manager_interface", + "${base_path}:appexecfwk_base", + ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + ] + subsystem_name = "bundlemanager" + part_name = "bundle_framework" +} + +ohos_source_set("quick_fix_manager_stub") { + sanitize = { + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + debug = false + integer_overflow = true + ubsan = true + } + cflags = [ + "-Os", + "-fstack-protector-strong", + ] + + cflags_cc = [ + "-Os", + "-fstack-protector-strong", + ] + + if (target_cpu == "arm") { + cflags += [ "-DBINDER_IPC_32BIT" ] + } + include_dirs = [ "include/quick_fix" ] + output_values = get_target_outputs(":quick_fix_manager_interface") + sources = filter_include(output_values, [ "*quick_fix_manager_stub.cpp" ]) + deps = [ + ":quick_fix_manager_interface", + "${base_path}:appexecfwk_base", + ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + ] + subsystem_name = "bundlemanager" + part_name = "bundle_framework" +} diff --git a/interfaces/inner_api/appexecfwk_core/IQuickFixManager.idl b/interfaces/inner_api/appexecfwk_core/IQuickFixManager.idl new file mode 100644 index 0000000000000000000000000000000000000000..a8314951aa64b4227970df67bb3f084692542983 --- /dev/null +++ b/interfaces/inner_api/appexecfwk_core/IQuickFixManager.idl @@ -0,0 +1,25 @@ +/* + * 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. + */ + +interface OHOS.AppExecFwk.IQuickFixStatusCallback; + +option_stub_hooks on; +interface_token ohos.bundleManager.QuickFixManager; +interface OHOS.AppExecFwk.IQuickFixManager { + [ipccode 0]void DeployQuickFix([in] String[] bundleFilePaths, [in] IQuickFixStatusCallback statusCallback, [in] boolean isDebug, [in] String targetPath, [in] boolean isReplace, [out] int funcResult); + [ipccode 1]void SwitchQuickFix([in] String bundleName, [in] boolean enable, [in] IQuickFixStatusCallback statusCallback, [out] int funcResult); + [ipccode 2]void DeleteQuickFix([in] String bundleName, [in] IQuickFixStatusCallback statusCallback, [out] int funcResult); + [ipccode 3]void CreateFd([in] String fileName, [out] FileDescriptor fd, [out] String path, [out] int funcResult); +} \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/bundle_framework_core_ipc_interface_code.h b/interfaces/inner_api/appexecfwk_core/include/bundle_framework_core_ipc_interface_code.h index fa43eea1e577a3d58fc54e4fdd95545d14f62aaa..2f465723186e2ccdc1890f6120e47930cba4af0f 100644 --- a/interfaces/inner_api/appexecfwk_core/include/bundle_framework_core_ipc_interface_code.h +++ b/interfaces/inner_api/appexecfwk_core/include/bundle_framework_core_ipc_interface_code.h @@ -333,14 +333,6 @@ enum class OverlayManagerInterfaceCode : uint8_t { SET_OVERLAY_ENABLED_FOR_SELF = 8, }; -/* SAID: 401-81 Interface No.81 subservice also provides the following interfaces */ -enum class QuickFixManagerInterfaceCode : uint8_t { - DEPLOY_QUICK_FIX = 0, - SWITCH_QUICK_FIX = 1, - DELETE_QUICK_FIX = 2, - CREATE_FD = 3 -}; - /* SAID: 401-81 Interface No.81 subservice also provides the following interfaces */ enum class QuickFixStatusCallbackInterfaceCode : uint8_t { ON_PATCH_DEPLOYED = 1, 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 7e56825cd19d11e5963c1c8f400337c8b205d1f8..72fd8c95ada075f7dbd6c3386727f0b6d0115e9b 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 @@ -17,6 +17,7 @@ #define FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_BUNDLEMGR_BUNDLE_MGR_INTERFACE_H #include "ability_info.h" +#include "appexecfwk_core/iquick_fix_manager.h" #include "appexecfwk_errors.h" #include "application_info.h" #include "app_provision_info.h" @@ -41,7 +42,6 @@ #include "ibundle_mgr_ext.h" #include "ioverlay_manager.h" #include "plugin/plugin_bundle_info.h" -#include "quick_fix_manager_interface.h" #include "iverify_manager.h" #include "distributed_bundle_info.h" #include "form_info.h" diff --git a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_host.h b/interfaces/inner_api/appexecfwk_core/include/quick_fix/iquick_fix_status_callback.h similarity index 47% rename from interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_host.h rename to interfaces/inner_api/appexecfwk_core/include/quick_fix/iquick_fix_status_callback.h index ba9e1d181f8a7e2d07d594baa49ecfdbc126f6bf..d95cb913e86971f06428bdeb0c787b6b814db1a6 100644 --- a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_host.h +++ b/interfaces/inner_api/appexecfwk_core/include/quick_fix/iquick_fix_status_callback.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -13,30 +13,14 @@ * limitations under the License. */ -#ifndef FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_HOST_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_HOST_H +#ifndef FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_IQUICK_FIX_STATUS_CALLBACK_H +#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_IQUICK_FIX_STATUS_CALLBACK_H -#include "quick_fix_manager_interface.h" -#include "iremote_stub.h" -#include "nocopyable.h" +#include "quick_fix_status_callback_interface.h" namespace OHOS { namespace AppExecFwk { -class QuickFixManagerHost : public IRemoteStub { -public: - QuickFixManagerHost(); - virtual ~QuickFixManagerHost(); - - int OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option) override; - -private: - ErrCode HandleDeployQuickFix(MessageParcel& data, MessageParcel& reply); - ErrCode HandleSwitchQuickFix(MessageParcel& data, MessageParcel& reply); - ErrCode HandleDeleteQuickFix(MessageParcel& data, MessageParcel& reply); - ErrCode HandleCreateFd(MessageParcel& data, MessageParcel& reply); - - DISALLOW_COPY_AND_MOVE(QuickFixManagerHost); -}; +using OHOS::AppExecFwk::IQuickFixStatusCallback; } // AppExecFwk } // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_HOST_H +#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_IQUICK_FIX_STATUS_CALLBACK_H diff --git a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_client.h b/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_client.h new file mode 100644 index 0000000000000000000000000000000000000000..0724d405377902c7657a357aa928d2c62c7bf866 --- /dev/null +++ b/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_client.h @@ -0,0 +1,69 @@ +/* + * 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_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_CLIENT_H +#define FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_CLIENT_H + +#include + +#include "appexecfwk_core/iquick_fix_manager.h" +#include "appexecfwk_errors.h" +#include "bundle_mgr_interface.h" +#include "quick_fix_status_callback_interface.h" + +namespace OHOS { +namespace AppExecFwk { + +class QuickFixManagerClient { +public: + static QuickFixManagerClient &GetInstance(); + + ErrCode DeployQuickFix(const std::vector &bundleFilePaths, + const sptr &statusCallback, bool isDebug = false, + const std::string &inputTargetPath = "", bool isReplace = false); + + ErrCode SwitchQuickFix(const std::string &bundleName, bool enable, + const sptr &statusCallback); + + ErrCode DeleteQuickFix(const std::string &bundleName, + const sptr &statusCallback); + + ErrCode CreateFd(const std::string &fileName, int32_t &fd, std::string &path); + ErrCode CopyFiles(const std::vector &sourceFiles, std::vector &destFiles); + +private: + QuickFixManagerClient(); + ~QuickFixManagerClient(); + DISALLOW_COPY_AND_MOVE(QuickFixManagerClient); + + class QuickFixManagerDeathRecipient : public IRemoteObject::DeathRecipient { + public: + QuickFixManagerDeathRecipient() = default; + ~QuickFixManagerDeathRecipient() override = default; + void OnRemoteDied(const wptr& remote) override; + + private: + DISALLOW_COPY_AND_MOVE(QuickFixManagerDeathRecipient); + }; + void ResetQuickFixManagerProxy(const wptr& remote); + sptr GetQuickFixManagerProxy(); + + std::mutex mutex_; + sptr deathRecipient_ = nullptr; + sptr quickFixManager_; +}; +} +} +#endif // FOUNDATION_APPEXECFWK_INTERFACES_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_CLIENT_H \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_interface.h b/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_interface.h deleted file mode 100644 index cbb625d172745ed3c426500bc2dd7ae76a944143..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_interface.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * Copyright (c) 2022 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_QUICK_FIX_MANAGER_INTERFACE_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_INTERFACE_H - -#include "appexecfwk_errors.h" -#include "quick_fix_status_callback_interface.h" -#include "iremote_broker.h" - -#include -#include - -namespace OHOS { -namespace AppExecFwk { -class IQuickFixManager : public IRemoteBroker { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.bundleManager.QuickFixManager"); - - virtual ErrCode DeployQuickFix(const std::vector &bundleFilePaths, - const sptr &statusCallback, bool isDebug = false, const std::string &targetPath = "", - bool isReplace = false) - { - return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR; - } - - virtual ErrCode SwitchQuickFix(const std::string &bundleName, bool enable, - const sptr &statusCallback) - { - return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR; - } - - virtual ErrCode DeleteQuickFix(const std::string &bundleName, - const sptr &statusCallback) - { - return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR; - } - - virtual ErrCode CreateFd(const std::string &fileName, int32_t &fd, std::string &path) - { - return ERR_APPEXECFWK_SERVICE_INTERNAL_ERROR; - } - - virtual ErrCode CopyFiles(const std::vector &sourceFiles, std::vector &destFiles) - { - return ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; - } -}; -} // AppExecFwk -} // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_INTERFACE_H \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_proxy.h b/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_proxy.h deleted file mode 100644 index 4c2f1a13e16cad1e0b31236f3c4e96e3bd1cf479..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/include/quick_fix/quick_fix_manager_proxy.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright (c) 2022 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_QUICK_FIX_MANAGER_PROXY_H -#define FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_PROXY_H - -#include "bundle_framework_core_ipc_interface_code.h" -#include "quick_fix_manager_interface.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace AppExecFwk { -class QuickFixManagerProxy : public IRemoteProxy { -public: - explicit QuickFixManagerProxy(const sptr &object); - virtual ~QuickFixManagerProxy(); - - virtual ErrCode DeployQuickFix(const std::vector &bundleFilePaths, - const sptr &statusCallback, bool isDebug = false, - const std::string &inputTargetPath = "", bool isReplace = false) override; - - virtual ErrCode SwitchQuickFix(const std::string &bundleName, bool enable, - const sptr &statusCallback) override; - - virtual ErrCode DeleteQuickFix(const std::string &bundleName, - const sptr &statusCallback) override; - - virtual ErrCode CopyFiles(const std::vector &sourceFiles, - std::vector &destFiles) override; - -private: - virtual ErrCode CreateFd(const std::string &fileName, int32_t &fd, std::string &path) override; - bool SendRequest(QuickFixManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply); - - static inline BrokerDelegator delegator_; -}; -} // AppExecFwk -} // OHOS -#endif // FOUNDATION_BUNDLEMANAGER_BUNDLE_FRAMEWORK_INNERKITS_APPEXECFWK_CORE_INCLUDE_QUICK_FIX_MANAGER_PROXY_H diff --git a/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_proxy.cpp b/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_client.cpp similarity index 36% rename from interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_proxy.cpp rename to interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_client.cpp index 47eda95acb3c4b8b1c5626da009738b75a6ac7f8..876083540c1148f87178cc4f17c7a67ad1f611a0 100644 --- a/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_proxy.cpp +++ b/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_client.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2025 Huawei Device Co., Ltd. + * 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 @@ -12,8 +12,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -#include "quick_fix_manager_proxy.h" +#include "quick_fix_manager_client.h" #include #include @@ -21,228 +20,175 @@ #include "app_log_tag_wrapper.h" #include "app_log_wrapper.h" -#include "appexecfwk_errors.h" #include "bundle_file_util.h" -#include "directory_ex.h" +#include "bundle_mgr_interface.h" +#include "bundle_mgr_proxy.h" +#include "bundle_mgr_service_death_recipient.h" #include "hitrace_meter.h" -#include "ipc_types.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" namespace OHOS { namespace AppExecFwk { -namespace { const std::string SEPARATOR = "/"; const int32_t DEFAULT_BUFFER_SIZE = 65536; + +QuickFixManagerClient &QuickFixManagerClient::GetInstance() +{ + static QuickFixManagerClient instance; + return instance; } -QuickFixManagerProxy::QuickFixManagerProxy(const sptr &object) : IRemoteProxy(object) +QuickFixManagerClient::QuickFixManagerClient() { - LOG_I(BMS_TAG_DEFAULT, "create QuickFixManagerProxy"); + APP_LOGD("create QuickFixManagerClient"); } -QuickFixManagerProxy::~QuickFixManagerProxy() +QuickFixManagerClient::~QuickFixManagerClient() { - LOG_I(BMS_TAG_DEFAULT, "destroy QuickFixManagerProxy"); + APP_LOGD("destory QuickFixManagerClient"); } -ErrCode QuickFixManagerProxy::DeployQuickFix(const std::vector &bundleFilePaths, +ErrCode QuickFixManagerClient::DeployQuickFix(const std::vector &bundleFilePaths, const sptr &statusCallback, bool isDebug, const std::string &inputTargetPath, bool isReplace) { - LOG_I(BMS_TAG_DEFAULT, "begin to call DeployQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - + APP_LOGI("begin to call DeployQuickFix"); if (bundleFilePaths.empty() || (statusCallback == nullptr)) { - LOG_E(BMS_TAG_DEFAULT, "DeployQuickFix failed due to params error"); + APP_LOGE("DeployQuickFix failed due to params error"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } - std::string targetPath = inputTargetPath; if (targetPath.find(".") != std::string::npos || targetPath.find("..") != std::string::npos || targetPath.find("/") != std::string::npos) { - LOG_E(BMS_TAG_DEFAULT, "input targetPath is invalid"); + APP_LOGE("input targetPath is invalid"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - LOG_E(BMS_TAG_DEFAULT, "WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteStringVector(bundleFilePaths)) { - LOG_E(BMS_TAG_DEFAULT, "write bundleFilePaths failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteBool(isDebug)) { - LOG_E(BMS_TAG_DEFAULT, "write isDebug failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(targetPath)) { - LOG_E(BMS_TAG_DEFAULT, "write targetPath failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteBool(isReplace)) { - LOG_E(BMS_TAG_DEFAULT, "write isReplace failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + auto proxy = GetQuickFixManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get quick fix manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; } - if (!data.WriteRemoteObject(statusCallback->AsObject())) { - LOG_E(BMS_TAG_DEFAULT, "write parcel failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + ErrCode funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode ipcRet = proxy->DeployQuickFix( + bundleFilePaths, statusCallback, isDebug, inputTargetPath, isReplace, funcResult); + if (ipcRet != ERR_OK) { + APP_LOGE("DeployQuickFix failed due to ipc error, err: %{public}d", ipcRet); + return ipcRet; } - - MessageParcel reply; - if (!SendRequest(QuickFixManagerInterfaceCode::DEPLOY_QUICK_FIX, data, reply)) { - LOG_E(BMS_TAG_DEFAULT, "SendRequest failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED; - } - - return reply.ReadInt32(); + return funcResult; } -ErrCode QuickFixManagerProxy::SwitchQuickFix(const std::string &bundleName, bool enable, +ErrCode QuickFixManagerClient::SwitchQuickFix(const std::string &bundleName, bool enable, const sptr &statusCallback) { - LOG_I(BMS_TAG_DEFAULT, "begin to call SwitchQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - + APP_LOGI("begin to call SwitchQuickFix"); if (bundleName.empty() || (statusCallback == nullptr)) { - LOG_E(BMS_TAG_DEFAULT, "SwitchQuickFix failed due to params error"); + APP_LOGE("SwitchQuickFix failed due to params error"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - LOG_E(BMS_TAG_DEFAULT, "WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + auto proxy = GetQuickFixManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get quick fix manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; } - if (!data.WriteString(bundleName)) { - LOG_E(BMS_TAG_DEFAULT, "write bundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteBool(enable)) { - LOG_E(BMS_TAG_DEFAULT, "write enable failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteRemoteObject(statusCallback->AsObject())) { - LOG_E(BMS_TAG_DEFAULT, "write parcel failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - - MessageParcel reply; - if (!SendRequest(QuickFixManagerInterfaceCode::SWITCH_QUICK_FIX, data, reply)) { - LOG_E(BMS_TAG_DEFAULT, "SendRequest failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED; + ErrCode funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode ipcRet = proxy->SwitchQuickFix(bundleName, enable, statusCallback, funcResult); + if (ipcRet != ERR_OK) { + APP_LOGE("SwitchQuickFix failed due to ipc error, err: %{public}d", ipcRet); + return ipcRet; } - - return reply.ReadInt32(); + return funcResult; } -ErrCode QuickFixManagerProxy::DeleteQuickFix(const std::string &bundleName, +ErrCode QuickFixManagerClient::DeleteQuickFix(const std::string &bundleName, const sptr &statusCallback) { - LOG_I(BMS_TAG_DEFAULT, "begin to call DeleteQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - + APP_LOGI("begin to call DeleteQuickFix"); if (bundleName.empty() || (statusCallback == nullptr)) { - LOG_E(BMS_TAG_DEFAULT, "DeleteQuickFix failed due to params error"); + APP_LOGE("DeleteQuickFix failed due to params error"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } - - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - LOG_E(BMS_TAG_DEFAULT, "WriteInterfaceToken failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(bundleName)) { - LOG_E(BMS_TAG_DEFAULT, "write bundleName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteRemoteObject(statusCallback->AsObject())) { - LOG_E(BMS_TAG_DEFAULT, "write parcel failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + auto proxy = GetQuickFixManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get quick fix manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; } - - MessageParcel reply; - if (!SendRequest(QuickFixManagerInterfaceCode::DELETE_QUICK_FIX, data, reply)) { - LOG_E(BMS_TAG_DEFAULT, "SendRequest failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED; + ErrCode funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode ipcRet = proxy->DeleteQuickFix(bundleName, statusCallback, funcResult); + if (ipcRet != ERR_OK) { + APP_LOGE("DeleteQuickFix failed due to ipc error, err: %{public}d", ipcRet); + return ipcRet; } - - return reply.ReadInt32(); + return funcResult; } -ErrCode QuickFixManagerProxy::CreateFd(const std::string &fileName, int32_t &fd, std::string &path) +ErrCode QuickFixManagerClient::CreateFd(const std::string &fileName, int32_t &fd, std::string &path) { - LOG_D(BMS_TAG_DEFAULT, "begin to create fd"); + APP_LOGD("begin to create fd"); if (fileName.empty()) { - LOG_E(BMS_TAG_DEFAULT, "fileName is empty"); + APP_LOGE("fileName is empty"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor())) { - LOG_E(BMS_TAG_DEFAULT, "write interface token failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!data.WriteString(fileName)) { - LOG_E(BMS_TAG_DEFAULT, "write fileName failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + auto proxy = GetQuickFixManagerProxy(); + if (proxy == nullptr) { + APP_LOGE("failed to get quick fix manager proxy"); + return ERR_APPEXECFWK_NULL_PTR; } - MessageParcel reply; - if (!SendRequest(QuickFixManagerInterfaceCode::CREATE_FD, data, reply)) { - LOG_E(BMS_TAG_DEFAULT, "send request failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; + ErrCode funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + ErrCode ipcRet = proxy->CreateFd(fileName, fd, path, funcResult); + if (ipcRet != ERR_OK) { + APP_LOGE("CreateFd failed due to ipc error, err: %{public}d", ipcRet); + return ipcRet; } - auto ret = reply.ReadInt32(); - if (ret != ERR_OK) { - LOG_E(BMS_TAG_DEFAULT, "reply return false"); - return ret; - } - fd = reply.ReadFileDescriptor(); if (fd < 0) { - LOG_E(BMS_TAG_DEFAULT, "invalid fd"); + APP_LOGE("invalid fd"); return ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED; } - path = reply.ReadString(); if (path.empty()) { - LOG_E(BMS_TAG_DEFAULT, "invalid path"); + APP_LOGE("invalid path"); close(fd); return ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_TARGET_DIR; } - LOG_D(BMS_TAG_DEFAULT, "create fd success"); - return ERR_OK; + if (funcResult != ERR_OK) { + APP_LOGE("create fd failed, err: %{public}d", funcResult); + close(fd); + } + return funcResult; } -ErrCode QuickFixManagerProxy::CopyFiles( +ErrCode QuickFixManagerClient::CopyFiles( const std::vector &sourceFiles, std::vector &destFiles) { - LOG_D(BMS_TAG_DEFAULT, "begin to copy files"); + APP_LOGD("begin to copy files"); if (sourceFiles.empty()) { - LOG_E(BMS_TAG_DEFAULT, "sourceFiles empty"); + APP_LOGE("sourceFiles empty"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } std::vector hqfFilePaths; if (!BundleFileUtil::CheckFilePath(sourceFiles, hqfFilePaths)) { - LOG_E(BMS_TAG_DEFAULT, "CopyFiles CheckFilePath failed"); + APP_LOGE("CopyFiles CheckFilePath failed"); return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; } for (const std::string &sourcePath : hqfFilePaths) { size_t pos = sourcePath.find_last_of(SEPARATOR); if (pos == std::string::npos) { - LOG_E(BMS_TAG_DEFAULT, "invalid sourcePath"); + APP_LOGE("invalid sourcePath"); return ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH; } std::string fileName = sourcePath.substr(pos + 1); - LOG_D(BMS_TAG_DEFAULT, "sourcePath:%{private}s fileName:%{private}s", sourcePath.c_str(), fileName.c_str()); + APP_LOGD("sourcePath:%{private}s fileName:%{private}s", sourcePath.c_str(), fileName.c_str()); int32_t sourceFd = open(sourcePath.c_str(), O_RDONLY); if (sourceFd < 0) { - LOG_E(BMS_TAG_DEFAULT, "open file failed, errno:%{public}d", errno); + APP_LOGE("open file failed, errno:%{public}d", errno); return ERR_BUNDLEMANAGER_QUICK_FIX_OPEN_SOURCE_FILE_FAILED; } int32_t destFd = -1; std::string destPath; auto ret = CreateFd(fileName, destFd, destPath); if ((ret != ERR_OK) || (destFd < 0) || (destPath.empty())) { - LOG_E(BMS_TAG_DEFAULT, "create fd failed"); + APP_LOGE("create fd failed"); close(sourceFd); return ret; } @@ -250,7 +196,7 @@ ErrCode QuickFixManagerProxy::CopyFiles( int offset = -1; while ((offset = read(sourceFd, buffer, sizeof(buffer))) > 0) { if (write(destFd, buffer, offset) < 0) { - LOG_E(BMS_TAG_DEFAULT, "write file to the temp dir failed, errno %{public}d", errno); + APP_LOGE("write file to the temp dir failed, errno %{public}d", errno); close(sourceFd); close(destFd); return ERR_BUNDLEMANAGER_QUICK_FIX_WRITE_FILE_FAILED; @@ -261,24 +207,81 @@ ErrCode QuickFixManagerProxy::CopyFiles( fsync(destFd); close(destFd); } - LOG_D(BMS_TAG_DEFAULT, "copy files success"); + APP_LOGD("copy files success"); return ERR_OK; } -bool QuickFixManagerProxy::SendRequest(QuickFixManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply) +void QuickFixManagerClient::ResetQuickFixManagerProxy(const wptr& remote) +{ + APP_LOGD("begin to reset quick fix manager proxy"); + std::lock_guard lock(mutex_); + if (quickFixManager_ == nullptr) { + APP_LOGE("Proxy is nullptr"); + return; + } + auto serviceRemote = quickFixManager_->AsObject(); + if ((serviceRemote != nullptr) && (serviceRemote == remote.promote())) { + serviceRemote->RemoveDeathRecipient(deathRecipient_); + } + quickFixManager_ = nullptr; + deathRecipient_ = nullptr; + APP_LOGD("reset quick fix manager proxy success"); +} + +void QuickFixManagerClient::QuickFixManagerDeathRecipient::OnRemoteDied(const wptr &remote) { - MessageOption option(MessageOption::TF_SYNC); - sptr remote = Remote(); + APP_LOGD("begin to on remote died"); if (remote == nullptr) { - LOG_E(BMS_TAG_DEFAULT, "failed to send request %{public}hhu due to remote object null", code); - return false; + APP_LOGE("remote is nullptr"); + return; } - int32_t result = remote->SendRequest(static_cast(code), data, reply, option); - if (result != NO_ERROR) { - LOG_E(BMS_TAG_DEFAULT, "receive error code %{public}d in transact %{public}hhu", result, code); - return false; + QuickFixManagerClient::GetInstance().ResetQuickFixManagerProxy(remote); + APP_LOGD("on remote died success"); +} + +sptr QuickFixManagerClient::GetQuickFixManagerProxy() +{ + APP_LOGD("begin to get quick fix manager proxy"); + std::lock_guard lock(mutex_); + if (quickFixManager_ != nullptr) { + return quickFixManager_; + } + 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("get bms sa failed"); + return nullptr; + } + auto bundleMgr = iface_cast(remoteObject); + if (bundleMgr == nullptr) { + APP_LOGE("get bundle mgr failed"); + return nullptr; + } + quickFixManager_ = bundleMgr->GetQuickFixManagerProxy(); + if ((quickFixManager_ == nullptr) || (quickFixManager_->AsObject() == nullptr)) { + APP_LOGE("failed to get quick fix manager proxy"); + return nullptr; + } + deathRecipient_ = new (std::nothrow) QuickFixManagerDeathRecipient(); + if (deathRecipient_ == nullptr) { + APP_LOGE("failed to create quick fix manager death recipient"); + return nullptr; } - return true; + + if ((quickFixManager_->AsObject()->IsProxyObject()) && + (!quickFixManager_->AsObject()->AddDeathRecipient(deathRecipient_))) { + APP_LOGE("Failed to add death recipient"); + deathRecipient_ = nullptr; + quickFixManager_ = nullptr; + return nullptr; + } + APP_LOGD("get quick fix manager proxy success"); + return quickFixManager_; } } // AppExecFwk } // OHOS \ No newline at end of file diff --git a/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_host.cpp b/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_host.cpp deleted file mode 100644 index 204e8a5cf31052251930bd46b627602a30c5d020..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/appexecfwk_core/src/quick_fix/quick_fix_manager_host.cpp +++ /dev/null @@ -1,165 +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 "quick_fix_manager_host.h" - -#include -#include - -#include "app_log_wrapper.h" -#include "appexecfwk_errors.h" -#include "app_log_tag_wrapper.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 { -QuickFixManagerHost::QuickFixManagerHost() -{ - LOG_I(BMS_TAG_DEFAULT, "create QuickFixManagerHost"); -} - -QuickFixManagerHost::~QuickFixManagerHost() -{ - LOG_I(BMS_TAG_DEFAULT, "destroy QuickFixManagerHost"); -} - -int QuickFixManagerHost::OnRemoteRequest(uint32_t code, MessageParcel& data, - MessageParcel& reply, MessageOption& option) -{ - BundleMemoryGuard memoryGuard; - LOG_I(BMS_TAG_DEFAULT, "QuickFixManagerHost OnRemoteRequest, message code : %{public}u", code); - std::u16string descriptor = QuickFixManagerHost::GetDescriptor(); - std::u16string remoteDescriptor = data.ReadInterfaceToken(); - if (descriptor != remoteDescriptor) { - LOG_E(BMS_TAG_DEFAULT, "descriptor invalid"); - return OBJECT_NULL; - } - - switch (code) { - case static_cast(QuickFixManagerInterfaceCode::DEPLOY_QUICK_FIX): - return HandleDeployQuickFix(data, reply); - case static_cast(QuickFixManagerInterfaceCode::SWITCH_QUICK_FIX): - return HandleSwitchQuickFix(data, reply); - case static_cast(QuickFixManagerInterfaceCode::DELETE_QUICK_FIX): - return HandleDeleteQuickFix(data, reply); - case static_cast(QuickFixManagerInterfaceCode::CREATE_FD): - return HandleCreateFd(data, reply); - default: - LOG_W(BMS_TAG_DEFAULT, "QuickFixManagerHost receive unknown code, code = %{public}d", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } -} - -ErrCode QuickFixManagerHost::HandleDeployQuickFix(MessageParcel& data, MessageParcel& reply) -{ - LOG_I(BMS_TAG_DEFAULT, "begin to HandleDeployQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::vector bundleFilePaths; - if (!data.ReadStringVector(&bundleFilePaths)) { - LOG_E(BMS_TAG_DEFAULT, "read bundleFilePaths failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - bool isDebug = data.ReadBool(); - std::string targetPath = data.ReadString(); - bool isReplace = data.ReadBool(); - sptr object = data.ReadRemoteObject(); - if (object == nullptr) { - LOG_E(BMS_TAG_DEFAULT, "read statusCallback failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - sptr statusCallback = iface_cast(object); - - auto ret = DeployQuickFix(bundleFilePaths, statusCallback, isDebug, targetPath, isReplace); - if (!reply.WriteInt32(ret)) { - LOG_E(BMS_TAG_DEFAULT, "write ret failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - return ERR_OK; -} - -ErrCode QuickFixManagerHost::HandleSwitchQuickFix(MessageParcel& data, MessageParcel& reply) -{ - LOG_I(BMS_TAG_DEFAULT, "begin to HandleSwitchQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - bool enable = data.ReadBool(); - sptr object = data.ReadRemoteObject(); - if (object == nullptr) { - LOG_E(BMS_TAG_DEFAULT, "read statusCallback failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - sptr statusCallback = iface_cast(object); - - auto ret = SwitchQuickFix(bundleName, enable, statusCallback); - if (!reply.WriteInt32(ret)) { - LOG_E(BMS_TAG_DEFAULT, "write ret failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - return ERR_OK; -} - -ErrCode QuickFixManagerHost::HandleDeleteQuickFix(MessageParcel& data, MessageParcel& reply) -{ - LOG_I(BMS_TAG_DEFAULT, "begin to HandleDeleteQuickFix"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string bundleName = data.ReadString(); - sptr object = data.ReadRemoteObject(); - if (object == nullptr) { - LOG_E(BMS_TAG_DEFAULT, "read statusCallback failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - sptr statusCallback = iface_cast(object); - - auto ret = DeleteQuickFix(bundleName, statusCallback); - if (!reply.WriteInt32(ret)) { - LOG_E(BMS_TAG_DEFAULT, "write ret failed"); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - return ERR_OK; -} - -ErrCode QuickFixManagerHost::HandleCreateFd(MessageParcel& data, MessageParcel& reply) -{ - LOG_D(BMS_TAG_DEFAULT, "begin to HandleCreateFd"); - HITRACE_METER_NAME_EX(HITRACE_LEVEL_INFO, HITRACE_TAG_APP, __PRETTY_FUNCTION__, nullptr); - std::string fileName = data.ReadString(); - int32_t fd = -1; - std::string path; - auto ret = CreateFd(fileName, fd, path); - if (!reply.WriteInt32(ret)) { - LOG_E(BMS_TAG_DEFAULT, "write ret failed"); - close(fd); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (ret == ERR_OK) { - if (!reply.WriteFileDescriptor(fd)) { - LOG_E(BMS_TAG_DEFAULT, "write fd failed"); - close(fd); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - if (!reply.WriteString(path)) { - LOG_E(BMS_TAG_DEFAULT, "write path failed"); - close(fd); - return ERR_APPEXECFWK_PARCEL_ERROR; - } - } - close(fd); - return ERR_OK; -} -} // AppExecFwk -} // namespace OHOS diff --git a/services/bundlemgr/include/quick_fix/quick_fix_manager_host_impl.h b/services/bundlemgr/include/quick_fix/quick_fix_manager_host_impl.h index f4abf35da617eda8e98223a59d34f09f0b71e376..8602224c527503b74147b946787ebb316fa2e1c6 100644 --- a/services/bundlemgr/include/quick_fix/quick_fix_manager_host_impl.h +++ b/services/bundlemgr/include/quick_fix/quick_fix_manager_host_impl.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * 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 @@ -19,26 +19,30 @@ #include #include "quick_fix_mgr.h" -#include "quick_fix_manager_host.h" +#include "quick_fix_manager_stub.h" namespace OHOS { namespace AppExecFwk { -class QuickFixManagerHostImpl : public QuickFixManagerHost { +class QuickFixManagerHostImpl : public QuickFixManagerStub { public: QuickFixManagerHostImpl(); virtual ~QuickFixManagerHostImpl(); + 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; + virtual ErrCode DeployQuickFix(const std::vector &bundleFilePaths, - const sptr &statusCallback, bool isDebug = false, - const std::string &targetPath = "", bool isReplace = false) override; + const sptr &statusCallback, bool isDebug, + const std::string &targetPath, bool isReplace, int32_t &funcResult) override; virtual ErrCode SwitchQuickFix(const std::string &bundleName, bool enable, - const sptr &statusCallback) override; + const sptr &statusCallback, int32_t &funcResult) override; virtual ErrCode DeleteQuickFix(const std::string &bundleName, - const sptr &statusCallback) override; + const sptr &statusCallback, int32_t &funcResult) override; - virtual ErrCode CreateFd(const std::string &fileName, int32_t &fd, std::string &path) override; + virtual ErrCode CreateFd( + const std::string &fileName, int32_t &fd, std::string &path, int32_t &funcResult) override; private: bool GetQuickFixMgr(); diff --git a/services/bundlemgr/src/quick_fix/quick_fix_manager_host_impl.cpp b/services/bundlemgr/src/quick_fix/quick_fix_manager_host_impl.cpp index 79c2219de1c787d5e624ce73b77a12460354d7f1..7903185acb53c1c4937277df91860f5331589869 100644 --- a/services/bundlemgr/src/quick_fix/quick_fix_manager_host_impl.cpp +++ b/services/bundlemgr/src/quick_fix/quick_fix_manager_host_impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * 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 @@ -16,6 +16,7 @@ #include "quick_fix_manager_host_impl.h" #include "app_log_tag_wrapper.h" +#include "bundle_memory_guard.h" #include "bundle_permission_mgr.h" #include "bundle_util.h" @@ -31,118 +32,152 @@ QuickFixManagerHostImpl::~QuickFixManagerHostImpl() LOG_I(BMS_TAG_DEFAULT, "destory QuickFixManagerHostImpl"); } +int32_t QuickFixManagerHostImpl::CallbackEnter([[maybe_unused]] uint32_t code) +{ + BundleMemoryGuard::SetBundleMemoryGuard(); + return ERR_OK; +} +int32_t QuickFixManagerHostImpl::CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) +{ + BundleMemoryGuard::ClearBundleMemoryGuard(); + return ERR_OK; +} + ErrCode QuickFixManagerHostImpl::DeployQuickFix(const std::vector &bundleFilePaths, const sptr &statusCallback, bool isDebug, const std::string &targetPath, - bool isReplace) + bool isReplace, int32_t &funcResult) { LOG_I(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeployQuickFix start"); if (bundleFilePaths.empty() || (statusCallback == nullptr)) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeployQuickFix wrong parms"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + return ERR_OK; } if (!BundlePermissionMgr::IsSystemApp()) { LOG_E(BMS_TAG_DEFAULT, "non-system app is not allowed 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_INSTALL_BUNDLE) && !BundlePermissionMgr::VerifyCallingPermissionForAll(ServiceConstants::PERMISSION_INSTALL_QUICK_FIX_BUNDLE)) { LOG_E(BMS_TAG_DEFAULT, "verify install permission failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + return ERR_OK; } if (!GetQuickFixMgr()) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeployQuickFix quickFixerMgr is nullptr"); - return ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + return ERR_OK; } std::vector securityFilePaths; - ErrCode result = CopyHqfToSecurityDir(bundleFilePaths, securityFilePaths); - if (result != ERR_OK) { - LOG_E(BMS_TAG_DEFAULT, "copy file to secure dir failed %{public}d", result); - return result; + funcResult = CopyHqfToSecurityDir(bundleFilePaths, securityFilePaths); + if (funcResult != ERR_OK) { + LOG_E(BMS_TAG_DEFAULT, "copy file to secure dir failed %{public}d", funcResult); + return ERR_OK; } - return quickFixMgr_->DeployQuickFix(securityFilePaths, statusCallback, isDebug, targetPath, isReplace); + funcResult = quickFixMgr_->DeployQuickFix(securityFilePaths, statusCallback, isDebug, targetPath, isReplace); + return ERR_OK; } ErrCode QuickFixManagerHostImpl::SwitchQuickFix(const std::string &bundleName, bool enable, - const sptr &statusCallback) + const sptr &statusCallback, int32_t &funcResult) { LOG_I(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::SwitchQuickFix start"); if (bundleName.empty() || (statusCallback == nullptr)) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::SwitchQuickFix wrong parms"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + return ERR_OK; } if (!BundlePermissionMgr::IsSystemApp()) { LOG_E(BMS_TAG_DEFAULT, "non-system app is not allowed 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_INSTALL_BUNDLE) && !BundlePermissionMgr::VerifyCallingPermissionForAll(ServiceConstants::PERMISSION_INSTALL_QUICK_FIX_BUNDLE)) { LOG_E(BMS_TAG_DEFAULT, "verify install permission failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + return ERR_OK; } if (!GetQuickFixMgr()) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::SwitchQuickFix quickFixerMgr is nullptr"); - return ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + return ERR_OK; } - return quickFixMgr_->SwitchQuickFix(bundleName, enable, statusCallback); + funcResult = quickFixMgr_->SwitchQuickFix(bundleName, enable, statusCallback); + return ERR_OK; } ErrCode QuickFixManagerHostImpl::DeleteQuickFix(const std::string &bundleName, - const sptr &statusCallback) + const sptr &statusCallback, int32_t &funcResult) { LOG_I(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeleteQuickFix start"); if (bundleName.empty() || (statusCallback == nullptr)) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeleteQuickFix wrong parms"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + return ERR_OK; } if (!BundlePermissionMgr::IsSystemApp()) { LOG_E(BMS_TAG_DEFAULT, "non-system app is not allowed 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_INSTALL_BUNDLE) && !BundlePermissionMgr::VerifyCallingPermissionForAll(ServiceConstants::PERMISSION_UNINSTALL_QUICK_FIX_BUNDLE)) { LOG_E(BMS_TAG_DEFAULT, "verify install permission failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + return ERR_OK; } if (!GetQuickFixMgr()) { LOG_E(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::DeleteQuickFix quickFixerMgr is nullptr"); - return ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR; + return ERR_OK; } - return quickFixMgr_->DeleteQuickFix(bundleName, statusCallback); + funcResult = quickFixMgr_->DeleteQuickFix(bundleName, statusCallback); + return ERR_OK; } -ErrCode QuickFixManagerHostImpl::CreateFd(const std::string &fileName, int32_t &fd, std::string &path) +ErrCode QuickFixManagerHostImpl::CreateFd( + const std::string &fileName, int32_t &fd, std::string &path, int32_t &funcResult) { LOG_D(BMS_TAG_DEFAULT, "QuickFixManagerHostImpl::CreateFd start"); if (!BundlePermissionMgr::IsSystemApp()) { LOG_E(BMS_TAG_DEFAULT, "non-system app is not allowed 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_INSTALL_BUNDLE) && !BundlePermissionMgr::VerifyCallingPermissionForAll(ServiceConstants::PERMISSION_INSTALL_QUICK_FIX_BUNDLE)) { LOG_E(BMS_TAG_DEFAULT, "verify install permission failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PERMISSION_DENIED; + return ERR_OK; } if (!BundleUtil::CheckFileType(fileName, ServiceConstants::QUICK_FIX_FILE_SUFFIX)) { LOG_E(BMS_TAG_DEFAULT, "not quick fix file"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + return ERR_OK; } if (!IsFileNameValid(fileName)) { LOG_E(BMS_TAG_DEFAULT, "invalid fileName"); - return ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR; + return ERR_OK; } std::string tmpDir = BundleUtil::CreateInstallTempDir(++id_, DirType::QUICK_FIX_DIR); if (tmpDir.empty()) { LOG_E(BMS_TAG_DEFAULT, "create tmp dir failed"); - return ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_TARGET_DIR_FAILED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_TARGET_DIR_FAILED; + return ERR_OK; } path = tmpDir + fileName; if ((fd = BundleUtil::CreateFileDescriptor(path, 0)) < 0) { LOG_E(BMS_TAG_DEFAULT, "create file descriptor failed"); BundleUtil::DeleteDir(tmpDir); - return ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED; + funcResult = ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED; + return ERR_OK; } + funcResult = ERR_OK; return ERR_OK; } 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 24909deccc4b36de2ecbe7559e3490ed0497225a..71fdafa1890fc43929517ce1ba817d586391d4c9 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 @@ -44,6 +44,7 @@ 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 diff --git a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_deleter_test/bms_bundle_quick_fix_deleter_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_deleter_test/bms_bundle_quick_fix_deleter_test.cpp index 17a9935cae9b081ba72f0148450476d9bc248ba1..5c6ab24cf18b9d5c9d9edb7dca6af0211e280544 100755 --- a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_deleter_test/bms_bundle_quick_fix_deleter_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_deleter_test/bms_bundle_quick_fix_deleter_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -147,8 +147,9 @@ HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0100, Functi auto quickFixHost = std::make_shared(); sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->DeleteQuickFix("", callback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->DeleteQuickFix("", callback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -161,8 +162,9 @@ HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0100, Functi HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0200, Function | SmallTest | Level0) { auto quickFixHost = std::make_shared(); - ErrCode result = quickFixHost->DeleteQuickFix(BUNDLE_NAME, nullptr); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->DeleteQuickFix(BUNDLE_NAME, nullptr, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -177,8 +179,9 @@ HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0300, Functi auto quickFixHost = std::make_shared(); sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); } @@ -197,8 +200,9 @@ HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0400, Functi auto quickFixHost = std::make_shared(); sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); } @@ -217,8 +221,9 @@ HWTEST_F(BmsBundleQuickFixDeleterTest, BmsBundleQuickFixDeleterTest_0500, Functi auto quickFixHost = std::make_shared(); sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->DeleteQuickFix(BUNDLE_NAME, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); } diff --git a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_manager_test/bms_bundle_quick_fix_manager_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_manager_test/bms_bundle_quick_fix_manager_test.cpp index 07b7d3a2d38cd30109163d11d217a4300ebe858d..d05ed8f46b258ba79a2e104ed62bbd17d95914e6 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_manager_test/bms_bundle_quick_fix_manager_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_manager_test/bms_bundle_quick_fix_manager_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * 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 @@ -26,6 +26,7 @@ #include "inner_app_quick_fix.h" #include "iservice_registry.h" #include "quick_fix_data_mgr.h" +#include "quick_fix_manager_client.h" #include "quick_fix_manager_rdb.h" #include "system_ability_definition.h" @@ -55,7 +56,6 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - sptr GetQuickFixManagerProxy(); void CreateFiles(const std::vector& sourceFiles); void DeleteFiles(const std::vector& destFiles); static std::vector sourceFiles; @@ -105,26 +105,6 @@ AppQuickFix BmsBundleQuickFixManagerTest::CreateAppQuickFix() return appQuickFix; } -sptr BmsBundleQuickFixManagerTest::GetQuickFixManagerProxy() -{ - auto systemAbilityManager = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); - if (systemAbilityManager == nullptr) { - APP_LOGE("GetSystemAbilityManager failed."); - return nullptr; - } - auto bundleMgrSa = systemAbilityManager->GetSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); - if (bundleMgrSa == nullptr) { - APP_LOGE("GetSystemAbility failed."); - return nullptr; - } - auto bundleMgr = OHOS::iface_cast(bundleMgrSa); - if (bundleMgr == nullptr) { - APP_LOGE("iface_cast failed."); - return nullptr; - } - return bundleMgr->GetQuickFixManagerProxy(); -} - void BmsBundleQuickFixManagerTest::CreateFiles(const std::vector& sourceFiles) { for (const auto& path : sourceFiles) { @@ -148,12 +128,10 @@ HWTEST_F(BmsBundleQuickFixManagerTest, BmsBundleQuickFixManager_0100, Function | { APP_LOGI("begin of BmsBundleQuickFixManager_0100."); #ifdef BUNDLE_FRAMEWORK_QUICK_FIX - auto quickFixManagerProxy = GetQuickFixManagerProxy(); - ASSERT_NE(quickFixManagerProxy, nullptr); std::vector sourceFiles {FILE1_PATH, FILE2_PATH}; CreateFiles(sourceFiles); std::vector destFiles; - auto ret = quickFixManagerProxy->CopyFiles(sourceFiles, destFiles); + auto ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_EQ(ret, ERR_OK); ASSERT_EQ(destFiles.size(), sourceFiles.size()); EXPECT_TRUE(FileExists(destFiles[0])); @@ -181,12 +159,10 @@ HWTEST_F(BmsBundleQuickFixManagerTest, BmsBundleQuickFixManager_0200, Function | { APP_LOGI("begin of BmsBundleQuickFixManager_0200."); #ifdef BUNDLE_FRAMEWORK_QUICK_FIX - auto quickFixManagerProxy = GetQuickFixManagerProxy(); - ASSERT_NE(quickFixManagerProxy, nullptr); std::vector sourceFiles {INVALID_FILE_SUFFIX_PATH}; CreateFiles(sourceFiles); std::vector destFiles; - auto ret = quickFixManagerProxy->CopyFiles(sourceFiles, destFiles); + auto ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); DeleteFiles(sourceFiles); #else @@ -204,11 +180,9 @@ HWTEST_F(BmsBundleQuickFixManagerTest, BmsBundleQuickFixManager_0300, Function | { APP_LOGI("begin of BmsBundleQuickFixManager_0300."); #ifdef BUNDLE_FRAMEWORK_QUICK_FIX - auto quickFixManagerProxy = GetQuickFixManagerProxy(); - ASSERT_NE(quickFixManagerProxy, nullptr); std::vector sourceFiles {NOT_EXIST_FILE_PATH}; std::vector destFiles; - auto ret = quickFixManagerProxy->CopyFiles(sourceFiles, destFiles); + auto ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); #else ASSERT_TRUE(true); @@ -225,11 +199,9 @@ HWTEST_F(BmsBundleQuickFixManagerTest, BmsBundleQuickFixManager_0400, Function | { APP_LOGI("begin of BmsBundleQuickFixManager_0400."); #ifdef BUNDLE_FRAMEWORK_QUICK_FIX - auto quickFixManagerProxy = GetQuickFixManagerProxy(); - ASSERT_NE(quickFixManagerProxy, nullptr); std::vector sourceFiles; std::vector destFiles; - auto ret = quickFixManagerProxy->CopyFiles(sourceFiles, destFiles); + auto ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); #else ASSERT_TRUE(true); diff --git a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_mgr_rdb_test/bms_bundle_quick_fix_mgr_rdb_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_mgr_rdb_test/bms_bundle_quick_fix_mgr_rdb_test.cpp index 48bda6aefdb408b71c567bea417de8429eeb68f9..f9abf5d2fb13dbc3e07c10433822b9ad3c8b7e64 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_mgr_rdb_test/bms_bundle_quick_fix_mgr_rdb_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_mgr_rdb_test/bms_bundle_quick_fix_mgr_rdb_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 @@ -507,8 +507,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0001, auto impl = std::make_shared(); std::vector bundleFilePaths; sptr statusCallback = nullptr; - auto result = impl->DeployQuickFix(bundleFilePaths, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeployQuickFix(bundleFilePaths, statusCallback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -522,8 +523,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0002, std::vector bundleFilePaths; bundleFilePaths.emplace_back("/etc/path"); sptr statusCallback = nullptr; - auto result = impl->DeployQuickFix(bundleFilePaths, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeployQuickFix(bundleFilePaths, statusCallback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -538,8 +540,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0003, bundleFilePaths.emplace_back("/etc/path"); sptr object = nullptr; sptr statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(object); - auto result = impl->DeployQuickFix(bundleFilePaths, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeployQuickFix(bundleFilePaths, statusCallback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); } /** @@ -554,8 +557,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0004, bool enable = false; std::vector bundleFilePaths; sptr statusCallback = nullptr; - auto result = impl->SwitchQuickFix(bundleName, enable, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->SwitchQuickFix(bundleName, enable, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -569,8 +573,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0005, std::string bundleName = "bundle"; bool enable = false; sptr statusCallback = nullptr; - auto result = impl->SwitchQuickFix(bundleName, enable, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->SwitchQuickFix(bundleName, enable, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -585,8 +590,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0006, bool enable = false; sptr object = nullptr; sptr statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(object); - auto result = impl->SwitchQuickFix(bundleName, enable, statusCallback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->SwitchQuickFix(bundleName, enable, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); } /** @@ -599,8 +605,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0007, auto impl = std::make_shared(); std::string bundleName; sptr statusCallback = nullptr; - auto result = impl->DeleteQuickFix(bundleName, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeleteQuickFix(bundleName, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -613,8 +620,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0008, auto impl = std::make_shared(); std::string bundleName = "bundle"; sptr statusCallback = nullptr; - auto result = impl->DeleteQuickFix(bundleName, statusCallback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeleteQuickFix(bundleName, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -628,8 +636,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0009, std::string bundleName = "bundle"; sptr object = nullptr; sptr statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(object); - auto result = impl->DeleteQuickFix(bundleName, statusCallback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->DeleteQuickFix(bundleName, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); } /** @@ -643,8 +652,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0010, std::string fileName; int32_t fd; std::string path; - auto result = impl->CreateFd(fileName, fd, path); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -661,8 +671,9 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0011, std::string fileName = "entry.hqf"; int32_t fd; std::string path = "/data/app/el1/bundle/public/com.example.l3jsdemo/patch_1000001/"; - auto result = impl->CreateFd(fileName, fd, path); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); ret = UninstallBundle(BUNDLE_NAME); EXPECT_EQ(ret, ERR_OK) << "Uninstall bundle com.example.l3jsdemo failed"; @@ -696,69 +707,14 @@ HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0013, std::string fileName = "entry.hqf"; int32_t fd; std::string path = "/data/app/el1/bundle/public/com.example.l3jsdemo/patch_1000001/"; - auto result = impl->CreateFd(fileName, fd, path); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + impl->CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); ret = UninstallBundle(BUNDLE_NAME); EXPECT_EQ(ret, ERR_OK) << "Uninstall bundle com.example.l3jsdemo failed"; } -/* - * @tc.number: BmsBundleQuickFixManagerHostImplTest_0014 - * @tc.name: HandleCreateFd - * @tc.desc: 1. test HandleCreateFd - */ -HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0014, Function | SmallTest | Level0) -{ - QuickFixManagerHostImpl impl; - MessageParcel data; - MessageParcel reply; - auto result = impl.HandleCreateFd(data, reply); - EXPECT_EQ(result, ERR_OK); -} - -/* - * @tc.number: BmsBundleQuickFixManagerHostImplTest_0015 - * @tc.name: HandleDeployQuickFix - * @tc.desc: 1. test HandleDeployQuickFix - */ -HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0015, Function | SmallTest | Level0) -{ - QuickFixManagerHostImpl impl; - MessageParcel data; - MessageParcel reply; - auto ret = impl.HandleDeployQuickFix(data, reply); - EXPECT_EQ(ret, ERR_APPEXECFWK_PARCEL_ERROR); -} - -/* - * @tc.number: BmsBundleQuickFixManagerHostImplTest_0016 - * @tc.name: HandleSwitchQuickFix - * @tc.desc: 1. test HandleSwitchQuickFix - */ -HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0016, Function | SmallTest | Level0) -{ - QuickFixManagerHostImpl impl; - MessageParcel data; - MessageParcel reply; - auto ret = impl.HandleSwitchQuickFix(data, reply); - EXPECT_EQ(ret, ERR_APPEXECFWK_PARCEL_ERROR); -} - -/* - * @tc.number: BmsBundleQuickFixManagerHostImplTest_0017 - * @tc.name: HandleDeleteQuickFix - * @tc.desc: 1. test HandleDeleteQuickFix - */ -HWTEST_F(BmsBundleQuickFixMgrRdbTest, BmsBundleQuickFixManagerHostImplTest_0017, Function | SmallTest | Level0) -{ - QuickFixManagerHostImpl impl; - MessageParcel data; - MessageParcel reply; - auto ret = impl.HandleDeleteQuickFix(data, reply); - EXPECT_EQ(ret, ERR_APPEXECFWK_PARCEL_ERROR); -} - /** * @tc.number: UpdateQuickFixStatus_0100 * @tc.name: UpdateQuickFixStatus diff --git a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_switcher_test/bms_bundle_quick_fix_switcher_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_switcher_test/bms_bundle_quick_fix_switcher_test.cpp index 13e7b5ed226c02d97276deb135d0a8f863159d91..b1fe90f524b3c750a9fcea98603c8977ea043147 100755 --- a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_switcher_test/bms_bundle_quick_fix_switcher_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_switcher_test/bms_bundle_quick_fix_switcher_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -227,8 +227,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0100, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix("", true, callback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix("", true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -244,8 +245,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0200, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix("", false, callback); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix("", false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -259,8 +261,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0300, Func { auto quickFixHost = DelayedSingleton::GetInstance()->GetQuickFixManagerProxy(); EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, nullptr); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, nullptr, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -274,8 +277,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0400, Func { auto quickFixHost = DelayedSingleton::GetInstance()->GetQuickFixManagerProxy(); EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, nullptr); - EXPECT_EQ(result, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, nullptr, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -291,8 +295,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0500, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_NO_PATCH_IN_DATABASE); } @@ -320,8 +325,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0600, Func sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME_TEST, true, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME_TEST, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME_TEST, ERR_BUNDLEMANAGER_QUICK_FIX_NO_PATCH_IN_DATABASE); ret = UninstallBundle(BUNDLE_NAME); @@ -344,9 +350,10 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0700, Func AddInnerAppQuickFix(innerAppQuickFix); sptr callback = new (std::nothrow) MockQuickFixCallback(); - EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(result, ERR_OK); + EXPECT_NE(callback, nullptr) << "the callback is nullptr";\ + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATCH_STATUS); DeleteInnerAppQuickFix(BUNDLE_NAME); @@ -369,8 +376,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0800, Func sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_NOT_EXISTED_BUNDLE_INFO); DeleteInnerAppQuickFix(BUNDLE_NAME); @@ -403,8 +411,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_0900, Func sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); ret = UninstallBundle(BUNDLE_NAME); @@ -438,14 +447,15 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1000, Func sptr callback1 = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback1, nullptr) << "the callback1 is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback1); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback1, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback1, BUNDLE_NAME, ERR_OK); sptr callback2 = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback2, nullptr) << "the callback2 is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback2); - EXPECT_EQ(ret, ERR_OK); + quickFixHost->SwitchQuickFix(BUNDLE_NAME, true, callback2, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback2, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_NO_PATCH_IN_DATABASE); ret = UninstallBundle(BUNDLE_NAME); @@ -466,8 +476,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1100, Func sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_NOT_EXISTED_BUNDLE_INFO); } @@ -496,8 +507,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1200, Func sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_NO_PATCH_INFO_IN_BUNDLE_INFO); ret = UninstallBundle(BUNDLE_NAME); @@ -531,8 +543,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1300, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); ret = UninstallBundle(BUNDLE_NAME); @@ -555,8 +568,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1400, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode result = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback); - EXPECT_EQ(result, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATCH_STATUS); DeleteInnerAppQuickFix(BUNDLE_NAME); @@ -591,8 +605,9 @@ HWTEST_F(BmsBundleQuickFixSwitcherTest, BmsBundleQuickFixSwitcherTest_1500, Func EXPECT_NE(quickFixHost, nullptr) << "the quickFixHost is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ret = quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixHost->SwitchQuickFix(BUNDLE_NAME, false, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); CheckResult(callback, BUNDLE_NAME, ERR_OK); ret = UninstallBundle(BUNDLE_NAME); diff --git a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_test/bms_bundle_quick_fix_test.cpp b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_test/bms_bundle_quick_fix_test.cpp index a7d6ce3a57910a51d4c1c9a6393b6248c14dccf9..35ac0cd339f3e1ed8910d9409df5c90d17eee466 100644 --- a/services/bundlemgr/test/unittest/bms_bundle_quick_fix_test/bms_bundle_quick_fix_test.cpp +++ b/services/bundlemgr/test/unittest/bms_bundle_quick_fix_test/bms_bundle_quick_fix_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * 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 @@ -37,6 +37,7 @@ #include "quick_fix_data_mgr.h" #include "quick_fix_deleter.h" #include "quick_fix_deployer.h" +#include "quick_fix_manager_client.h" #include "quick_fix_manager_proxy.h" #include "quick_fix_switcher.h" #include "quick_fix_checker.h" @@ -87,6 +88,13 @@ const std::string VALID_FILE_PATH_4 = "../"; const std::string INVALID_FILE_NAME = "..hello.hqf"; const std::string VALID_FILE_NAME = "hello.hqf"; const int32_t ERR_CODE = 8388613; +const uint32_t DEPLOY_QUICK_FIX = 0; +const uint32_t SWITCH_QUICK_FIX = 1; +const uint32_t DELETE_QUICK_FIX = 2; +const uint32_t CREATE_FD = 3; +const std::string EMPTY_STRING = ""; +const std::string INVALID_PATH = "/data/service/el1/public/bms/bundle_manager_service/../../a.hsp"; +const std::string BUNDLE_PATH = "/data/test/resource/bms/quick_fix/quickFixTest.hap"; } // namespace class BmsBundleQuickFixTest : public testing::Test { @@ -1064,11 +1072,12 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0027, Function | SmallTest sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; std::vector path; - ErrCode ret = quickFixProxy->DeployQuickFix(path, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); callback = nullptr; - ret = quickFixProxy->DeployQuickFix(path, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixProxy->DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -1085,8 +1094,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0028, Function | SmallTest sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; std::vector path {HAP_FILE_PATH1}; - ErrCode ret = quickFixProxy->DeployQuickFix(path, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); } /** @@ -1103,8 +1113,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0029, Function | SmallTest sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; std::vector path {HQF_FILE_PATH1}; - ErrCode ret = quickFixProxy->DeployQuickFix(path, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_PATH); } /** @@ -1554,11 +1565,12 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0049, Function | SmallTest std::string fileName = "test.hqf"; int32_t fd = -1; std::string path = ""; - auto res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); const std::vector sourceFiles {path}; std::vector secureDirs; - res = quickFixManagerHostImpl.CopyHqfToSecurityDir(sourceFiles, secureDirs); + ErrCode res = quickFixManagerHostImpl.CopyHqfToSecurityDir(sourceFiles, secureDirs); EXPECT_EQ(res, ERR_OK); std::vector realFilePaths; auto ret = deployer->ProcessBundleFilePaths(secureDirs, realFilePaths); @@ -2522,15 +2534,16 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0097, Function | SmallTest QuickFixManagerHostImpl quickFixManagerHostImpl; std::vector path; sptr callback = nullptr; - auto res = quickFixManagerHostImpl.DeployQuickFix(path, callback); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixManagerHostImpl.DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); callback = new (std::nothrow) MockQuickFixCallback(); - res = quickFixManagerHostImpl.DeployQuickFix(path, callback); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); callback = nullptr; path.push_back("data/test"); - res = quickFixManagerHostImpl.DeployQuickFix(path, callback); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.DeployQuickFix(path, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -2546,33 +2559,34 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0098, Function | SmallTest std::string fileName = "test.hqf"; int32_t fd = -1; std::string path = ""; - auto res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); fd = 8; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_OK); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); path = "data/test"; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_OK); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); fileName = ""; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); fileName = "../test.hqf"; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); fileName = "/test.hqf"; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); fileName = "\\test.hqf"; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); fileName = "%test.hqf"; - res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -3511,8 +3525,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleSwitchQuickFix_0001, Function | SmallTe EXPECT_NE(quickFixProxy, nullptr) << "the quickFixProxy is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy->SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); ErrCode unInstallResult = UnInstallBundle(BUNDLE_NAME); EXPECT_EQ(unInstallResult, ERR_OK); @@ -3531,8 +3546,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleSwitchQuickFix_0002, Function | SmallTe EXPECT_NE(quickFixProxy, nullptr) << "the quickFixProxy is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy->SwitchQuickFix("", true, callback); - EXPECT_NE(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->SwitchQuickFix("", true, callback, funcResult); + EXPECT_NE(funcResult, ERR_OK); } /** @@ -3551,8 +3567,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleDeleteQuickFix_0001, Function | SmallTe EXPECT_NE(quickFixProxy, nullptr) << "the quickFixProxy is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy->DeleteQuickFix(BUNDLE_NAME, callback); - EXPECT_EQ(ret, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->DeleteQuickFix(BUNDLE_NAME, callback, funcResult); + EXPECT_EQ(funcResult, ERR_OK); ErrCode unInstallResult = UnInstallBundle(BUNDLE_NAME); EXPECT_EQ(unInstallResult, ERR_OK); @@ -3571,10 +3588,11 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleDeleteQuickFix_0002, Function | SmallTe EXPECT_NE(quickFixProxy, nullptr) << "the quickFixProxy is nullptr"; sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy->DeleteQuickFix("", callback); - EXPECT_NE(ret, ERR_OK); - ErrCode res = quickFixProxy->DeleteQuickFix("wrong", nullptr); - EXPECT_EQ(res, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->DeleteQuickFix("", callback, funcResult); + EXPECT_NE(funcResult, ERR_OK); + quickFixProxy->DeleteQuickFix("wrong", nullptr, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } @@ -3675,7 +3693,7 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleCopyFiles_0001, Function | SmallTest | const std::vector sourceFiles {FILE1_PATH, FILE2_PATH}; CreateFiles(sourceFiles); std::vector destFiles; - ErrCode ret = quickFixProxy->CopyFiles(sourceFiles, destFiles); + ErrCode ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); if (!ret) { EXPECT_EQ(ret, ERR_OK); } @@ -3694,7 +3712,7 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleCopyFiles_0002, Function | SmallTest | EXPECT_NE(quickFixProxy, nullptr) << "the quickFixProxy is nullptr"; const std::vector sourceFiles {"", ""}; std::vector destFiles; - ErrCode ret = quickFixProxy->CopyFiles(sourceFiles, destFiles); + ErrCode ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_NE(ret, ERR_OK); } @@ -3712,8 +3730,8 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleCopyFiles_0003, Function | SmallTest | const std::vector sourceFiles {FILE1_PATH, ""}; CreateFiles(sourceFiles); std::vector destFiles = {"hello.hqf"}; - ErrCode ret = quickFixProxy->CopyFiles(sourceFiles, destFiles); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_INTERNAL_ERROR); + ErrCode ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); DeleteFiles(sourceFiles); DeleteFiles(destFiles); } @@ -3730,8 +3748,9 @@ HWTEST_F(BmsBundleQuickFixTest, CreateFd_0100, Function | SmallTest | Level0) std::string fileName = ""; int32_t fd = 0; std::string path; - ErrCode ret = quickFixProxy->CreateFd(fileName, fd, path); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy->CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -4081,18 +4100,19 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerHostImpl_0100, Function | SmallTe sptr statusCallback; QuickFixManagerHostImpl quickFixMgrHostImpl; const std::vector bundleFilePaths; - auto ret = quickFixMgrHostImpl.DeployQuickFix(bundleFilePaths, statusCallback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); - ret = quickFixMgrHostImpl.SwitchQuickFix("", false, statusCallback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); - ret = quickFixMgrHostImpl.DeleteQuickFix("", statusCallback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixMgrHostImpl.DeployQuickFix(bundleFilePaths, statusCallback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixMgrHostImpl.SwitchQuickFix("", false, statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixMgrHostImpl.DeleteQuickFix("", statusCallback, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); std::string fileName = ""; int32_t fd = 0; std::string path; - auto res = quickFixMgrHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixMgrHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); } /** @@ -4685,8 +4705,9 @@ HWTEST_F(BmsBundleQuickFixTest, BmsBundleQuickFixTest_0430, Function | SmallTest std::string fileName = "test.hqf"; int32_t fd = -1; std::string path = ""; - auto res = quickFixManagerHostImpl.CreateFd(fileName, fd, path); - EXPECT_EQ(res, ERR_OK); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixManagerHostImpl.CreateFd(fileName, fd, path, funcResult); + EXPECT_EQ(funcResult, ERR_OK); const std::vector sourceFiles {path}; std::vector realFilePaths; auto ret = deployer->ProcessBundleFilePaths(sourceFiles, realFilePaths); @@ -5185,26 +5206,22 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerHost_0100, Function | SmallTest | { QuickFixManagerHostImpl quickFixMgrHostImpl; - uint32_t code = static_cast(QuickFixManagerInterfaceCode::DEPLOY_QUICK_FIX); MessageParcel data; MessageParcel reply; MessageOption option; - int ret = quickFixMgrHostImpl.OnRemoteRequest(code, data, reply, option); + int ret = quickFixMgrHostImpl.OnRemoteRequest(DEPLOY_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::SWITCH_QUICK_FIX); - ret = quickFixMgrHostImpl.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHostImpl.OnRemoteRequest(SWITCH_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::DELETE_QUICK_FIX); - ret = quickFixMgrHostImpl.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHostImpl.OnRemoteRequest(DELETE_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::CREATE_FD); - ret = quickFixMgrHostImpl.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHostImpl.OnRemoteRequest(CREATE_FD, data, reply, option); EXPECT_NE(ret, 0); - code = -1; + uint32_t code = -1; ret = quickFixMgrHostImpl.OnRemoteRequest(code, data, reply, option); EXPECT_NE(ret, 0); } @@ -5216,46 +5233,28 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerHost_0100, Function | SmallTest | */ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerHost_0200, Function | SmallTest | Level0) { - QuickFixManagerHost quickFixMgrHost; + QuickFixManagerHostImpl quickFixMgrHost; - uint32_t code = static_cast(QuickFixManagerInterfaceCode::DEPLOY_QUICK_FIX); MessageParcel data; MessageParcel reply; MessageOption option; - int ret = quickFixMgrHost.OnRemoteRequest(code, data, reply, option); + int ret = quickFixMgrHost.OnRemoteRequest(DEPLOY_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::SWITCH_QUICK_FIX); - ret = quickFixMgrHost.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHost.OnRemoteRequest(SWITCH_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::DELETE_QUICK_FIX); - ret = quickFixMgrHost.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHost.OnRemoteRequest(DELETE_QUICK_FIX, data, reply, option); EXPECT_NE(ret, 0); - code = static_cast(QuickFixManagerInterfaceCode::CREATE_FD); - ret = quickFixMgrHost.OnRemoteRequest(code, data, reply, option); + ret = quickFixMgrHost.OnRemoteRequest(CREATE_FD, data, reply, option); EXPECT_NE(ret, 0); - code = -1; + uint32_t code = -1; ret = quickFixMgrHost.OnRemoteRequest(code, data, reply, option); EXPECT_NE(ret, 0); } -/** - * @tc.number: QuickFixManagerHost_0300 - * @tc.name: test HandleCreateFd by QuickFixManagerHost - * @tc.desc: HandleCreateFd - */ -HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerHost_0300, Function | SmallTest | Level0) -{ - QuickFixManagerHost quickFixManagerHost; - MessageParcel data; - MessageParcel reply; - auto ret = quickFixManagerHost.HandleCreateFd(data, reply); - EXPECT_EQ(ret, ERR_OK); -} - /** * @tc.number: DeployQuickFixResult_0300 * @tc.name: Test ReadFromParcel @@ -5366,15 +5365,16 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerProxy_0100, Function | SmallTest EXPECT_NE(callback, nullptr) << "the callback is nullptr"; std::vector bundleFilePaths; - ErrCode ret = quickFixProxy.DeployQuickFix(bundleFilePaths, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy.DeployQuickFix(bundleFilePaths, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); bundleFilePaths.push_back(HAP_FILE_PATH1); - ret = quickFixProxy.DeployQuickFix(bundleFilePaths, nullptr); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixProxy.DeployQuickFix(bundleFilePaths, nullptr, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); - ret = quickFixProxy.DeployQuickFix(bundleFilePaths, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED); + quickFixProxy.DeployQuickFix(bundleFilePaths, callback, false, "", false, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); } /** @@ -5390,11 +5390,12 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerProxy_0200, Function | SmallTest sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy.SwitchQuickFix("", true, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy.SwitchQuickFix("", true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); - ret = quickFixProxy.SwitchQuickFix(BUNDLE_NAME, true, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED); + quickFixProxy.SwitchQuickFix(BUNDLE_NAME, true, callback, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); } /** @@ -5410,14 +5411,15 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerProxy_0300, Function | SmallTest sptr callback = new (std::nothrow) MockQuickFixCallback(); EXPECT_NE(callback, nullptr) << "the callback is nullptr"; - ErrCode ret = quickFixProxy.DeleteQuickFix("", callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + int32_t funcResult = ERR_APPEXECFWK_IDL_GET_RESULT_ERROR; + quickFixProxy.DeleteQuickFix("", callback, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); - ret = quickFixProxy.DeleteQuickFix(BUNDLE_NAME, nullptr); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + quickFixProxy.DeleteQuickFix(BUNDLE_NAME, nullptr, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); - ret = quickFixProxy.DeleteQuickFix(BUNDLE_NAME, callback); - EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_SEND_REQUEST_FAILED); + quickFixProxy.DeleteQuickFix(BUNDLE_NAME, callback, funcResult); + EXPECT_EQ(funcResult, ERR_APPEXECFWK_IDL_GET_RESULT_ERROR); } /** @@ -5432,13 +5434,13 @@ HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerProxy_0400, Function | SmallTest QuickFixManagerProxy quickFixProxy(object); std::vector sourceFiles; std::vector destFiles; - ErrCode ret = quickFixProxy.CopyFiles(sourceFiles, destFiles); + ErrCode ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); sourceFiles.push_back(FILE1_PATH); CreateFiles(sourceFiles); - ret = quickFixProxy.CopyFiles(sourceFiles, destFiles); - EXPECT_EQ(ret, ERR_CODE); + ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); + EXPECT_EQ(ret, ERR_OK); DeleteFiles(sourceFiles); } @@ -5697,4 +5699,208 @@ HWTEST_F(BmsBundleQuickFixTest, ToDeployStartStatus_0004, TestSize.Level1) EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PROFILE_PARSE_FAILED); } } + +/** + * @tc.number: QuickFixManagerClient_0001 + * Function: DeployQuickFix + * @tc.name: test DeployQuickFix + * @tc.desc: DeployQuickFix + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0001, TestSize.Level1) +{ + std::vector bundlePaths; + sptr statusCallback = nullptr; + bool isDebug = false; + std::string targetPath; + auto ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + bundlePaths.push_back(HAP_FILE_PATH1); + ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + sptr object; + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(systemAbilityManager, nullptr); + object = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + ASSERT_NE(object, nullptr); + statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(object); + ASSERT_NE(statusCallback, nullptr); + targetPath = ".HAP"; + ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + targetPath = "..HAP"; + ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + targetPath = "H/AP"; + ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + targetPath = "validPath"; + ret = QuickFixManagerClient::GetInstance().DeployQuickFix(bundlePaths, statusCallback, isDebug, targetPath); + EXPECT_NE(ret, ERR_OK); +} + +/** + * @tc.number: QuickFixManagerClient_0002 + * Function: SwitchQuickFix + * @tc.name: test SwitchQuickFix + * @tc.desc: SwitchQuickFix + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0002, TestSize.Level1) +{ + bool enable = true; + sptr statusCallback = nullptr; + auto ret = QuickFixManagerClient::GetInstance().SwitchQuickFix(EMPTY_STRING, enable, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + ret = QuickFixManagerClient::GetInstance().SwitchQuickFix(BUNDLE_NAME, enable, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(nullptr); + ret = QuickFixManagerClient::GetInstance().SwitchQuickFix(BUNDLE_NAME, enable, statusCallback); + EXPECT_NE(ret, ERR_OK); +} + +/** + * @tc.number: QuickFixManagerClient_0003 + * Function: DeleteQuickFix + * @tc.name: test DeleteQuickFix + * @tc.desc: DeleteQuickFix + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0003, TestSize.Level1) +{ + sptr statusCallback = nullptr; + auto ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(EMPTY_STRING, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(BUNDLE_NAME, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(nullptr); + ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(BUNDLE_NAME, statusCallback); + EXPECT_NE(ret, ERR_OK); +} + +/** + * @tc.number: QuickFixManagerClient_0004 + * Function: DeleteQuickFix + * @tc.name: test DeleteQuickFix + * @tc.desc: DeleteQuickFix + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0004, TestSize.Level1) +{ + sptr statusCallback = nullptr; + auto ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(EMPTY_STRING, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(BUNDLE_NAME, statusCallback); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + statusCallback = new (std::nothrow) QuickFixStatusCallbackProxy(nullptr); + ret = QuickFixManagerClient::GetInstance().DeleteQuickFix(BUNDLE_NAME, statusCallback); + EXPECT_NE(ret, ERR_OK); +} + +/** + * @tc.number: QuickFixManagerClient_0005 + * Function: DeleteQuickFix + * @tc.name: test DeleteQuickFix + * @tc.desc: DeleteQuickFix + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0005, TestSize.Level1) +{ + int32_t fd; + std::string path; + auto ret = QuickFixManagerClient::GetInstance().CreateFd(EMPTY_STRING, fd, path); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + std::string fileName = "fileName"; + path = EMPTY_STRING; + fd = 1; + ret = QuickFixManagerClient::GetInstance().CreateFd(fileName, fd, path); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_INVALID_TARGET_DIR); + + fd = -1; + ret = QuickFixManagerClient::GetInstance().CreateFd(fileName, fd, path); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED); + + path = HAP_FILE_PATH1; + fd = 1; + ret = QuickFixManagerClient::GetInstance().CreateFd(fileName, fd, path); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED); +} + +/** + * @tc.number: QuickFixManagerClient_0006 + * Function: CopyFiles + * @tc.name: test CopyFiles + * @tc.desc: CopyFiles + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0006, TestSize.Level1) +{ + std::vector sourceFiles; + std::vector destFiles; + auto ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + sourceFiles.emplace_back(INVALID_PATH); + ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_PARAM_ERROR); + + sourceFiles.clear(); + sourceFiles.emplace_back(HAP_PATH_TEST_RAW_FILE); + ret = QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); + EXPECT_EQ(ret, ERR_BUNDLEMANAGER_QUICK_FIX_CREATE_FD_FAILED); +} + +/** + * @tc.number: QuickFixManagerClient_0007 + * Function: ResetQuickFixManagerProxy + * @tc.name: test ResetQuickFixManagerProxy + * @tc.desc: ResetQuickFixManagerProxy + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0007, TestSize.Level1) +{ + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(systemAbilityManager, nullptr); + wptr remote = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + ASSERT_NE(remote, nullptr); + QuickFixManagerClient::GetInstance().quickFixManager_ = nullptr; + QuickFixManagerClient::GetInstance().ResetQuickFixManagerProxy(remote); + auto quickFixManager = QuickFixManagerClient::GetInstance().GetQuickFixManagerProxy(); + EXPECT_NE(quickFixManager, nullptr); + QuickFixManagerClient::GetInstance().ResetQuickFixManagerProxy(remote); + EXPECT_EQ(QuickFixManagerClient::GetInstance().quickFixManager_, nullptr); + EXPECT_EQ(QuickFixManagerClient::GetInstance().deathRecipient_, nullptr); +} + +/** + * @tc.number: QuickFixManagerClient_0008 + * Function: OnRemoteDied + * @tc.name: test OnRemoteDied + * @tc.desc: OnRemoteDied + */ +HWTEST_F(BmsBundleQuickFixTest, QuickFixManagerClient_0008, TestSize.Level1) +{ + wptr remote = nullptr; + auto quickFixManager = QuickFixManagerClient::GetInstance().GetQuickFixManagerProxy(); + EXPECT_NE(quickFixManager, nullptr); + QuickFixManagerClient::QuickFixManagerDeathRecipient deathRecipient; + deathRecipient.OnRemoteDied(remote); + EXPECT_NE(QuickFixManagerClient::GetInstance().quickFixManager_, nullptr); + EXPECT_NE(QuickFixManagerClient::GetInstance().deathRecipient_, nullptr); + + QuickFixManagerClient::GetInstance().GetQuickFixManagerProxy(); + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + remote = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + deathRecipient.OnRemoteDied(remote); + EXPECT_EQ(QuickFixManagerClient::GetInstance().quickFixManager_, nullptr); + EXPECT_EQ(QuickFixManagerClient::GetInstance().deathRecipient_, nullptr); +} } // OHOS diff --git a/test/fuzztest/fuzztest_others/copyfiles_fuzzer/copyfiles_fuzzer.cpp b/test/fuzztest/fuzztest_others/copyfiles_fuzzer/copyfiles_fuzzer.cpp index 621d3331f77a9dc0175174e075b2f9177509cbf8..6913b7d75ec9dd0a52d469a5b956f861277df053 100755 --- a/test/fuzztest/fuzztest_others/copyfiles_fuzzer/copyfiles_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/copyfiles_fuzzer/copyfiles_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -16,23 +16,23 @@ #include #include -#include "quick_fix_manager_proxy.h" +#include +#include #include "copyfiles_fuzzer.h" +#include "quick_fix_manager_client.h" using namespace OHOS::AppExecFwk; namespace OHOS { bool DoSomethingInterestingWithMyAPI(const uint8_t* data, size_t size) { - sptr object; - QuickFixManagerProxy quickFix(object); std::vector sourceFiles; std::string sourceFile (reinterpret_cast(data), size); sourceFiles.push_back(sourceFile); std::vector destFiles; std::string destFile (reinterpret_cast(data), size); destFiles.push_back(destFile); - quickFix.CopyFiles(sourceFiles, destFiles); + QuickFixManagerClient::GetInstance().CopyFiles(sourceFiles, destFiles); return true; } } diff --git a/test/fuzztest/fuzztest_others/deletequickfix_fuzzer/deletequickfix_fuzzer.cpp b/test/fuzztest/fuzztest_others/deletequickfix_fuzzer/deletequickfix_fuzzer.cpp index 893381bb251c7934bf08961e72ef8591292d2141..106788ba43943e27483aa5d1685f53894e717c06 100755 --- a/test/fuzztest/fuzztest_others/deletequickfix_fuzzer/deletequickfix_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/deletequickfix_fuzzer/deletequickfix_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -28,7 +28,8 @@ namespace OHOS { QuickFixManagerProxy quickFix(object); std::string bundleName (reinterpret_cast(data), size); sptr statusCallback; - quickFix.DeleteQuickFix(bundleName, statusCallback); + int32_t funcResult = 0; + quickFix.DeleteQuickFix(bundleName, statusCallback, funcResult); return true; } } diff --git a/test/fuzztest/fuzztest_others/deployquickfix_fuzzer/deployquickfix_fuzzer.cpp b/test/fuzztest/fuzztest_others/deployquickfix_fuzzer/deployquickfix_fuzzer.cpp index f2eab93c955c518ace1e4ba128f6adf7949096f2..082a36fc89f56ea512d61a35527abbdf3ae9f0c8 100755 --- a/test/fuzztest/fuzztest_others/deployquickfix_fuzzer/deployquickfix_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/deployquickfix_fuzzer/deployquickfix_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -30,7 +30,8 @@ namespace OHOS { std::string bundleFilePath (reinterpret_cast(data), size); bundleFilePaths.push_back(bundleFilePath); sptr statusCallback; - quickFix.DeployQuickFix(bundleFilePaths, statusCallback); + int32_t funcResult = 0; + quickFix.DeployQuickFix(bundleFilePaths, statusCallback, false, "", false, funcResult); return true; } } diff --git a/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/BUILD.gn b/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/BUILD.gn index 4bb8b1bb4754bfe7bd51542539011d9cedfcf2dc..69cd5a98be60f0e6050c342f36b4912651c50b97 100644 --- a/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/BUILD.gn +++ b/test/fuzztest/fuzztest_others/quickfixmanagerhost_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 @@ -36,6 +36,7 @@ ohos_fuzztest("QuickFixManagerHostFuzzTest") { "${base_path}:appexecfwk_base", "${common_path}:libappexecfwk_common", "${core_path}:appexecfwk_core", + "${core_path}:quick_fix_manager_stub", ] external_deps = [ "ability_base:want", diff --git a/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/quickfixmanagerhost_fuzzer.cpp b/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/quickfixmanagerhost_fuzzer.cpp index 24d7ab36f114678213769275d75dd87d6c5111a3..1660e26a4c3f567129f0c902dbaa8ccea1461454 100644 --- a/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/quickfixmanagerhost_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/quickfixmanagerhost_fuzzer/quickfixmanagerhost_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 #define private public -#include "quick_fix_manager_host.h" +#include "quick_fix_manager_stub.h" #include "securec.h" using namespace OHOS::AppExecFwk; @@ -26,17 +26,50 @@ namespace OHOS { constexpr size_t U32_AT_SIZE = 4; constexpr uint32_t CODE_MAX = 3; +class TestQuickFixManagerStub : public QuickFixManagerStub { +public: + int32_t CallbackEnter([[maybe_unused]] uint32_t code) + { + return 0; + } + int32_t CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) + { + return 0; + } + ErrCode DeployQuickFix(const std::vector &bundleFilePaths, + const sptr &statusCallback, bool isDebug, + const std::string &targetPath, bool isReplace, int32_t &funcResult) + { + return ERR_OK; + } + ErrCode SwitchQuickFix(const std::string &bundleName, bool enable, + const sptr &statusCallback, int32_t &funcResult) + { + return ERR_OK; + } + ErrCode DeleteQuickFix(const std::string &bundleName, + const sptr &statusCallback, int32_t &funcResult) + { + return ERR_OK; + } + ErrCode CreateFd( + const std::string &fileName, int32_t &fd, std::string &path, int32_t &funcResult) + { + return ERR_OK; + } +}; + bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) { for (uint32_t code = 0; code <= CODE_MAX; code++) { MessageParcel datas; - std::u16string descriptor = QuickFixManagerHost::GetDescriptor(); + std::u16string descriptor = QuickFixManagerStub::GetDescriptor(); datas.WriteInterfaceToken(descriptor); datas.WriteBuffer(data, size); datas.RewindRead(0); MessageParcel reply; MessageOption option; - QuickFixManagerHost quickFixManagerHost; + TestQuickFixManagerStub quickFixManagerHost; quickFixManagerHost.OnRemoteRequest(code, datas, reply, option); } return true; diff --git a/test/fuzztest/fuzztest_others/quickfixmanagerhostipml_fuzzer/quickfixmanagerhostipml_fuzzer.cpp b/test/fuzztest/fuzztest_others/quickfixmanagerhostipml_fuzzer/quickfixmanagerhostipml_fuzzer.cpp index d2db906a8c27d622208d0cebc0154ec352e46a46..30862b676ecc257459e795c26377e3d66fbbf1e9 100644 --- a/test/fuzztest/fuzztest_others/quickfixmanagerhostipml_fuzzer/quickfixmanagerhostipml_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/quickfixmanagerhostipml_fuzzer/quickfixmanagerhostipml_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 @@ -41,14 +41,15 @@ bool DoSomethingInterestingWithMyAPI(const char* data, size_t size) std::vector bundleFilePaths; sptr statusCallback = nullptr; std::string targetPath(data, size); - quickFixManagerHostImpl->DeployQuickFix(bundleFilePaths, statusCallback, false, targetPath); + int32_t funcResult = 0; + quickFixManagerHostImpl->DeployQuickFix(bundleFilePaths, statusCallback, false, targetPath, false, funcResult); std::string bundleName(data, size); - quickFixManagerHostImpl->SwitchQuickFix(bundleName, false, statusCallback); - quickFixManagerHostImpl->DeleteQuickFix(bundleName, statusCallback); + quickFixManagerHostImpl->SwitchQuickFix(bundleName, false, statusCallback, funcResult); + quickFixManagerHostImpl->DeleteQuickFix(bundleName, statusCallback, funcResult); std::string fileName(data, size); int32_t fd = static_cast(GetU32Data(data)); std::string path(data, size); - quickFixManagerHostImpl->CreateFd(fileName, fd, path); + quickFixManagerHostImpl->CreateFd(fileName, fd, path, funcResult); quickFixManagerHostImpl->GetQuickFixMgr(); quickFixManagerHostImpl->IsFileNameValid(fileName); std::vector securityFilePaths; diff --git a/test/fuzztest/fuzztest_others/switchquickfix_fuzzer/switchquickfix_fuzzer.cpp b/test/fuzztest/fuzztest_others/switchquickfix_fuzzer/switchquickfix_fuzzer.cpp index 5ebfb5e754a03aba53fcea52cf16bbece2b752dc..80b595c4f6237f117c8fca41deb3610b9f0d7470 100755 --- a/test/fuzztest/fuzztest_others/switchquickfix_fuzzer/switchquickfix_fuzzer.cpp +++ b/test/fuzztest/fuzztest_others/switchquickfix_fuzzer/switchquickfix_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -34,7 +34,8 @@ constexpr size_t THRESHOLD = 2; } std::string bundleName (reinterpret_cast(data), size); sptr statusCallback; - quickFix.SwitchQuickFix(bundleName, enable, statusCallback); + int32_t funcResult = 0; + quickFix.SwitchQuickFix(bundleName, enable, statusCallback, funcResult); return true; } }