diff --git a/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h b/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h
index 572bf7c4d0f2b6ed27da3ce50fdd8fb1b02bab40..fd36397f62477ec45af4ff427cb209cfd89e63d7 100755
--- a/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h
+++ b/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h
@@ -219,6 +219,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 
     enum RequestCode {
         E_STATE_INITIAL = 0,
diff --git a/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h b/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h
index 2c172379b52e42422081f5924fa5fce4c66b09b8..6e2af77dfd3d02d8809c70055fc10007972d185f 100644
--- a/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h
+++ b/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h
@@ -186,6 +186,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 
     AbilityLifeCycleState curstate_ = AbilityLifeCycleState::ABILITY_STATE_INITIAL;
     sptr<IAbilityScheduler> abilityScheduler_;  // kit interface used to schedule ability life
diff --git a/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h b/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h
index c27d94e0e0c96b0993914336873ec8eac1f2f9f7..90a6d7f0fbd4648369d2abfb68aba47ecd6bad33 100755
--- a/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h
+++ b/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h
@@ -202,6 +202,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 
     sptr<IAbilityScheduler> abilityScheduler_ = nullptr;  // kit interface used to schedule ability life
     Want want_;
diff --git a/interfaces/innerkits/ability_manager/include/ability_manager_client.h b/interfaces/innerkits/ability_manager/include/ability_manager_client.h
index 57887f13dc8208f93c5ffb114d51adcb6efbd75a..f427149344664adf6101e95ed826676814b7b720 100644
--- a/interfaces/innerkits/ability_manager/include/ability_manager_client.h
+++ b/interfaces/innerkits/ability_manager/include/ability_manager_client.h
@@ -22,6 +22,7 @@
 #include "ability_manager_errors.h"
 #include "ability_scheduler_interface.h"
 #include "ability_manager_interface.h"
+#include "snapshot.h"
 #include "want.h"
 
 #include "iremote_object.h"
@@ -568,6 +569,15 @@ public:
      */
     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
+     * @return Returns ERR_OK on success, others on failure.
+     */
+    ErrCode GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot);
+
     /**
      * @brief Clean mission by id.
      * @param missionId Id of target mission.
@@ -623,6 +633,13 @@ public:
      * @return Returns ERR_OK on success, others on failure.
      */
     ErrCode StopUser(int accountId, const sptr<IStopUserCallback> &callback);
+
+    /**
+     * @brief Register the snapshot handler
+     * @param handler snapshot handler
+     * @return ErrCode Returns ERR_OK on success, others on failure.
+     */
+    ErrCode RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler);
 private:
     static std::mutex mutex_;
     static std::shared_ptr<AbilityManagerClient> instance_;
diff --git a/interfaces/innerkits/ability_manager/include/ability_manager_interface.h b/interfaces/innerkits/ability_manager/include/ability_manager_interface.h
index 31bf7e3d1cd20f5539966973008bb4329eded7d1..4357ee24a3c76fc40fa9f8b51c587f20dee25fdc 100755
--- a/interfaces/innerkits/ability_manager/include/ability_manager_interface.h
+++ b/interfaces/innerkits/ability_manager/include/ability_manager_interface.h
@@ -40,6 +40,7 @@
 #include "system_memory_attr.h"
 #include "mission_listener_interface.h"
 #include "mission_info.h"
+#include "snapshot.h"
 #include "start_options.h"
 #include "stop_user_callback.h"
 #include "remote_mission_listener_interface.h"
@@ -531,6 +532,8 @@ public:
     virtual int GetMissionInfo(const std::string& deviceId, int32_t missionId,
         MissionInfo &missionInfo) = 0;
 
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) = 0;
+
     virtual int CleanMission(int32_t missionId) = 0;
 
     virtual int CleanAllMissions() = 0;
@@ -563,6 +566,13 @@ public:
     virtual int UnRegisterMissionListener(const std::string &deviceId,
         const sptr<IRemoteMissionListener> &listener) = 0;
 
