split so file

Signed-off-by: zhangzezhong <zhangzezhong8@huawei-partners.com>
2026-08-24 22:21:36 -04:00 · 2025-05-28 17:57:13 +08:00
parent d632c34d76
commit 77b3207a44
16 changed files with 3526 additions and 36 deletions
@@ -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",
@@ -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" ]
@@ -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 <mutex>

 #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<IRemoteObject> 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<IRemoteObject> 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<ExtensionRunningInfo> &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<IRemoteObject> &callerToken, int32_t resultCode,
+        const Want &want);
 private:
    class ExtensionMgrDeathRecipient : public IRemoteObject::DeathRecipient {
    public:
        ExtensionMgrDeathRecipient() = default;
        ~ExtensionMgrDeathRecipient() = default;
-        void OnRemoteDied(const wptr<IRemoteObject>& remote) override;
+        void OnRemoteDied(const wptr<IRemoteObject> &remote) override;
    private:
        DISALLOW_COPY_AND_MOVE(ExtensionMgrDeathRecipient);
    };

    sptr<IExtensionManager> GetExtensionManager();
    void Connect();
-    void ResetProxy(const wptr<IRemoteObject>& remote);
+    void ResetProxy(const wptr<IRemoteObject> &remote);
    ErrCode RemoveDeathRecipient();

    std::mutex mutex_;
@@ -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 <iremote_broker.h>
+#include <vector>
+
+#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<IRemoteObject> &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<IRemoteObject> &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<IRemoteObject> &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<ExtensionRunningInfo> &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<IRemoteObject> &callerToken, int32_t resultCode,
+        const Want &want)
+    {
+        return 0;
+    }
 };
 }  // namespace AAFwk
 }  // namespace OHOS
@@ -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<IRemoteObject> &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<IRemoteObject> &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<IRemoteObject> &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<ExtensionRunningInfo> &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<IRemoteObject> &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 <typename T>
+    int GetParcelableInfos(MessageParcel &reply, std::vector<T> &parcelableInfos);
 private:
    static inline BrokerDelegator<ExtensionManagerProxy> delegator_;
 };
@@ -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<IRemoteObject>& remote)
+void ExtensionManagerClient::ResetProxy(const wptr<IRemoteObject> &remote)
 {
    std::lock_guard<std::mutex> lock(mutex_);
    if (proxy_ == nullptr) {
@@ -86,7 +98,7 @@ void ExtensionManagerClient::ResetProxy(const wptr<IRemoteObject>& remote)
    }
 }

