caochunlei1@huawei.com

Signed-off-by: caochunlei <caochunlei1@huawei.com>

frameworks/js/napi/aafwk/mission_manager/mission_manager.cpp

@@ -79,7 +79,13 @@ public:
     static NativeValue* GetMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info)
     {
         JsMissionManager* me = CheckParamsAndGetThis<JsMissionManager>(engine, info);
-        return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info) : nullptr;
+        return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, false) : nullptr;
+    }
+
+    static NativeValue* GetLowResolutionMissionSnapShot(NativeEngine* engine, NativeCallbackInfo* info)
+    {
+        JsMissionManager* me = CheckParamsAndGetThis<JsMissionManager>(engine, info);
+        return (me != nullptr) ? me->OnGetMissionSnapShot(*engine, *info, true) : nullptr;
     }
 
     static NativeValue* LockMission(NativeEngine* engine, NativeCallbackInfo* info)
@@ -266,7 +272,7 @@ private:
         return result;
     }
 
-    NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info)
+    NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info, bool isLowResolution)
     {
         HILOG_INFO("%{public}s is called", __FUNCTION__);
         int32_t errCode = 0;
@@ -285,14 +291,14 @@ private:
             errCode = ERR_NOT_OK;
         }
         AsyncTask::CompleteCallback complete =
-            [deviceId, missionId, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
+            [deviceId, missionId, errCode, isLowResolution](NativeEngine &engine, AsyncTask &task, int32_t status) {
                 if (errCode != 0) {
                     task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
                     return;
                 }
                 AAFwk::MissionSnapshot missionSnapshot;
                 auto ret = AbilityManagerClient::GetInstance()->GetMissionSnapshot(
-                    deviceId, missionId, missionSnapshot);
+                    deviceId, missionId, missionSnapshot, isLowResolution);
                 if (ret == 0) {
                     NativeValue* objValue = engine.CreateObject();
                     NativeObject* object = ConvertNativeValueTo<NativeObject>(objValue);
@@ -515,6 +521,8 @@ NativeValue* JsMissionManagerInit(NativeEngine* engine, NativeValue* exportObj)
     BindNativeFunction(*engine, *object, "getMissionInfos", JsMissionManager::GetMissionInfos);
     BindNativeFunction(*engine, *object, "getMissionInfo", JsMissionManager::GetMissionInfo);
     BindNativeFunction(*engine, *object, "getMissionSnapShot", JsMissionManager::GetMissionSnapShot);
+    BindNativeFunction(*engine, *object, "getLowResolutionMissionSnapShot",
+        JsMissionManager::GetLowResolutionMissionSnapShot);
     BindNativeFunction(*engine, *object, "lockMission", JsMissionManager::LockMission);
     BindNativeFunction(*engine, *object, "unlockMission", JsMissionManager::UnlockMission);
     BindNativeFunction(*engine, *object, "clearMission", JsMissionManager::ClearMission);

frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.h

@@ -149,7 +149,7 @@ public:
     }
 
     int GetMissionSnapshot(
-        const std::string& deviceId, const int32_t missionId, MissionSnapshot& snapshot) override
+        const std::string& deviceId, const int32_t missionId, MissionSnapshot& snapshot, bool isLowResolution) override
     {
         return 0;
     }

frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h

@@ -192,7 +192,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

frameworks/kits/appkit/native/test/mock/ability_delegator/mock_ability_delegator_stub.cpp

@@ -97,7 +97,7 @@ int MockAbilityDelegatorStub::ReleaseAbility(const sptr<IAbilityConnection> &con
 }
 
 int MockAbilityDelegatorStub::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
-    MissionSnapshot& snapshot)
+    MissionSnapshot& snapshot, bool isLowResolution)
 {
     return 0;
 }
@@ -279,7 +279,7 @@ int MockAbilityDelegatorStub2::ReleaseAbility(const sptr<IAbilityConnection> &co
 }
 
 int MockAbilityDelegatorStub2::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
-    MissionSnapshot& snapshot)
+    MissionSnapshot& snapshot, bool isLowResolution)
 {
     return 0;
 }

frameworks/kits/appkit/native/test/mock/ability_delegator/mock_ability_delegator_stub.h

@@ -125,7 +125,8 @@ public:
         const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken) override;
     virtual int ReleaseAbility(const sptr<IAbilityConnection> &connect,
         const AppExecFwk::ElementName &element) override;
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) override;
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution) override;
     virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
     virtual int SendANRProcessID(int pid) override;
     virtual int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,