+    /**
+     * @brief Register the snapshot handler
+     * @param handler snapshot handler
+     * @return int Returns ERR_OK on success, others on failure.
+     */
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) = 0;
+
     enum {
         // ipc id 1-1000 for kit
         // ipc id for terminating ability (1)
@@ -783,6 +793,7 @@ public:
         UNREGISTER_REMOTE_MISSION_LISTENER = 1111,
         START_SYNC_MISSIONS = 1112,
         STOP_SYNC_MISSIONS = 1113,
+        REGISTER_SNAPSHOT_HANDLER = 1114,
 
         // ipc id 2001-3000 for tools
         // ipc id for dumping state (2001)
diff --git a/interfaces/innerkits/ability_manager/include/mission_snapshot.h b/interfaces/innerkits/ability_manager/include/mission_snapshot.h
index ed1b0dd209a0ac37b8f6cbad71d35774a5efd914..ca1fdcbdf7a79b9252298d2e6f7e0d82fbba2f9f 100644
--- a/interfaces/innerkits/ability_manager/include/mission_snapshot.h
+++ b/interfaces/innerkits/ability_manager/include/mission_snapshot.h
@@ -37,9 +37,13 @@ struct MissionPixelMap : public Parcelable {
     static MissionPixelMap *Unmarshalling(Parcel &parcel);
 };
 
-struct MissionSnapshot {
+struct MissionSnapshot : public Parcelable {
     AppExecFwk::ElementName topAbility;
     std::shared_ptr<Media::PixelMap> snapshot;
+
+    bool ReadFromParcel(Parcel &parcel);
+    virtual bool Marshalling(Parcel &parcel) const override;
+    static MissionSnapshot *Unmarshalling(Parcel &parcel);
 };
 
 }  // namespace AAFwk
diff --git a/interfaces/innerkits/ability_manager/include/snapshot.h b/interfaces/innerkits/ability_manager/include/snapshot.h
new file mode 100644
index 0000000000000000000000000000000000000000..9236a4e8cb21232015e656cb759b070458b6c1d3
--- /dev/null
+++ b/interfaces/innerkits/ability_manager/include/snapshot.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2021 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_AAFWK_SNAPSHOT_H
+#define OHOS_AAFWK_SNAPSHOT_H
+
+#include <iremote_broker.h>
+
+namespace OHOS {
+namespace Media {
+class PixelMap;
+}
+namespace AAFwk {
+/**
+ * @class Snapshot
+ * Snapshot info
+ */
+class Snapshot {
+public:
+    Snapshot() = default;
+    ~Snapshot() = default;
+    const std::shared_ptr<Media::PixelMap>& GetPixelMap() const
+    {
+        return pixelMap_;
+    }
+    void SetPixelMap(const std::shared_ptr<Media::PixelMap>& pixelMap)
+    {
+        pixelMap_ = pixelMap;
+    }
+private:
+    std::shared_ptr<Media::PixelMap> pixelMap_ = nullptr;
+};
+
+/**
+ * @class ISnapshotHandler
+ * Snapshot handler, use to get snapshot
+ */
+class ISnapshotHandler : public OHOS::IRemoteBroker {
+public:
+    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.aafwk.SnapshotHandler");
+
+    enum {
+        TRANS_ID_GET_SNAPSHOT
+    };
+
+    /**
+     * @brief Get the Snapshot object
+     * @param token remote object token
+     * @param snapshot the application snapshot
+     * @return int32_t function result
+     */
+    virtual int32_t GetSnapshot(const sptr<IRemoteObject>& token, Snapshot& snapshot) = 0;
+};
+} // namespace AAFwk
+} // namespace OHOS
+#endif // OHOS_AAFWK_SNAPSHOT_H
\ No newline at end of file
diff --git a/interfaces/kits/napi/aafwk/mission_manager/BUILD.gn b/interfaces/kits/napi/aafwk/mission_manager/BUILD.gn
index 000028cc9b249751c6108a08f0b96885435e7d3b..f0acd3349d46a65a576a965fe4856357306da6be 100644
--- a/interfaces/kits/napi/aafwk/mission_manager/BUILD.gn
+++ b/interfaces/kits/napi/aafwk/mission_manager/BUILD.gn
@@ -46,6 +46,7 @@ ohos_shared_library("missionmanager_napi") {
     "appexecfwk_standard:appexecfwk_base",
     "hiviewdfx_hilog_native:libhilog",
     "ipc:ipc_core",
+    "multimedia_image_standard:image",
   ]
 
   relative_install_dir = "module/application"
diff --git a/interfaces/kits/napi/aafwk/mission_manager/mission_manager.cpp b/interfaces/kits/napi/aafwk/mission_manager/mission_manager.cpp
index 1deb73c862f381caa2fdfbd863af6c68a6153262..3f9a59de06d0b5193ea1cb7913dd463ac851f804 100644
--- a/interfaces/kits/napi/aafwk/mission_manager/mission_manager.cpp
+++ b/interfaces/kits/napi/aafwk/mission_manager/mission_manager.cpp
@@ -23,6 +23,7 @@
 #include "js_mission_listener.h"
 #include "js_runtime_utils.h"
 #include "mission_snapshot.h"
+#include "pixel_map_napi.h"
 
 #include <mutex>
 
@@ -30,6 +31,10 @@ namespace OHOS {
 namespace AbilityRuntime {
 using namespace OHOS::AppExecFwk;
 using AbilityManagerClient = AAFwk::AbilityManagerClient;
+namespace {
+    constexpr int32_t ARG_COUNT_TWO = 1;
+    constexpr int32_t ARG_COUNT_THREE = 1;
+}
 class JsMissionManager {
 public:
     JsMissionManager() = default;
@@ -241,7 +246,38 @@ private:
     NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info)
     {
         HILOG_INFO("%{public}s is called", __FUNCTION__);
-        return nullptr;
+        if (info.argc != ARG_COUNT_TWO && info.argc != ARG_COUNT_THREE) {
+            HILOG_ERROR("missionSnapshot: need two or three params");
+            return engine.CreateUndefined();
+        }
+        std::string deviceId;
+        if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) {
+            HILOG_ERROR("missionSnapshot: Parse deviceId failed");
+            return engine.CreateUndefined();
+        }
+        int32_t missionId = -1;
+        if (!ConvertFromJsValue(engine, info.argv[0], missionId)) {
+            HILOG_ERROR("missionSnapshot: Parse missionId failed");
+            return engine.CreateUndefined();
+        }
+        AsyncTask::CompleteCallback complete =
+            [deviceId, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) {
+                AAFwk::MissionSnapshot missionSnapshot;
+                auto errcode = AbilityManagerClient::GetInstance()->GetMissionSnapshot(
+                    deviceId, missionId, missionSnapshot);
+                if (errcode == 0) {
+                    auto nativeValue = reinterpret_cast<NativeValue*>(Media::PixelMapNapi::CreatePixelMap(
+                        reinterpret_cast<napi_env>(&engine), missionSnapshot.snapshot));
+                    task.Resolve(engine, nativeValue);
+                } else {
+                    task.Reject(engine, CreateJsError(engine, errcode, "Get mission snapshot failed."));
+                }
+            };
+        NativeValue* lastParam = (info.argc == ARG_COUNT_TWO) ? nullptr : info.argv[2];
+        NativeValue* result = nullptr;
+        AsyncTask::Schedule(
+            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
+        return result;
     }
 
     NativeValue* OnLockMission(NativeEngine &engine, NativeCallbackInfo &info)
diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h
index 849cd60fd050785f28de4d9fa0dbe7733ed1c5fb..ed35e559fbf1f0a4b0e67c33ff2e595399163ee1 100755
--- a/services/abilitymgr/include/ability_manager_proxy.h
+++ b/services/abilitymgr/include/ability_manager_proxy.h
@@ -531,6 +531,10 @@ public:
     virtual int UnRegisterMissionListener(const std::string &deviceId,
         const sptr<IRemoteMissionListener> &listener) override;
 
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
+
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) override;
+
 private:
     template<typename T>
     int GetParcelableInfos(MessageParcel &reply, std::vector<T> &parcelableInfos);
diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h
index 04fd7a110a0ec988bafe20e06026953bf42457ab..bf5bee2b625af1d1424465bf13e541eacc0cb0c8 100644
--- a/services/abilitymgr/include/ability_manager_service.h
+++ b/services/abilitymgr/include/ability_manager_service.h
@@ -707,6 +707,11 @@ public:
 
     virtual int StopUser(int userId, const sptr<IStopUserCallback> &callback) override;
 
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
+
+    virtual int32_t GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot) override;
+
     // MSG 0 - 20 represents timeout message
     static constexpr uint32_t LOAD_TIMEOUT_MSG = 0;
     static constexpr uint32_t ACTIVE_TIMEOUT_MSG = 1;
@@ -890,6 +895,7 @@ private:
     std::unordered_map<int, std::shared_ptr<MissionListManager>> missionListManagers_;
     std::shared_ptr<MissionListManager> currentMissionListManager_;
     std::shared_ptr<KernalAbilityManager> kernalAbilityManager_;
+    sptr<ISnapshotHandler> snapshotHandler_;
 };
 
 }  // namespace AAFwk
