diff --git a/frameworks/inner_api/sandbox_manager/src/sandbox_manager_proxy.cpp b/frameworks/inner_api/sandbox_manager/src/sandbox_manager_proxy.cpp
index d27f33f5718026b82b9bb7812bc1e1dfd80deb59..71c0c4cd7ef0a03122447b858123f2354738761a 100644
--- a/frameworks/inner_api/sandbox_manager/src/sandbox_manager_proxy.cpp
+++ b/frameworks/inner_api/sandbox_manager/src/sandbox_manager_proxy.cpp
@@ -56,6 +56,112 @@ static void MarshalPolicy(std::stringstream &ss, const std::vector<PolicyInfo> &
         ss.write(reinterpret_cast<const char *>(&policy[i].mode), sizeof(policy[i].mode));
     }
 }
+
+/**
+ * Unmarshals a vector of uint32_t from a stringstream.
+ * @param inputStream The stringstream from which to read the data.
+ * @param result The vector that will hold the unmarshaled data.
+ * @return Returns a status code indicating whether the operation is successful.
+ */
+static int UnMarshalResult(std::stringstream &inputStream, std::vector<uint32_t> &result)
+{
+    uint32_t resultNum = 0;
+    if (!inputStream.read(reinterpret_cast<char *>(&resultNum), sizeof(resultNum))) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result count from inputStream.");
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+    }
+
+    for (uint32_t i = 0; i < resultNum; i++) {
+        uint32_t value = 0;
+        if (!inputStream.read(reinterpret_cast<char *>(&value), sizeof(value))) {
+            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result value from inputStream.");
+            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+        }
+        result.emplace_back(value);
+    }
+    return SANDBOX_MANAGER_OK;
+}
+
+/**
+ * Unmarshals a vector of bool values from a stringstream.
+ * The stringstream is expected to contain binary data where '1' represents true and '0' represents false.
+ * @param inputStream The stringstream from which to read the data.
+ * @param result The vector that will hold the unmarshaled data.
+ * @return Returns a status code indicating whether the operation is successful.
+ */
+static int UnMarshalResult(std::stringstream &inputStream, std::vector<bool> &result)
+{
+    uint32_t resultNum = 0;
+    if (!inputStream.read(reinterpret_cast<char *>(&resultNum), sizeof(resultNum))) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result count from inputStream.");
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+    }
+
+    for (uint32_t i = 0; i < resultNum; i++) {
+        char value = 0;
+        if (!inputStream.read(&value, sizeof(value))) {
+            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result value from inputStream.");
+            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+        }
+        bool bitValue = value == '1' ? true : false;
+        result.emplace_back(bitValue);
+    }
+    return SANDBOX_MANAGER_OK;
+}
+
+static bool ReadResultParcel(MessageParcel &reply, std::vector<uint32_t> &result)
+{
+    uint32_t rawStringLength = reply.ReadUint32();
+    const void *buffer = reply.ReadRawData(rawStringLength);
+    if (buffer == nullptr) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
+        return false;
+    }
+    std::stringstream replyRawStream;
+    replyRawStream.write(reinterpret_cast<const char *>(buffer), rawStringLength);
+    int32_t unMarshlResultRet = UnMarshalResult(replyRawStream, result);
+    if (unMarshlResultRet != SANDBOX_MANAGER_OK) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "UnMarshalResult data failed");
+        return false;
+    }
+    return true;
+}
+
+static bool ReadResultParcel(MessageParcel &reply, std::vector<bool> &result)
+{
+    uint32_t rawStringLength = reply.ReadUint32();
+    const void *buffer = reply.ReadRawData(rawStringLength);
+    if (buffer == nullptr) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
+        return false;
+    }
+    std::stringstream replyRawStream;
+    replyRawStream.write(reinterpret_cast<const char *>(buffer), rawStringLength);
+    int32_t unMarshlResultRet = UnMarshalResult(replyRawStream, result);
+    if (unMarshlResultRet != SANDBOX_MANAGER_OK) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "UnMarshalResult data failed");
+        return false;
+    }
+    return true;
+}
+
+static bool WritePolicyParcel(MessageParcel &data, const std::vector<PolicyInfo> &policy)
+{
+    std::stringstream ss;
+    MarshalPolicy(ss, policy);
+
+    if (!data.WriteUint32(ss.str().length())) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
+        return false;
+    }
+
+    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+        return false;
+    }
+    return true;
+}
+
 int32_t SandboxManagerProxy::SendRequest(SandboxManagerInterfaceCode code, MessageParcel &data, MessageParcel &reply)
 {
     MessageOption option(MessageOption::TF_SYNC);
@@ -103,16 +209,7 @@ int32_t SandboxManagerProxy::PersistPolicy(const std::vector<PolicyInfo> &policy
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -129,7 +226,7 @@ int32_t SandboxManagerProxy::PersistPolicy(const std::vector<PolicyInfo> &policy
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -144,19 +241,10 @@ int32_t SandboxManagerProxy::UnPersistPolicy(const std::vector<PolicyInfo> &poli
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    
     MessageParcel reply;
     int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION, data, reply);
     if (requestRet != SANDBOX_MANAGER_OK) {
@@ -170,7 +258,7 @@ int32_t SandboxManagerProxy::UnPersistPolicy(const std::vector<PolicyInfo> &poli
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -190,19 +278,10 @@ int32_t SandboxManagerProxy::PersistPolicyByTokenId(
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    
     MessageParcel reply;
     int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::PERSIST_PERMISSION_BY_TOKENID, data, reply);
     if (requestRet != SANDBOX_MANAGER_OK) {
@@ -216,7 +295,7 @@ int32_t SandboxManagerProxy::PersistPolicyByTokenId(
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -235,19 +314,11 @@ int32_t SandboxManagerProxy::UnPersistPolicyByTokenId(
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Write tokenId fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
 
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    
     MessageParcel reply;
     int32_t requestRet = SendRequest(SandboxManagerInterfaceCode::UNPERSIST_PERMISSION_BY_TOKENID, data, reply);
     if (requestRet != SANDBOX_MANAGER_OK) {
@@ -261,7 +332,7 @@ int32_t SandboxManagerProxy::UnPersistPolicyByTokenId(
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -284,17 +355,8 @@ static bool WriteSetPolicyParcel(MessageParcel &data, uint32_t tokenId, const st
         return false;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+    if (!WritePolicyParcel(data, policy)) {
+        return false;
     }
 
     if (!data.WriteUint64(policyFlag)) {
@@ -304,58 +366,6 @@ static bool WriteSetPolicyParcel(MessageParcel &data, uint32_t tokenId, const st
     return true;
 }
 
-/**
- * Unmarshals a vector of uint32_t from a stringstream.
- * @param inputStream The stringstream from which to read the data.
- * @param result The vector that will hold the unmarshaled data.
- * @return Returns a status code indicating whether the operation is successful.
- */
-static int UnMarshalResult(std::stringstream &inputStream, std::vector<uint32_t> &result)
-{
-    uint32_t resultNum = 0;
-    if (!inputStream.read(reinterpret_cast<char *>(&resultNum), sizeof(resultNum))) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result count from inputStream.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    for (uint32_t i = 0; i < resultNum; i++) {
-        uint32_t value = 0;
-        if (!inputStream.read(reinterpret_cast<char *>(&value), sizeof(value))) {
-            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result value from inputStream.");
-            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-        }
-        result.emplace_back(value);
-    }
-    return SANDBOX_MANAGER_OK;
-}
-
-/**
- * Unmarshals a vector of bool values from a stringstream.
- * The stringstream is expected to contain binary data where '1' represents true and '0' represents false.
- * @param inputStream The stringstream from which to read the data.
- * @param result The vector that will hold the unmarshaled data.
- * @return Returns a status code indicating whether the operation is successful.
- */
-static int UnMarshalResult(std::stringstream &inputStream, std::vector<bool> &result)
-{
-    uint32_t resultNum = 0;
-    if (!inputStream.read(reinterpret_cast<char *>(&resultNum), sizeof(resultNum))) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result count from inputStream.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    for (uint32_t i = 0; i < resultNum; i++) {
-        char value = 0;
-        if (!inputStream.read(&value, sizeof(value))) {
-            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to read result value from inputStream.");
-            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-        }
-        bool bitValue = value == '1' ? true : false;
-        result.emplace_back(bitValue);
-    }
-    return SANDBOX_MANAGER_OK;
-}
-
 int32_t SandboxManagerProxy::SetPolicy(uint32_t tokenId, const std::vector<PolicyInfo> &policy,
                                        uint64_t policyFlag, std::vector<uint32_t> &result, uint64_t timestamp)
 {
@@ -379,20 +389,10 @@ int32_t SandboxManagerProxy::SetPolicy(uint32_t tokenId, const std::vector<Polic
     if (remoteRet != SANDBOX_MANAGER_OK) {
         return remoteRet;
     }
-    uint32_t rawStringLength = reply.ReadUint32();
-    const void *buffer = reply.ReadRawData(rawStringLength);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
+    if (!ReadResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    std::stringstream replyRawStream;
-    replyRawStream.write(reinterpret_cast<const char *>(buffer), rawStringLength);
-    int32_t unMarshlResultRet = UnMarshalResult(replyRawStream, result);
-    if (unMarshlResultRet != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "UnMarshalResult data failed");
-        return unMarshlResultRet;
-    }
-    return remoteRet;
+    return SANDBOX_MANAGER_OK;
 }
 
 int32_t SandboxManagerProxy::SetPolicyAsync(uint32_t tokenId, const std::vector<PolicyInfo> &policy,
@@ -474,16 +474,7 @@ int32_t SandboxManagerProxy::CheckPolicy(uint32_t tokenId, const std::vector<Pol
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -502,20 +493,10 @@ int32_t SandboxManagerProxy::CheckPolicy(uint32_t tokenId, const std::vector<Pol
     if (remoteRet != SANDBOX_MANAGER_OK) {
         return remoteRet;
     }
-    uint32_t rawStringLength = reply.ReadUint32();
-    const void *buffer = reply.ReadRawData(rawStringLength);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
+    if (!ReadResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
-    std::stringstream replyRawStream;
-    replyRawStream.write(reinterpret_cast<const char *>(buffer), rawStringLength);
-    int32_t unMarshlResultRet = UnMarshalResult(replyRawStream, result);
-    if (unMarshlResultRet != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "UnMarshalResult data failed");
-        return unMarshlResultRet;
-    }
-    return remoteRet;
+    return SANDBOX_MANAGER_OK;
 }
 
 int32_t SandboxManagerProxy::StartAccessingPolicy(const std::vector<PolicyInfo> &policy, std::vector<uint32_t> &result,
@@ -542,16 +523,7 @@ int32_t SandboxManagerProxy::StartAccessingPolicy(const std::vector<PolicyInfo>
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     
@@ -568,7 +540,7 @@ int32_t SandboxManagerProxy::StartAccessingPolicy(const std::vector<PolicyInfo>
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -583,16 +555,7 @@ int32_t SandboxManagerProxy::StopAccessingPolicy(const std::vector<PolicyInfo> &
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -609,7 +572,7 @@ int32_t SandboxManagerProxy::StopAccessingPolicy(const std::vector<PolicyInfo> &
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadUInt32Vector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
@@ -629,16 +592,7 @@ int32_t SandboxManagerProxy::CheckPersistPolicy(uint32_t tokenId, const std::vec
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     
-    std::stringstream ss;
-    MarshalPolicy(ss, policy);
-
-    if (!data.WriteUint32(ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write policy len failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    if (!data.WriteRawData(reinterpret_cast<const void *>(ss.str().data()), ss.str().length())) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WritePolicyParcel(data, policy)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -655,7 +609,7 @@ int32_t SandboxManagerProxy::CheckPersistPolicy(uint32_t tokenId, const std::vec
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    if (remoteRet == SANDBOX_MANAGER_OK && !reply.ReadBoolVector(&result)) {
+    if (remoteRet == SANDBOX_MANAGER_OK && !ReadResultParcel(reply, result)) {
         SANDBOXMANAGER_LOG_ERROR(LABEL, "Read result fail");
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
diff --git a/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp b/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp
index fb52e5559f5173a5610a8061133a027d4f0d70c2..5a3e471500e831b8142e68108d215dfbb1a3555c 100644
--- a/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp
+++ b/frameworks/inner_api/sandbox_manager/test/unittest/src/sandbox_manager_kit_test.cpp
@@ -835,6 +835,346 @@ HWTEST_F(SandboxManagerKitTest, PersistPolicy016, TestSize.Level1)
 }
 #endif
 
+#ifdef DEC_ENABLED
+/**
+ * @tc.name: MassiveIPCTest001
+ * @tc.desc: IPC with massive policyinfos.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SandboxManagerKitTest, MassiveIPCTest001, TestSize.Level1)
+{
+    std::vector<PolicyInfo> policy;
+    uint64_t policySize = 90000;
+    uint64_t policyFlag = 1;
+
+    for (uint64_t i = 0; i < policySize; i++) {
+        PolicyInfo info;
+        info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE;
+        char path[1024];
+        sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persistbytoken/%d", i);
+        info.path.assign(path);
+        policy.emplace_back(info);
+    }
+
+    std::vector<uint32_t> ret;
+    const uint32_t tokenId = 654321; // 123456 is a mocked tokenid.
+    auto start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(tokenId, policy, policyFlag, ret));
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> duration = end - start;
+    std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl;
+
+    ASSERT_EQ(policySize, ret.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, ret[i]);
+    }
+    std::vector<bool> result;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(tokenId, policy, result));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl;
+
+    ASSERT_EQ(policySize, result.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(result[i]);
+    }
+    std::vector<uint32_t> policyResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(tokenId, policy, policyResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, policyResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, policyResult[i]);
+    }
+
+    std::vector<bool> checkResult1;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(tokenId, policy, checkResult1));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, checkResult1.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(checkResult1[i]);
+    }
+
+    std::vector<uint32_t> unPersistResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(tokenId, policy, unPersistResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, unPersistResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]);
+    }
+
+    std::vector<bool> checkResult2;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(tokenId, policy, checkResult2));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, checkResult2.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_FALSE(checkResult2[i]);
+    }
+}
+#endif
+
+#ifdef DEC_ENABLED
+/**
+ * @tc.name: MassiveIPCTest002
+ * @tc.desc: IPC with massive policyinfos.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SandboxManagerKitTest, MassiveIPCTest002, TestSize.Level1)
+{
+    std::vector<PolicyInfo> policy;
+    uint64_t policySize = 90000;
+    uint64_t policyFlag = 1;
+
+    for (uint64_t i = 0; i < policySize; i++) {
+        PolicyInfo info;
+        info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE;
+        char path[1024];
+        sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/persist/%d", i);
+        info.path.assign(path);
+        policy.emplace_back(info);
+    }
+
+    std::vector<uint32_t> ret;
+    auto start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(g_mockToken, policy, policyFlag, ret));
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> duration = end - start;
+    std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, ret.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, ret[i]);
+    }
+
+    std::vector<bool> result;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(g_mockToken, policy, result));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl;
+
+    ASSERT_EQ(policySize, result.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(result[i]);
+    }
+
+    std::vector<uint32_t> policyResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(policy, policyResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, policyResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, policyResult[i]);
+    }
+
+    std::vector<bool> checkResult1;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(g_mockToken, policy, checkResult1));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, checkResult1.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(checkResult1[i]);
+    }
+
+    std::vector<uint32_t> unPersistResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(policy, unPersistResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, unPersistResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]);
+    }
+
+    std::vector<bool> checkResult2;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPersistPolicy(g_mockToken, policy, checkResult2));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, unPersistResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_FALSE(checkResult2[i]);
+    }
+}
+#endif
+
+#ifdef DEC_ENABLED
+/**
+ * @tc.name: MassiveIPCTest003
+ * @tc.desc: IPC with massive policyinfos.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SandboxManagerKitTest, MassiveIPCTest003, TestSize.Level1)
+{
+    SetDeny("/data/temp");
+    std::vector<PolicyInfo> policy;
+    uint64_t policySize = 90000;
+    uint64_t policyFlag = 1;
+
+    for (uint64_t i = 0; i < policySize; i++) {
+        PolicyInfo info;
+        info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE;
+        char path[1024];
+        sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/async_accessing/%d", i);
+        info.path.assign(path);
+        policy.emplace_back(info);
+    }
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicyAsync(g_mockToken, policy, policyFlag));
+    sleep(5);
+    std::vector<bool> result;
+    auto start  = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(g_mockToken, policy, result));
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> duration = end - start;
+    std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, result.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(result[i]);
+    }
+
+    std::vector<uint32_t> retType;
+    start  = std::chrono::high_resolution_clock::now();
+    EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(g_mockToken, policy, retType));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, retType.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, retType[i]);
+    }
+
+    start  = std::chrono::high_resolution_clock::now();
+    EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnSetPolicyAsync(g_mockToken, policy[0]));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "UnSetPolicyAsync cost " << duration.count() << "s" << std::endl;
+    sleep(1);
+    start  = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(g_mockToken, policy, result));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, result.size());
+    EXPECT_FALSE(result[0]);
+    for (uint64_t i = 1; i < policySize; i++) {
+        EXPECT_TRUE(result[i]);
+    }
+
+    start  = std::chrono::high_resolution_clock::now();
+    EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::StartAccessingPolicy(policy, retType));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "StartAccessingPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, retType.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, retType[i]);
+    }
+
+    start  = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::CheckPolicy(g_mockToken, policy, result));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "CheckPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, result.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_TRUE(result[i]);
+    }
+
+    start  = std::chrono::high_resolution_clock::now();
+    EXPECT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnSetPolicyAsync(g_mockToken, policy[0]));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "UnSetPolicyAsync cost " << duration.count() << "s" << std::endl;
+}
+#endif
+
+#ifdef DEC_ENABLED
+/**
+ * @tc.name: MassiveIPCTest004
+ * @tc.desc: IPC with massive policyinfos.
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(SandboxManagerKitTest, MassiveIPCTest004, TestSize.Level1)
+{
+    std::vector<PolicyInfo> policy;
+    uint64_t policySize = 90000;
+    uint64_t policyFlag = 1;
+
+    for (uint64_t i = 0; i < policySize; i++) {
+        PolicyInfo info;
+        info.mode = OperateMode::READ_MODE | OperateMode::WRITE_MODE;
+        char path[1024];
+        sprintf_s(path, sizeof(path), "/data/temp/a/b/c/d/e/f/g/h/i/j/stop_access/%d", i);
+        info.path.assign(path);
+        policy.emplace_back(info);
+    }
+    std::vector<uint32_t> result;
+    auto start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::SetPolicy(g_mockToken, policy, policyFlag, result));
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double> duration = end - start;
+    std::cout << "SetPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, result.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, result[i]);
+    }
+
+    std::vector<uint32_t> persistResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::PersistPolicy(policy, persistResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "PersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, persistResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, persistResult[i]);
+    }
+
+    std::vector<uint32_t> startResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::StopAccessingPolicy(policy, startResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "StopAccessingPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, startResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, startResult[i]);
+    }
+
+    std::vector<uint32_t> unPersistResult;
+    start = std::chrono::high_resolution_clock::now();
+    ASSERT_EQ(SANDBOX_MANAGER_OK, SandboxManagerKit::UnPersistPolicy(policy, unPersistResult));
+    end = std::chrono::high_resolution_clock::now();
+    duration = end - start;
+    std::cout << "UnPersistPolicy cost " << duration.count() << "s" << std::endl;
+    ASSERT_EQ(policySize, unPersistResult.size());
+    for (uint64_t i = 0; i < policySize; i++) {
+        EXPECT_EQ(OPERATE_SUCCESSFULLY, unPersistResult[i]);
+    }
+}
+#endif
+
 #ifdef DEC_ENABLED
 /**
  * @tc.name: CheckPolicyTest001
diff --git a/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp b/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
index 8e0a2e0b812382add303b5ad3d81390d9492106c..42b7dabf1007666c5ca2fb1dc0ce5c169868a6d6 100644
--- a/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
+++ b/services/sandbox_manager/main/cpp/src/service/sandbox_manager_stub.cpp
@@ -66,6 +66,110 @@ static int UnMarshalPolicy(std::stringstream &ss, std::vector<PolicyInfo> &polic
     return SANDBOX_MANAGER_OK;
 }
 
+/**
+ * Serializes a `std::vector<uint32_t>` into binary data and writes it to an output stream.
+ * @param outputStream The output stream to write the serialized data to.
+ * @param result The `std::vector<uint32_t>` to serialize.
+ * @return Returns a status code indicating whether the operation is successful.
+ */
+static int MarshalResult(std::stringstream &outputStream, const std::vector<uint32_t> &result)
+{
+    uint32_t resultNum = result.size();
+    if (!outputStream.write(reinterpret_cast<const char *>(&resultNum), sizeof(resultNum))) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result count to outputStream.");
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+    }
+    for (uint32_t i = 0; i < resultNum; i++) {
+        if (!outputStream.write(reinterpret_cast<const char *>(&result[i]), sizeof(uint32_t))) {
+            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result value to outputStream.");
+            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+        }
+    }
+    return SANDBOX_MANAGER_OK;
+}
+
+/**
+ * Serializes a `std::vector<bool>` into binary data and writes it to an output stream.
+ * @param outputStream The output stream to write the serialized data to.
+ * @param result The `std::vector<bool>` to serialize.
+ * @return Returns a status code indicating whether the operation is successful.
+ */
+static int MarshalResult(std::stringstream &outputStream, const std::vector<bool> &result)
+{
+    uint32_t resultNum = result.size();
+    if (!outputStream.write(reinterpret_cast<const char *>(&resultNum), sizeof(resultNum))) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result count to outputStream.");
+        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+    }
+    for (uint32_t i = 0; i < resultNum; i++) {
+        // Convert the boolean value to a character ('1' for true, '0' for false)
+        char boolChar = result[i] ? '1' : '0';
+        if (!outputStream.write(&boolChar, sizeof(char))) {
+            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result value to outputStream.");
+            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
+        }
+    }
+    return SANDBOX_MANAGER_OK;
+}
+
+static bool ReadPolicyParcel(MessageParcel &data, std::vector<PolicyInfo> &policyVec)
+{
+    auto vecDataSize = data.ReadUint32();
+    const void *buffer = data.ReadRawData(vecDataSize);
+    if (buffer == nullptr) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
+        return false;
+    }
+
+    std::stringstream ss;
+    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
+    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+        return false;
+    }
+    return true;
+}
+
+static bool WriteResultParcel(MessageParcel &reply, const std::vector<uint32_t> &result)
+{
+    std::stringstream replyRawString;
+    int32_t marshlResultRet = MarshalResult(replyRawString, result);
+    if (marshlResultRet != SANDBOX_MANAGER_OK) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "MarshalResult failed.");
+        return false;
+    }
+    size_t rawStringLength = replyRawString.str().length();
+    if (!reply.WriteUint32(rawStringLength)) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write rawStringLength failed.");
+        return false;
+    }
+    if (!reply.WriteRawData(reinterpret_cast<const void *>(replyRawString.str().data()), rawStringLength)) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+        return false;
+    }
+    return true;
+}
+
+static bool WriteResultParcel(MessageParcel &reply, const std::vector<bool> &result)
+{
+    std::stringstream replyRawString;
+    int32_t marshlResultRet = MarshalResult(replyRawString, result);
+    if (marshlResultRet != SANDBOX_MANAGER_OK) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "MarshalResult failed.");
+        return false;
+    }
+    size_t rawStringLength = replyRawString.str().length();
+    if (!reply.WriteUint32(rawStringLength)) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write rawStringLength failed.");
+        return false;
+    }
+    if (!reply.WriteRawData(reinterpret_cast<const void *>(replyRawString.str().data()), rawStringLength)) {
+        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+        return false;
+    }
+    return true;
+}
+
 int32_t SandboxManagerStub::OnRemoteRequest(
     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
 {
@@ -123,17 +227,7 @@ int32_t SandboxManagerStub::PersistPolicyInner(MessageParcel &data, MessageParce
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -147,8 +241,7 @@ int32_t SandboxManagerStub::PersistPolicyInner(MessageParcel &data, MessageParce
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Reply sandbox manager vector parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -162,17 +255,7 @@ int32_t SandboxManagerStub::UnPersistPolicyInner(MessageParcel &data, MessagePar
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -187,8 +270,7 @@ int32_t SandboxManagerStub::UnPersistPolicyInner(MessageParcel &data, MessagePar
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Reply sandbox manager vector parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -206,17 +288,7 @@ int32_t SandboxManagerStub::PersistPolicyByTokenIdInner(MessageParcel &data, Mes
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -230,8 +302,7 @@ int32_t SandboxManagerStub::PersistPolicyByTokenIdInner(MessageParcel &data, Mes
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Reply sandbox manager vector parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -249,17 +320,7 @@ int32_t SandboxManagerStub::UnPersistPolicyByTokenIdInner(MessageParcel &data, M
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -274,8 +335,7 @@ int32_t SandboxManagerStub::UnPersistPolicyByTokenIdInner(MessageParcel &data, M
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Reply sandbox manager vector parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -299,17 +359,7 @@ static int32_t ReadSetPolicyParcel(MessageParcel &data, uint32_t &tokenId,
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -321,52 +371,6 @@ static int32_t ReadSetPolicyParcel(MessageParcel &data, uint32_t &tokenId,
     return SANDBOX_MANAGER_OK;
 }
 
-/**
- * Serializes a `std::vector<uint32_t>` into binary data and writes it to an output stream.
- * @param outputStream The output stream to write the serialized data to.
- * @param result The `std::vector<uint32_t>` to serialize.
- * @return Returns a status code indicating whether the operation is successful.
- */
-static int MarshalResult(std::stringstream &outputStream, const std::vector<uint32_t> &result)
-{
-    uint32_t resultNum = result.size();
-    if (!outputStream.write(reinterpret_cast<const char *>(&resultNum), sizeof(resultNum))) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result count to outputStream.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    for (uint32_t i = 0; i < resultNum; i++) {
-        if (!outputStream.write(reinterpret_cast<const char *>(&result[i]), sizeof(uint32_t))) {
-            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result value to outputStream.");
-            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-        }
-    }
-    return SANDBOX_MANAGER_OK;
-}
-
-/**
- * Serializes a `std::vector<bool>` into binary data and writes it to an output stream.
- * @param outputStream The output stream to write the serialized data to.
- * @param result The `std::vector<bool>` to serialize.
- * @return Returns a status code indicating whether the operation is successful.
- */
-static int MarshalResult(std::stringstream &outputStream, const std::vector<bool> &result)
-{
-    uint32_t resultNum = result.size();
-    if (!outputStream.write(reinterpret_cast<const char *>(&resultNum), sizeof(resultNum))) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result count to outputStream.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    for (uint32_t i = 0; i < resultNum; i++) {
-        // Convert the boolean value to a character ('1' for true, '0' for false)
-        char boolChar = result[i] ? '1' : '0';
-        if (!outputStream.write(&boolChar, sizeof(char))) {
-            SANDBOXMANAGER_LOG_ERROR(LABEL, "Failed to write result value to outputStream.");
-            return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-        }
-    }
-    return SANDBOX_MANAGER_OK;
-}
-
 int32_t SandboxManagerStub::SetPolicyInner(MessageParcel &data, MessageParcel &reply)
 {
     uint32_t tokenId;
@@ -389,19 +393,7 @@ int32_t SandboxManagerStub::SetPolicyInner(MessageParcel &data, MessageParcel &r
         return ret;
     }
 
-    std::stringstream replyRawString;
-    int32_t marshlResultRet = MarshalResult(replyRawString, result);
-    if (marshlResultRet != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "MarshalResult failed.");
-        return marshlResultRet;
-    }
-    size_t rawStringLength = replyRawString.str().length();
-    if (!reply.WriteUint32(rawStringLength)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write rawStringLength failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    if (!reply.WriteRawData(reinterpret_cast<const void *>(replyRawString.str().data()), rawStringLength)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -487,17 +479,7 @@ int32_t SandboxManagerStub::CheckPolicyInner(MessageParcel &data, MessageParcel
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     std::vector<bool> result;
@@ -510,19 +492,7 @@ int32_t SandboxManagerStub::CheckPolicyInner(MessageParcel &data, MessageParcel
         return ret;
     }
 
-    std::stringstream replyRawString;
-    int32_t marshlResultRet = MarshalResult(replyRawString, result);
-    if (marshlResultRet != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "MarshalResult failed.");
-        return marshlResultRet;
-    }
-    size_t rawStringLength = replyRawString.str().length();
-    if (!reply.WriteUint32(rawStringLength)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write rawStringLength failed.");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-    if (!reply.WriteRawData(reinterpret_cast<const void *>(replyRawString.str().data()), rawStringLength)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write raw data failed.");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -554,17 +524,7 @@ int32_t SandboxManagerStub::StartAccessingPolicyInner(MessageParcel &data, Messa
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -579,8 +539,7 @@ int32_t SandboxManagerStub::StartAccessingPolicyInner(MessageParcel &data, Messa
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -594,17 +553,7 @@ int32_t SandboxManagerStub::StopAccessingPolicyInner(MessageParcel &data, Messag
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -619,8 +568,7 @@ int32_t SandboxManagerStub::StopAccessingPolicyInner(MessageParcel &data, Messag
         return ret;
     }
 
-    if (!reply.WriteUInt32Vector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;
@@ -640,17 +588,7 @@ int32_t SandboxManagerStub::CheckPersistPolicyInner(MessageParcel &data, Message
     }
 
     std::vector<PolicyInfo> policyVec;
-    auto vecDataSize = data.ReadUint32();
-    const void *buffer = data.ReadRawData(vecDataSize);
-    if (buffer == nullptr) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Read raw data failed");
-        return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
-    }
-
-    std::stringstream ss;
-    ss.write(reinterpret_cast<const char *>(buffer), vecDataSize);
-    if (UnMarshalPolicy(ss, policyVec) != SANDBOX_MANAGER_OK) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Unmarshal failed");
+    if (!ReadPolicyParcel(data, policyVec)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
 
@@ -664,8 +602,7 @@ int32_t SandboxManagerStub::CheckPersistPolicyInner(MessageParcel &data, Message
         return ret;
     }
 
-    if (!reply.WriteBoolVector(result)) {
-        SANDBOXMANAGER_LOG_ERROR(LABEL, "Write sandbox manager reply parcel fail");
+    if (!WriteResultParcel(reply, result)) {
         return SANDBOX_MANAGER_SERVICE_PARCEL_ERR;
     }
     return SANDBOX_MANAGER_OK;