@@ -260,7 +261,8 @@ public:
         const Want &want, const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken) override;
     virtual int ReleaseAbility(const sptr<IAbilityConnection> &connect,
         const AppExecFwk::ElementName &element) override;
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) override;
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution) override;
     virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
     virtual int SendANRProcessID(int pid) override;
     virtual int SetAbilityController(const sptr<AppExecFwk::IAbilityController> &abilityController,

frameworks/kits/appkit/native/test/mock/include/mock_ability_manager_client_interface1.cpp

@@ -137,11 +137,6 @@ ErrCode AbilityManagerClient::StopServiceAbility(const Want &want, const sptr<IR
     return ERR_OK;
 }
 
-ErrCode AbilityManagerClient::GetMissionSnapshot(const int32_t missionId, MissionSnapshot &snapshot)
-{
-    return ERR_OK;
-}
-
 ErrCode AbilityManagerClient::KillProcess(const std::string &bundleName)
 {
     return ERR_OK;

frameworks/kits/test/mock/AMS/mock_ability_manager_service.h

@@ -176,7 +176,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h

@@ -188,7 +188,8 @@ public:
         return 0;
     }
 
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

interfaces/inner_api/ability_manager/include/ability_manager_client.h

@@ -311,14 +311,6 @@ public:
      */
     ErrCode StopServiceAbility(const Want &want);
 
-    /**
-     * Get mission snapshot by mission id
-     *
-     * @param missionId the id of the mission to retrieve the sAutoapshots
-     * @return Returns ERR_OK on success, others on failure.
-     */
-    ErrCode GetMissionSnapshot(const int32_t missionId, MissionSnapshot &missionSnapshot);
-
     /**
      * Kill the process immediately.
      *
@@ -376,7 +368,7 @@ public:
      * @param SystemMemoryAttr, memory information.
      */
     void GetSystemMemoryAttr(AppExecFwk::SystemMemoryAttr &memoryInfo);
-    
+
     ErrCode GetAppMemorySize();
 
     bool IsRamConstrainedDevice();
@@ -502,10 +494,12 @@ public:
      * @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 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);
+    ErrCode GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution = false);
 
     /**
      * @brief Clean mission by id.

interfaces/inner_api/ability_manager/include/ability_manager_interface.h

@@ -438,7 +438,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 GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution) = 0;
 
     virtual int CleanMission(int32_t missionId) = 0;
 

services/abilitymgr/include/ability_manager_proxy.h

@@ -474,7 +474,8 @@ public:
 
     virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
 
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot) override;
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution) override;
 
     virtual int StartUserTest(const Want &want, const sptr<IRemoteObject> &observer) override;
 

services/abilitymgr/include/ability_manager_service.h

@@ -628,7 +628,7 @@ public:
     virtual int RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handler) override;
 
     virtual int32_t GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
-        MissionSnapshot& snapshot) override;
+        MissionSnapshot& snapshot, bool isLowResolution) override;
 
     /**
      * Set ability controller.

services/abilitymgr/include/mission_data_storage.h

@@ -29,8 +29,12 @@ namespace AAFwk {
 const std::string TASK_DATA_FILE_BASE_PATH = "/data/service/el1/public/AbilityManagerService";
 const std::string MISSION_DATA_FILE_PATH = "MissionInfo";
 const std::string MISSION_JSON_FILE_PREFIX = "mission";
+const std::string LOW_RESOLUTION_FLAG = "little";
 const std::string JSON_FILE_SUFFIX = ".json";
 const std::string PNG_FILE_SUFFIX = ".png";
+const std::string FILE_SEPARATOR = "/";
+const std::string UNDERLINE_SEPARATOR = "_";
+const int32_t SCALE = 2;
 
 class MissionDataStorage : public std::enable_shared_from_this<MissionDataStorage> {
 public:
@@ -73,25 +77,31 @@ public:
 
     /**
      * @brief Get the Mission Snapshot object
-     * @param missionId
-     * @param missionSnapshot
+     * @param missionId id of mission.
+     * @param missionSnapshot snapshot of target mission id.
+     * @param isLowResolution low resolution.
      * @return Returns true if this function is successfully called; returns false otherwise.
      */
-    bool GetMissionSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot);
+    bool GetMissionSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot, bool isLowResolution);
 
 #ifdef SUPPORT_GRAPHICS