diff --git a/services/abilitymgr/include/ability_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h
index 3609c0e65b2b05162e7a6853b3c9f2d4dd35c996..21aa80c8c3da4f0cd18edd053940fea62117fc33 100755
--- a/services/abilitymgr/include/ability_manager_stub.h
+++ b/services/abilitymgr/include/ability_manager_stub.h
@@ -128,6 +128,8 @@ private:
 
     int StartSyncRemoteMissionsInner(MessageParcel &data, MessageParcel &reply);
     int StopSyncRemoteMissionsInner(MessageParcel &data, MessageParcel &reply);
+    int RegisterSnapshotHandlerInner(MessageParcel &data, MessageParcel &reply);
+    int GetMissionSnapshotInfoInner(MessageParcel &data, MessageParcel &reply);
 
     using RequestFuncType = int (AbilityManagerStub::*)(MessageParcel &data, MessageParcel &reply);
     std::map<uint32_t, RequestFuncType> requestFuncMap_;
diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp
index 8c336f67077ae0a39f8f55b7db44da05f84fdb0a..c54f280f0dbb3be3544f592e1e572c3ffd15c99f 100644
--- a/services/abilitymgr/src/ability_manager_client.cpp
+++ b/services/abilitymgr/src/ability_manager_client.cpp
@@ -794,5 +794,20 @@ ErrCode AbilityManagerClient::StopUser(int accountId, const sptr<IStopUserCallba
     sptr<IAbilityManager> abms = iface_cast<IAbilityManager>(remoteObject_);
     return abms->StopUser(accountId, callback);
 }