-void ExtensionManagerClient::ExtensionMgrDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
+void ExtensionManagerClient::ExtensionMgrDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &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<IRemoteObject> 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<IRemoteObject> 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<ExtensionRunningInfo> &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<IRemoteObject> &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
@@ -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<IRemoteOb
 {
    if (connect == nullptr) {
        TAG_LOGE(AAFwkTag::EXTMGR, "null connect");
-        return ERR_INVALID_VALUE;
+        return CONNECTION_NOT_EXIST;
    }

    MessageParcel data;
    if (!WriteInterfaceToken(data)) {
-        return INNER_ERR;
+        return INVALID_PARAMETERS_ERR;
    }
    if (!data.WriteParcelable(&want)) {
        TAG_LOGE(AAFwkTag::EXTMGR, "want write failed");
-        return ERR_INVALID_VALUE;
+        return INVALID_PARAMETERS_ERR;
    }
    if (!data.WriteBool(true) || !data.WriteRemoteObject(connect)) {
        TAG_LOGE(AAFwkTag::EXTMGR, "flag or connect write failed");
-        return ERR_INVALID_VALUE;
+        return INVALID_PARAMETERS_ERR;
    }
    if (callerToken) {
        if (!data.WriteBool(true) || !data.WriteRemoteObject(callerToken)) {
            TAG_LOGE(AAFwkTag::EXTMGR, "flag or callerToken write failed");
-            return ERR_INVALID_VALUE;
+            return INVALID_PARAMETERS_ERR;
        }
    } else {
        if (!data.WriteBool(false)) {
            TAG_LOGE(AAFwkTag::EXTMGR, "flag write failed");
-            return ERR_INVALID_VALUE;
+            return INVALID_PARAMETERS_ERR;
        }
    }
    if (!data.WriteInt32(userId)) {
        TAG_LOGE(AAFwkTag::EXTMGR, "userId write failed.");
-        return INNER_ERR;
+        return INVALID_PARAMETERS_ERR;
    }
    if (!data.WriteInt32(static_cast<int32_t>(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<IRemoteObject> &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<IRemoteObject> &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<uint32_t>(code), data, reply, option);
 }
+
+int32_t ExtensionManagerProxy::StartExtensionAbility(const Want &want, const sptr<IRemoteObject> &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<int32_t>(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<IRemoteObject> &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<int32_t>(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 <typename T>
+int ExtensionManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector<T> &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<T> info(reply.ReadParcelable<T>());
+        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<ExtensionRunningInfo> &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<ExtensionRunningInfo>(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<IRemoteObject> &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
@@ -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"
+}
@@ -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 <mutex>
+
+#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<IRemoteObject> 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<IRemoteObject> &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<IMissionListener> 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<IMissionListener> 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<IRemoteMissionListener> 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<IRemoteMissionListener> 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<MissionInfo> &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<int32_t> &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<int32_t> &missionIds, std::vector<int32_t> &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<IRemoteObject> 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<IRemoteObject> token, const AAFwk::ContinueState &state,
+        sptr<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> abilityToken,
+        std::shared_ptr<OHOS::Media::PixelMap> icon);
+
+    /**
+     * Called to update mission snapshot.
+     * @param token The target ability.
+     * @param pixelMap The snapshot.
+     */
+    void UpdateMissionSnapShot(sptr<IRemoteObject> token,
+        std::shared_ptr<OHOS::Media::PixelMap> 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<int32_t> &missionIds, std::vector<MissionValidResult> &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<IRemoteObject> &remote) override;
+    private:
+        DISALLOW_COPY_AND_MOVE(MissionMgrDeathRecipient);
+    };
+
+    sptr<IMissionManager> GetMissionManager();
+    void Connect();
+    void ResetProxy(const wptr<IRemoteObject> &remote);
+    ErrCode RemoveDeathRecipient();
+
+    std::mutex mutex_;
+    sptr<IMissionManager> proxy_;
+    sptr<IRemoteObject::DeathRecipient> deathRecipient_;
+};
+}  // namespace AAFwk
+}  // namespace OHOS
+#endif  // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_CLIENT_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 <iremote_broker.h>
+#include <vector>
+
+#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<IRemoteObject> &callBack, AAFwk::WantParams &wantParams) = 0;
+
+    virtual int ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo, const sptr<IRemoteObject> &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<IMissionListener> &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<IMissionListener> &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<IRemoteMissionListener> &listener) = 0;
+
+    virtual int UnRegisterMissionListener(const std::string &deviceId,
+        const sptr<IRemoteMissionListener> &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<MissionInfo> &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<int32_t> &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<int32_t> &missionIds, std::vector<int32_t> &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<IRemoteObject> &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<IRemoteObject> &token, const AAFwk::ContinueState &state)
+    {
+        return 0;
+    };
+
+#ifdef SUPPORT_SCREEN
+    virtual int SetMissionLabel(const sptr<IRemoteObject> &abilityToken, const std::string &label) = 0;
+
+    virtual int SetMissionIcon(const sptr<IRemoteObject> &token,
+        const std::shared_ptr<OHOS::Media::PixelMap> &icon) = 0;
+
+    /**
+     * Called to update mission snapshot.
+     * @param token The target ability.
+     * @param pixelMap The snapshot.
+     */
+    virtual void UpdateMissionSnapShot(const sptr<IRemoteObject> &token,
+        const std::shared_ptr<OHOS::Media::PixelMap> &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<int32_t> &missionIds, std::vector<MissionValidResult> &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
@@ -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<IMissionManager> {
+public:
+    explicit MissionManagerProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IMissionManager>(impl) {}
+    virtual ~MissionManagerProxy() = default;
+
+    virtual int ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
+        int32_t missionId, const sptr<IRemoteObject> &callBack, AAFwk::WantParams &wantParams) override;
+
+    virtual int ContinueMission(AAFwk::ContinueMissionInfo continueMissionInfo,
+        const sptr<IRemoteObject> &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<IMissionListener> &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<IMissionListener> &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<IRemoteMissionListener> &listener) override;
+    
+    virtual int UnRegisterMissionListener(const std::string &deviceId,
+        const sptr<IRemoteMissionListener> &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<MissionInfo> &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<int32_t>& 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<int32_t>& missionIds,
+        std::vector<int32_t>& 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<IRemoteObject> &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<IRemoteObject> &token, const AAFwk::ContinueState &state) override;
+
+#ifdef SUPPORT_SCREEN
+    virtual int SetMissionLabel(const sptr<IRemoteObject> &abilityToken, const std::string &label) override;
+
+    virtual int SetMissionIcon(const sptr<IRemoteObject> &token,
+        const std::shared_ptr<OHOS::Media::PixelMap> &icon) override;
+
+    virtual void UpdateMissionSnapShot(const sptr<IRemoteObject> &token,
+        const std::shared_ptr<Media::PixelMap> &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<int32_t> &missionIds, std::vector<MissionValidResult> &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 <typename T>
+    int GetParcelableInfos(MessageParcel &reply, std::vector<T> &parcelableInfos);
+
+private:
+    static inline BrokerDelegator<MissionManagerProxy> delegator_;
+};
+}  // namespace AAFwk
+}  // namespace OHOS
+#endif  // OHOS_ABILITY_RUNTIME_MISSION_MANAGER_PROXY_H
@@ -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<Rosen::WSError, int32_t> 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<IMissionManager> MissionManagerClient::GetMissionManager()
+{
+    std::lock_guard<std::mutex> 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<IMissionManager>(new MissionManagerProxy(remoteObj));
+    TAG_LOGD(AAFwkTag::MISSION, "Connect AMS success");
+}
+
+void MissionManagerClient::ResetProxy(const wptr<IRemoteObject> &remote)
+{
+    std::lock_guard<std::mutex> 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<IRemoteObject> &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<std::mutex> 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<IRemoteObject> 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<IRemoteObject> &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<int>(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<int>(err);
+    }
+#endif //SUPPORT_SCREEN
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->UnlockMissionForCleanup(missionId);
+}
+
+
+ErrCode MissionManagerClient::RegisterMissionListener(sptr<IMissionListener> 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<int>(err);
+    }
+#endif //SUPPORT_SCREEN
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->RegisterMissionListener(listener);
+}
+
+
+ErrCode MissionManagerClient::UnRegisterMissionListener(sptr<IMissionListener> 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<int>(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<IRemoteMissionListener> listener)
+{
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->RegisterMissionListener(deviceId, listener);
+}
+
+ErrCode MissionManagerClient::UnRegisterMissionListener(const std::string &deviceId,
+    sptr<IRemoteMissionListener> 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<MissionInfo> &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<int>(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<int>(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<int>(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<int>(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<int>(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<int32_t> &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<int>(errAMS);
+    }
+#endif //SUPPORT_SCREEN
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->MoveMissionsToForeground(missionIds, topMissionId);
+}
+
+ErrCode MissionManagerClient::MoveMissionsToBackground(const std::vector<int32_t> &missionIds,
+    std::vector<int32_t> &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<int>(err);
+    }
+#endif //SUPPORT_SCREEN
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->MoveMissionsToBackground(missionIds, result);
+}
+
+ErrCode MissionManagerClient::GetMissionIdByToken(sptr<IRemoteObject> 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<IRemoteObject> token,
+    const AAFwk::ContinueState &state, sptr<IRemoteObject> 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<uint32_t>(state);
+        Rosen::ContinueState continueState = static_cast<Rosen::ContinueState>(value);
+        TAG_LOGI(AAFwkTag::MISSION, "scb call, SetMissionContinueState");
+        auto ret = static_cast<int>(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<IRemoteObject> 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<int>(err);
+    }
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->SetMissionLabel(token, label);
+}
+
+ErrCode MissionManagerClient::SetMissionIcon(
+    sptr<IRemoteObject> abilityToken, std::shared_ptr<OHOS::Media::PixelMap> 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<int>(err);
+    }
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
+    return abms->SetMissionIcon(abilityToken, icon);
+}
+
+void MissionManagerClient::UpdateMissionSnapShot(sptr<IRemoteObject> token,
+    std::shared_ptr<Media::PixelMap> pixelMap)
+{
+    auto abms = GetMissionManager();
+    CHECK_POINTER_RETURN(abms);
+    return abms->UpdateMissionSnapShot(token, pixelMap);
+}
+
+#endif
+
+int32_t MissionManagerClient::IsValidMissionIds(
+    const std::vector<int32_t> &missionIds, std::vector<MissionValidResult> &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<bool> isValidList;
+        auto err = sceneSessionManager->IsValidSessionIds(missionIds, isValidList);
+        TAG_LOGI(AAFwkTag::MISSION, "scb call, IsValidSessionIds: %{public}d, size: %{public}d",
+            static_cast<int>(err), static_cast<int32_t>(isValidList.size()));
+        for (auto i = 0; i < static_cast<int32_t>(isValidList.size()); ++i) {
+            MissionValidResult missionResult = {};
+            missionResult.missionId = missionIds.at(i);
+            missionResult.isValid = isValidList.at(i);
+            results.push_back(missionResult);
+        }
+        return static_cast<int>(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<int32_t>(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<int32_t>(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
@@ -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<uint32_t>(code), data, reply, option);
+}
+
+int MissionManagerProxy::ContinueMission(const std::string &srcDeviceId, const std::string &dstDeviceId,
+    int32_t missionId, const sptr<IRemoteObject> &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<IRemoteObject> &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<IMissionListener> &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<IMissionListener> &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<IRemoteMissionListener> &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<IRemoteMissionListener> &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 <typename T>
+int MissionManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector<T> &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<T> info(reply.ReadParcelable<T>());
+        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<MissionInfo> &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<MissionInfo>(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<MissionInfo> info(reply.ReadParcelable<MissionInfo>());
+    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<MissionSnapshot> info(reply.ReadParcelable<MissionSnapshot>());
+    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<int32_t> &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<int32_t> &missionIds, std::vector<int32_t> &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<IRemoteObject> &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<IRemoteObject> &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<int32_t>(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<IRemoteObject> &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<IRemoteObject> &token,
+    const std::shared_ptr<OHOS::Media::PixelMap> &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<IRemoteObject> &token,
+    const std::shared_ptr<Media::PixelMap> &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<int32_t> &missionIds, std::vector<MissionValidResult> &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<int32_t>(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<MissionValidResult> info(reply.ReadParcelable<MissionValidResult>());
+        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
@@ -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<ExtensionManagerClient>();
+    Want want;
+    sptr<IRemoteObject> 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<ExtensionManagerClient>();
+    Want want;
+    sptr<IRemoteObject> 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<ExtensionManagerClient>();
+    int upperLimit = 1;
+    std::vector<ExtensionRunningInfo> 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<ExtensionManagerClient>();
+    sptr<IRemoteObject> callerToken;
+    int resultCode = 0;
+    Want resultWant;
+    auto result = client->TransferAbilityResultForExtension(callerToken, resultCode, resultWant);
+    EXPECT_NE(result, NO_ERROR);
+}
 }
 }
@@ -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" ]
+}
@@ -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 <gtest/gtest.h>
+
+#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<MissionManagerClient> client_{ nullptr };
+};
+
+class AbilityConnectCallback : public AbilityConnectionStub {
+public:
+    AbilityConnectCallback() {};
+    virtual ~AbilityConnectCallback() {};
+    virtual void OnAbilityConnectDone(
+        const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& 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<MissionManagerClient>();
+}
+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<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> 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<IMissionListener> 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<IMissionListener> 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<MissionInfo> 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<IRemoteObject> 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<IRemoteObject> token = nullptr;
+        sptr<IRemoteObject> 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<IRemoteObject> token = nullptr;
+        sptr<IRemoteObject> 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<IRemoteObject> 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<IRemoteObject> abilityToken = nullptr;
+    std::shared_ptr<OHOS::Media::PixelMap> 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<IRemoteObject> token = nullptr;
+    auto pixelMap = std::shared_ptr<Media::PixelMap>();
+    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";
+}
+}
+}