diff --git a/frameworks/js/napi/privacy/src/napi_context_common.cpp b/frameworks/js/napi/privacy/src/napi_context_common.cpp
index 116ae46481489c69631d3808eca7975c138f1c98..66e29103d9a8bf1274bfcfa043c75b008459aedf 100644
--- a/frameworks/js/napi/privacy/src/napi_context_common.cpp
+++ b/frameworks/js/napi/privacy/src/napi_context_common.cpp
@@ -197,6 +197,9 @@ void NotifyChangeResponse(const PermActiveStatusWorker* permActiveStatusData)
 bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result)
 {
     napi_value element;
+    NAPI_CALL_BASE(env, napi_create_uint32(env, result.callingTokenID, &element), false);
+    NAPI_CALL_BASE(env, napi_set_named_property(env, value, "callingTokenId", element), false);
+    element = nullptr;
     NAPI_CALL_BASE(env, napi_create_uint32(env, result.tokenID, &element), false);
     NAPI_CALL_BASE(env, napi_set_named_property(env, value, "tokenId", element), false);
     element = nullptr;
@@ -210,6 +213,9 @@ bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveCha
     element = nullptr;
     NAPI_CALL_BASE(env, napi_create_int32(env, result.type, &element), false);
     NAPI_CALL_BASE(env, napi_set_named_property(env, value, "activeStatus", element), false);
+    element = nullptr;
+    NAPI_CALL_BASE(env, napi_create_int32(env, result.usedType, &element), false);
+    NAPI_CALL_BASE(env, napi_set_named_property(env, value, "usedType", element), false);
     return true;
 }
 }  // namespace AccessToken
diff --git a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
index d8f3f53acda55cc9f376be7be3d473d29ec5c875..d7b8486261fde4e6103c751d1c079c9bf3cd8b48 100644
--- a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
+++ b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
@@ -34,7 +34,8 @@ static constexpr int32_t ADD_PERMISSION_RECORD_MAX_PARAMS = 5;
 static constexpr int32_t ADD_PERMISSION_RECORD_MIN_PARAMS = 4;
 static constexpr int32_t GET_PERMISSION_RECORD_MAX_PARAMS = 2;
 static constexpr int32_t ON_OFF_MAX_PARAMS = 3;
-static constexpr int32_t START_STOP_MAX_PARAMS = 3;
+static constexpr int32_t START_STOP_MAX_PARAMS = 4;
+static constexpr int32_t START_STOP_MIN_PARAMS = 2;
 static constexpr int32_t GET_PERMISSION_USED_TYPE_MAX_PARAMS = 2;
 static constexpr int32_t GET_PERMISSION_USED_TYPE_ONE_PARAMS = 1;
 static constexpr int32_t FIRST_PARAM = 0;
@@ -161,6 +162,9 @@ static bool ParseAddPermissionFifthParam(const napi_env env, const napi_value& v
             ParamResolveErrorThrow(env, "callback", "AsyncCallback");
             return false;
         }
+    } else {
+        ParamResolveErrorThrow(env, "fifth param", "options or AsyncCallback");
+        return false;
     }
 
     return true;
@@ -216,6 +220,34 @@ static bool ParseAddPermissionRecord(
     return true;
 }
 
+static bool ParseStartAndStopThirdParam(const napi_env env, const napi_value& value,
+    RecordManagerAsyncContext& asyncContext)
+{
+    napi_valuetype typeValue = napi_undefined;
+    if (napi_typeof(env, value, &typeValue) != napi_ok) {
+        return false;
+    }
+
+    if (typeValue == napi_number) {
+        // pid
+        if (!ParseInt32(env, value, asyncContext.pid)) {
+            ParamResolveErrorThrow(env, "pid", "number");
+            return false;
+        }
+    } else if (typeValue == napi_function) {
+        // callback
+        if (!IsUndefinedOrNull(env, value) && !ParseCallback(env, value, asyncContext.callbackRef)) {
+            ParamResolveErrorThrow(env, "callback", "AsyncCallback");
+            return false;
+        }
+    } else {
+        ParamResolveErrorThrow(env, "third param", "pid or AsyncCallback");
+        return false;
+    }
+
+    return true;
+}
+
 static bool ParseStartAndStopUsingPermission(
     const napi_env env, const napi_callback_info info, RecordManagerAsyncContext& asyncContext)
 {
@@ -225,30 +257,45 @@ static bool ParseStartAndStopUsingPermission(
     void* data = nullptr;
 
     NAPI_CALL_BASE(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data), false);
-    if (argc < START_STOP_MAX_PARAMS - 1) {
+    if (argc < START_STOP_MIN_PARAMS) {
         NAPI_CALL_BASE(env,
             napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_ILLEGAL, "Parameter is missing.")), false);
         return false;
     }
 
     asyncContext.env = env;