+
+ErrCode AbilityManagerClient::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+{
+    CHECK_REMOTE_OBJECT_AND_RETURN(remoteObject_, ABILITY_SERVICE_NOT_CONNECTED);
+    auto abms = iface_cast<IAbilityManager>(remoteObject_);
+    return abms->RegisterSnapshotHandler(handler);
+}
+
+ErrCode AbilityManagerClient::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+    MissionSnapshot& snapshot)
+{
+    CHECK_REMOTE_OBJECT_AND_RETURN(remoteObject_, ABILITY_SERVICE_NOT_CONNECTED);
+    auto abms = iface_cast<IAbilityManager>(remoteObject_);
+    return abms->GetMissionSnapshot(deviceId, missionId, snapshot);
+}
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp
index 0d8de5e105ba4e84e45187b0a90fb3b8ff63ad3f..559c1dcbf6121a171986905ea5c3c9aae70ee53c 100755
--- a/services/abilitymgr/src/ability_manager_proxy.cpp
+++ b/services/abilitymgr/src/ability_manager_proxy.cpp
@@ -666,6 +666,38 @@ int AbilityManagerProxy::GetMissionSnapshot(const int32_t missionId, MissionPixe
     return reply.ReadInt32();
 }
 
+int AbilityManagerProxy::GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+{
+    int error;
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    if (!WriteInterfaceToken(data)) {
+        return INNER_ERR;
+    }
+    if (!data.WriteString(deviceId)) {
+        HILOG_ERROR("deviceId write failed.");
+        return INNER_ERR;
+    }
+    if (!data.WriteInt32(missionId)) {
+        HILOG_ERROR("missionId write failed.");
+        return ERR_INVALID_VALUE;
+    }
+    error = Remote()->SendRequest(IAbilityManager::GET_MISSION_SNAPSHOT, data, reply, option);
+    if (error != NO_ERROR) {
+        HILOG_ERROR("Send request error: %{public}d", error);
+        return error;
+    }
+    std::unique_ptr<MissionSnapshot> info(reply.ReadParcelable<MissionSnapshot>());
+    if (!info) {
+        HILOG_ERROR("readParcelableInfo failed.");
+        return ERR_UNKNOWN_OBJECT;
+    }
+    snapshot = *info;
+    return reply.ReadInt32();
+}
+
 int AbilityManagerProxy::MoveMissionToTop(int32_t missionId)
 {
     int error;
@@ -2033,5 +2065,25 @@ int AbilityManagerProxy::UnRegisterMissionListener(const std::string &deviceId,
     }
     return reply.ReadInt32();
 }
