diff --git a/bundle.json b/bundle.json index 38fc7eb4e9..4eaaac37a4 100644 --- a/bundle.json +++ b/bundle.json @@ -530,6 +530,15 @@ }, "name": "//foundation/ability/ability_runtime/interfaces/inner_api/extension_manager:extension_manager" }, + { + "header": { + "header_base": "//foundation/ability/ability_runtime/interfaces/inner_api/mission_manager/include", + "header_files": [ + "mission_manager_client.h" + ] + }, + "name": "//foundation/ability/ability_runtime/interfaces/inner_api/mission_manager:mission_manager" + }, { "header": { "header_base": "//foundation/ability/ability_runtime/interfaces/inner_api/session_handler/include", diff --git a/interfaces/inner_api/extension_manager/BUILD.gn b/interfaces/inner_api/extension_manager/BUILD.gn index 2a0d85fb82..e62106f7b5 100755 --- a/interfaces/inner_api/extension_manager/BUILD.gn +++ b/interfaces/inner_api/extension_manager/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 @@ -29,6 +29,7 @@ config("extension_manager_config") { visibility = [ ":*" ] include_dirs = [ + "${ability_runtime_innerkits_path}/ability_manager/include", "${ability_runtime_services_path}/abilitymgr/include/utils", "${ability_runtime_services_path}/abilitymgr/include", "${ability_runtime_services_path}/common/include", @@ -41,6 +42,7 @@ ohos_shared_library("extension_manager") { sources = [ "src/extension_manager_client.cpp", "src/extension_manager_proxy.cpp", + "${ability_runtime_services_path}/abilitymgr/src/extension_running_info.cpp", ] configs = [ ":extension_manager_config" ] diff --git a/interfaces/inner_api/extension_manager/include/extension_manager_client.h b/interfaces/inner_api/extension_manager/include/extension_manager_client.h index e00e8946c2..e4cb9eb10e 100755 --- a/interfaces/inner_api/extension_manager/include/extension_manager_client.h +++ b/interfaces/inner_api/extension_manager/include/extension_manager_client.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -19,7 +19,6 @@ #include #include "extension_manager_interface.h" - #include "iremote_object.h" namespace OHOS { @@ -63,19 +62,68 @@ public: ErrCode Release(); + /** + * Start extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to start. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be started. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode StartExtensionAbility( + const Want &want, + sptr callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED); + + /** + * Stop extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to stop. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be stopped. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode StopExtensionAbility( + const Want &want, + sptr callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED); + + /** + * @brief Get the extension running information. + * + * @param upperLimit The maximum limit of information wish to get. + * @param info Extension running information. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetExtensionRunningInfos(int upperLimit, std::vector &info); + + /** + * Transfer resultCode & want to abms. + * + * @param callerToken caller ability token. + * @param requestCode the resultCode of the ability to start. + * @param want Indicates the ability to start. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t TransferAbilityResultForExtension(const sptr &callerToken, int32_t resultCode, + const Want &want); private: class ExtensionMgrDeathRecipient : public IRemoteObject::DeathRecipient { public: ExtensionMgrDeathRecipient() = default; ~ExtensionMgrDeathRecipient() = default; - void OnRemoteDied(const wptr& remote) override; + void OnRemoteDied(const wptr &remote) override; private: DISALLOW_COPY_AND_MOVE(ExtensionMgrDeathRecipient); }; sptr GetExtensionManager(); void Connect(); - void ResetProxy(const wptr& remote); + void ResetProxy(const wptr &remote); ErrCode RemoveDeathRecipient(); std::mutex mutex_; diff --git a/interfaces/inner_api/extension_manager/include/extension_manager_interface.h b/interfaces/inner_api/extension_manager/include/extension_manager_interface.h index 329d4a1945..b8d2c9e58e 100755 --- a/interfaces/inner_api/extension_manager/include/extension_manager_interface.h +++ b/interfaces/inner_api/extension_manager/include/extension_manager_interface.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -17,6 +17,11 @@ #define OHOS_ABILITY_RUNTIME_EXTENSION_MANAGER_INTERFACE_H #include +#include + +#include "extension_ability_info.h" +#include "extension_running_info.h" + namespace OHOS { namespace AppExecFwk { @@ -59,6 +64,64 @@ public: * @return Returns ERR_OK on success, others on failure. */ virtual int DisconnectAbility(const sptr &connect) = 0; + + /** + * Start extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to start. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be started. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t StartExtensionAbility( + const Want &want, + const sptr &callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED) + { + return 0; + } + + /** + * Stop extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to stop. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be stopped. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int StopExtensionAbility( + const Want &want, + const sptr &callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED) + { + return 0; + } + + /** + * @brief Get the extension running information. + * + * @param upperLimit The maximum limit of information wish to get. + * @param info Extension running information. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetExtensionRunningInfos(int upperLimit, std::vector &info) = 0; + + /** + * Transfer resultCode & want to ability manager service. + * + * @param resultCode, the resultCode of the ability to terminate. + * @param resultWant, the Want of the ability to return. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t TransferAbilityResultForExtension(const sptr &callerToken, int32_t resultCode, + const Want &want) + { + return 0; + } }; } // namespace AAFwk } // namespace OHOS diff --git a/interfaces/inner_api/extension_manager/include/extension_manager_proxy.h b/interfaces/inner_api/extension_manager/include/extension_manager_proxy.h index 5c8bf08220..5bc5c41583 100755 --- a/interfaces/inner_api/extension_manager/include/extension_manager_proxy.h +++ b/interfaces/inner_api/extension_manager/include/extension_manager_proxy.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2023 Huawei Device Co., Ltd. + * Copyright (c) 2023-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -17,7 +17,6 @@ #define OHOS_ABILITY_RUNTIME_EXTENSION_MANAGER_PROXY_H #include "extension_manager_interface.h" - #include "iremote_proxy.h" namespace OHOS { @@ -54,11 +53,61 @@ public: */ virtual int DisconnectAbility(const sptr &connect) override; + /** + * Start extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to start. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be started. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t StartExtensionAbility( + const Want &want, + const sptr &callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED) override; + + /** + * Stop extension ability with want, send want to ability manager service. + * + * @param want, the want of the ability to stop. + * @param callerToken, caller ability token. + * @param userId, Designation User ID. + * @param extensionType If an ExtensionAbilityType is set, only extension of that type can be stopped. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int StopExtensionAbility( + const Want &want, + const sptr &callerToken, + int32_t userId = DEFAULT_INVALID_USER_ID, + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED) override; + + /** + * @brief Get the extension running information. + * + * @param upperLimit The maximum limit of information wish to get. + * @param info Extension running information. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetExtensionRunningInfos(int upperLimit, std::vector &info) override; + + /** + * Transfer resultCode & want to ability manager service. + * + * @param callerToken caller ability token. + * @param requestCode the resultCode of the ability to start. + * @param want Indicates the ability to start. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t TransferAbilityResultForExtension(const sptr &callerToken, int32_t resultCode, + const Want &want) override; private: bool WriteInterfaceToken(MessageParcel &data); ErrCode SendRequest(AbilityManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply, - MessageOption& option); - + MessageOption &option); + template + int GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos); private: static inline BrokerDelegator delegator_; }; diff --git a/interfaces/inner_api/extension_manager/src/extension_manager_client.cpp b/interfaces/inner_api/extension_manager/src/extension_manager_client.cpp index 59bab39131..01a1cf8261 100755 --- a/interfaces/inner_api/extension_manager/src/extension_manager_client.cpp +++ b/interfaces/inner_api/extension_manager/src/extension_manager_client.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 @@ -13,11 +13,11 @@ * limitations under the License. */ -#include "extension_manager_client.h" - #include "ability_manager_errors.h" #include "extension_ability_info.h" +#include "extension_manager_client.h" #include "extension_manager_proxy.h" +#include "extension_running_info.h" #include "hilog_tag_wrapper.h" #include "hitrace_meter.h" #include "iservice_registry.h" @@ -26,10 +26,22 @@ namespace OHOS { namespace AAFwk { -#define CHECK_POINTER_RETURN_NOT_CONNECTED(object) \ - if (!object) { \ +#define CHECK_POINTER_RETURN(object) \ +if (!object) { \ + TAG_LOGE(AAFwkTag::EXTMGR, "null proxy"); \ + return; \ +} + +#define CHECK_POINTER_RETURN_NOT_CONNECTED(object) \ + if (!object) { \ TAG_LOGE(AAFwkTag::EXTMGR, "null proxy"); \ - return ABILITY_SERVICE_NOT_CONNECTED; \ + return ABILITY_SERVICE_NOT_CONNECTED; \ + } + +#define CHECK_POINTER_RETURN_INVALID_VALUE(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::EXTMGR, "null proxy"); \ + return ERR_INVALID_VALUE; \ } ExtensionManagerClient& ExtensionManagerClient::GetInstance() @@ -71,7 +83,7 @@ void ExtensionManagerClient::Connect() TAG_LOGD(AAFwkTag::EXTMGR, "Connect AMS success"); } -void ExtensionManagerClient::ResetProxy(const wptr& remote) +void ExtensionManagerClient::ResetProxy(const wptr &remote) { std::lock_guard lock(mutex_); if (proxy_ == nullptr) { @@ -86,7 +98,7 @@ void ExtensionManagerClient::ResetProxy(const wptr& remote) } } -void ExtensionManagerClient::ExtensionMgrDeathRecipient::OnRemoteDied(const wptr& remote) +void ExtensionManagerClient::ExtensionMgrDeathRecipient::OnRemoteDied(const wptr &remote) { TAG_LOGI(AAFwkTag::EXTMGR, "called"); ExtensionManagerClient::GetInstance().ResetProxy(remote); @@ -198,5 +210,42 @@ ErrCode ExtensionManagerClient::RemoveDeathRecipient() TAG_LOGI(AAFwkTag::EXTMGR, "RemoveDeathRecipient success"); return ERR_OK; } + +ErrCode ExtensionManagerClient::StartExtensionAbility(const Want &want, sptr callerToken, + int32_t userId, AppExecFwk::ExtensionAbilityType extensionType) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetExtensionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + TAG_LOGI(AAFwkTag::EXTMGR, "name:%{public}s %{public}s, userId=%{public}d.", + want.GetElement().GetAbilityName().c_str(), want.GetElement().GetBundleName().c_str(), userId); + return abms->StartExtensionAbility(want, callerToken, userId, extensionType); +} + +ErrCode ExtensionManagerClient::StopExtensionAbility(const Want &want, sptr callerToken, + int32_t userId, AppExecFwk::ExtensionAbilityType extensionType) +{ + auto abms = GetExtensionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + TAG_LOGI(AAFwkTag::EXTMGR, "name:%{public}s %{public}s, userId=%{public}d.", + want.GetElement().GetAbilityName().c_str(), want.GetElement().GetBundleName().c_str(), userId); + return abms->StopExtensionAbility(want, callerToken, userId, extensionType); +} + +ErrCode ExtensionManagerClient::GetExtensionRunningInfos(int upperLimit, std::vector &info) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetExtensionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->GetExtensionRunningInfos(upperLimit, info); +} + +int32_t ExtensionManagerClient::TransferAbilityResultForExtension(const sptr &callerToken, + int32_t resultCode, const Want &want) +{ + auto abms = GetExtensionManager(); + CHECK_POINTER_RETURN_INVALID_VALUE(abms); + return abms->TransferAbilityResultForExtension(callerToken, resultCode, want); +} } // namespace AAFwk } // namespace OHOS diff --git a/interfaces/inner_api/extension_manager/src/extension_manager_proxy.cpp b/interfaces/inner_api/extension_manager/src/extension_manager_proxy.cpp index 1430c248fe..167d8e9f75 100755 --- a/interfaces/inner_api/extension_manager/src/extension_manager_proxy.cpp +++ b/interfaces/inner_api/extension_manager/src/extension_manager_proxy.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 @@ -13,15 +13,17 @@ * limitations under the License. */ -#include "extension_manager_proxy.h" - #include "ability_manager_errors.h" #include "ability_manager_ipc_interface_code.h" +#include "extension_manager_proxy.h" +#include "extension_running_info.h" #include "hilog_tag_wrapper.h" +#include "hitrace_meter.h" #include "message_parcel.h" #include "want.h" namespace OHOS::AAFwk { +constexpr int32_t CYCLE_LIMIT = 1000; bool ExtensionManagerProxy::WriteInterfaceToken(MessageParcel &data) { if (!data.WriteInterfaceToken(ExtensionManagerProxy::GetDescriptor())) { @@ -37,43 +39,43 @@ int ExtensionManagerProxy::ConnectAbilityCommon(const Want &want, sptr(extensionType))) { TAG_LOGE(AAFwkTag::EXTMGR, "extensionType write failed."); - return INNER_ERR; + return INVALID_PARAMETERS_ERR; } if (!data.WriteBool(isQueryExtensionOnly)) { TAG_LOGE(AAFwkTag::EXTMGR, "isQueryExtensionOnly write failed"); - return INNER_ERR; + return INVALID_PARAMETERS_ERR; } MessageParcel reply; @@ -90,16 +92,16 @@ int ExtensionManagerProxy::DisconnectAbility(const sptr &connect) { if (connect == nullptr) { TAG_LOGE(AAFwkTag::EXTMGR, "disconnect ability failed"); - return ERR_INVALID_VALUE; + return INVALID_PARAMETERS_ERR; } MessageParcel data; if (!WriteInterfaceToken(data)) { - return INNER_ERR; + return INVALID_PARAMETERS_ERR; } if (!data.WriteRemoteObject(connect)) { TAG_LOGE(AAFwkTag::EXTMGR, "connect write failed"); - return ERR_INVALID_VALUE; + return INVALID_PARAMETERS_ERR; } MessageParcel reply; @@ -113,14 +115,174 @@ int ExtensionManagerProxy::DisconnectAbility(const sptr &connect) } ErrCode ExtensionManagerProxy::SendRequest(AbilityManagerInterfaceCode code, MessageParcel &data, - MessageParcel &reply, MessageOption& option) + MessageParcel &reply, MessageOption &option) { auto remote = Remote(); if (remote == nullptr) { TAG_LOGE(AAFwkTag::EXTMGR, "null remote"); - return INNER_ERR; + return INVALID_REMOTE_PARAMETERS_ERR; } return remote->SendRequest(static_cast(code), data, reply, option); } + +int32_t ExtensionManagerProxy::StartExtensionAbility(const Want &want, const sptr &callerToken, + int32_t userId, AppExecFwk::ExtensionAbilityType extensionType) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&want)) { + TAG_LOGE(AAFwkTag::EXTMGR, "want write fail"); + return INVALID_PARAMETERS_ERR; + } + if (callerToken) { + if (!data.WriteBool(true) || !data.WriteRemoteObject(callerToken)) { + TAG_LOGE(AAFwkTag::EXTMGR, "flag and callerToken write fail"); + return INVALID_PARAMETERS_ERR; + } + } else { + if (!data.WriteBool(false)) { + TAG_LOGE(AAFwkTag::EXTMGR, "flag write fail"); + return INVALID_PARAMETERS_ERR; + } + } + if (!data.WriteInt32(userId)) { + TAG_LOGE(AAFwkTag::EXTMGR, "userId write failed"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(static_cast(extensionType))) { + TAG_LOGE(AAFwkTag::EXTMGR, "extensionType write failed"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::START_EXTENSION_ABILITY, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::EXTMGR, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int ExtensionManagerProxy::StopExtensionAbility(const Want &want, const sptr &callerToken, + int32_t userId, AppExecFwk::ExtensionAbilityType extensionType) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&want)) { + TAG_LOGE(AAFwkTag::EXTMGR, "want write fail"); + return INVALID_PARAMETERS_ERR; + } + if (callerToken) { + if (!data.WriteBool(true) || !data.WriteRemoteObject(callerToken)) { + TAG_LOGE(AAFwkTag::EXTMGR, "flag and callerToken write fail"); + return INVALID_PARAMETERS_ERR; + } + } else { + if (!data.WriteBool(false)) { + TAG_LOGE(AAFwkTag::EXTMGR, "flag write fail"); + return INVALID_PARAMETERS_ERR; + } + } + if (!data.WriteInt32(userId)) { + TAG_LOGE(AAFwkTag::EXTMGR, "userId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(static_cast(extensionType))) { + TAG_LOGE(AAFwkTag::EXTMGR, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::STOP_EXTENSION_ABILITY, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::EXTMGR, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +template +int ExtensionManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos) +{ + int32_t infoSize = reply.ReadInt32(); + if (infoSize > CYCLE_LIMIT) { + TAG_LOGE(AAFwkTag::EXTMGR, "infoSize large"); + return INVALID_PARAMETERS_ERR; + } + + for (int32_t i = 0; i < infoSize; i++) { + std::unique_ptr info(reply.ReadParcelable()); + if (!info) { + TAG_LOGE(AAFwkTag::EXTMGR, "readParcelableInfos fail"); + return INVALID_PARAMETERS_ERR; + } + parcelableInfos.emplace_back(*info); + } + return NO_ERROR; +} + +int ExtensionManagerProxy::GetExtensionRunningInfos(int upperLimit, std::vector &info) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteInt32(upperLimit)) { + TAG_LOGE(AAFwkTag::EXTMGR, "upperLimit write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::GET_EXTENSION_RUNNING_INFO, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::EXTMGR, "request error:%{public}d", error); + return error; + } + error = GetParcelableInfos(reply, info); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::EXTMGR, "getParcelableInfos fail, error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int32_t ExtensionManagerProxy::TransferAbilityResultForExtension(const sptr &callerToken, + int32_t resultCode, const Want &want) +{ + if (callerToken == nullptr) { + TAG_LOGE(AAFwkTag::EXTMGR, "null callerToken"); + return INVALID_PARAMETERS_ERR; + } + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(callerToken) || !data.WriteInt32(resultCode)) { + TAG_LOGE(AAFwkTag::EXTMGR, "callerToken or resultCode write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&want)) { + TAG_LOGE(AAFwkTag::EXTMGR, "want write fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::TRANSFER_ABILITY_RESULT, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::EXTMGR, "request error:%{public}d", error); + return error; + } + return NO_ERROR; +} } // namespace OHOS::AAFwk diff --git a/interfaces/inner_api/mission_manager/BUILD.gn b/interfaces/inner_api/mission_manager/BUILD.gn new file mode 100644 index 0000000000..e108d192ec --- /dev/null +++ b/interfaces/inner_api/mission_manager/BUILD.gn @@ -0,0 +1,73 @@ +# 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. + +import("//build/ohos.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +config("mission_manager_public_config") { + include_dirs = [ + "include", + "${ability_runtime_innerkits_path}/ability_manager/include", + ] + + if (target_cpu == "arm") { + cflags = [ "-DBINDER_IPC_32BIT" ] + } +} + +config("mission_manager_config") { + visibility = [ ":*" ] + + include_dirs = [ + "${ability_runtime_innerkits_path}/mission_manager/include", + "${ability_runtime_services_path}/abilitymgr/include/utils", + "${ability_runtime_services_path}/abilitymgr/include", + "${ability_runtime_services_path}/common/include", + ] +} + +ohos_shared_library("mission_manager") { + branch_protector_ret = "pac_ret" + + sources = [ + "src/mission_manager_client.cpp", + "src/mission_manager_proxy.cpp", + ] + + configs = [ ":mission_manager_config" ] + public_configs = [ ":mission_manager_public_config" ] + + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_connect_callback_stub", + "${ability_runtime_innerkits_path}/ability_manager:mission_info" + ] + + external_deps = [ + "ability_base:want", + "ability_base:session_info", + "bundle_framework:appexecfwk_base", + "c_utils:utils", + "c_utils:utilsbase", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_single", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + "window_manager:session_manager_lite", + "window_manager:libwsutils", + ] + + innerapi_tags = [ "platformsdk" ] + subsystem_name = "ability" + part_name = "ability_runtime" +} diff --git a/interfaces/inner_api/mission_manager/include/mission_manager_client.h b/interfaces/inner_api/mission_manager/include/mission_manager_client.h new file mode 100755 index 0000000000..1335640134 --- /dev/null +++ b/interfaces/inner_api/mission_manager/include/mission_manager_client.h @@ -0,0 +1,304 @@ +/* + * 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 OHOS_ABILITY_RUNTIME_MISSION_MANAGER_CLIENT_H +#define OHOS_ABILITY_RUNTIME_MISSION_MANAGER_CLIENT_H + +#include + +#include "iremote_object.h" +#include "mission_manager_interface.h" + +namespace OHOS { +namespace AAFwk { +/** + * @class MissionManagerClient + * MissionManagerClient is used to access ability manager services. + */ +class MissionManagerClient { +public: + MissionManagerClient() = default; + virtual ~MissionManagerClient() = default; + static MissionManagerClient& GetInstance(); + + ErrCode Release(); + + /** + * ContinueMission, continue ability from mission center. + * + * @param srcDeviceId, origin deviceId. + * @param dstDeviceId, target deviceId. + * @param missionId, indicates which ability to continue. + * @param callBack, notify result back. + * @param wantParams, extended params. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId, int32_t missionId, + sptr callback, AAFwk::WantParams &wantParams); + + /** + * ContinueMission, continue ability from mission center. + * + * @param srcDeviceId, origin deviceId. + * @param dstDeviceId, target deviceId. + * @param bundleName, indicates which bundleName to continue. + * @param callBack, notify result back. + * @param wantParams, extended params. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, const sptr &callback); + + /** + * @brief Lock specified mission. + * @param missionId The id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode LockMissionForCleanup(int32_t missionId); + + /** + * @brief Unlock specified mission. + * @param missionId The id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode UnlockMissionForCleanup(int32_t missionId); + + /** + * @brief Register mission listener to ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode RegisterMissionListener(sptr listener); + + /** + * @brief UnRegister mission listener from ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode UnRegisterMissionListener(sptr listener); + + /** + * @brief Register mission listener to ability manager service. + * @param deviceId The remote device Id. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode RegisterMissionListener(const std::string &deviceId, sptr listener); + + /** + * @brief UnRegister mission listener from ability manager service. + * @param deviceId The remote device Id. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode UnRegisterMissionListener(const std::string &deviceId, sptr listener); + + /** + * @brief Get mission infos from ability mgr. + * @param deviceId local or remote deviceId. + * @param numMax max number of missions. + * @param missionInfos mission info result. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetMissionInfos(const std::string &deviceId, int32_t numMax, std::vector &missionInfos); + + /** + * @brief Get mission info by id. + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param missionInfo mission info of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetMissionInfo(const std::string &deviceId, int32_t missionId, MissionInfo &missionInfo); + + /** + * @brief Get the Mission Snapshot Info object + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param snapshot snapshot of target mission. + * @param isLowResolution get low resolution snapshot. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetMissionSnapshot(const std::string &deviceId, int32_t missionId, + MissionSnapshot &snapshot, bool isLowResolution = false); + + /** + * @brief Clean mission by id. + * @param missionId Id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode CleanMission(int32_t missionId); + + /** + * @brief Clean all missions in system. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode CleanAllMissions(); + + /** + * @brief Move a mission to front. + * @param missionId Id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MoveMissionToFront(int32_t missionId); + + /** + * @brief Move a mission to front. + * @param missionId Id of target mission. + * @param startOptions Special startOptions for target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MoveMissionToFront(int32_t missionId, const StartOptions &startOptions); + + /** + * Move missions to front + * @param missionIds Ids of target missions + * @param topMissionId Indicate which mission will be moved to top, if set to -1, missions' order won't change + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MoveMissionsToForeground(const std::vector &missionIds, int32_t topMissionId); + + /** + * Move missions to background + * @param missionIds Ids of target missions + * @param result The result of move missions to background, and the array is sorted by zOrder + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MoveMissionsToBackground(const std::vector &missionIds, std::vector &result); + + /** + * @brief Get mission id by ability token. + * + * @param token ability token. + * @param missionId output mission id. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode GetMissionIdByToken(sptr token, int32_t &missionId); + + /** + * Start synchronizing remote device mission + * @param devId, deviceId. + * @param fixConflict, resolve synchronizing conflicts flag. + * @param tag, call tag. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag); + + /** + * Stop synchronizing remote device mission + * @param devId, deviceId. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode StopSyncRemoteMissions(const std::string &devId); + + /** + * Set mission continue state of this ability. + * + * @param token Indicate token of ability. + * @param state the mission continuation state of this ability. + * @return Returns ERR_OK if success. + */ + ErrCode SetMissionContinueState(sptr token, const AAFwk::ContinueState &state, + sptr sessionToken); + +#ifdef SUPPORT_SCREEN + /** + * Set mission label of this ability. + * + * @param abilityToken Indicate token of ability. + * @param label Indicate the label showed of the ability in recent missions. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode SetMissionLabel(sptr abilityToken, const std::string &label); + + /** + * Set mission icon of this ability. + * + * @param abilityToken Indicate token of ability. + * @param icon Indicate the icon showed of the ability in recent missions. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode SetMissionIcon(sptr abilityToken, + std::shared_ptr icon); + + /** + * Called to update mission snapshot. + * @param token The target ability. + * @param pixelMap The snapshot. + */ + void UpdateMissionSnapShot(sptr token, + std::shared_ptr pixelMap); +#endif + + /** + * Called to verify that the MissionId is valid. + * @param missionIds Query mission list. + * @param results Output parameters, return results up to 20 query results. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t IsValidMissionIds(const std::vector &missionIds, std::vector &results); + + /** + * Open atomic service window prior to finishing free install. + * + * @param bundleName, the bundle name of the atomic service. + * @param moduleName, the module name of the atomic service. + * @param abilityName, the ability name of the atomic service. + * @param startTime, the starting time of the free install task. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t PreStartMission(const std::string &bundleName, const std::string &moduleName, + const std::string &abilityName, const std::string &startTime); + + /** + * Terminate process by bundleName. + * + * @param missionId, The mission id of the UIAbility need to be terminated. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode TerminateMission(int32_t missionId); +private: + class MissionMgrDeathRecipient : public IRemoteObject::DeathRecipient { + public: + MissionMgrDeathRecipient() = default; + ~MissionMgrDeathRecipient() = default; + void OnRemoteDied(const wptr &remote) override; + private: + DISALLOW_COPY_AND_MOVE(MissionMgrDeathRecipient); + }; + + sptr GetMissionManager(); + void Connect(); + void ResetProxy(const wptr &remote); + ErrCode RemoveDeathRecipient(); + + std::mutex mutex_; + sptr proxy_; + sptr deathRecipient_; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_CLIENT_H diff --git a/interfaces/inner_api/mission_manager/include/mission_manager_interface.h b/interfaces/inner_api/mission_manager/include/mission_manager_interface.h new file mode 100755 index 0000000000..330bdb2d65 --- /dev/null +++ b/interfaces/inner_api/mission_manager/include/mission_manager_interface.h @@ -0,0 +1,259 @@ +/* + * 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 OHOS_ABILITY_RUNTIME_MISSION_MANAGER_INTERFACE_H +#define OHOS_ABILITY_RUNTIME_MISSION_MANAGER_INTERFACE_H + +#include +#include + +#include "dms_continueInfo.h" +#include "mission_listener_interface.h" +#include "mission_info.h" +#include "mission_snapshot.h" +#include "remote_mission_listener_interface.h" +#include "session_manager_lite.h" +#include "start_options.h" +#include "want.h" +#include "want_receiver_interface.h" +#include "want_sender_info.h" +#include "want_sender_interface.h" + +namespace OHOS { +namespace AppExecFwk { +enum class ExtensionAbilityType; +} +namespace AAFwk { +namespace { +constexpr int DEFAULT_INVALID_USER_ID = -1; +constexpr int CYCLE_LIMIT = 1000; +} +class Want; +/** + * @class IMissionManager + * IMissionManager interface is used to access ability manager services. + */ +class IMissionManager : public OHOS::IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.aafwk.MissionManager") + + virtual int ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId, int32_t missionId, + const sptr &callBack, AAFwk::WantParams &wantParams) = 0; + + virtual int ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, const sptr &callback) + { + return 0; + } + + virtual int LockMissionForCleanup(int32_t missionId) = 0; + + virtual int UnlockMissionForCleanup(int32_t missionId) = 0; + + /** + * @brief Register mission listener to ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int RegisterMissionListener(const sptr &listener) = 0; + + /** + * @brief UnRegister mission listener from ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int UnRegisterMissionListener(const sptr &listener) = 0; + + /** + * @brief Register mission listener to ability manager service. + * @param deviceId The remote device Id. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int RegisterMissionListener(const std::string &deviceId, const sptr &listener) = 0; + + virtual int UnRegisterMissionListener(const std::string &deviceId, + const sptr &listener) = 0; + + /** + * @brief Get mission infos from ability mgr. + * @param deviceId local or remote deviceId. + * @param numMax max number of missions. + * @param missionInfos mission info result. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionInfos( + const std::string &deviceId, int32_t numMax, std::vector &missionInfos) = 0; + + /** + * @brief Get mission info by id. + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param missionInfo mission info of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionInfo(const std::string &deviceId, int32_t missionId, MissionInfo &missionInfo) = 0; + + /** + * @brief Get the Mission Snapshot Info object + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param snapshot snapshot of target mission. + * @param isLowResolution get low resolution snapshot. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionSnapshot(const std::string &deviceId, int32_t missionId, + MissionSnapshot &snapshot, bool isLowResolution) = 0; + + /** + * @brief Clean mission by id. + * @param missionId Id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CleanMission(int32_t missionId) = 0; + + /** + * @brief Clean all missions in system. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CleanAllMissions() = 0; + + /** + * @brief Move a mission to front. + * @param missionId Id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionToFront(int32_t missionId) = 0; + + /** + * @brief Move a mission to front. + * @param missionId Id of target mission. + * @param startOptions Special startOptions for target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionToFront(int32_t missionId, const StartOptions &startOptions) = 0; + + /** + * Move missions to front + * @param missionIds Ids of target missions + * @param topMissionId Indicate which mission will be moved to top, if set to -1, missions' order won't change + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionsToForeground(const std::vector &missionIds, int32_t topMissionId) + { + return 0; + } + + /** + * Move missions to background + * @param missionIds Ids of target missions + * @param result The result of move missions to background, and the array is sorted by zOrder + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionsToBackground(const std::vector &missionIds, std::vector &result) + { + return 0; + } + + /** + * Get mission id by ability token. + * + * @param token The token of ability. + * @return Returns -1 if do not find mission, otherwise return mission id. + */ + virtual int32_t GetMissionIdByToken(const sptr &token) = 0; + + /** + * Start synchronizing remote device mission + * @param devId, deviceId. + * @param fixConflict, resolve synchronizing conflicts flag. + * @param tag, call tag. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag) = 0; + + /** + * Stop synchronizing remote device mission + * @param devId, deviceId. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int StopSyncRemoteMissions(const std::string &devId) = 0; + + virtual int SetMissionContinueState(const sptr &token, const AAFwk::ContinueState &state) + { + return 0; + }; + +#ifdef SUPPORT_SCREEN + virtual int SetMissionLabel(const sptr &abilityToken, const std::string &label) = 0; + + virtual int SetMissionIcon(const sptr &token, + const std::shared_ptr &icon) = 0; + + /** + * Called to update mission snapshot. + * @param token The target ability. + * @param pixelMap The snapshot. + */ + virtual void UpdateMissionSnapShot(const sptr &token, + const std::shared_ptr &pixelMap) {}; +#endif + + /** + * Called to verify that the MissionId is valid. + * @param missionIds Query mission list. + * @param results Output parameters, return results up to 20 query results. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t IsValidMissionIds( + const std::vector &missionIds, std::vector &results) = 0; + + /** + * Open atomic service window prior to finishing free install. + * + * @param bundleName, the bundle name of the atomic service. + * @param moduleName, the module name of the atomic service. + * @param abilityName, the ability name of the atomic service. + * @param startTime, the starting time of the free install task. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t PreStartMission(const std::string &bundleName, const std::string &moduleName, + const std::string &abilityName, const std::string &startTime) + { + return 0; + } + + /** + * Terminate the mission. + * + * @param missionId, The mission id of the UIAbility need to be terminated. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t TerminateMission(int32_t missionId) + { + return 0; + } +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_INTERFACE_H diff --git a/interfaces/inner_api/mission_manager/include/mission_manager_proxy.h b/interfaces/inner_api/mission_manager/include/mission_manager_proxy.h new file mode 100755 index 0000000000..874b23436b --- /dev/null +++ b/interfaces/inner_api/mission_manager/include/mission_manager_proxy.h @@ -0,0 +1,215 @@ +/* + * 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 OHOS_ABILITY_RUNTIME_MISSION_MANAGER_PROXY_H +#define OHOS_ABILITY_RUNTIME_MISSION_MANAGER_PROXY_H + +#include "iremote_proxy.h" +#include "mission_manager_interface.h" + +namespace OHOS { +class MessageParcel; +namespace AAFwk { +enum class AbilityManagerInterfaceCode; +/** + * @class MissionManagerProxy + * MissionManagerProxy. + */ +class MissionManagerProxy : public IRemoteProxy { +public: + explicit MissionManagerProxy(const sptr &impl) : IRemoteProxy(impl) {} + virtual ~MissionManagerProxy() = default; + + virtual int ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId, + int32_t missionId, const sptr &callBack, AAFwk::WantParams &wantParams) override; + + virtual int ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, + const sptr &callback) override; + + virtual int LockMissionForCleanup(int32_t missionId) override; + + virtual int UnlockMissionForCleanup(int32_t missionId) override; + + /** + * @brief Register mission listener to ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int RegisterMissionListener(const sptr &listener) override; + + /** + * @brief UnRegister mission listener from ability mgr. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int UnRegisterMissionListener(const sptr &listener) override; + + /** + * @brief Register mission listener to ability manager service. + * @param deviceId The remote device Id. + * @param listener The handler of listener. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int RegisterMissionListener(const std::string &deviceId, + const sptr &listener) override; + + virtual int UnRegisterMissionListener(const std::string &deviceId, + const sptr &listener) override; + + /** + * @brief Get mission infos from ability mgr. + * @param deviceId local or remote deviceId. + * @param numMax max number of missions. + * @param missionInfos mission info result. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionInfos(const std::string& deviceId, int32_t numMax, + std::vector &missionInfos) override; + + /** + * @brief Get mission info by id. + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param missionInfo mission info of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionInfo(const std::string& deviceId, int32_t missionId, + MissionInfo &missionInfos) override; + + /** + * @brief Get the Mission Snapshot Info object + * @param deviceId local or remote deviceId. + * @param missionId Id of target mission. + * @param snapshot snapshot of target mission. + * @param isLowResolution get low resolution snapshot. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, + MissionSnapshot& snapshot, bool isLowResolution) override; + + /** + * @brief Clean mission by id. + * @param missionId Id of target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CleanMission(int32_t missionId) override; + + /** + * @brief Clean all missions in system. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CleanAllMissions() override; + + virtual int MoveMissionToFront(int32_t missionId) override; + + /** + * @brief Move a mission to front. + * @param missionId Id of target mission. + * @param startOptions Special startOptions for target mission. + * + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionToFront(int32_t missionId, const StartOptions &startOptions) override; + + /** + * Move missions to front + * @param missionIds Ids of target missions + * @param topMissionId Indicate which mission will be moved to top, if set to -1, missions' order won't change + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionsToForeground(const std::vector& missionIds, int32_t topMissionId) override; + + /** + * Move missions to background + * @param missionIds Ids of target missions + * @param result The result of move missions to background, and the array is sorted by zOrder + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MoveMissionsToBackground(const std::vector& missionIds, + std::vector& result) override; + + /** + * Get mission id by ability token. + * + * @param token The token of ability. + * @return Returns -1 if do not find mission, otherwise return mission id. + */ + virtual int32_t GetMissionIdByToken(const sptr &token) override; + + virtual int StartSyncRemoteMissions(const std::string& devId, bool fixConflict, int64_t tag) override; + + virtual int StopSyncRemoteMissions(const std::string& devId) override; + + virtual int SetMissionContinueState(const sptr &token, const AAFwk::ContinueState &state) override; + +#ifdef SUPPORT_SCREEN + virtual int SetMissionLabel(const sptr &abilityToken, const std::string &label) override; + + virtual int SetMissionIcon(const sptr &token, + const std::shared_ptr &icon) override; + + virtual void UpdateMissionSnapShot(const sptr &token, + const std::shared_ptr &pixelMap) override; +#endif + + /** + * Called to verify that the MissionId is valid. + * @param missionIds Query mission list. + * @param results Output parameters, return results up to 20 query results. + * @return Returns ERR_OK on success, others on failure. + */ + int32_t IsValidMissionIds( + const std::vector &missionIds, std::vector &results) override; + + /** + * Open atomic service window prior to finishing free install. + * + * @param bundleName, the bundle name of the atomic service. + * @param moduleName, the module name of the atomic service. + * @param abilityName, the ability name of the atomic service. + * @param startTime, the starting time of the free install task. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t PreStartMission(const std::string& bundleName, const std::string& moduleName, + const std::string& abilityName, const std::string& startTime) override; + + /** + * Terminate the mission. + * + * @param missionId, The mission id of the UIAbility need to be terminated. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int32_t TerminateMission(int32_t missionId) override; +private: + bool WriteInterfaceToken(MessageParcel &data); + ErrCode SendRequest(AbilityManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply, + MessageOption& option); + + template + int GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos); + +private: + static inline BrokerDelegator delegator_; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_PROXY_H diff --git a/interfaces/inner_api/mission_manager/src/mission_manager_client.cpp b/interfaces/inner_api/mission_manager/src/mission_manager_client.cpp new file mode 100755 index 0000000000..7ecadc17eb --- /dev/null +++ b/interfaces/inner_api/mission_manager/src/mission_manager_client.cpp @@ -0,0 +1,643 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ability_manager_errors.h" +#include "extension_ability_info.h" +#include "hilog_tag_wrapper.h" +#include "hitrace_meter.h" +#include "iservice_registry.h" +#include "mission_manager_client.h" +#include "mission_manager_proxy.h" +#include "scene_board_judgement.h" +#include "system_ability_definition.h" +#include "want.h" + +namespace OHOS { +namespace AAFwk { +namespace { +#ifdef SUPPORT_SCREEN +static std::unordered_map SCB_TO_MISSION_ERROR_CODE_MAP { + { Rosen::WSError::WS_ERROR_INVALID_PERMISSION, CHECK_PERMISSION_FAILED }, + { Rosen::WSError::WS_ERROR_NOT_SYSTEM_APP, ERR_NOT_SYSTEM_APP }, + { Rosen::WSError::WS_ERROR_INVALID_PARAM, INVALID_PARAMETERS_ERR }, +}; +#endif // SUPPORT_SCREEN +} +#ifdef SUPPORT_SCREEN +using OHOS::Rosen::SessionManagerLite; +#endif // SUPPORT_SCREEN + +#define CHECK_POINTER_RETURN(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::MISSION, "null proxy"); \ + return; \ + } + +#define CHECK_POINTER_RETURN_NOT_CONNECTED(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::MISSION, "null proxy"); \ + return ABILITY_SERVICE_NOT_CONNECTED; \ + } + +#define CHECK_POINTER_RETURN_INVALID_VALUE(object) \ + if (!object) { \ + TAG_LOGE(AAFwkTag::MISSION, "null proxy"); \ + return ERR_INVALID_VALUE; \ + } + +MissionManagerClient& MissionManagerClient::GetInstance() +{ + static MissionManagerClient instance; + return instance; +} + +sptr MissionManagerClient::GetMissionManager() +{ + std::lock_guard lock(mutex_); + if (proxy_ == nullptr) { + Connect(); + } + + return proxy_; +} + +void MissionManagerClient::Connect() +{ + auto systemManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (systemManager == nullptr) { + TAG_LOGE(AAFwkTag::MISSION, "Get SAMgr failed"); + return; + } + auto remoteObj = systemManager->GetSystemAbility(ABILITY_MGR_SERVICE_ID); + if (remoteObj == nullptr) { + TAG_LOGE(AAFwkTag::MISSION, "Connect AMS failed"); + return; + } + + deathRecipient_ = new MissionMgrDeathRecipient(); + if (remoteObj->IsProxyObject() && !remoteObj->AddDeathRecipient(deathRecipient_)) { + TAG_LOGE(AAFwkTag::MISSION, "AddDeathRecipient failed"); + return; + } + + proxy_ = sptr(new MissionManagerProxy(remoteObj)); + TAG_LOGD(AAFwkTag::MISSION, "Connect AMS success"); +} + +void MissionManagerClient::ResetProxy(const wptr &remote) +{ + std::lock_guard lock(mutex_); + if (proxy_ == nullptr) { + TAG_LOGI(AAFwkTag::MISSION, "null proxy_, no need reset"); + return; + } + + auto serviceRemote = proxy_->AsObject(); + if (serviceRemote != nullptr && serviceRemote == remote.promote()) { + serviceRemote->RemoveDeathRecipient(deathRecipient_); + proxy_ = nullptr; + } +} + +void MissionManagerClient::MissionMgrDeathRecipient::OnRemoteDied(const wptr &remote) +{ + TAG_LOGI(AAFwkTag::MISSION, "called"); + MissionManagerClient::GetInstance().ResetProxy(remote); +} + +ErrCode MissionManagerClient::Release() +{ + TAG_LOGI(AAFwkTag::MISSION, "Release"); + return RemoveDeathRecipient(); +} + +ErrCode MissionManagerClient::RemoveDeathRecipient() +{ + TAG_LOGI(AAFwkTag::MISSION, "RemoveDeathRecipient"); + std::lock_guard lock(mutex_); + if (proxy_ == nullptr) { + TAG_LOGW(AAFwkTag::MISSION, "null proxy_"); + return ERR_NULL_OBJECT; + } + if (deathRecipient_ == nullptr) { + TAG_LOGW(AAFwkTag::MISSION, "null deathRecipient_"); + return ERR_NULL_OBJECT; + } + auto serviceRemote = proxy_->AsObject(); + if (serviceRemote == nullptr) { + TAG_LOGW(AAFwkTag::MISSION, "null serviceRemote"); + return ERR_NULL_OBJECT; + } + bool ret = serviceRemote->RemoveDeathRecipient(deathRecipient_); + if (!ret) { + TAG_LOGW(AAFwkTag::MISSION, "RemoveDeathRecipient fail"); + return ERR_INVALID_VALUE; + } + proxy_ = nullptr; + deathRecipient_ = nullptr; + TAG_LOGI(AAFwkTag::MISSION, "RemoveDeathRecipient success"); + return ERR_OK; +} + + +ErrCode MissionManagerClient::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId, + int32_t missionId, sptr callback, AAFwk::WantParams &wantParams) +{ + if (srcDeviceId.empty() || dstDeviceId.empty() || callback == nullptr) { + TAG_LOGE(AAFwkTag::MISSION, "srcDeviceId or dstDeviceId or callback null"); + return ERR_INVALID_VALUE; + } + + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + int result = abms->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + return result; +} + + +ErrCode MissionManagerClient::ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, + const sptr &callback) + +{ + if (continueMissionInfo.srcDeviceId.empty() || continueMissionInfo.dstDeviceId.empty() || callback == nullptr) { + TAG_LOGE(AAFwkTag::MISSION, "srcDeviceId or dstDeviceId or callback null"); + return ERR_INVALID_VALUE; + } + + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + int result = abms->ContinueMission(continueMissionInfo, callback); + return result; +} + + +ErrCode MissionManagerClient::LockMissionForCleanup(int32_t missionId) +{ +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, LockMissionForCleanup"); + auto err = sceneSessionManager->LockSession(missionId); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, LockMissionForCleanup err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->LockMissionForCleanup(missionId); +} + + +ErrCode MissionManagerClient::UnlockMissionForCleanup(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, UnlockMissionForCleanup"); + auto err = sceneSessionManager->UnlockSession(missionId); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, UnlockMissionForCleanup err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->UnlockMissionForCleanup(missionId); +} + + +ErrCode MissionManagerClient::RegisterMissionListener(sptr listener) +{ +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, RegisterMissionListener"); + auto err = sceneSessionManager->RegisterSessionListener(listener); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, RegisterMissionListener err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->RegisterMissionListener(listener); +} + + +ErrCode MissionManagerClient::UnRegisterMissionListener(sptr listener) +{ +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, UnRegisterMissionListener"); + auto err = sceneSessionManager->UnRegisterSessionListener(listener); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, UnRegisterMissionListener err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->UnRegisterMissionListener(listener); +} + + +ErrCode MissionManagerClient::RegisterMissionListener(const std::string &deviceId, + sptr listener) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->RegisterMissionListener(deviceId, listener); +} + +ErrCode MissionManagerClient::UnRegisterMissionListener(const std::string &deviceId, + sptr listener) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->UnRegisterMissionListener(deviceId, listener); +} + + +ErrCode MissionManagerClient::GetMissionInfos(const std::string &deviceId, int32_t numMax, + std::vector &missionInfos) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, GetMissionInfos"); + auto err = sceneSessionManager->GetSessionInfos(deviceId, numMax, missionInfos); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, GetMissionInfos err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->GetMissionInfos(deviceId, numMax, missionInfos); +} + +ErrCode MissionManagerClient::GetMissionInfo(const std::string &deviceId, int32_t missionId, + MissionInfo &missionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, GetMissionInfo"); + auto err = sceneSessionManager->GetSessionInfo(deviceId, missionId, missionInfo); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, GetMissionInfo err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->GetMissionInfo(deviceId, missionId, missionInfo); +} + + +ErrCode MissionManagerClient::GetMissionSnapshot(const std::string &deviceId, int32_t missionId, + MissionSnapshot &snapshot, bool isLowResolution) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, GetMissionSnapshot"); + auto err = sceneSessionManager->GetSessionSnapshot(deviceId, missionId, snapshot, isLowResolution); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, GetMissionSnapshot err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution); +} + + +ErrCode MissionManagerClient::CleanMission(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, CleanMission"); + auto err = sceneSessionManager->ClearSession(missionId); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, CleanMission err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->CleanMission(missionId); +} + + +ErrCode MissionManagerClient::CleanAllMissions() +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, CleanAllMissions"); + auto err = sceneSessionManager->ClearAllSessions(); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, CleanAllMissions err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->CleanAllMissions(); +} + + +ErrCode MissionManagerClient::MoveMissionToFront(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->MoveMissionToFront(missionId); +} + +ErrCode MissionManagerClient::MoveMissionToFront(int32_t missionId, const StartOptions &startOptions) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->MoveMissionToFront(missionId, startOptions); +} + + +ErrCode MissionManagerClient::MoveMissionsToForeground(const std::vector &missionIds, int32_t topMissionId) +{ + TAG_LOGI(AAFwkTag::MISSION, "call,topMissionId:%{public}d", topMissionId); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, MoveMissionsToForeground"); + auto err = sceneSessionManager->MoveSessionsToForeground(missionIds, topMissionId); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, MoveMissionsToForeground err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + if (missionIds.empty()) { + return ERR_INVALID_VALUE; + } + int32_t missionId = topMissionId; + if (topMissionId > 0) { + missionId = topMissionId; + } else { + missionId = missionIds[0]; + } + auto errAMS = abms->MoveMissionToFront(missionId); + return static_cast(errAMS); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->MoveMissionsToForeground(missionIds, topMissionId); +} + +ErrCode MissionManagerClient::MoveMissionsToBackground(const std::vector &missionIds, + std::vector &result) +{ + TAG_LOGI(AAFwkTag::MISSION, "call"); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, MoveMissionsToBackground"); + auto err = sceneSessionManager->MoveSessionsToBackground(missionIds, result); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, MoveMissionsToBackground err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->MoveMissionsToBackground(missionIds, result); +} + +ErrCode MissionManagerClient::GetMissionIdByToken(sptr token, int32_t &missionId) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + missionId = abms->GetMissionIdByToken(token); + if (missionId <= 0) { + TAG_LOGE(AAFwkTag::MISSION, "get missionid failed"); + return MISSION_NOT_FOUND; + } + return ERR_OK; +} + +/** + * Start synchronizing remote device mission + * @param devId, deviceId. + * @param fixConflict, resolve synchronizing conflicts flag. + * @param tag, call tag. + * @return Returns ERR_OK on success, others on failure. + */ +ErrCode MissionManagerClient::StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->StartSyncRemoteMissions(devId, fixConflict, tag); +} + +ErrCode MissionManagerClient::StopSyncRemoteMissions(const std::string &devId) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->StopSyncRemoteMissions(devId); +} + +ErrCode MissionManagerClient::SetMissionContinueState(sptr token, + const AAFwk::ContinueState &state, sptr sessionToken) +{ + TAG_LOGI(AAFwkTag::MISSION, + "called state:%{public}d", state); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled() && sessionToken) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + uint32_t value = static_cast(state); + Rosen::ContinueState continueState = static_cast(value); + TAG_LOGI(AAFwkTag::MISSION, "scb call, SetMissionContinueState"); + auto ret = static_cast(sceneSessionManager->SetSessionContinueState(sessionToken, continueState)); + if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, SetMissionContinueState err"); + } + return ret; + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->SetMissionContinueState(token, state); +} + + +#ifdef SUPPORT_SCREEN +ErrCode MissionManagerClient::SetMissionLabel(sptr token, const std::string &label) +{ + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, SetMissionLabel"); + auto err = sceneSessionManager->SetSessionLabel(token, label); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, SetMissionLabel err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->SetMissionLabel(token, label); +} + +ErrCode MissionManagerClient::SetMissionIcon( + sptr abilityToken, std::shared_ptr icon) +{ + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, SetMissionIcon"); + auto err = sceneSessionManager->SetSessionIcon(abilityToken, icon); + if (SCB_TO_MISSION_ERROR_CODE_MAP.count(err)) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, SetMissionIcon err"); + return SCB_TO_MISSION_ERROR_CODE_MAP[err]; + } + return static_cast(err); + } + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->SetMissionIcon(abilityToken, icon); +} + +void MissionManagerClient::UpdateMissionSnapShot(sptr token, + std::shared_ptr pixelMap) +{ + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN(abms); + return abms->UpdateMissionSnapShot(token, pixelMap); +} + +#endif + +int32_t MissionManagerClient::IsValidMissionIds( + const std::vector &missionIds, std::vector &results) +{ + TAG_LOGI(AAFwkTag::MISSION, "call"); +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + std::vector isValidList; + auto err = sceneSessionManager->IsValidSessionIds(missionIds, isValidList); + TAG_LOGI(AAFwkTag::MISSION, "scb call, IsValidSessionIds: %{public}d, size: %{public}d", + static_cast(err), static_cast(isValidList.size())); + for (auto i = 0; i < static_cast(isValidList.size()); ++i) { + MissionValidResult missionResult = {}; + missionResult.missionId = missionIds.at(i); + missionResult.isValid = isValidList.at(i); + results.push_back(missionResult); + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->IsValidMissionIds(missionIds, results); +} + +ErrCode MissionManagerClient::PreStartMission(const std::string &bundleName, const std::string &moduleName, + const std::string &abilityName, const std::string &startTime) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + return abms->PreStartMission(bundleName, moduleName, abilityName, startTime); +} + + +ErrCode MissionManagerClient::TerminateMission(int32_t missionId) +{ +#ifdef SUPPORT_SCREEN + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + auto sceneSessionManager = SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); + CHECK_POINTER_RETURN_INVALID_VALUE(sceneSessionManager); + TAG_LOGI(AAFwkTag::MISSION, "scb call, TerminateMission"); + auto err = sceneSessionManager->TerminateSessionByPersistentId(missionId); + if (err != OHOS::Rosen::WMError::WM_OK) { + TAG_LOGE(AAFwkTag::MISSION, "scb call, TerminateMission err: %{public}d.", static_cast(err)); + } + if (err == Rosen::WMError::WM_ERROR_INVALID_PERMISSION) { + return CHECK_PERMISSION_FAILED; + } + if (err == Rosen::WMError::WM_ERROR_NOT_SYSTEM_APP) { + return ERR_NOT_SYSTEM_APP; + } + return static_cast(err); + } +#endif //SUPPORT_SCREEN + auto abms = GetMissionManager(); + CHECK_POINTER_RETURN_INVALID_VALUE(abms); + int32_t ret = abms->TerminateMission(missionId); + if (ret != ERR_OK) { + TAG_LOGE(AAFwkTag::MISSION, "failed,err:%{public}d", ret); + } + return ret; +} +} // namespace AAFwk +} // namespace OHOS diff --git a/interfaces/inner_api/mission_manager/src/mission_manager_proxy.cpp b/interfaces/inner_api/mission_manager/src/mission_manager_proxy.cpp new file mode 100755 index 0000000000..944366d2f1 --- /dev/null +++ b/interfaces/inner_api/mission_manager/src/mission_manager_proxy.cpp @@ -0,0 +1,854 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ability_manager_errors.h" +#include "ability_manager_ipc_interface_code.h" +#include "hilog_tag_wrapper.h" +#include "hitrace_meter.h" +#include "message_parcel.h" +#include "mission_manager_proxy.h" +#include "want.h" + +namespace OHOS::AAFwk { +bool MissionManagerProxy::WriteInterfaceToken(MessageParcel &data) +{ + if (!data.WriteInterfaceToken(MissionManagerProxy::GetDescriptor())) { + TAG_LOGE(AAFwkTag::MISSION, "write token failed"); + return false; + } + return true; +} + +ErrCode MissionManagerProxy::SendRequest(AbilityManagerInterfaceCode code, MessageParcel &data, + MessageParcel &reply, MessageOption &option) +{ + auto remote = Remote(); + if (remote == nullptr) { + TAG_LOGE(AAFwkTag::MISSION, "null remote"); + return INVALID_REMOTE_PARAMETERS_ERR; + } + + return remote->SendRequest(static_cast(code), data, reply, option); +} + +int MissionManagerProxy::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId, + int32_t missionId, const sptr &callBack, AAFwk::WantParams &wantParams) +{ + TAG_LOGI(AAFwkTag::MISSION, "called"); + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(srcDeviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "srcDeviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(dstDeviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "dstDeviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "missionId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(callBack)) { + TAG_LOGE(AAFwkTag::MISSION, "callBack write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&wantParams)) { + TAG_LOGE(AAFwkTag::MISSION, "wantParams write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::CONTINUE_MISSION, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "sendRequest error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, + const sptr &callback) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(continueMissionInfo.srcDeviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "srcDeviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(continueMissionInfo.dstDeviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "dstDeviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(continueMissionInfo.bundleName)) { + TAG_LOGE(AAFwkTag::MISSION, "missionId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(callback)) { + TAG_LOGE(AAFwkTag::MISSION, "callBack write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&continueMissionInfo.wantParams)) { + TAG_LOGE(AAFwkTag::MISSION, "wantParams write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(continueMissionInfo.srcBundleName)) { + TAG_LOGE(AAFwkTag::MISSION, "srcBundleName write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(continueMissionInfo.continueType)) { + TAG_LOGE(AAFwkTag::MISSION, "continueType write fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::CONTINUE_MISSION_OF_BUNDLENAME, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::LockMissionForCleanup(int32_t missionId) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "missionId write fail"); + return INVALID_PARAMETERS_ERR; + } + + error = SendRequest(AbilityManagerInterfaceCode::LOCK_MISSION_FOR_CLEANUP, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "send error:%d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::UnlockMissionForCleanup(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::UNLOCK_MISSION_FOR_CLEANUP, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "unlock mission,error:%d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::RegisterMissionListener(const sptr &listener) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!listener) { + TAG_LOGE(AAFwkTag::MISSION, "listener null"); + return INVALID_PARAMETERS_ERR; + } + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(listener->AsObject())) { + TAG_LOGE(AAFwkTag::MISSION, "write missionListener fail"); + return INVALID_PARAMETERS_ERR; + } + + error = SendRequest(AbilityManagerInterfaceCode::REGISTER_MISSION_LISTENER, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::UnRegisterMissionListener(const sptr &listener) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!listener) { + TAG_LOGE(AAFwkTag::MISSION, "listener null"); + return INVALID_PARAMETERS_ERR; + } + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(listener->AsObject())) { + TAG_LOGE(AAFwkTag::MISSION, "write missionListener fail"); + return INVALID_PARAMETERS_ERR; + } + + error = SendRequest(AbilityManagerInterfaceCode::UNREGISTER_MISSION_LISTENER, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::RegisterMissionListener(const std::string &deviceId, + const sptr &listener) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(deviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "deviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(listener->AsObject())) { + TAG_LOGE(AAFwkTag::MISSION, "listener write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::REGISTER_REMOTE_MISSION_LISTENER, + data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::UnRegisterMissionListener(const std::string &deviceId, + const sptr &listener) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(deviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "deviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(listener->AsObject())) { + TAG_LOGE(AAFwkTag::MISSION, "listener write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::UNREGISTER_REMOTE_MISSION_LISTENER, + data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +template +int MissionManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos) +{ + int32_t infoSize = reply.ReadInt32(); + if (infoSize > CYCLE_LIMIT) { + TAG_LOGE(AAFwkTag::MISSION, "infoSize large"); + return INVALID_PARAMETERS_ERR; + } + + for (int32_t i = 0; i < infoSize; i++) { + std::unique_ptr info(reply.ReadParcelable()); + if (!info) { + TAG_LOGE(AAFwkTag::MISSION, "readParcelableInfos fail"); + return INVALID_PARAMETERS_ERR; + } + parcelableInfos.emplace_back(*info); + } + return NO_ERROR; +} + +int MissionManagerProxy::GetMissionInfos(const std::string &deviceId, int32_t numMax, + std::vector &missionInfos) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString16(Str8ToStr16(deviceId))) { + TAG_LOGE(AAFwkTag::MISSION, "write deviceId fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(numMax)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::GET_MISSION_INFOS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, " request error:%{public}d", error); + return error; + } + error = GetParcelableInfos(reply, missionInfos); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "getMissionInfos error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::GetMissionInfo(const std::string &deviceId, int32_t missionId, + MissionInfo &missionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString16(Str8ToStr16(deviceId))) { + TAG_LOGE(AAFwkTag::MISSION, "write deviceId failed"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 failed"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::GET_MISSION_INFO_BY_ID, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + + std::unique_ptr info(reply.ReadParcelable()); + if (!info) { + TAG_LOGE(AAFwkTag::MISSION, "read missioninfo fail"); + return ERR_UNKNOWN_OBJECT; + } + missionInfo = *info; + return reply.ReadInt32(); +} + +int MissionManagerProxy::GetMissionSnapshot(const std::string &deviceId, int32_t missionId, + MissionSnapshot &snapshot, bool isLowResolution) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(deviceId)) { + TAG_LOGE(AAFwkTag::MISSION, "deviceId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "missionId write fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteBool(isLowResolution)) { + TAG_LOGE(AAFwkTag::MISSION, "isLowResolution write fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::GET_MISSION_SNAPSHOT_INFO, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + std::unique_ptr info(reply.ReadParcelable()); + if (!info) { + TAG_LOGE(AAFwkTag::MISSION, "readParcelableInfo fail"); + auto errorCode = reply.ReadInt32(); + return errorCode ? errorCode : ERR_UNKNOWN_OBJECT; + } + snapshot = *info; + return reply.ReadInt32(); +} + +int MissionManagerProxy::CleanMission(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::CLEAN_MISSION, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "clean mission, error: %d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::CleanAllMissions() +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::CLEAN_ALL_MISSIONS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::MoveMissionToFront(int32_t missionId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::MoveMissionToFront(int32_t missionId, const StartOptions &startOptions) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt32 fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteParcelable(&startOptions)) { + TAG_LOGE(AAFwkTag::MISSION, "startOptions write fail"); + return INVALID_PARAMETERS_ERR; + } + error = SendRequest(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT_BY_OPTIONS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::MoveMissionsToForeground(const std::vector &missionIds, int32_t topMissionId) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteInt32Vector(missionIds)) { + TAG_LOGE(AAFwkTag::MISSION, "missionIds write fail"); + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteInt32(topMissionId)) { + TAG_LOGE(AAFwkTag::MISSION, "topMissionId write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_FOREGROUND, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + + return reply.ReadInt32(); +} + +int MissionManagerProxy::MoveMissionsToBackground(const std::vector &missionIds, std::vector &result) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteInt32Vector(missionIds)) { + TAG_LOGE(AAFwkTag::MISSION, "mission id write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_BACKGROUND, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + + if (!reply.ReadInt32Vector(&result)) { + TAG_LOGE(AAFwkTag::MISSION, "read result fail"); + return INVALID_PARAMETERS_ERR; + } + return reply.ReadInt32(); +} + +int32_t MissionManagerProxy::GetMissionIdByToken(const sptr &token) +{ + if (!token) { + TAG_LOGE(AAFwkTag::MISSION, "token null"); + return ERR_INVALID_CALLER; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteRemoteObject(token)) { + TAG_LOGE(AAFwkTag::MISSION, "data write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::GET_MISSION_ID_BY_ABILITY_TOKEN, + data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return INVALID_PARAMETERS_ERR; + } + + return reply.ReadInt32(); +} + +int MissionManagerProxy::StartSyncRemoteMissions(const std::string &devId, bool fixConflict, int64_t tag) +{ + TAG_LOGI(AAFwkTag::MISSION, "called"); + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInterfaceToken fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(devId)) { + TAG_LOGE(AAFwkTag::MISSION, "write deviceId fail"); + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteBool(fixConflict)) { + TAG_LOGE(AAFwkTag::MISSION, "writeBool fail"); + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteInt64(tag)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInt64 fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::START_SYNC_MISSIONS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int32_t MissionManagerProxy::StopSyncRemoteMissions(const std::string &devId) +{ + TAG_LOGI(AAFwkTag::MISSION, "call"); + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + TAG_LOGE(AAFwkTag::MISSION, "writeInterfaceToken fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(devId)) { + TAG_LOGE(AAFwkTag::MISSION, "write deviceId fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::STOP_SYNC_MISSIONS, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::SetMissionContinueState(const sptr &token, const AAFwk::ContinueState &state) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(token)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(static_cast(state))) { + TAG_LOGE(AAFwkTag::MISSION, "write state fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +#ifdef SUPPORT_SCREEN +int MissionManagerProxy::SetMissionLabel(const sptr &token, const std::string &label) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(token)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString16(Str8ToStr16(label))) { + TAG_LOGE(AAFwkTag::MISSION, "write label fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::SET_MISSION_LABEL, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int MissionManagerProxy::SetMissionIcon(const sptr &token, + const std::shared_ptr &icon) +{ + if (!token || !icon) { + TAG_LOGE(AAFwkTag::MISSION, "abilitytoken or icon invalid"); + return INVALID_PARAMETERS_ERR; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteRemoteObject(token)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return INVALID_PARAMETERS_ERR; + } + + if (!data.WriteParcelable(icon.get())) { + TAG_LOGE(AAFwkTag::MISSION, "write icon fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::SET_MISSION_ICON, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +void MissionManagerProxy::UpdateMissionSnapShot(const sptr &token, + const std::shared_ptr &pixelMap) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option(MessageOption::TF_ASYNC); + + if (!WriteInterfaceToken(data)) { + return; + } + if (!data.WriteRemoteObject(token)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return; + } + if (!data.WriteParcelable(pixelMap.get())) { + TAG_LOGE(AAFwkTag::MISSION, "write pixelMap fail"); + return; + } + auto error = SendRequest(AbilityManagerInterfaceCode::UPDATE_MISSION_SNAPSHOT_FROM_WMS, + data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + } +} +#endif + +int32_t MissionManagerProxy::IsValidMissionIds( + const std::vector &missionIds, std::vector &results) +{ + TAG_LOGI(AAFwkTag::MISSION, "call, query size:%{public}zu", missionIds.size()); + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + TAG_LOGE(AAFwkTag::MISSION, "write token fail"); + return INVALID_PARAMETERS_ERR; + } + + constexpr int32_t MAX_COUNT = 20; + int32_t num = static_cast(missionIds.size() > MAX_COUNT ? MAX_COUNT : missionIds.size()); + if (!data.WriteInt32(num)) { + TAG_LOGE(AAFwkTag::MISSION, "write num fail"); + return INVALID_PARAMETERS_ERR; + } + for (auto i = 0; i < num; ++i) { + if (!data.WriteInt32(missionIds.at(i))) { + TAG_LOGE(AAFwkTag::MISSION, "write missionId fail"); + return INVALID_PARAMETERS_ERR; + } + } + + auto error = SendRequest(AbilityManagerInterfaceCode::QUERY_MISSION_VAILD, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + + auto resultCode = reply.ReadInt32(); + if (resultCode != ERR_OK) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", resultCode); + return resultCode; + } + + auto infoSize = reply.ReadInt32(); + for (auto i = 0; i < infoSize && i < MAX_COUNT; ++i) { + std::unique_ptr info(reply.ReadParcelable()); + if (!info) { + TAG_LOGE(AAFwkTag::MISSION, "read result fail"); + return INVALID_PARAMETERS_ERR; + } + results.emplace_back(*info); + } + + return resultCode; +} + +int32_t MissionManagerProxy::PreStartMission(const std::string &bundleName, const std::string &moduleName, + const std::string &abilityName, const std::string &startTime) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(bundleName)) { + TAG_LOGE(AAFwkTag::MISSION, "write bundleName fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(moduleName)) { + TAG_LOGE(AAFwkTag::MISSION, "write moduleName fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(abilityName)) { + TAG_LOGE(AAFwkTag::MISSION, "write abilityName fail"); + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteString(startTime)) { + TAG_LOGE(AAFwkTag::MISSION, "write startTime fail"); + return INVALID_PARAMETERS_ERR; + } + auto error = SendRequest(AbilityManagerInterfaceCode::PRE_START_MISSION, data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error:%{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +int32_t MissionManagerProxy::TerminateMission(int32_t missionId) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INVALID_PARAMETERS_ERR; + } + if (!data.WriteInt32(missionId)) { + TAG_LOGE(AAFwkTag::MISSION, "missionId write fail"); + return INVALID_PARAMETERS_ERR; + } + + auto error = SendRequest(AbilityManagerInterfaceCode::TERMINATE_MISSION, + data, reply, option); + if (error != NO_ERROR) { + TAG_LOGE(AAFwkTag::MISSION, "request error: %{public}d", error); + return error; + } + + return reply.ReadInt32(); +} +} // namespace OHOS::AAFwk diff --git a/test/unittest/extension_manager_client_test/extension_manager_client_test.cpp b/test/unittest/extension_manager_client_test/extension_manager_client_test.cpp index 828947a8a3..95aca854cb 100644 --- a/test/unittest/extension_manager_client_test/extension_manager_client_test.cpp +++ b/test/unittest/extension_manager_client_test/extension_manager_client_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 @@ -171,5 +171,62 @@ HWTEST_F(ExtensionManagerClientTest, ExtensionManagerClientTest_010, TestSize.Le auto result = client->ConnectEnterpriseAdminExtensionAbility(want, connect, callerToken, userId); EXPECT_TRUE(result != ERR_OK); } + +/* + * Feature: ExtensionManagerClient + * Function: StartExtensionAbility + */ +HWTEST_F(ExtensionManagerClientTest, StartExtensionAbility_0100, TestSize.Level1) +{ + auto client = std::make_shared(); + Want want; + sptr callerToken = nullptr; + int32_t userId = DEFAULT_INVAL_VALUE; + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED; + auto result = client->StartExtensionAbility(want, callerToken, userId, extensionType); + EXPECT_NE(ERR_OK, result); +} + +/* + * Feature: ExtensionManagerClient + * Function: StopExtensionAbility + */ +HWTEST_F(ExtensionManagerClientTest, StopExtensionAbility_0100, TestSize.Level1) +{ + auto client = std::make_shared(); + Want want; + sptr callerToken = nullptr; + int32_t userId = DEFAULT_INVAL_VALUE; + AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED; + auto result = client->StopExtensionAbility(want, callerToken, userId, extensionType); + EXPECT_NE(ERR_OK, result); +} + +/* + * Feature: ExtensionManagerClient + * Function: GetExtensionRunningInfos + */ +HWTEST_F(ExtensionManagerClientTest, GetExtensionRunningInfos_0100, TestSize.Level1) +{ + auto client = std::make_shared(); + int upperLimit = 1; + std::vector info; + auto result = client->GetExtensionRunningInfos(upperLimit, info); + EXPECT_EQ(result, ERR_OK); +} + +/* + * Feature: ExtensionManagerClient + * Function: TransferAbilityResultForExtension + */ +HWTEST_F(ExtensionManagerClientTest, TransferAbilityResultForExtension_0100, TestSize.Level1) +{ + auto client = std::make_shared(); + sptr callerToken; + int resultCode = 0; + Want resultWant; + auto result = client->TransferAbilityResultForExtension(callerToken, resultCode, resultWant); + EXPECT_NE(result, NO_ERROR); +} } } \ No newline at end of file diff --git a/test/unittest/mission_manager_client_test/BUILD.gn b/test/unittest/mission_manager_client_test/BUILD.gn new file mode 100644 index 0000000000..67986fa4a3 --- /dev/null +++ b/test/unittest/mission_manager_client_test/BUILD.gn @@ -0,0 +1,64 @@ +# 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. + +import("//build/test.gni") +import("//foundation/ability/ability_runtime/ability_runtime.gni") + +module_output_path = "ability_runtime/abilitymgr" + +ohos_unittest("mission_manager_client_test") { + module_out_path = module_output_path + + sources = [ + "${ability_runtime_services_path}/abilitymgr/src/ability_connect_callback_stub.cpp", + "mission_manager_client_test.cpp", + ] + + include_dirs = [ + "${ability_runtime_innerkits_path}/mission_manager/include/", + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_path}/interfaces/inner_api/app_manager/include/appmgr", + "${ability_runtime_path}/services/abilitymgr/include", + ] + + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:mission_info", + "${ability_runtime_innerkits_path}/mission_manager:mission_manager", + "${ability_runtime_services_path}/abilitymgr:abilityms", + "${ability_runtime_services_path}/common:perm_verification", + ] + + external_deps = [ + "ability_base:session_info", + "ability_base:want", + "bundle_framework:appexecfwk_base", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "common_event_service:cesfwk_innerkits", + "ffrt:libffrt", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "image_framework:image_native", + "ipc:ipc_core", + "jsoncpp:jsoncpp", + "window_manager:libwsutils", + "window_manager:session_manager_lite", + ] +} + +group("unittest") { + testonly = true + + deps = [ ":mission_manager_client_test" ] +} diff --git a/test/unittest/mission_manager_client_test/mission_manager_client_test.cpp b/test/unittest/mission_manager_client_test/mission_manager_client_test.cpp new file mode 100644 index 0000000000..1fc08cc603 --- /dev/null +++ b/test/unittest/mission_manager_client_test/mission_manager_client_test.cpp @@ -0,0 +1,639 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#define private public +#include "mission_manager_client.h" +#undef private +#include "ability_manager_errors.h" +#include "ability_connect_callback_stub.h" +#include "ability_manager_client.h" +#include "appexecfwk_errors.h" +#include "scene_board_judgement.h" +#include "mission_snapshot.h" +#include "mission_info.h" +#include "ability_connect_callback_stub.h" + +using namespace testing::ext; +using namespace OHOS::AppExecFwk; + +const std::string BUNDLE_NAME = "bundleName"; + +namespace OHOS { +namespace AAFwk { + +class MissionManagerClientTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr client_{ nullptr }; +}; + +class AbilityConnectCallback : public AbilityConnectionStub { +public: + AbilityConnectCallback() {}; + virtual ~AbilityConnectCallback() {}; + virtual void OnAbilityConnectDone( + const AppExecFwk::ElementName& element, const sptr& remoteObject, int resultCode) override + {} + virtual void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override + {} + static int onAbilityConnectDoneCount; + static int onAbilityDisconnectDoneCount; +}; + +void MissionManagerClientTest::SetUpTestCase(void) +{} +void MissionManagerClientTest::TearDownTestCase(void) +{} +void MissionManagerClientTest::SetUp(void) +{ + client_ = std::make_shared(); +} +void MissionManagerClientTest::TearDown(void) +{} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0100 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0100 start"; + std::string srcDeviceId = "123"; + std::string dstDeviceId = "ABC"; + int32_t missionId = 5; + sptr callback = nullptr; + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0200 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0200 start"; + std::string srcDeviceId = ""; + std::string dstDeviceId = "ABC"; + int32_t missionId = 5; + sptr callback = nullptr; + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0200 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0300 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0300, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0300 start"; + std::string srcDeviceId = "123"; + std::string dstDeviceId = ""; + int32_t missionId = 5; + sptr callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback(); + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0300 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0400 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0400, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0400 start"; + std::string srcDeviceId = ""; + std::string dstDeviceId = "ABC"; + int32_t missionId = 5; + sptr callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback(); + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0400 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0500 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0500, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0500 start"; + std::string srcDeviceId = ""; + std::string dstDeviceId = ""; + int32_t missionId = 5; + sptr callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback(); + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0500 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0600 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0600, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0600 start"; + std::string srcDeviceId = "123"; + std::string dstDeviceId = ""; + int32_t missionId = 5; + sptr callback = nullptr; + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_VALUE); + GTEST_LOG_(INFO) << "ContinueMission_0600 end"; +} + +/** + * @tc.name: MissionManagerClient_ContinueMission_0700 + * @tc.desc: ContinueMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, ContinueMission_0700, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ContinueMission_0700 start"; + std::string srcDeviceId = "123"; + std::string dstDeviceId = "ABC"; + int32_t missionId = 5; + sptr callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback(); + WantParams wantParams; + auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams); + + EXPECT_EQ(result, ERR_INVALID_STATE); + GTEST_LOG_(INFO) << "ContinueMission_0700 end"; +} + + +/** + * @tc.name: MissionManagerClient_LockMissionForCleanup_0100 + * @tc.desc: LockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issueI5NRWT + */ +HWTEST_F(MissionManagerClientTest, LockMissionForCleanup_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->LockMissionForCleanup(1); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(ERR_INVALID_STATE, result); + } +} + +/** + * @tc.name: MissionManagerClient_LockMissionForCleanup_0200 + * @tc.desc: LockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issueI5NRWT + */ +HWTEST_F(MissionManagerClientTest, LockMissionForCleanup_0200, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->LockMissionForCleanup(1); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0100 + * @tc.desc: UnlockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->UnlockMissionForCleanup(5); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0200 + * @tc.desc: UnlockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0200, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->UnlockMissionForCleanup(5); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + + +/** + * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0300 + * @tc.desc: UnlockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0300, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->UnlockMissionForCleanup(5); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_UnlockMissionForCleanup_0400 + * @tc.desc: UnlockMissionForCleanup + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, UnlockMissionForCleanup_0400, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->UnlockMissionForCleanup(5); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_RegisterMissionListener_0100 + * @tc.desc: RegisterMissionListener + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, RegisterMissionListener_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + sptr listener = nullptr; + auto result = client_->RegisterMissionListener(listener); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, INVALID_PARAMETERS_ERR); + } +} + +/** + * @tc.name: MissionManagerClient_UnRegisterMissionListener_0100 + * @tc.desc: UnRegisterMissionListener + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, UnRegisterMissionListener_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + sptr listener = nullptr; + auto result = client_->UnRegisterMissionListener(listener); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, INVALID_PARAMETERS_ERR); + } +} + +/** + * @tc.name: MissionManagerClient_GetMissionInfos_0100 + * @tc.desc: GetMissionInfos + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, GetMissionInfos_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + std::string deviceId = "123"; + std::vector missionInfos; + auto result = client_->GetMissionInfos(deviceId, 10, missionInfos); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_GetMissionInfo_0100 + * @tc.desc: GetMissionInfo + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, GetMissionInfo_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + std::string deviceId = "123"; + int32_t missionId = 1; + MissionInfo missionInfo; + auto result = client_->GetMissionInfo(deviceId, missionId, missionInfo); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + + +/** + * @tc.name: MissionManagerClient_GetMissionSnapshot_0100 + * @tc.desc: GetMissionSnapshot + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, GetMissionSnapshot_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + std::string deviceId = "123"; + MissionSnapshot snapshot; + bool isLowResolution = false; + auto result = client_->GetMissionSnapshot(deviceId, 10, snapshot, isLowResolution); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_CleanMission_0100 + * @tc.desc: CleanMission + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, CleanMission_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->CleanMission(10); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_CleanAllMissions_0100 + * @tc.desc: CleanAllMissions + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, CleanAllMissions_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->CleanAllMissions(); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_MoveMissionToFront_0100 + * @tc.desc: MoveMissionToFront + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, MoveMissionToFront_0100, TestSize.Level1) +{ + auto result = client_->MoveMissionToFront(10); + EXPECT_EQ(result, ERR_INVALID_STATE); +} + +/** + * @tc.name: MissionManagerClient_MoveMissionToFront_0200 + * @tc.desc: MoveMissionToFront + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, MoveMissionToFront_0200, TestSize.Level1) +{ + StartOptions startOptions; + auto result = client_->MoveMissionToFront(1, startOptions); + EXPECT_EQ(result, ERR_INVALID_STATE); +} + +/** + * @tc.name: MissionManagerClient_MoveMissionsToForeground_0100 + * @tc.desc: MoveMissionsToForeground + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, MoveMissionsToForeground_0100, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_MoveMissionsToForeground_0200 + * @tc.desc: MoveMissionsToForeground + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(MissionManagerClientTest, MoveMissionsToForeground_0200, TestSize.Level1) +{ + EXPECT_TRUE(client_ != nullptr); + auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } +} + +/** + * @tc.name: MissionManagerClient_GetMissionIdByToken_0100 + * @tc.desc: GetMissionIdByToken + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, GetMissionIdByToken_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 start"; + sptr token = nullptr; + int32_t missionId = 1; + auto result = client_->GetMissionIdByToken(token, missionId); + + EXPECT_EQ(result, ERR_OK); + GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_StartSyncRemoteMissions_0100 + * @tc.desc: StartSyncRemoteMissions + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, StartSyncRemoteMissions_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 start"; + std::string devId = BUNDLE_NAME; + bool fixConflict = true; + int64_t tag = 1; + auto result = client_->StartSyncRemoteMissions(devId, fixConflict, tag); + + EXPECT_EQ(result, ERR_INVALID_STATE); + GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_StopSyncRemoteMissions_0100 + * @tc.desc: StopSyncRemoteMissions + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, StopSyncRemoteMissions_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 start"; + std::string devId = BUNDLE_NAME; + auto result = client_->StopSyncRemoteMissions(devId); + + EXPECT_EQ(result, ERR_INVALID_STATE); + GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 end"; +} + + +/** + * @tc.name: MissionManagerClient_SetMissionContinueState_0100 + * @tc.desc: SetMissionContinueState + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, SetMissionContinueState_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetMissionContinueState_0100 start"; + EXPECT_NE(client_, nullptr); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + sptr token = nullptr; + sptr sessionToken = nullptr; + AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_ACTIVE; + auto result = client_->SetMissionContinueState(token, state, sessionToken); + EXPECT_EQ(INVALID_PARAMETERS_ERR, result); + } + GTEST_LOG_(INFO) << "SetMissionContinueState_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_SetMissionContinueState_0200 + * @tc.desc: SetMissionContinueState + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, SetMissionContinueState_0200, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SetMissionContinueState_0200 start"; + EXPECT_NE(client_, nullptr); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + sptr token = nullptr; + sptr sessionToken = nullptr; + AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_INACTIVE; + auto result = client_->SetMissionContinueState(token, state, sessionToken); + EXPECT_EQ(INVALID_PARAMETERS_ERR, result); + } + GTEST_LOG_(INFO) << "SetMissionContinueState_0200 end"; +} + +#ifdef SUPPORT_SCREEN +/** + * @tc.name: MissionManagerClient_SetMissionLabel_0100 + * @tc.desc: SetMissionLabel + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, MissionManagerClient_SetMissionLabel_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "MissionManagerClient_SetMissionLabel_0100 start"; + sptr token = nullptr; + std::string label = "label"; + ErrCode ret = client_->SetMissionLabel(token, label); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(ret, INVALID_PARAMETERS_ERR); + } + EXPECT_TRUE(client_ != nullptr); + GTEST_LOG_(INFO) << "MissionManagerClient_SetMissionLabel_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_SetMissionIcon_0100 + * @tc.desc: SetMissionIcon + * @tc.type: FUNC + * @tc.require: SR000GVIJQ + */ +HWTEST_F(MissionManagerClientTest, MissionManagerClient_SetMissionIcon_0100, TestSize.Level1) +{ + sptr abilityToken = nullptr; + std::shared_ptr icon = nullptr; + + auto result = client_->SetMissionIcon(abilityToken, icon); + EXPECT_NE(result, ERR_OK); +} +#endif + +#ifdef WITH_DLP +/** + * @tc.number: UpdateMissionSnapShot_0100 + * @tc.name: UpdateMissionSnapShot + * @tc.desc: The caller is expected to be dlp manager. + */ +HWTEST_F(MissionManagerClientTest, UpdateMissionSnapShot_0100, TestSize.Level1) +{ + sptr token = nullptr; + auto pixelMap = std::shared_ptr(); + client_->UpdateMissionSnapShot(token, pixelMap); + EXPECT_TRUE(client_ != nullptr); +} +#endif // WITH_DLP + +/** + * @tc.name: MissionManagerClient_PreStartMission_0100 + * @tc.desc: CallRequestDone + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, PreStartMission_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "PreStartMission_0100 start"; + EXPECT_TRUE(client_ != nullptr); + std::string bundleName = "bundleName"; + std::string moduleName = "moduleName"; + std::string abilityName = "abilityName"; + std::string startTime = "startTime"; + ErrCode result = client_->PreStartMission(bundleName, moduleName, abilityName, startTime); + EXPECT_EQ(result, ERR_INVALID_STATE); + GTEST_LOG_(INFO) << "PreStartMission_0100 end"; +} + +/** + * @tc.name: MissionManagerClient_TerminateMission_0100 + * @tc.desc: TerminateMission + * @tc.type: FUNC + */ +HWTEST_F(MissionManagerClientTest, MissionManagerClient_TerminateMission_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "MissionManagerClient_TerminateMission_0100 start"; + int32_t missionId = 1; + ErrCode result = client_->TerminateMission(missionId); + if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + EXPECT_EQ(result, ERR_INVALID_STATE); + } + EXPECT_NE(client_, nullptr); + GTEST_LOG_(INFO) << "MissionManagerClient_TerminateMission_0100 end"; +} +} +} \ No newline at end of file