-    // 0: the first parameter of argv
-    if (!ParseUint32(env, argv[0], asyncContext.tokenId)) {
+    // 0: the first parameter of argv is tokenId
+    if (!ParseUint32(env, argv[FIRST_PARAM], asyncContext.tokenId)) {
         ParamResolveErrorThrow(env, "tokenId", "number");
         return false;
     }
 
-    // 1: the second parameter of argv
-    if (!ParseString(env, argv[1], asyncContext.permissionName)) {
+    // 1: the second parameter of argv is permissionName
+    if (!ParseString(env, argv[SECOND_PARAM], asyncContext.permissionName)) {
         ParamResolveErrorThrow(env, "permissionName", "string");
         return false;
     }
-    if (argc == START_STOP_MAX_PARAMS) {
-        // 2: the third parameter of argv
-        if (!IsUndefinedOrNull(env, argv[2]) && !ParseCallback(env, argv[2], asyncContext.callbackRef)) {
-            ParamResolveErrorThrow(env, "callback", "AsyncCallback");
+
+    if (argc == START_STOP_MAX_PARAMS - 1) {
+        // 2: the third paramter of argv, may be callback or pid
+        if (!ParseStartAndStopThirdParam(env, argv[THIRD_PARAM], asyncContext)) {
             return false;
         }
+    } else if (argc == START_STOP_MAX_PARAMS) {
+        // 2: the third paramter of argv is pid
+        if (!ParseInt32(env, argv[THIRD_PARAM], asyncContext.pid)) {
+            ParamResolveErrorThrow(env, "pid", "number");
+            return false;
+        }
+
+        // 3: the fourth paramter of argv is usedType
+        uint32_t usedType = 0;
+        if (!ParseUint32(env, argv[FOURTH_PARAM], usedType)) {
+            ParamResolveErrorThrow(env, "usedType", "number");
+            return false;
+        }
+
+        asyncContext.type = static_cast<PermissionUsedType>(usedType);
     }
     return true;
 }
@@ -549,7 +596,7 @@ static void StartUsingPermissionExecute(napi_env env, void* data)
     }
 
     asyncContext->retCode = PrivacyKit::StartUsingPermission(asyncContext->tokenId,
-        asyncContext->permissionName);
+        asyncContext->permissionName, asyncContext->pid, asyncContext->type);
 }
 
 static void StartUsingPermissionComplete(napi_env env, napi_status status, void* data)
diff --git a/frameworks/privacy/include/i_privacy_manager.h b/frameworks/privacy/include/i_privacy_manager.h
index 2d4468cf98156f39bb0e83c28d2178b6f1c3929d..19cbcce78d69a7b7de6473da04de9f19a7b5e492 100644
--- a/frameworks/privacy/include/i_privacy_manager.h
+++ b/frameworks/privacy/include/i_privacy_manager.h
@@ -44,9 +44,10 @@ public:
     DECLARE_INTERFACE_DESCRIPTOR(u"ohos.security.accesstoken.IPrivacyManager");
 
     virtual int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) = 0;
-    virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) = 0;
     virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