+
+int AbilityManagerProxy::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!WriteInterfaceToken(data)) {
+        return INNER_ERR;
+    }
+    if (!data.WriteRemoteObject(handler->AsObject())) {
+        HILOG_ERROR("snapshot: handler write failed.");
+        return INNER_ERR;
+    }
+    auto error = Remote()->SendRequest(IAbilityManager::REGISTER_SNAPSHOT_HANDLER, data, reply, option);
+    if (error != NO_ERROR) {
+        HILOG_ERROR("snapshot: send request error: %{public}d", error);
+        return error;
+    }
+    return reply.ReadInt32();
+}
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp
index 3fc23ab7ce50183bde2b7f60c854cd450cdfd77b..016320bfe553c237c328b2727485b91cde39025d 100644
--- a/services/abilitymgr/src/ability_manager_service.cpp
+++ b/services/abilitymgr/src/ability_manager_service.cpp
@@ -2776,5 +2776,24 @@ int AbilityManagerService::StopUser(int userId, const sptr<IStopUserCallback> &c
     }
     return 0;
 }
+
+int AbilityManagerService::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+{
+    HILOG_INFO("snapshot: AbilityManagerService register snapshot handler success.");
+    snapshotHandler_ = handler;
+    return 0;
+}
+
+int32_t AbilityManagerService::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+    MissionSnapshot& missionSnapshot)
+{
+    if (!snapshotHandler_) {
+        return 0;
+    }
+    Snapshot snapshot;
+    int32_t result = snapshotHandler_->GetSnapshot(GetAbilityTokenByMissionId(missionId), snapshot);
+    missionSnapshot.snapshot = snapshot.GetPixelMap();
+    return result;
+}
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp
index 8f0ec348e006f7dbc60f281764cb985235cc7c9d..bfb6d7b5cd4f464bcfc8082a32e94900c402fc3c 100755
--- a/services/abilitymgr/src/ability_manager_stub.cpp
+++ b/services/abilitymgr/src/ability_manager_stub.cpp
@@ -1179,5 +1179,32 @@ int AbilityManagerStub::UnRegisterRemoteMissionListenerInner(MessageParcel &data
     HILOG_INFO("AbilityManagerStub: UnRegisterRemoteMissionListenerInner result = %{public}d", result);
     return result;
 }
+
+int AbilityManagerStub::RegisterSnapshotHandlerInner(MessageParcel &data, MessageParcel &reply)
+{
+    sptr<ISnapshotHandler> handler = iface_cast<ISnapshotHandler>(data.ReadRemoteObject());
+    if (handler == nullptr) {
+        HILOG_ERROR("snapshot: AbilityManagerStub read snapshot handler failed!");
+        return ERR_NULL_OBJECT;
+    }
+    int32_t result = RegisterSnapshotHandler(handler);
+    HILOG_INFO("snapshot: AbilityManagerStub register snapshot handler result = %{public}d", result);
+    return result;
+}
+
+int AbilityManagerStub::GetMissionSnapshotInfoInner(MessageParcel &data, MessageParcel &reply)
+{
+    std::string deviceId = data.ReadString();
+    if (deviceId.empty()) {
+        HILOG_ERROR("missionSnapshot: get deviceId empty!");
+        return ERR_NULL_OBJECT;
+    }
+    int32_t missionId = data.ReadInt32();
+    MissionSnapshot missionSnapshot;
+    int32_t result = GetMissionSnapshot(deviceId, missionId, missionSnapshot);
+    HILOG_INFO("snapshot: AbilityManagerStub get snapshot result = %{public}d", result);
+    reply.WriteParcelable(&missionSnapshot);
+    return result;
+}
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/abilitymgr/src/mission_snapshot.cpp b/services/abilitymgr/src/mission_snapshot.cpp
index 1cb4cc918853ecf2dd85dfd87832c577220c1424..05caf6b6fa11132b679cb54ce288184493da5403 100644
--- a/services/abilitymgr/src/mission_snapshot.cpp
+++ b/services/abilitymgr/src/mission_snapshot.cpp
@@ -60,5 +60,45 @@ bool MissionPixelMap::Marshalling(Parcel &parcel) const
     }
     return true;
 }