-public:
+    /**
+     * Get low resoultion pixelmap of source.
+     *
+     * @param source source pixelmap.
+     * @return return reduced pixel map.
+     */
+    static std::shared_ptr<OHOS::Media::PixelMap> GetReducedPixelMap(
+        const std::shared_ptr<OHOS::Media::PixelMap>& source);
+
     /**
      * @brief Get the Snapshot object
      * @param missionId Indicates this mission id.
      * @return Returns PixelMap of snapshot.
      */
-    sptr<Media::PixelMap> GetSnapshot(int missionId) const;
-    
-    std::unique_ptr<Media::PixelMap> GetPixelMap(int missionId) const;
+    sptr<Media::PixelMap> GetSnapshot(int missionId, bool isLowResolution = false) const;
 
-private:
-    std::map<int32_t, std::shared_ptr<Media::PixelMap>> cachedPixelMap_;
+    std::unique_ptr<Media::PixelMap> GetPixelMap(int missionId, bool isLowResolution) const;
 #endif
 
 private:
@@ -99,10 +109,11 @@ private:
 
     std::string GetMissionDataFilePath(int missionId);
 
-    std::string GetMissionSnapshotPath(int32_t missionId) const;
+    std::string GetMissionSnapshotPath(int32_t missionId, bool isLowResolution) const;
 
     bool CheckFileNameValid(const std::string &fileName);
 
+#ifdef SUPPORT_GRAPHICS
     bool WriteToPng(const char* fileName, uint32_t width, uint32_t height, const uint8_t* data);
 
     bool GetCachedSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot);
@@ -110,13 +121,20 @@ private:
     bool SaveCachedSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot);
 
     bool DeleteCachedSnapshot(int32_t missionId);
+    void DeleteMissionSnapshot(int32_t missionId, bool isLowResolution);
 
     void SaveSnapshotFile(int32_t missionId, const MissionSnapshot& missionSnapshot);
 
+    void SaveSnapshotFile(int32_t missionId, const std::shared_ptr<OHOS::Media::PixelMap>& snapshot,
+        bool isPrivate, bool isLowResolution);
+
+    std::map<int32_t, std::shared_ptr<Media::PixelMap>> cachedPixelMap_;
+#endif
+
     int userId_ = 0;
     std::shared_ptr<AppExecFwk::EventHandler> handler_;
     std::mutex cachedPixelMapMutex_;
 };
 }  // namespace AAFwk
 }  // namespace OHOS
-#endif  // FOUNDATION_AAFWK_SERVICES_ABILITYMGR_INCLUDE_MISSION_DATA_STORAGE_H
+#endif  // FOUNDATION_AAFWK_SERVICES_ABILITYMGR_INCLUDE_MISSION_DATA_STORAGE_H

services/abilitymgr/include/mission_info_mgr.h

@@ -137,10 +137,11 @@ public:
      * @param missionId mission id
      * @param abilityToken abilityToken to get current mission snapshot
      * @param missionSnapshot result of snapshot
+     * @param isLowResolution low resolution snapshot.
      * @return return true if update mission snapshot success, else false
      */
     bool UpdateMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-        MissionSnapshot& missionSnapshot) const;
+        MissionSnapshot& missionSnapshot, bool isLowResolution = false) const;
 
 #ifdef SUPPORT_GRAPHICS
     /**
@@ -156,11 +157,12 @@ public:
      * @param missionId mission id
      * @param abilityToken abilityToken to get current mission snapshot
      * @param missionSnapshot result of snapshot
+     # @param isLowResolution low resolution.
      * @param force force get snapshot from window manager service.
      * @return true return true if get mission snapshot success, else false
      */
     bool GetMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-        MissionSnapshot& missionSnapshot, bool force = false) const;
+        MissionSnapshot& missionSnapshot, bool isLowResolution, bool force = false) const;
 
     /**
      * @brief register snapshotHandler

services/abilitymgr/include/mission_list_manager.h

@@ -317,10 +317,11 @@ public:
      * @param missionId mission id
      * @param abilityToken abilityToken to get current mission snapshot
      * @param missionSnapshot result of snapshot
+     * @param isLowResolution low resolution.
      * @return Returns true on success, false on failure.
      */
     bool GetMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-        MissionSnapshot& missionSnapshot);
+        MissionSnapshot& missionSnapshot, bool isLowResolution);
     void GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info, bool isPerm);
 
     #ifdef ABILITY_COMMAND_FOR_TEST

services/abilitymgr/include/task_data_persistence_mgr.h

@@ -88,10 +88,11 @@ public:
     /**
      * @brief Get the mission snapshot object
      * @param missionId id of mission
-     * @param missionSnapshot
+     * @param missionSnapshot output snapshot of mission.
+     * @param isLowResolution low resolution.
      * @return return true if update mission snapshot success, else false
      */