-        const sptr<IRemoteObject>& callback) = 0;
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) = 0;
+    virtual int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
+        const sptr<IRemoteObject>& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) = 0;
     virtual int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) = 0;
     virtual int32_t RemovePermissionUsedRecords(AccessTokenID tokenID) = 0;
     virtual int32_t GetPermissionUsedRecords(
diff --git a/frameworks/privacy/src/perm_active_response_parcel.cpp b/frameworks/privacy/src/perm_active_response_parcel.cpp
index 49617f9d70b046a6d95d7f96d61725d3786744b8..a66c8ca2ba1b583b4771594775a55bafc7c5c916 100644
--- a/frameworks/privacy/src/perm_active_response_parcel.cpp
+++ b/frameworks/privacy/src/perm_active_response_parcel.cpp
@@ -21,10 +21,12 @@ namespace Security {
 namespace AccessToken {
 bool ActiveChangeResponseParcel::Marshalling(Parcel& out) const
 {
+    RETURN_IF_FALSE(out.WriteUint32(this->changeResponse.callingTokenID));
     RETURN_IF_FALSE(out.WriteUint32(this->changeResponse.tokenID));
     RETURN_IF_FALSE(out.WriteString(this->changeResponse.permissionName));
     RETURN_IF_FALSE(out.WriteString(this->changeResponse.deviceId));
     RETURN_IF_FALSE(out.WriteInt32(this->changeResponse.type));
+    RETURN_IF_FALSE(out.WriteInt32(this->changeResponse.usedType));
     return true;
 }
 
@@ -35,6 +37,8 @@ ActiveChangeResponseParcel* ActiveChangeResponseParcel::Unmarshalling(Parcel& in
         return nullptr;
     }
 
+    RELEASE_IF_FALSE(in.ReadUint32(activeChangeResponseParcel->changeResponse.callingTokenID),
+        activeChangeResponseParcel);
     RELEASE_IF_FALSE(in.ReadUint32(activeChangeResponseParcel->changeResponse.tokenID), activeChangeResponseParcel);
     RELEASE_IF_FALSE(in.ReadString(activeChangeResponseParcel->changeResponse.permissionName),
         activeChangeResponseParcel);
@@ -43,6 +47,9 @@ ActiveChangeResponseParcel* ActiveChangeResponseParcel::Unmarshalling(Parcel& in
     int32_t type;
     RELEASE_IF_FALSE(in.ReadInt32(type), activeChangeResponseParcel);
     activeChangeResponseParcel->changeResponse.type = static_cast<ActiveChangeType>(type);
+    int32_t usedType;
+    RELEASE_IF_FALSE(in.ReadInt32(usedType), activeChangeResponseParcel);
+    activeChangeResponseParcel->changeResponse.usedType = static_cast<PermissionUsedType>(usedType);
     return activeChangeResponseParcel;
 }
 } // namespace AccessToken
diff --git a/interfaces/innerkits/privacy/include/active_change_response_info.h b/interfaces/innerkits/privacy/include/active_change_response_info.h
index 44503ad2c922a5d247337864f5d692cf45f378e0..1244277b60988804e5c0c552ed5364b3e2fadf32 100644
--- a/interfaces/innerkits/privacy/include/active_change_response_info.h
+++ b/interfaces/innerkits/privacy/include/active_change_response_info.h
@@ -39,6 +39,7 @@
 #include <vector>
 
 #include "access_token.h"
+#include "permission_used_type.h"
 
 namespace OHOS {
 namespace Security {
@@ -65,6 +66,7 @@ enum LockScreenStatusChangeType {
  * @brief Permission active state change response struct
  */
 struct ActiveChangeResponse {
+    AccessTokenID callingTokenID;
     AccessTokenID tokenID;
     std::string permissionName;
     std::string deviceId;
@@ -73,6 +75,7 @@ struct ActiveChangeResponse {
      * see the definition above.
      */
     ActiveChangeType type;
+    PermissionUsedType usedType;
 };
 } // namespace AccessToken
 } // namespace Security
diff --git a/interfaces/innerkits/privacy/include/privacy_kit.h b/interfaces/innerkits/privacy/include/privacy_kit.h
index 4902688c3ffd3ea98ab976a04c95d61cb0d7f4aa..e37649e92d7a98db5117100c5585080b864ffbd8 100644
--- a/interfaces/innerkits/privacy/include/privacy_kit.h
+++ b/interfaces/innerkits/privacy/include/privacy_kit.h
@@ -81,7 +81,8 @@ public:
      * @param permissionName permission nanme
      * @return error code, see privacy_error.h
      */
-    static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid = -1);
+    static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid = -1,
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
     /**
      * @brief Input tokenID start using input permission and return by callback,
      *        only those services which has float window such as camera or
@@ -92,7 +93,8 @@ public:
      * @return error code, see privacy_error.h
      */
     static int32_t StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName,
-        const std::shared_ptr<StateCustomizedCbk>& callback, int32_t pid = -1);
+        const std::shared_ptr<StateCustomizedCbk>& callback, int32_t pid = -1,
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
     /**
      * @brief Input tokenID stop using input permission.
      * @param tokenID token id
diff --git a/interfaces/innerkits/privacy/libprivacy_sdk.map b/interfaces/innerkits/privacy/libprivacy_sdk.map
index c730121e60c946a4d440356a5693bf7ebb85eb92..f32079ed43720d23059685f52a094add39253492 100644
--- a/interfaces/innerkits/privacy/libprivacy_sdk.map
+++ b/interfaces/innerkits/privacy/libprivacy_sdk.map
@@ -18,7 +18,7 @@
       "OHOS::Security::AccessToken::PermActiveStatusCustomizedCbk::~PermActiveStatusCustomizedCbk()";
       "OHOS::Security::AccessToken::PrivacyKit::AddPermissionUsedRecord(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, int, int, bool)";
       "OHOS::Security::AccessToken::PrivacyKit::AddPermissionUsedRecord(OHOS::Security::AccessToken::AddPermParamInfo const&, bool)";
-      "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, int)";
+      "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, int, OHOS::Security::AccessToken::PermissionUsedTypeValue)";
       "OHOS::Security::AccessToken::PrivacyKit::StopUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, int)";
       "OHOS::Security::AccessToken::PrivacyKit::GetPermissionUsedRecords(OHOS::Security::AccessToken::PermissionUsedRequest const&, OHOS::Security::AccessToken::PermissionUsedResult&)";
       "OHOS::Security::AccessToken::PermActiveStatusCustomizedCbk::GetPermList(std::__h::vector<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>>, std::__h::allocator<std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>>>>&) const";
@@ -26,7 +26,7 @@
       "OHOS::Security::AccessToken::PrivacyKit::UnRegisterPermActiveStatusCallback(std::__h::shared_ptr<OHOS::Security::AccessToken::PermActiveStatusCustomizedCbk> const&)";
       "OHOS::Security::AccessToken::PrivacyKit::RemovePermissionUsedRecords(unsigned int)";
       "OHOS::Security::AccessToken::StateCustomizedCbk::StateCustomizedCbk()";
-      "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, std::__h::shared_ptr<OHOS::Security::AccessToken::StateCustomizedCbk> const&, int)";
+      "OHOS::Security::AccessToken::PrivacyKit::StartUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&, std::__h::shared_ptr<OHOS::Security::AccessToken::StateCustomizedCbk> const&, int, OHOS::Security::AccessToken::PermissionUsedTypeValue)";
       "OHOS::Security::AccessToken::PrivacyKit::GetPermissionUsedRecords(OHOS::Security::AccessToken::PermissionUsedRequest const&, OHOS::sptr<OHOS::Security::AccessToken::OnPermissionUsedRecordCallback> const&)";
       "OHOS::Security::AccessToken::PrivacyKit::IsAllowedUsingPermission(unsigned int, std::__h::basic_string<char, std::__h::char_traits<char>, std::__h::allocator<char>> const&)";
       "OHOS::Security::AccessToken::PrivacyKit::RegisterSecCompEnhance(OHOS::Security::AccessToken::SecCompEnhanceData const&)";
diff --git a/interfaces/innerkits/privacy/src/privacy_kit.cpp b/interfaces/innerkits/privacy/src/privacy_kit.cpp
index 572d1eb141ce20bee951bf60375d0e0b67c8b826..5618ac7f037f57438a96ba3a2b4755a2d58610c4 100644
--- a/interfaces/innerkits/privacy/src/privacy_kit.cpp
+++ b/interfaces/innerkits/privacy/src/privacy_kit.cpp
@@ -96,27 +96,32 @@ int32_t PrivacyKit::AddPermissionUsedRecord(const AddPermParamInfo& info, bool a
     return RET_SUCCESS;
 }
 
-int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid)
+int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid,
+    PermissionUsedType type)
 {
-    if (!DataValidator::IsTokenIDValid(tokenID) || !DataValidator::IsPermissionNameValid(permissionName)) {
+    if ((!DataValidator::IsTokenIDValid(tokenID)) ||
+        (!DataValidator::IsPermissionNameValid(permissionName)) ||
+        (!DataValidator::IsPermissionUsedTypeValid(type))) {
         return PrivacyError::ERR_PARAM_INVALID;
     }
     if (!DataValidator::IsHapCaller(tokenID)) {
         return PrivacyError::ERR_PARAM_INVALID;
     }
-    return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName);
+    return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, type);
 }
 
 int32_t PrivacyKit::StartUsingPermission(AccessTokenID tokenID, const std::string& permissionName,
-    const std::shared_ptr<StateCustomizedCbk>& callback, int32_t pid)
+    const std::shared_ptr<StateCustomizedCbk>& callback, int32_t pid, PermissionUsedType type)
 {
-    if (!DataValidator::IsTokenIDValid(tokenID) || !DataValidator::IsPermissionNameValid(permissionName)) {
+    if ((!DataValidator::IsTokenIDValid(tokenID)) ||
+        (!DataValidator::IsPermissionNameValid(permissionName)) ||
+        (!DataValidator::IsPermissionUsedTypeValid(type))) {
         return PrivacyError::ERR_PARAM_INVALID;
     }
     if (!DataValidator::IsHapCaller(tokenID)) {
         return PrivacyError::ERR_PARAM_INVALID;
     }
-    return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, callback);
+    return PrivacyManagerClient::GetInstance().StartUsingPermission(tokenID, pid, permissionName, callback, type);
 }
 
 int32_t PrivacyKit::StopUsingPermission(AccessTokenID tokenID, const std::string& permissionName, int32_t pid)
diff --git a/interfaces/innerkits/privacy/src/privacy_manager_client.cpp b/interfaces/innerkits/privacy/src/privacy_manager_client.cpp
index ec27452cf6ec5669ee8d8e80ee7f4de756dba515..16f423fa60c4f80ff473a693fb82cf210baa4ad2 100644
--- a/interfaces/innerkits/privacy/src/privacy_manager_client.cpp
+++ b/interfaces/innerkits/privacy/src/privacy_manager_client.cpp
@@ -71,14 +71,14 @@ int32_t PrivacyManagerClient::AddPermissionUsedRecord(const AddPermParamInfo& in
 }
 
 int32_t PrivacyManagerClient::StartUsingPermission(
-    AccessTokenID tokenID, int32_t pid, const std::string& permissionName)
+    AccessTokenID tokenID, int32_t pid, const std::string& permissionName, PermissionUsedType type)
 {
     auto proxy = GetProxy();
     if (proxy == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Proxy is null.");
         return PrivacyError::ERR_SERVICE_ABNORMAL;
     }
-    return proxy->StartUsingPermission(tokenID, pid, permissionName);
+    return proxy->StartUsingPermission(tokenID, pid, permissionName, type);
 }
 
 int32_t PrivacyManagerClient::CreateStateChangeCbk(uint64_t id,
@@ -99,9 +99,8 @@ int32_t PrivacyManagerClient::CreateStateChangeCbk(uint64_t id,
     return RET_SUCCESS;
 }
 
-int32_t PrivacyManagerClient::StartUsingPermission(
-    AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
-    const std::shared_ptr<StateCustomizedCbk>& callback)
+int32_t PrivacyManagerClient::StartUsingPermission(AccessTokenID tokenId, int32_t pid,
+    const std::string& permissionName, const std::shared_ptr<StateCustomizedCbk>& callback, PermissionUsedType type)
 {
     if (callback == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Callback is nullptr.");
@@ -121,7 +120,7 @@ int32_t PrivacyManagerClient::StartUsingPermission(
         return PrivacyError::ERR_SERVICE_ABNORMAL;
     }
 
-    result = proxy->StartUsingPermission(tokenId, pid, permissionName, callbackWrap->AsObject());
+    result = proxy->StartUsingPermission(tokenId, pid, permissionName, callbackWrap->AsObject(), type);
     if (result == RET_SUCCESS) {
         std::lock_guard<std::mutex> lock(stateCbkMutex_);
         stateChangeCallbackMap_[id] = callbackWrap;
diff --git a/interfaces/innerkits/privacy/src/privacy_manager_client.h b/interfaces/innerkits/privacy/src/privacy_manager_client.h
index 94a3614031044ccf92df5e12de31cf461388b4f2..76a4c22b821285f18f0b5c84e299a2a70c4e687c 100644
--- a/interfaces/innerkits/privacy/src/privacy_manager_client.h
+++ b/interfaces/innerkits/privacy/src/privacy_manager_client.h
@@ -38,11 +38,12 @@ public:
     virtual ~PrivacyManagerClient();
 
     int32_t AddPermissionUsedRecord(const AddPermParamInfo& info, bool asyncMode = false);
-    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName);
+    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
+        PermissionUsedType type);
     int32_t CreateStateChangeCbk(uint64_t id, const std::shared_ptr<StateCustomizedCbk>& callback,
         sptr<StateChangeCallback>& callbackWrap);
     int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
-        const std::shared_ptr<StateCustomizedCbk>& callback);
+        const std::shared_ptr<StateCustomizedCbk>& callback, PermissionUsedType type);
     int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName);
     int32_t RemovePermissionUsedRecords(AccessTokenID tokenID);
     int32_t GetPermissionUsedRecords(const PermissionUsedRequest& request, PermissionUsedResult& result);
diff --git a/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp b/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp
index 5495eed05013f0ff843453d34b869aa214450649..bbef0ea332ce97a7c3a411edffa2292f82b580c3 100644
--- a/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp
+++ b/interfaces/innerkits/privacy/src/privacy_manager_proxy.cpp
@@ -59,7 +59,7 @@ int32_t PrivacyManagerProxy::AddPermissionUsedRecord(const AddPermParamInfoParce
 }
 
 int32_t PrivacyManagerProxy::StartUsingPermission(
-    AccessTokenID tokenID, int32_t pid, const std::string& permissionName)
+    AccessTokenID tokenID, int32_t pid, const std::string& permissionName, PermissionUsedType type)
 {
     MessageParcel startData;
     startData.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
@@ -75,6 +75,11 @@ int32_t PrivacyManagerProxy::StartUsingPermission(
         ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write permissionName");
         return PrivacyError::ERR_WRITE_PARCEL_FAILED;
     }
+    uint32_t usedType = static_cast<uint32_t>(type);
+    if (!startData.WriteUint32(usedType)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write type");
+        return PrivacyError::ERR_WRITE_PARCEL_FAILED;
+    }
 
     MessageParcel reply;
     if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION, startData, reply)) {
@@ -88,7 +93,7 @@ int32_t PrivacyManagerProxy::StartUsingPermission(
 
 int32_t PrivacyManagerProxy::StartUsingPermission(
     AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
-    const sptr<IRemoteObject>& callback)
+    const sptr<IRemoteObject>& callback, PermissionUsedType type)
 {
     MessageParcel data;
     data.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
@@ -108,6 +113,11 @@ int32_t PrivacyManagerProxy::StartUsingPermission(
         ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write remote object.");
         return PrivacyError::ERR_WRITE_PARCEL_FAILED;
     }
+    uint32_t usedType = static_cast<uint32_t>(type);
+    if (!data.WriteUint32(usedType)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write type");
+        return PrivacyError::ERR_WRITE_PARCEL_FAILED;
+    }
 
     MessageParcel reply;
     if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION_CALLBACK, data, reply)) {
diff --git a/interfaces/innerkits/privacy/src/privacy_manager_proxy.h b/interfaces/innerkits/privacy/src/privacy_manager_proxy.h
index 96c6ae5c2479c4e621578bbbadad587c3e3c18c1..52206a9b9878bba8aa40a07208096181d1b32c79 100644
--- a/interfaces/innerkits/privacy/src/privacy_manager_proxy.h
+++ b/interfaces/innerkits/privacy/src/privacy_manager_proxy.h
@@ -30,9 +30,10 @@ public:
     ~PrivacyManagerProxy() override;
 
     int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) override;
-    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) override;
     int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
-        const sptr<IRemoteObject>& callback) override;
+        PermissionUsedType type) override;
+    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
+        const sptr<IRemoteObject>& callback, PermissionUsedType type) override;
     int32_t StopUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName) override;
     int32_t RemovePermissionUsedRecords(AccessTokenID tokenID) override;
     int32_t GetPermissionUsedRecords(
diff --git a/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h b/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h
index 36d48ceb83f92d725fd9df945a5286896ca338be..931080eadfa1ee2942f298e4a8b1deff9b36c3e6 100644
--- a/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h
+++ b/interfaces/kits/js/napi/privacy/include/permission_record_manager_napi.h
@@ -37,6 +37,7 @@ struct RecordManagerAsyncContext : public PrivacyAsyncWorkData {
     std::string     permissionName;
     int32_t         successCount = 0;
     int32_t         failCount = 0;
+    int32_t         pid = -1;
     PermissionUsedType type = PermissionUsedType::NORMAL_TYPE;
     PermissionUsedRequest request;
     PermissionUsedResult result;
diff --git a/services/privacymanager/include/active/active_status_callback_manager.h b/services/privacymanager/include/active/active_status_callback_manager.h
index fae55908244147c6bd698bfd36040ea22d1e21ee..f1507daf2edca30701bcbc77d52f94ad5f875a71 100644
--- a/services/privacymanager/include/active/active_status_callback_manager.h
+++ b/services/privacymanager/include/active/active_status_callback_manager.h
@@ -24,6 +24,7 @@
 #endif
 #include "access_token.h"
 #include "accesstoken_log.h"
+#include "active_change_response_info.h"
 #include "perm_active_status_callback_death_recipient.h"
 #include "perm_active_status_change_callback_proxy.h"
 
@@ -52,13 +53,11 @@ public:
         AccessTokenID regiterTokenId, const std::vector<std::string>& permList, const sptr<IRemoteObject>& callback);
     int32_t RemoveCallback(const sptr<IRemoteObject>& callback);
     bool NeedCalled(const std::vector<std::string>& permList, const std::string& permName);
-    void ExecuteCallbackAsync(
-        AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType);
+    void ExecuteCallbackAsync(ActiveChangeResponse& info);
 #ifdef EVENTHANDLER_ENABLE
     void InitEventHandler(const std::shared_ptr<AccessEventHandler>& eventHandler);
 #endif
-    void ActiveStatusChange(AccessTokenID tokenId, const std::string& permName,
-        const std::string& deviceId, ActiveChangeType changeType);
+    void ActiveStatusChange(ActiveChangeResponse& info);
 private:
     std::mutex mutex_;
     std::vector<CallbackData> callbackDataList_;
diff --git a/services/privacymanager/include/record/permission_record_manager.h b/services/privacymanager/include/record/permission_record_manager.h
index 842fb3ea047679ea5ce18f0dc19fa66d745440b1..00bdcdbc7cfa7644ff7709b72b1e01b0d255cc3c 100644
--- a/services/privacymanager/include/record/permission_record_manager.h
+++ b/services/privacymanager/include/record/permission_record_manager.h
@@ -78,15 +78,17 @@ public:
     int32_t GetPermissionUsedRecords(const PermissionUsedRequest& request, PermissionUsedResult& result);
     int32_t GetPermissionUsedRecordsAsync(
         const PermissionUsedRequest& request, const sptr<OnPermissionUsedRecordCallback>& callback);
-    int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName);
     int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
-        const sptr<IRemoteObject>& callback);
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
+    int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
+        const sptr<IRemoteObject>& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
     int32_t StopUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName);
     int32_t RegisterPermActiveStatusCallback(
         AccessTokenID regiterTokenId, const std::vector<std::string>& permList, const sptr<IRemoteObject>& callback);
     int32_t UnRegisterPermActiveStatusCallback(const sptr<IRemoteObject>& callback);
 
-    void CallbackExecute(AccessTokenID tokenId, const std::string& permissionName, int32_t status);
+    void CallbackExecute(AccessTokenID tokenId, const std::string& permissionName, int32_t status,
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
     int32_t PermissionListFilter(const std::vector<std::string>& listSrc, std::vector<std::string>& listRes);
     bool IsAllowedUsingPermission(AccessTokenID tokenId, const std::string& permissionName);
     int32_t GetPermissionUsedTypeInfos(const AccessTokenID tokenId, const std::string& permissionName,
@@ -151,7 +153,8 @@ private:
     bool ShowGlobalDialog(const std::string& permissionName);
 #endif
     int32_t RemoveRecordFromStartList(AccessTokenID tokenId, int32_t pid, const std::string& permissionName);
-    int32_t AddRecordToStartList(uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status);
+    int32_t AddRecordToStartList(uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status,
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE);
 
     void PermListToString(const std::vector<std::string>& permList);
     bool GetGlobalSwitchStatus(const std::string& permissionName);
diff --git a/services/privacymanager/include/service/privacy_manager_service.h b/services/privacymanager/include/service/privacy_manager_service.h
index c628d53964b86ec40a6d5e75cce998899405a86c..8048ef52caef5f6400fddcf28d013d9feed0c948 100644
--- a/services/privacymanager/include/service/privacy_manager_service.h
+++ b/services/privacymanager/include/service/privacy_manager_service.h
@@ -40,9 +40,10 @@ public:
     void OnStop() override;
 
     int32_t AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode = false) override;
-    int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName) override;
     int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
-        const sptr<IRemoteObject>& callback) override;
+        PermissionUsedType type) override;
+    int32_t StartUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName,
+        const sptr<IRemoteObject>& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE) override;
     int32_t StopUsingPermission(AccessTokenID tokenId, int32_t pid, const std::string& permissionName) override;
     int32_t RemovePermissionUsedRecords(AccessTokenID tokenId) override;
     int32_t GetPermissionUsedRecords(
diff --git a/services/privacymanager/src/active/active_status_callback_manager.cpp b/services/privacymanager/src/active/active_status_callback_manager.cpp
index 191f5c6fddbf2ca026f8cd391d07f08e99c90f5a..f4d162ed72b3b5bd8135f3089e91afc530afbd37 100644
--- a/services/privacymanager/src/active/active_status_callback_manager.cpp
+++ b/services/privacymanager/src/active/active_status_callback_manager.cpp
@@ -22,6 +22,7 @@
 
 #include "accesstoken_dfx_define.h"
 #include "accesstoken_log.h"
+#include "ipc_skeleton.h"
 #include "privacy_error.h"
 
 namespace OHOS {
@@ -124,16 +125,16 @@ bool ActiveStatusCallbackManager::NeedCalled(const std::vector<std::string>& per
 }
 
 
-void ActiveStatusCallbackManager::ActiveStatusChange(
-    AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType)
+void ActiveStatusCallbackManager::ActiveStatusChange(ActiveChangeResponse& info)
 {
     std::vector<sptr<IRemoteObject>> list;
     {
         std::lock_guard<std::mutex> lock(mutex_);
         for (auto it = callbackDataList_.begin(); it != callbackDataList_.end(); ++it) {
             std::vector<std::string> permList = (*it).permList_;
-            if (!NeedCalled(permList, permName)) {
-                ACCESSTOKEN_LOG_INFO(LABEL, "TokenId %{public}u, perm %{public}s", tokenId, permName.c_str());
+            if (!NeedCalled(permList, info.permissionName)) {
+                ACCESSTOKEN_LOG_INFO(LABEL, "TokenId %{public}u, perm %{public}s", info.tokenID,
+                    info.permissionName.c_str());
                 continue;
             }
             list.emplace_back((*it).callbackObject_);
@@ -142,26 +143,20 @@ void ActiveStatusCallbackManager::ActiveStatusChange(
     for (auto it = list.begin(); it != list.end(); ++it) {
         auto callback = new PermActiveStatusChangeCallbackProxy(*it);
         if (callback != nullptr) {
-            ActiveChangeResponse resInfo;
-            resInfo.type = changeType;
-            resInfo.permissionName = permName;
-            resInfo.tokenID = tokenId;
-            resInfo.deviceId = deviceId;
-            ACCESSTOKEN_LOG_INFO(LABEL,
-                "callback execute tokenId %{public}u, permision %{public}s changeType %{public}d",
-                tokenId, permName.c_str(), changeType);
-            callback->ActiveStatusChangeCallback(resInfo);
+            ACCESSTOKEN_LOG_INFO(LABEL, "callback execute callingTokenId %{public}u, tokenId %{public}u, "
+                "permision %{public}s, changeType %{public}d, usedType %{public}d", info.callingTokenID,
+                info.tokenID, info.permissionName.c_str(), info.type, info.usedType);
+            callback->ActiveStatusChangeCallback(info);
         }
     }
 }
 
-void ActiveStatusCallbackManager::ExecuteCallbackAsync(
-    AccessTokenID tokenId, const std::string& permName, const std::string& deviceId, ActiveChangeType changeType)
+void ActiveStatusCallbackManager::ExecuteCallbackAsync(ActiveChangeResponse& info)
 {
-    if (changeType == PERM_ACTIVE_IN_BACKGROUND) {
+    if (info.type == PERM_ACTIVE_IN_BACKGROUND) {
         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "PERMISSION_CHECK_EVENT",
             HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "CODE", BACKGROUND_CALL_EVENT,
-            "CALLER_TOKENID", tokenId, "PERMISSION_NAME", permName, "REASON", "background call");
+            "CALLER_TOKENID", info.tokenID, "PERMISSION_NAME", info.permissionName, "REASON", "background call");
     }
 
 #ifdef EVENTHANDLER_ENABLE
@@ -169,13 +164,13 @@ void ActiveStatusCallbackManager::ExecuteCallbackAsync(
         ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to get EventHandler");
         return;
     }
-    std::string taskName = permName + std::to_string(tokenId);
+    std::string taskName = info.permissionName + std::to_string(info.tokenID);
     ACCESSTOKEN_LOG_INFO(LABEL, "Add permission task name:%{public}s", taskName.c_str());
-    std::function<void()> task = ([tokenId, permName, deviceId, changeType]() {
-        ActiveStatusCallbackManager::GetInstance().ActiveStatusChange(tokenId, permName, deviceId, changeType);
+    std::function<void()> task = ([info]() mutable {
+        ActiveStatusCallbackManager::GetInstance().ActiveStatusChange(info);
         ACCESSTOKEN_LOG_INFO(LABEL,
             "Token: %{public}u, permName:  %{public}s, changeType: %{public}d, ActiveStatusChange end",
-            tokenId, permName.c_str(), changeType);
+            info.tokenID, info.permissionName.c_str(), info.type);
     });
     eventHandler_->ProxyPostTask(task, taskName);
     ACCESSTOKEN_LOG_INFO(LABEL, "The callback execution is complete");
diff --git a/services/privacymanager/src/record/permission_record_manager.cpp b/services/privacymanager/src/record/permission_record_manager.cpp
index a459103811f8dad87b9c5d13450bbf2a9d49b7e6..fc283e1545f8f63915e773ae214e83086b351e25 100644
--- a/services/privacymanager/src/record/permission_record_manager.cpp
+++ b/services/privacymanager/src/record/permission_record_manager.cpp
@@ -758,7 +758,7 @@ int32_t PermissionRecordManager::DeletePermissionRecord(int32_t days)
 }
 
 int32_t PermissionRecordManager::AddRecordToStartList(
-    uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status)
+    uint32_t tokenId, int32_t pid, const std::string& permissionName, int32_t status, PermissionUsedType type)
 {
     int32_t ret = Constant::SUCCESS;
     int32_t opCode;
@@ -794,7 +794,7 @@ int32_t PermissionRecordManager::AddRecordToStartList(
         }
         startRecordList_.emplace_back(record);
     }
-    CallbackExecute(tokenId, permissionName, status);
+    CallbackExecute(tokenId, permissionName, status, type);
     if (hasTokenStarted && hasPidStarted) {
         ret = PrivacyError::ERR_PERMISSION_ALREADY_START_USING;
     }
@@ -1006,13 +1006,21 @@ void PermissionRecordManager::RemoveRecordFromStartListByOp(int32_t opCode)
 }
 
 void PermissionRecordManager::CallbackExecute(
-    AccessTokenID tokenId, const std::string& permissionName, int32_t status)
+    AccessTokenID tokenId, const std::string& permissionName, int32_t status, PermissionUsedType type)
 {
     ACCESSTOKEN_LOG_INFO(LABEL,
-        "ExecuteCallbackAsync, tokenId %{public}d using permission %{public}s, status %{public}d",
-        tokenId, permissionName.c_str(), status);
-    ActiveStatusCallbackManager::GetInstance().ExecuteCallbackAsync(
-        tokenId, permissionName, "", (ActiveChangeType)status);
+        "ExecuteCallbackAsync, tokenId %{public}d using permission %{public}s, status %{public}d, type %{public}d",
+        tokenId, permissionName.c_str(), status, type);
+
+    ActiveChangeResponse info;
+    info.callingTokenID = IPCSkeleton::GetCallingTokenID();
+    info.tokenID = tokenId;
+    info.permissionName = permissionName;
+    info.deviceId = "";
+    info.type = static_cast<ActiveChangeType>(status);
+    info.usedType = type;
+
+    ActiveStatusCallbackManager::GetInstance().ExecuteCallbackAsync(info);
 }
 
 bool PermissionRecordManager::GetGlobalSwitchStatus(const std::string& permissionName)
@@ -1121,7 +1129,7 @@ void PermissionRecordManager::ExecuteCameraCallbackAsync(AccessTokenID tokenId,
 }
 
 int32_t PermissionRecordManager::StartUsingPermission(
-    AccessTokenID tokenId, int32_t pid, const std::string& permissionName)
+    AccessTokenID tokenId, int32_t pid, const std::string& permissionName, PermissionUsedType type)
 {
     if (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP) {
         ACCESSTOKEN_LOG_DEBUG(LABEL, "Not hap(%{public}d).", tokenId);
@@ -1146,11 +1154,11 @@ int32_t PermissionRecordManager::StartUsingPermission(
         status = PERM_INACTIVE;
     }
 #endif
-    return AddRecordToStartList(tokenId, pid, permissionName, status);
+    return AddRecordToStartList(tokenId, pid, permissionName, status, type);
 }
 
-int32_t PermissionRecordManager::StartUsingPermission(
-    AccessTokenID tokenId, int32_t pid, const std::string& permissionName, const sptr<IRemoteObject>& callback)
+int32_t PermissionRecordManager::StartUsingPermission(AccessTokenID tokenId, int32_t pid,
+    const std::string& permissionName, const sptr<IRemoteObject>& callback, PermissionUsedType type)
 {
     if ((permissionName != CAMERA_PERMISSION_NAME) || (AccessTokenKit::GetTokenTypeFlag(tokenId) != TOKEN_HAP)) {
         ACCESSTOKEN_LOG_DEBUG(LABEL, "Token(%{public}u), perm(%{public}s).", tokenId, permissionName.c_str());
@@ -1181,7 +1189,7 @@ int32_t PermissionRecordManager::StartUsingPermission(
         cameraCallbackMap_.Erase(id);
         return PrivacyError::ERR_WINDOW_CALLBACK_FAILED;
     }
-    int32_t ret = AddRecordToStartList(tokenId, pid, permissionName, status);
+    int32_t ret = AddRecordToStartList(tokenId, pid, permissionName, status, type);
     if (ret != RET_SUCCESS) {
         cameraCallbackMap_.Erase(id);
     }
diff --git a/services/privacymanager/src/service/privacy_manager_service.cpp b/services/privacymanager/src/service/privacy_manager_service.cpp
index 0520226184037185ff563ca35d8fc3e5cc263e75..05a23b3b1fc7e7ad4245737cbfa15a5da48654a4 100644
--- a/services/privacymanager/src/service/privacy_manager_service.cpp
+++ b/services/privacymanager/src/service/privacy_manager_service.cpp
@@ -102,19 +102,19 @@ int32_t PrivacyManagerService::AddPermissionUsedRecord(const AddPermParamInfoPar
 }
 
 int32_t PrivacyManagerService::StartUsingPermission(
-    AccessTokenID tokenId, int32_t pid, const std::string& permissionName)
+    AccessTokenID tokenId, int32_t pid, const std::string& permissionName, PermissionUsedType type)
 {
-    ACCESSTOKEN_LOG_INFO(LABEL, "id: %{public}u, pid: %{public}d, perm: %{public}s",
-        tokenId, pid, permissionName.c_str());
-    return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName);
+    ACCESSTOKEN_LOG_INFO(LABEL, "Id: %{public}u, pid: %{public}d, perm: %{public}s, type: %{public}d.",
+        tokenId, pid, permissionName.c_str(), type);
+    return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, type);
 }
 
-int32_t PrivacyManagerService::StartUsingPermission(
-    AccessTokenID tokenId, int32_t pid, const std::string& permissionName, const sptr<IRemoteObject>& callback)
+int32_t PrivacyManagerService::StartUsingPermission(AccessTokenID tokenId, int32_t pid,
+    const std::string& permissionName, const sptr<IRemoteObject>& callback, PermissionUsedType type)
 {
-    ACCESSTOKEN_LOG_INFO(LABEL, "id: %{public}u, pid: %{public}d, perm: %{public}s",
-        tokenId, pid, permissionName.c_str());
-    return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, callback);
+    ACCESSTOKEN_LOG_INFO(LABEL, "Id: %{public}u, pid: %{public}d, perm: %{public}s, type: %{public}d.",
+        tokenId, pid, permissionName.c_str(), type);
+    return PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, pid, permissionName, callback, type);
 }
 
 int32_t PrivacyManagerService::StopUsingPermission(
diff --git a/services/privacymanager/src/service/privacy_manager_stub.cpp b/services/privacymanager/src/service/privacy_manager_stub.cpp
index b9d89a68e38a4cb3d7c71160fc9b68a8d4ead146..03406b1849c2f1b1f17827fb6200227816c5f015 100644
--- a/services/privacymanager/src/service/privacy_manager_stub.cpp
+++ b/services/privacymanager/src/service/privacy_manager_stub.cpp
@@ -144,7 +144,9 @@ void PrivacyManagerStub::StartUsingPermissionInner(MessageParcel& data, MessageP
     AccessTokenID tokenId = data.ReadUint32();
     int32_t pid = data.ReadInt32();
     std::string permissionName = data.ReadString();
-    reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName));
+    uint32_t usedType = data.ReadUint32();
+    PermissionUsedType type = static_cast<PermissionUsedType>(usedType);
+    reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, type));
 }
 
 void PrivacyManagerStub::StartUsingPermissionCallbackInner(MessageParcel& data, MessageParcel& reply)
@@ -162,7 +164,9 @@ void PrivacyManagerStub::StartUsingPermissionCallbackInner(MessageParcel& data,
         reply.WriteInt32(PrivacyError::ERR_READ_PARCEL_FAILED);
         return;
     }
-    reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, callback));
+    uint32_t usedType = data.ReadUint32();
+    PermissionUsedType type = static_cast<PermissionUsedType>(usedType);
+    reply.WriteInt32(this->StartUsingPermission(tokenId, pid, permissionName, callback, type));
 }
 
 void PrivacyManagerStub::StopUsingPermissionInner(MessageParcel& data, MessageParcel& reply)
diff --git a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
index 491503907f0d206688d7a8bc841becbe3384f12f..ba11e3309c25bdd76881726c2909afc80a8e86bc 100644
--- a/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
+++ b/services/privacymanager/test/unittest/privacy_manager_service_test.cpp
@@ -281,12 +281,13 @@ public:
     {
         return RET_SUCCESS;
     }
-    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName)
+    int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid, const std::string& permissionName,
+        PermissionUsedType type = PermissionUsedType::NORMAL_TYPE)
     {
         return RET_SUCCESS;
     }
     int32_t StartUsingPermission(AccessTokenID tokenID, int32_t pid,  const std::string& permissionName,
-        const sptr<IRemoteObject>& callback)
+        const sptr<IRemoteObject>& callback, PermissionUsedType type = PermissionUsedType::NORMAL_TYPE)
     {
         return RET_SUCCESS;
     }