+
+bool MissionSnapshot::ReadFromParcel(Parcel &parcel)
+{
+    std::unique_ptr<AppExecFwk::ElementName> ability(parcel.ReadParcelable<AppExecFwk::ElementName>());
+    if (ability == nullptr) {
+        return false;
+    }
+    topAbility = *ability;
+    std::shared_ptr<Media::PixelMap> pixelMap(parcel.ReadParcelable<Media::PixelMap>());
+    if (ability == nullptr) {
+        return false;
+    }
+    snapshot = pixelMap;
+    return true;
+}
+
+MissionSnapshot *MissionSnapshot::Unmarshalling(Parcel &parcel)
+{
+    MissionSnapshot *info = new (std::nothrow) MissionSnapshot();
+    if (info == nullptr) {
+        return nullptr;
+    }
+
+    if (!info->ReadFromParcel(parcel)) {
+        delete info;
+        info = nullptr;
+    }
+    return info;
+}
+
+bool MissionSnapshot::Marshalling(Parcel &parcel) const
+{
+    if (!parcel.WriteParcelable(&topAbility)) {
+        return false;
+    }
+    if (!parcel.WriteParcelable(snapshot.get())) {
+        return false;
+    }
+    return true;
+}
 }  // namespace AAFwk
 }  // namespace OHOS
\ No newline at end of file
diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h
index 5f1bfccf16942f8b1d25295d1a2aba20f04b456a..3f452557446df0df8c303e841ead73170aef159f 100755
--- a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h
+++ b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h
@@ -326,6 +326,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
     MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject> &callerToken, int requestCode));
     MOCK_METHOD3(StartAbility, int(const Want &want, const sptr<IRemoteObject> &callerToken, int requestCode));
     MOCK_METHOD2(
diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h
index 5e8cc3294470a8f72d73b66e4e9b6ec13fcfa11a..77f2a6c4c091082a1f1d8aeb2c3505f66c535fbf 100755
--- a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h
+++ b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h
@@ -368,6 +368,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 };
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h b/services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h
index d7240704c88d2aaef438c65d4215ace8617b7779..f576842ebcea1d939d2c133721a45173b5e0ae77 100755
--- a/services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h
+++ b/services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h
@@ -130,6 +130,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 };
 }  // namespace AAFwk
 }  // namespace OHOS
diff --git a/services/test/mock/include/mock_ability_mgr_service.h b/services/test/mock/include/mock_ability_mgr_service.h
index 168aad5e16d1bd8bb5c3638226634c084aa025f6..cad93a239f64e20afcaa5c2dbe39ca175a1b1370 100755
--- a/services/test/mock/include/mock_ability_mgr_service.h
+++ b/services/test/mock/include/mock_ability_mgr_service.h
@@ -136,6 +136,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 
     void Wait()
     {
diff --git a/tools/test/mock/mock_ability_manager_stub.h b/tools/test/mock/mock_ability_manager_stub.h
index 27beedce574ce87affca716c368c2c5ee7a33d0f..0f0dd565e6a2684e76a1866bf9205507ce82b595 100755
--- a/tools/test/mock/mock_ability_manager_stub.h
+++ b/tools/test/mock/mock_ability_manager_stub.h
@@ -161,6 +161,14 @@ public:
     {
         return 0;
     }
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    {
+        return 0;
+    }
+    virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler)
+    {
+        return 0;
+    }
 public:
     std::string powerState_;
 };