-    bool GetMissionSnapshot(int missionId, MissionSnapshot& missionSnapshot);
+    bool GetMissionSnapshot(int missionId, MissionSnapshot& missionSnapshot, bool isLowResolution);
 
 private:
     std::unordered_map<int, std::shared_ptr<MissionDataStorage>> missionDataStorageMgr_;

services/abilitymgr/src/ability_manager_client.cpp

@@ -741,11 +741,11 @@ ErrCode AbilityManagerClient::RegisterSnapshotHandler(const sptr<ISnapshotHandle
 }
 
 ErrCode AbilityManagerClient::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
-    MissionSnapshot& snapshot)
+    MissionSnapshot& snapshot, bool isLowResolution)
 {
     auto abms = GetAbilityManager();
     CHECK_POINTER_RETURN_NOT_CONNECTED(abms);
-    return abms->GetMissionSnapshot(deviceId, missionId, snapshot);
+    return abms->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution);
 }
 
 ErrCode AbilityManagerClient::StartUserTest(const Want &want, const sptr<IRemoteObject> &observer)

services/abilitymgr/src/ability_manager_proxy.cpp

@@ -843,7 +843,8 @@ int AbilityManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector<T>
     return NO_ERROR;
 }
 
-int AbilityManagerProxy::GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+int AbilityManagerProxy::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+    MissionSnapshot& snapshot, bool isLowResolution)
 {
     int error;
     MessageParcel data;
@@ -861,6 +862,10 @@ int AbilityManagerProxy::GetMissionSnapshot(const std::string& deviceId, int32_t
         HILOG_ERROR("missionId write failed.");
         return ERR_INVALID_VALUE;
     }
+    if (!data.WriteBool(isLowResolution)) {
+        HILOG_ERROR("isLowResolution write failed.");
+        return ERR_INVALID_VALUE;
+    }
     error = Remote()->SendRequest(IAbilityManager::GET_MISSION_SNAPSHOT_INFO, data, reply, option);
     if (error != NO_ERROR) {
         HILOG_ERROR("Send request error: %{public}d", error);

services/abilitymgr/src/ability_manager_service.cpp

@@ -3795,7 +3795,7 @@ int AbilityManagerService::RegisterSnapshotHandler(const sptr<ISnapshotHandler>&
 }
 
 int32_t AbilityManagerService::GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
-    MissionSnapshot& missionSnapshot)
+    MissionSnapshot& missionSnapshot, bool isLowResolution)
 {
     if (VerifyMissionPermission() == CHECK_PERMISSION_FAILED) {
         HILOG_ERROR("%{public}s: Permission verification failed", __func__);
@@ -3812,7 +3812,7 @@ int32_t AbilityManagerService::GetMissionSnapshot(const std::string& deviceId, i
         return INNER_ERR;
     }
     auto token = GetAbilityTokenByMissionId(missionId);
-    bool result = currentMissionListManager_->GetMissionSnapshot(missionId, token, missionSnapshot);
+    bool result = currentMissionListManager_->GetMissionSnapshot(missionId, token, missionSnapshot, isLowResolution);
     if (!result) {
         return INNER_ERR;
     }

services/abilitymgr/src/ability_manager_stub.cpp

@@ -1188,8 +1188,9 @@ int AbilityManagerStub::GetMissionSnapshotInfoInner(MessageParcel &data, Message
 {
     std::string deviceId = data.ReadString();
     int32_t missionId = data.ReadInt32();
+    bool isLowResolution = data.ReadBool();
     MissionSnapshot missionSnapshot;
-    int32_t result = GetMissionSnapshot(deviceId, missionId, missionSnapshot);
+    int32_t result = GetMissionSnapshot(deviceId, missionId, missionSnapshot, isLowResolution);
     HILOG_INFO("snapshot: AbilityManagerStub get snapshot result = %{public}d", result);
     if (!reply.WriteParcelable(&missionSnapshot)) {
         HILOG_ERROR("GetMissionSnapshot error");

services/abilitymgr/src/mission_data_storage.cpp

@@ -103,6 +103,46 @@ void MissionDataStorage::DeleteMissionInfo(int missionId)
     DeleteMissionSnapshot(missionId);
 }
 
+void MissionDataStorage::SaveMissionSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot)
+{
+#ifdef SUPPORT_GRAPHICS
+    HILOG_INFO("snapshot: save snapshot from cache, missionId = %{public}d", missionId);
+    SaveCachedSnapshot(missionId, missionSnapshot);
+    SaveSnapshotFile(missionId, missionSnapshot);
+    HILOG_INFO("snapshot: delete snapshot from cache, missionId = %{public}d", missionId);
+    DeleteCachedSnapshot(missionId);
+#endif
+}
+
+void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId)
+{
+#ifdef SUPPORT_GRAPHICS
+    DeleteMissionSnapshot(missionId, false);
+    DeleteMissionSnapshot(missionId, true);
+#endif
+}
+
+bool MissionDataStorage::GetMissionSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot, bool isLowResolution)
+{
+#ifdef SUPPORT_GRAPHICS
+    if (GetCachedSnapshot(missionId, missionSnapshot)) {
+        if (isLowResolution) {
+            missionSnapshot.snapshot = GetReducedPixelMap(missionSnapshot.snapshot);
+        }
+        HILOG_INFO("snapshot: GetMissionSnapshot from cache, missionId = %{public}d", missionId);
+        return true;
+    }
+
+    auto pixelMap = GetPixelMap(missionId, isLowResolution);
+    if (!pixelMap) {
+        HILOG_ERROR("%{public}s: GetPixelMap failed.", __func__);
+        return false;
+    }
+    missionSnapshot.snapshot = std::move(pixelMap);
+#endif
+    return true;
+}
+
 std::string MissionDataStorage::GetMissionDataDirPath() const
 {
     return TASK_DATA_FILE_BASE_PATH + "/" + std::to_string(userId_) + "/" + MISSION_DATA_FILE_PATH;
@@ -114,6 +154,17 @@ std::string MissionDataStorage::GetMissionDataFilePath(int missionId)
         + MISSION_JSON_FILE_PREFIX + "_" + std::to_string(missionId) + JSON_FILE_SUFFIX;
 }
 
+std::string MissionDataStorage::GetMissionSnapshotPath(int32_t missionId, bool isLowResolution) const
+{
+    std::string filePath = GetMissionDataDirPath() + FILE_SEPARATOR + MISSION_JSON_FILE_PREFIX +
+        UNDERLINE_SEPARATOR + std::to_string(missionId);
+    if (isLowResolution) {
+        filePath = filePath + UNDERLINE_SEPARATOR + LOW_RESOLUTION_FLAG;
+    }
+    filePath = filePath + PNG_FILE_SUFFIX;
+    return filePath;
+}
+
 bool MissionDataStorage::CheckFileNameValid(const std::string &fileName)
 {
     std::string fileNameExcludePath = OHOS::HiviewDFX::FileUtil::ExtractFileName(fileName);
@@ -140,9 +191,21 @@ bool MissionDataStorage::CheckFileNameValid(const std::string &fileName)
     return true;
 }
 
+#ifdef SUPPORT_GRAPHICS
 void MissionDataStorage::SaveSnapshotFile(int32_t missionId, const MissionSnapshot& missionSnapshot)
 {
-    std::string filePath = GetMissionSnapshotPath(missionId);
+    SaveSnapshotFile(missionId, missionSnapshot.snapshot, missionSnapshot.isPrivate, false);
+    SaveSnapshotFile(missionId, GetReducedPixelMap(missionSnapshot.snapshot), missionSnapshot.isPrivate, true);
+}
+
+void MissionDataStorage::SaveSnapshotFile(int32_t missionId, const std::shared_ptr<OHOS::Media::PixelMap>& snapshot,
+    bool isPrivate, bool isLowResolution)
+{
+    if (!snapshot) {
+        return;
+    }
+
+    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
     std::string dirPath = OHOS::HiviewDFX::FileUtil::ExtractFilePath(filePath);
     if (!OHOS::HiviewDFX::FileUtil::FileExists(dirPath)) {
         bool createDir = OHOS::HiviewDFX::FileUtil::ForceCreateDirectory(dirPath);
@@ -151,79 +214,75 @@ void MissionDataStorage::SaveSnapshotFile(int32_t missionId, const MissionSnapsh
             return;
         }
     }
-#ifdef SUPPORT_GRAPHICS
+
     bool saveMissionFile = false;
-    if (missionSnapshot.isPrivate) {
-        ssize_t dataLength = missionSnapshot.snapshot->GetWidth() * missionSnapshot.snapshot->GetHeight() * BPP;
+    if (isPrivate) {
+        ssize_t dataLength = snapshot->GetWidth() * snapshot->GetHeight() * BPP;
         uint8_t* data = (uint8_t*) malloc(dataLength);
         if (memset_s(data, dataLength, 0xff, dataLength) == EOK) {
-            saveMissionFile = WriteToPng(filePath.c_str(), missionSnapshot.snapshot->GetWidth(),
-                missionSnapshot.snapshot->GetHeight(), data);
+            saveMissionFile = WriteToPng(filePath.c_str(), snapshot->GetWidth(), snapshot->GetHeight(), data);
         }
         free(data);
     } else {
-        const uint8_t* data = missionSnapshot.snapshot->GetPixels();
-        saveMissionFile = WriteToPng(filePath.c_str(), missionSnapshot.snapshot->GetWidth(),
-            missionSnapshot.snapshot->GetHeight(), data);
+        const uint8_t* data = snapshot->GetPixels();
+        saveMissionFile = WriteToPng(filePath.c_str(), snapshot->GetWidth(), snapshot->GetHeight(), data);
     }
 
     if (!saveMissionFile) {
         HILOG_ERROR("snapshot: save mission snapshot failed, path = %{public}s.", filePath.c_str());
     }
-#endif
 }
 
-void MissionDataStorage::SaveMissionSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot)
+std::shared_ptr<OHOS::Media::PixelMap> MissionDataStorage::GetReducedPixelMap(
+    const std::shared_ptr<OHOS::Media::PixelMap>& snapshot)
 {
-    HILOG_INFO("snapshot: save snapshot from cache, missionId = %{public}d", missionId);
-    SaveCachedSnapshot(missionId, missionSnapshot);
-    SaveSnapshotFile(missionId, missionSnapshot);
-    HILOG_INFO("snapshot: delete snapshot from cache, missionId = %{public}d", missionId);
-    DeleteCachedSnapshot(missionId);
+    if (!snapshot) {
+        return nullptr;
+    }
+
+    OHOS::Media::InitializationOptions options;
+    options.size.width = snapshot->GetWidth() / SCALE;
+    options.size.height = snapshot->GetHeight() / SCALE;
+    std::unique_ptr<OHOS::Media::PixelMap> reducedPixelMap = OHOS::Media::PixelMap::Create(*snapshot, options);
+    return std::shared_ptr<OHOS::Media::PixelMap>(reducedPixelMap.release());
 }
 
 bool MissionDataStorage::GetCachedSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot)
 {
-#ifdef SUPPORT_GRAPHICS
     std::lock_guard<std::mutex> lock(cachedPixelMapMutex_);
     auto pixelMap = cachedPixelMap_.find(missionId);
     if (pixelMap != cachedPixelMap_.end()) {
         missionSnapshot.snapshot = pixelMap->second;
         return true;
     }
-#endif
     return false;
 }
 
 bool MissionDataStorage::SaveCachedSnapshot(int32_t missionId, const MissionSnapshot& missionSnapshot)
 {
-#ifdef SUPPORT_GRAPHICS
     std::lock_guard<std::mutex> lock(cachedPixelMapMutex_);
     auto result = cachedPixelMap_.insert_or_assign(missionId, missionSnapshot.snapshot);
     if (!result.second) {
         HILOG_ERROR("snapshot: save snapshot cache failed, missionId = %{public}d", missionId);
         return false;
     }
-#endif
     return true;
 }
 
 bool MissionDataStorage::DeleteCachedSnapshot(int32_t missionId)
 {
-#ifdef SUPPORT_GRAPHICS
     std::lock_guard<std::mutex> lock(cachedPixelMapMutex_);
     auto result = cachedPixelMap_.erase(missionId);
     if (result != 1) {
         HILOG_ERROR("snapshot: delete snapshot cache failed, missionId = %{public}d", missionId);
         return false;
     }
-#endif
     return true;
 }
 
-void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId)
+void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId, bool isLowResolution)
 {
-    std::string filePath = GetMissionSnapshotPath(missionId);
+    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
     std::string dirPath = OHOS::HiviewDFX::FileUtil::ExtractFilePath(filePath);
     if (!OHOS::HiviewDFX::FileUtil::FileExists(filePath)) {
         HILOG_WARN("snapshot: remove snapshot file %{public}s failed, file not exists", filePath.c_str());
@@ -235,10 +294,9 @@ void MissionDataStorage::DeleteMissionSnapshot(int32_t missionId)
     }
 }
 
-#ifdef SUPPORT_GRAPHICS
-sptr<Media::PixelMap> MissionDataStorage::GetSnapshot(int missionId) const
+sptr<Media::PixelMap> MissionDataStorage::GetSnapshot(int missionId, bool isLowResolution) const
 {
-    auto pixelMapPtr = GetPixelMap(missionId);
+    auto pixelMapPtr = GetPixelMap(missionId, isLowResolution);
     if (!pixelMapPtr) {
         HILOG_ERROR("%{public}s: GetPixelMap failed.", __func__);
         return nullptr;
@@ -246,9 +304,9 @@ sptr<Media::PixelMap> MissionDataStorage::GetSnapshot(int missionId) const
     return sptr<Media::PixelMap>(pixelMapPtr.release());
 }
 
-std::unique_ptr<Media::PixelMap> MissionDataStorage::GetPixelMap(int missionId) const
+std::unique_ptr<Media::PixelMap> MissionDataStorage::GetPixelMap(int missionId, bool isLowResolution) const
 {
-    std::string filePath = GetMissionSnapshotPath(missionId);
+    std::string filePath = GetMissionSnapshotPath(missionId, isLowResolution);
     if (!OHOS::HiviewDFX::FileUtil::FileExists(filePath)) {
         HILOG_INFO("snapshot: storage snapshot not exists, missionId = %{public}d", missionId);
         return nullptr;
@@ -268,35 +326,9 @@ std::unique_ptr<Media::PixelMap> MissionDataStorage::GetPixelMap(int missionId)
     }
     return pixelMapPtr;
 }
-#endif
-
-bool MissionDataStorage::GetMissionSnapshot(int32_t missionId, MissionSnapshot& missionSnapshot)
-{
-#ifdef SUPPORT_GRAPHICS
-    if (GetCachedSnapshot(missionId, missionSnapshot)) {
-        HILOG_INFO("snapshot: GetMissionSnapshot from cache, missionId = %{public}d", missionId);
-        return true;
-    }
-
-    auto pixelMap = GetPixelMap(missionId);
-    if (!pixelMap) {
-        HILOG_ERROR("%{public}s: GetPixelMap failed.", __func__);
-        return false;
-    }
-    missionSnapshot.snapshot = std::move(pixelMap);
-#endif
-    return true;
-}
-
-std::string MissionDataStorage::GetMissionSnapshotPath(int32_t missionId) const
-{
-    return GetMissionDataDirPath() + "/"
-        + MISSION_JSON_FILE_PREFIX + "_" + std::to_string(missionId) + PNG_FILE_SUFFIX;
-}
 
 bool MissionDataStorage::WriteToPng(const char* fileName, uint32_t width, uint32_t height, const uint8_t* data)
 {
-#ifdef SUPPORT_GRAPHICS
     if (data == nullptr) {
         HILOG_ERROR("snapshot: data error, nullptr!\n");
         return false;
@@ -347,8 +379,9 @@ bool MissionDataStorage::WriteToPng(const char* fileName, uint32_t width, uint32
     // free memory
     png_destroy_write_struct(&png_ptr, &info_ptr);
     (void)fclose(fp);
-#endif
+
     return true;
 }
+#endif
 }  // namespace AAFwk
-}  // namespace OHOS
+}  // namespace OHOS

services/abilitymgr/src/mission_info_mgr.cpp

@@ -405,7 +405,7 @@ void MissionInfoMgr::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& handl
 }
 
 bool MissionInfoMgr::UpdateMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-    MissionSnapshot& missionSnapshot) const
+    MissionSnapshot& missionSnapshot, bool isLowResolution) const
 {
     HILOG_INFO("Update mission snapshot, missionId:%{public}d.", missionId);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -430,11 +430,18 @@ bool MissionInfoMgr::UpdateMissionSnapshot(int32_t missionId, const sptr<IRemote
         HILOG_ERROR("snapshot: taskDataPersistenceMgr_ is nullptr");
         return false;
     }
+
 #ifdef SUPPORT_GRAPHICS
-    missionSnapshot.snapshot = snapshot.GetPixelMap();
+    missionSnapshot.snapshot = isLowResolution ?
+        MissionDataStorage::GetReducedPixelMap(snapshot.GetPixelMap()) : snapshot.GetPixelMap();
 #endif
     missionSnapshot.topAbility = it->missionInfo.want.GetElement();
-    if (!taskDataPersistenceMgr_->SaveMissionSnapshot(missionId, missionSnapshot)) {
+
+    MissionSnapshot savedSnapshot = missionSnapshot;
+#ifdef SUPPORT_GRAPHICS
+    savedSnapshot.snapshot = snapshot.GetPixelMap();
+#endif
+    if (!taskDataPersistenceMgr_->SaveMissionSnapshot(missionId, savedSnapshot)) {
         HILOG_ERROR("snapshot: save mission snapshot failed");
         return false;
     }
@@ -463,7 +470,7 @@ sptr<Media::PixelMap> MissionInfoMgr::GetSnapshot(int32_t missionId) const
 #endif
 
 bool MissionInfoMgr::GetMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-    MissionSnapshot& missionSnapshot, bool force) const
+    MissionSnapshot& missionSnapshot, bool isLowResolution, bool force) const
 {
     HILOG_INFO("mission_list_info GetMissionSnapshot, missionId:%{public}d, force:%{public}d", missionId, force);
     std::lock_guard<std::recursive_mutex> lock(mutex_);
@@ -481,16 +488,16 @@ bool MissionInfoMgr::GetMissionSnapshot(int32_t missionId, const sptr<IRemoteObj
 
     if (force) {
         HILOG_INFO("force to get snapshot");
-        return UpdateMissionSnapshot(missionId, abilityToken, missionSnapshot);
+        return UpdateMissionSnapshot(missionId, abilityToken, missionSnapshot, isLowResolution);
     }
 
-    if (taskDataPersistenceMgr_->GetMissionSnapshot(missionId, missionSnapshot)) {
+    if (taskDataPersistenceMgr_->GetMissionSnapshot(missionId, missionSnapshot, isLowResolution)) {
         missionSnapshot.topAbility = it->missionInfo.want.GetElement();
         HILOG_ERROR("mission_list_info GetMissionSnapshot, find snapshot OK, missionId:%{public}d", missionId);
         return true;
     }
     HILOG_INFO("snapshot: storage mission snapshot not exists, create new snapshot");
-    return UpdateMissionSnapshot(missionId, abilityToken, missionSnapshot);
+    return UpdateMissionSnapshot(missionId, abilityToken, missionSnapshot, isLowResolution);
 }
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/src/mission_list_manager.cpp

@@ -2443,7 +2443,7 @@ void MissionListManager::RegisterSnapshotHandler(const sptr<ISnapshotHandler>& h
 }
 
 bool MissionListManager::GetMissionSnapshot(int32_t missionId, const sptr<IRemoteObject>& abilityToken,
-    MissionSnapshot& missionSnapshot)
+    MissionSnapshot& missionSnapshot, bool isLowResolution)
 {
     HILOG_INFO("snapshot: Start get mission snapshot.");
     bool forceSnapshot = false;
@@ -2455,7 +2455,7 @@ bool MissionListManager::GetMissionSnapshot(int32_t missionId, const sptr<IRemot
         }
     }
     return DelayedSingleton<MissionInfoMgr>::GetInstance()->GetMissionSnapshot(
-        missionId, abilityToken, missionSnapshot, forceSnapshot);
+        missionId, abilityToken, missionSnapshot, isLowResolution, forceSnapshot);
 }
 
 void MissionListManager::GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info, bool isPerm)

services/abilitymgr/src/task_data_persistence_mgr.cpp

@@ -150,14 +150,14 @@ sptr<Media::PixelMap> TaskDataPersistenceMgr::GetSnapshot(int missionId) const
 }
 #endif
 
-bool TaskDataPersistenceMgr::GetMissionSnapshot(int missionId, MissionSnapshot& snapshot)
+bool TaskDataPersistenceMgr::GetMissionSnapshot(int missionId, MissionSnapshot& snapshot, bool isLowResolution)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!currentMissionDataStorage_) {
         HILOG_ERROR("snapshot: currentMissionDataStorage_ is nullptr");
         return false;
     }
-    return currentMissionDataStorage_->GetMissionSnapshot(missionId, snapshot);
+    return currentMissionDataStorage_->GetMissionSnapshot(missionId, snapshot, isLowResolution);
 }
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/test/unittest/phone/ability_manager_client_test/ability_manager_stub_mock_test.h

@@ -205,7 +205,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h

@@ -211,7 +211,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h

@@ -283,7 +283,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h

@@ -120,7 +120,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

services/test/mock/include/mock_ability_mgr_service.h

@@ -153,7 +153,8 @@ public:
     {
         return 0;
     }
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }

tools/test/mock/mock_ability_manager_stub.h

@@ -158,7 +158,8 @@ public:
         return 0;
     }
 
-    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId, MissionSnapshot& snapshot)
+    virtual int GetMissionSnapshot(const std::string& deviceId, int32_t missionId,
+        MissionSnapshot& snapshot, bool isLowResolution)
     {
         return 0;
     }