!8500 支持URI授权组件化

Merge pull request !8500 from 段嗣钊/upms0510

interfaces/inner_api/uri_permission/include/uri_permission_manager_client.h

@@ -37,7 +37,7 @@ public:
      * @param targetBundleName The user of uri.
      */
     int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName, int32_t appIndex = 0,
-        uint32_t initiatorTokenId = 0);
+        uint32_t initiatorTokenId = 0, int32_t abilityId = -1);
 
     /**
      * @brief Authorize the uri permission of to targetBundleName.
@@ -46,8 +46,8 @@ public:
      * @param flag Want::FLAG_AUTH_READ_URI_PERMISSION or Want::FLAG_AUTH_WRITE_URI_PERMISSION.
      * @param targetBundleName The user of uri.
      */
-    int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0);
+    int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag, const std::string targetBundleName,
+        int32_t appIndex = 0, uint32_t initiatorTokenId = 0, int32_t abilityId = -1);
 
     /**
      * @brief Authorize the uri permission to targetBundleName.
@@ -78,15 +78,16 @@ public:
      * @brief Clear user's uri authorization record with auto remove flag.
      *
      * @param tokenId A tokenId of an application.
+     * @param abilityId The abilityId of an ability record.
      */
-    void RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId);
+    void RevokeUriPermission(const uint32_t tokenId, int32_t abilityId = -1);
 
     /**
      * @brief Clear user's all uri authorization record with auto remove flag.
      *
      * @param tokenId A tokenId of an application.
      */
-    int RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId);
+    int RevokeAllUriPermissions(const uint32_t tokenId);
 
     /**
      * @brief Clear user's uri authorization record.

interfaces/inner_api/uri_permission/include/uri_permission_manager_interface.h

@@ -34,8 +34,8 @@ public:
      * @param targetBundleName The user of uri.
      * @return Returns true if the authorization is successful, otherwise returns false.
      */
-    virtual int GrantUriPermission(const Uri &uri, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) = 0;
+    virtual int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName,
+        int32_t appIndex = 0, uint32_t initiatorTokenId = 0, int32_t abilityId = -1) = 0;
 
     /**
      * @brief Authorize the uri permission to targetBundleName.
@@ -46,7 +46,8 @@ public:
      * @return Returns true if the authorization is successful, otherwise returns false.
      */
     virtual int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) = 0;
+        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0,
+        int32_t abilityId = -1) = 0;
 
     /**
      * @brief Authorize the uri permission to targetBundleName.
@@ -77,9 +78,10 @@ public:
      * @brief Clear user's uri authorization record with autoremove flag.
      *
      * @param tokenId A tokenId of an application.
+     * @param abilityId The abilityId of an ability record.
      * @return Returns true if the remove is successful, otherwise returns false.
      */
-    virtual void RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId) = 0;
+    virtual void RevokeUriPermission(const uint32_t tokenId, int32_t abilityId = -1) = 0;
 
     /**
      * @brief Clear user's all uri authorization record with autoremove flag.
@@ -87,7 +89,7 @@ public:
      * @param tokenId A tokenId of an application.
      * @return Returns true if the remove is successful, otherwise returns false.
      */
-    virtual int RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId) = 0;
+    virtual int RevokeAllUriPermissions(const uint32_t tokenId) = 0;
 
     /**
      * @brief Clear user's uri authorization record.

interfaces/inner_api/uri_permission/include/uri_permission_manager_proxy.h

@@ -28,18 +28,20 @@ public:
     virtual ~UriPermissionManagerProxy() = default;
 
     virtual int GrantUriPermission(const Uri &uri, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) override;
+        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0,
+        int32_t abilityId = -1) override;
 
     virtual int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) override;
+        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0,
+        int32_t abilityId = -1) override;
 
     virtual int32_t GrantUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
         const std::string &targetBundleName, int32_t appIndex = 0) override;
     
     virtual int GrantUriPermissionFor2In1(const std::vector<Uri> &uriVec, unsigned int flag,
         const std::string &targetBundleName, int32_t appIndex = 0, bool isSystemAppCall = false) override;
-    virtual void RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId) override;
-    virtual int RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId) override;
+    virtual void RevokeUriPermission(const uint32_t tokenId, int32_t abilityId) override;
+    virtual int RevokeAllUriPermissions(const uint32_t tokenId) override;
     virtual int RevokeUriPermissionManually(const Uri &uri, const std::string bundleName) override;
     virtual bool VerifyUriPermission(const Uri &uri, uint32_t flag, uint32_t tokenId) override;
     virtual std::vector<bool> CheckUriAuthorization(const std::vector<std::string> &uriVec,

interfaces/inner_api/uri_permission/src/uri_permission_manager_client.cpp

@@ -36,18 +36,18 @@ UriPermissionManagerClient& UriPermissionManagerClient::GetInstance()
 }
 
 int UriPermissionManagerClient::GrantUriPermission(const Uri &uri, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "targetBundleName :%{public}s", targetBundleName.c_str());
     auto uriPermMgr = ConnectUriPermService();
     if (uriPermMgr) {
-        return uriPermMgr->GrantUriPermission(uri, flag, targetBundleName, appIndex, initiatorTokenId);
+        return uriPermMgr->GrantUriPermission(uri, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
     }
     return INNER_ERR;
 }
 
 int UriPermissionManagerClient::GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "targetBundleName: %{public}s, uriVec size: %{public}zu", targetBundleName.c_str(),
         uriVec.size());
@@ -57,7 +57,7 @@ int UriPermissionManagerClient::GrantUriPermission(const std::vector<Uri> &uriVe
     }
     auto uriPermMgr = ConnectUriPermService();
     if (uriPermMgr) {
-        return uriPermMgr->GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId);
+        return uriPermMgr->GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
     }
     return INNER_ERR;
 }
@@ -94,16 +94,16 @@ int UriPermissionManagerClient::GrantUriPermissionFor2In1(const std::vector<Uri>
     return INNER_ERR;
 }
 
-void UriPermissionManagerClient::RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId)
+void UriPermissionManagerClient::RevokeUriPermission(const uint32_t tokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerClient::RevokeUriPermission is called.");
     auto uriPermMgr = ConnectUriPermService();
     if (uriPermMgr) {
-        return uriPermMgr->RevokeUriPermission(tokenId);
+        return uriPermMgr->RevokeUriPermission(tokenId, abilityId);
     }
 }
 
-int UriPermissionManagerClient::RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId)
+int UriPermissionManagerClient::RevokeAllUriPermissions(const uint32_t tokenId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerClient::RevokeAllUriPermissions is called.");
     auto uriPermMgr = ConnectUriPermService();

interfaces/inner_api/uri_permission/src/uri_permission_manager_proxy.cpp

@@ -29,7 +29,7 @@ UriPermissionManagerProxy::UriPermissionManagerProxy(const sptr<IRemoteObject> &
     : IRemoteProxy<IUriPermissionManager>(impl) {}
 
 int UriPermissionManagerProxy::GrantUriPermission(const Uri &uri, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerProxy::GrantUriPermission is called.");
     MessageParcel data;
@@ -57,6 +57,10 @@ int UriPermissionManagerProxy::GrantUriPermission(const Uri &uri, unsigned int f
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Write initiatorTokenId failed.");
         return INNER_ERR;
     }
+    if (!data.WriteInt32(abilityId)) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "Write abilityId failed.");
+        return INNER_ERR;
+    }
     MessageParcel reply;
     MessageOption option;
     int error = SendTransactCmd(UriPermMgrCmd::ON_GRANT_URI_PERMISSION, data, reply, option);
@@ -68,7 +72,7 @@ int UriPermissionManagerProxy::GrantUriPermission(const Uri &uri, unsigned int f
 }
 
 int UriPermissionManagerProxy::GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerProxy::GrantUriPermission is called.");
     if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
@@ -106,6 +110,10 @@ int UriPermissionManagerProxy::GrantUriPermission(const std::vector<Uri> &uriVec
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Write initiatorTokenId failed.");
         return INNER_ERR;
     }
+    if (!data.WriteInt32(abilityId)) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "Write abilityId failed.");
+        return INNER_ERR;
+    }
     MessageParcel reply;
     MessageOption option;
     int error = SendTransactCmd(UriPermMgrCmd::ON_BATCH_GRANT_URI_PERMISSION, data, reply, option);
@@ -210,7 +218,7 @@ int UriPermissionManagerProxy::GrantUriPermissionFor2In1(const std::vector<Uri>
     return reply.ReadInt32();
 }
 
-void UriPermissionManagerProxy::RevokeUriPermission(const Security::AccessToken::AccessTokenID tokenId)
+void UriPermissionManagerProxy::RevokeUriPermission(const uint32_t tokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerProxy::RevokeUriPermission is called.");
     MessageParcel data;
@@ -222,6 +230,10 @@ void UriPermissionManagerProxy::RevokeUriPermission(const Security::AccessToken:
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed.");
         return;
     }
+    if (!data.WriteInt32(abilityId)) {
+        TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed.");
+        return;
+    }
     MessageParcel reply;
     MessageOption option;
     int error = SendTransactCmd(UriPermMgrCmd::ON_REVOKE_URI_PERMISSION, data, reply, option);
@@ -230,7 +242,7 @@ void UriPermissionManagerProxy::RevokeUriPermission(const Security::AccessToken:
     }
 }
 
-int UriPermissionManagerProxy::RevokeAllUriPermissions(const Security::AccessToken::AccessTokenID tokenId)
+int UriPermissionManagerProxy::RevokeAllUriPermissions(const uint32_t tokenId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerProxy::RevokeAllUriPermissions is called.");
     MessageParcel data;

interfaces/inner_api/uri_permission/src/uri_permission_manager_stub.cpp

@@ -72,7 +72,8 @@ int UriPermissionManagerStub::OnRemoteRequest(
 int UriPermissionManagerStub::HandleRevokeUriPermission(MessageParcel &data, MessageParcel &reply)
 {
     auto tokenId = data.ReadUint32();
-    RevokeUriPermission(tokenId);
+    auto abilityId = data.ReadInt32();
+    RevokeUriPermission(tokenId, abilityId);
     return ERR_OK;
 }
 
@@ -95,7 +96,8 @@ int UriPermissionManagerStub::HandleGrantUriPermission(MessageParcel &data, Mess
     auto targetBundleName = data.ReadString();
     auto appIndex = data.ReadInt32();
     auto initiatorTokenId = data.ReadUint32();
-    int result = GrantUriPermission(*uri, flag, targetBundleName, appIndex, initiatorTokenId);
+    auto abilityId = data.ReadInt32();
+    int result = GrantUriPermission(*uri, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
     reply.WriteInt32(result);
     return ERR_OK;
 }
@@ -120,7 +122,8 @@ int UriPermissionManagerStub::HandleBatchGrantUriPermission(MessageParcel &data,
     auto targetBundleName = data.ReadString();
     auto appIndex = data.ReadInt32();
     auto initiatorTokenId = data.ReadUint32();
-    int result = GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId);
+    auto abilityId = data.ReadInt32();
+    int result = GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
     reply.WriteInt32(result);
     return ERR_OK;
 }

services/abilitymgr/src/ability_record.cpp

@@ -1724,8 +1724,9 @@ void AbilityRecord::SendSandboxSavefileResult(const Want &want, int resultCode,
             }
             Uri uri(uriStr);
             uint32_t initiatorTokenId = IPCSkeleton::GetCallingTokenID();
+            bool flag = Want::FLAG_AUTH_WRITE_URI_PERMISSION;
             auto ret = IN_PROCESS_CALL(UriPermissionManagerClient::GetInstance().GrantUriPermission(uri,
-                Want::FLAG_AUTH_WRITE_URI_PERMISSION, abilityInfo_.bundleName, appIndex_, initiatorTokenId));
+                flag, abilityInfo_.bundleName, appIndex_, initiatorTokenId, recordId_));
             if (ret != ERR_OK) {
                 TAG_LOGW(AAFwkTag::ABILITYMGR, "GrantUriPermission failed");
             }
@@ -3082,7 +3083,7 @@ void AbilityRecord::GrantUriPermissionInner(Want &want, std::vector<std::string>
         return;
     }
     auto ret = IN_PROCESS_CALL(UriPermissionManagerClient::GetInstance().GrantUriPermission(validUriList, flag,
-        targetBundleName, appIndex_, callerTokenId));
+        targetBundleName, appIndex_, callerTokenId, recordId_));
     if (ret != ERR_OK) {
         TAG_LOGE(AAFwkTag::ABILITYMGR, "grant uri permission failed, Error Code is %{public}d", ret);
         return;
@@ -3107,7 +3108,7 @@ bool AbilityRecord::GrantPermissionToShell(const std::vector<std::string> &strUr
     uint32_t initiatorTokenId = IPCSkeleton::GetCallingTokenID();
     for (auto&& uri : uriVec) {
         auto ret = IN_PROCESS_CALL(UriPermissionManagerClient::GetInstance().GrantUriPermission(uri, flag, targetPkg,
-            appIndex_, initiatorTokenId));
+            appIndex_, initiatorTokenId, recordId_));
         if (ret == ERR_OK) {
             isGrantedUriPermission_ = true;
         }
@@ -3184,7 +3185,7 @@ void AbilityRecord::RevokeUriPermission()
 {
     if (isGrantedUriPermission_) {
         TAG_LOGD(AAFwkTag::ABILITYMGR, "To remove uri permission.");
-        UriPermissionManagerClient::GetInstance().RevokeUriPermission(applicationInfo_.accessTokenId);
+        UriPermissionManagerClient::GetInstance().RevokeUriPermission(applicationInfo_.accessTokenId, recordId_);
         isGrantedUriPermission_ = false;
     }
 }

services/uripermmgr/include/uri_permission_manager_stub_impl.h

@@ -19,6 +19,7 @@
 #include <functional>
 #include <map>
 #include <vector>
+#include <unordered_set>
 
 #include "app_mgr_interface.h"
 #include "bundle_mgr_helper.h"
@@ -32,13 +33,37 @@ namespace OHOS::AAFwk {
 namespace {
 using ClearProxyCallback = std::function<void(const wptr<IRemoteObject>&)>;
 using TokenId = Security::AccessToken::AccessTokenID;
+constexpr int32_t DEFAULT_ABILITY_ID = -1;
 }
 
 struct GrantInfo {
     unsigned int flag;
     const uint32_t fromTokenId;
     const uint32_t targetTokenId;
-    uint32_t autoRemove;
+    bool autoRemove;
+    std::unordered_set<int32_t> abilityIds;
+
+    void AddAbilityId(int32_t abilityId)
+    {
+        if (abilityId != DEFAULT_ABILITY_ID) {
+            abilityIds.insert(abilityId);
+        }
+    }
+
+    bool RemoveAbilityId(int32_t abilityId)
+    {
+        return abilityIds.erase(abilityId) > 0;
+    }
+
+    bool IsEmptyAbilityId()
+    {
+        return abilityIds.empty();
+    }
+
+    void ClearAbilityIds()
+    {
+        abilityIds.clear();
+    }
 };
 
 struct PolicyInfo final {
@@ -53,10 +78,11 @@ public:
     UriPermissionManagerStubImpl() = default;
     virtual ~UriPermissionManagerStubImpl() = default;
 
-    int GrantUriPermission(const Uri &uri, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) override;
+    int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName,
+        int32_t appIndex = 0, uint32_t initiatorTokenId = 0, int32_t abilityId = -1) override;
     int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0) override;
+        const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0,
+        int32_t abilityId = -1) override;
     int32_t GrantUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
         const std::string &targetBundleName, int32_t appIndex = 0) override;
     
@@ -67,7 +93,7 @@ public:
     int GrantUriPermissionFor2In1(const std::vector<Uri> &uriVec, unsigned int flag,
         const std::string &targetBundleName, int32_t appIndex = 0, bool isSystemAppCall = false) override;
     // only for foundation calling
-    void RevokeUriPermission(const TokenId tokenId) override;
+    void RevokeUriPermission(const TokenId tokenId, int32_t abilityId = -1) override;
     int RevokeAllUriPermissions(uint32_t tokenId) override;
     int RevokeUriPermissionManually(const Uri &uri, const std::string bundleName) override;
 
@@ -81,23 +107,23 @@ private:
     std::shared_ptr<AppExecFwk::BundleMgrHelper> ConnectManagerHelper();
     int32_t GetCurrentAccountId() const;
     int GrantUriPermissionImpl(const Uri &uri, unsigned int flag,
-        TokenId fromTokenId, TokenId targetTokenId, uint32_t autoRemove);
+        TokenId fromTokenId, TokenId targetTokenId, int32_t abilityId);
     int AddTempUriPermission(const std::string &uri, unsigned int flag, TokenId fromTokenId,
-        TokenId targetTokenId, uint32_t autoRemove);
+        TokenId targetTokenId, int32_t abilityId);
 
     int GrantBatchUriPermissionImpl(const std::vector<std::string> &uriVec, unsigned int flag,
-        TokenId initiatorTokenId, TokenId targetTokenId, uint32_t autoRemove);
+        TokenId initiatorTokenId, TokenId targetTokenId, int32_t abilityId);
     int GrantBatchUriPermission(const std::vector<Uri> &uriVec, unsigned int flag, uint32_t initiatorTokenId,
-        uint32_t targetTokenId, uint32_t autoRemove);
+        uint32_t targetTokenId, int32_t abilityId);
     
     int32_t GrantBatchUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
-        uint32_t callerTokenId, uint32_t targetTokenId, uint32_t autoRemove);
+        uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId = -1);
     
     int32_t GrantBatchUriPermissionFor2In1Privileged(const std::vector<Uri> &uriVec, uint32_t flag,
-        uint32_t callerTokenId, uint32_t targetTokenId, uint32_t autoRemove);
+        uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId = -1);
 
     int GrantSingleUriPermission(const Uri &uri, unsigned int flag, uint32_t callerTokenId, uint32_t targetTokenId,
-        uint32_t autoRemove);
+        int32_t abilityId);
 
     bool SendEvent(uint32_t callerTokenId, uint32_t targetTokenId, std::string &uri);
 
@@ -112,10 +138,11 @@ private:
     std::string GetBundleNameByTokenId(uint32_t tokenId);
 
     int GrantUriPermissionInner(const std::vector<Uri> &uriVec, unsigned int flag, const std::string targetBundleName,
-        int32_t appIndex, uint32_t initiatorTokenId);
+        int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId = -1);
 
     int GrantUriPermissionFor2In1Inner(const std::vector<Uri> &uriVec, unsigned int flag,
-        const std::string &targetBundleName, int32_t appIndex, bool isSystemAppCall, uint32_t initiatorTokenId = 0);
+        const std::string &targetBundleName, int32_t appIndex, bool isSystemAppCall, uint32_t initiatorTokenId = 0,
+        int32_t abilityId = -1);
 
     void HandleUriPermission(
         uint64_t tokenId, unsigned int flag, std::vector<PolicyInfo> &docsVec, bool isSystemAppCall);
@@ -136,6 +163,8 @@ private:
 
     bool IsLinuxFusionCall();
 
+    void RemoveUriRecord(std::vector<std::string> &uriList, const TokenId tokenId, int32_t abilityId);
+
     class ProxyDeathRecipient : public IRemoteObject::DeathRecipient {
     public:
         explicit ProxyDeathRecipient(ClearProxyCallback&& proxy) : proxy_(proxy) {}

services/uripermmgr/src/uri_permission_manager_stub_impl.cpp

@@ -45,6 +45,7 @@ namespace {
 constexpr int32_t DEFAULT_USER_ID = 0;
 constexpr int32_t ERR_OK = 0;
 constexpr uint32_t FLAG_READ_WRITE_URI = Want::FLAG_AUTH_READ_URI_PERMISSION | Want::FLAG_AUTH_WRITE_URI_PERMISSION;
+constexpr uint32_t FLAG_WRITE_URI = Want::FLAG_AUTH_WRITE_URI_PERMISSION;
 constexpr const char* CLOUND_DOCS_URI_MARK = "?networkid=";
 constexpr const char* FOUNDATION_PROCESS_NAME = "foundation";
 constexpr const char* LINUX_FUSION_SERVICE = "linux_fusion_service";
@@ -85,7 +86,7 @@ bool UriPermissionManagerStubImpl::IsAuthorizationUriAllowed(uint32_t fromTokenI
 }
 
 int UriPermissionManagerStubImpl::GrantUriPermission(const Uri &uri, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "Uri is %{private}s.", uri.ToString().c_str());
     if (!IsSAOrSystemAppCall()) {
@@ -93,11 +94,11 @@ int UriPermissionManagerStubImpl::GrantUriPermission(const Uri &uri, unsigned in
         return CHECK_PERMISSION_FAILED;
     }
     std::vector<Uri> uriVec = { uri };
-    return GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId);
+    return GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
 }
 
 int UriPermissionManagerStubImpl::GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "BundleName is %{public}s, appIndex is %{public}d, size of uriVec is %{public}zu.",
         targetBundleName.c_str(), appIndex, uriVec.size());
@@ -119,9 +120,9 @@ int UriPermissionManagerStubImpl::GrantUriPermission(const std::vector<Uri> &uri
             isSystemAppCall = CheckIsSystemAppByTokenId(initiatorTokenId);
         }
         return GrantUriPermissionFor2In1Inner(
-            uriVec, flag, targetBundleName, appIndex, isSystemAppCall, initiatorTokenId);
+            uriVec, flag, targetBundleName, appIndex, isSystemAppCall, initiatorTokenId, abilityId);
     }
-    return GrantUriPermissionInner(uriVec, flag, targetBundleName, appIndex, initiatorTokenId);
+    return GrantUriPermissionInner(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
 }
 
 int32_t UriPermissionManagerStubImpl::GrantUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
@@ -144,6 +145,7 @@ int32_t UriPermissionManagerStubImpl::GrantUriPermissionPrivileged(const std::ve
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Flag is invalid, value is %{public}u.", flag);
         return ERR_CODE_INVALID_URI_FLAG;
     }
+    flag &= FLAG_READ_WRITE_URI;
     uint32_t targetTokenId = 0;
     auto ret = GetTokenIdByBundleName(targetBundleName, 0, targetTokenId);
     if (ret != ERR_OK) {
@@ -151,15 +153,14 @@ int32_t UriPermissionManagerStubImpl::GrantUriPermissionPrivileged(const std::ve
         return ret;
     }
 
-    uint32_t autoRemove = IsFoundationCall() ? 1 : 0;
     if (AppUtils::GetInstance().IsGrantPersistUriPermission()) {
-        return GrantBatchUriPermissionFor2In1Privileged(uriVec, flag, callerTokenId, targetTokenId, autoRemove);
+        return GrantBatchUriPermissionFor2In1Privileged(uriVec, flag, callerTokenId, targetTokenId);
     }
-    return GrantBatchUriPermissionPrivileged(uriVec, flag, callerTokenId, targetTokenId, autoRemove);
+    return GrantBatchUriPermissionPrivileged(uriVec, flag, callerTokenId, targetTokenId);
 }
 
 int UriPermissionManagerStubImpl::GrantUriPermissionInner(const std::vector<Uri> &uriVec, unsigned int flag,
-    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId)
+    const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
 {
     TAG_LOGD(AAFwkTag::URIPERMMGR, "Called.");
     flag &= FLAG_READ_WRITE_URI;
@@ -169,20 +170,20 @@ int UriPermissionManagerStubImpl::GrantUriPermissionInner(const std::vector<Uri>
         TAG_LOGE(AAFwkTag::URIPERMMGR, "get tokenId of target bundle name failed.");
         return ret;
     }
-    // autoRemove will be set to 1 if the process name is foundation.
-    uint32_t autoRemove = 0;
+    // recordId will be set default id if the process name is not foundation.
+    int32_t recordId = -1;
     uint32_t appTokenId = IPCSkeleton::GetCallingTokenID();
     if (IsFoundationCall()) {
-        autoRemove = 1;
+        recordId = abilityId;
         appTokenId = initiatorTokenId;
         auto callerName = GetTokenName(appTokenId);
         TAG_LOGI(AAFwkTag::URIPERMMGR, "RealTokenId is %{public}u, RealCallerName is %{public}s.",
             appTokenId, callerName.c_str());
     }
     if (uriVec.size() == 1) {
-        return GrantSingleUriPermission(uriVec[0], flag, appTokenId, targetTokenId, autoRemove);
+        return GrantSingleUriPermission(uriVec[0], flag, appTokenId, targetTokenId, recordId);
     }
-    return GrantBatchUriPermission(uriVec, flag, appTokenId, targetTokenId, autoRemove);
+    return GrantBatchUriPermission(uriVec, flag, appTokenId, targetTokenId, recordId);
 }
 
 int checkPersistPermission(uint64_t tokenId, const std::vector<PolicyInfo> &policy, std::vector<bool> &result)
@@ -251,13 +252,15 @@ int UriPermissionManagerStubImpl::GrantUriPermissionFor2In1(const std::vector<Ur
 }
 
 int UriPermissionManagerStubImpl::AddTempUriPermission(const std::string &uri, unsigned int flag,
-    TokenId fromTokenId, TokenId targetTokenId, uint32_t autoRemove)
+    TokenId fromTokenId, TokenId targetTokenId, int32_t abilityId)
 {
     std::lock_guard<std::mutex> guard(mutex_);
     auto search = uriMap_.find(uri);
-    GrantInfo info = { flag, fromTokenId, targetTokenId, autoRemove };
+    bool autoRemove = (abilityId != DEFAULT_ABILITY_ID);
+    GrantInfo info = { flag, fromTokenId, targetTokenId, autoRemove, {} };
     if (search == uriMap_.end()) {
         TAG_LOGI(AAFwkTag::URIPERMMGR, "Insert an uri r/w permission.");
+        info.AddAbilityId(abilityId);
         std::list<GrantInfo> infoList = { info };
         uriMap_.emplace(uri, infoList);
         return ERR_OK;
@@ -265,17 +268,25 @@ int UriPermissionManagerStubImpl::AddTempUriPermission(const std::string &uri, u
     auto& infoList = search->second;
     for (auto& item : infoList) {
         if (item.fromTokenId == fromTokenId && item.targetTokenId == targetTokenId) {
-            TAG_LOGD(AAFwkTag::URIPERMMGR, "Item: flag is %{public}u, autoRemove is %{public}u.",
-                item.flag, item.autoRemove);
-            if (item.autoRemove == 1 && info.autoRemove == 0) {
-                TAG_LOGD(AAFwkTag::URIPERMMGR, "Update autoRemove.");
-                item.autoRemove = 1;
-            }
-            if ((flag & (item.flag | Want::FLAG_AUTH_READ_URI_PERMISSION)) == 0) {
+            TAG_LOGI(AAFwkTag::URIPERMMGR,
+                "Item: flag is %{public}u, autoRemove is %{public}u, ability size is %{public}zu.",
+                item.flag, item.autoRemove, item.abilityIds.size());
+            item.AddAbilityId(abilityId);
+            // r-w
+            if ((item.flag & FLAG_WRITE_URI) == 0 && (flag & FLAG_WRITE_URI) != 0) {
                 TAG_LOGI(AAFwkTag::URIPERMMGR, "Update uri r/w permission.");
-                item.flag = flag;
-            } else {
-                TAG_LOGI(AAFwkTag::URIPERMMGR, "Uri has been granted, not to grant again.");
+                item.autoRemove = autoRemove;
+                item.flag |= FLAG_WRITE_URI;
+                return ERR_OK;
+            }
+            // w-r
+            TAG_LOGI(AAFwkTag::URIPERMMGR, "Uri has been granted, not to grant again.");
+            if ((item.flag & FLAG_WRITE_URI) != 0 && (flag & FLAG_WRITE_URI) == 0) {
+                return ERR_OK;
+            }
+            // other
+            if (!autoRemove) {
+                item.autoRemove = autoRemove;
             }
             return ERR_OK;
         }
@@ -286,11 +297,11 @@ int UriPermissionManagerStubImpl::AddTempUriPermission(const std::string &uri, u
 }
 
 int UriPermissionManagerStubImpl::GrantUriPermissionImpl(const Uri &uri, unsigned int flag,
-    TokenId callerTokenId, TokenId targetTokenId, uint32_t autoRemove)
+    TokenId callerTokenId, TokenId targetTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "uri = %{private}s, flag = %{public}i, callerTokenId = %{public}i,"
-        "targetTokenId = %{public}i, autoRemove = %{public}i", uri.ToString().c_str(), flag, callerTokenId,
-        targetTokenId, autoRemove);
+        "targetTokenId = %{public}i, abilityId = %{public}i", uri.ToString().c_str(), flag, callerTokenId,
+        targetTokenId, abilityId);
     ConnectManager(storageManager_, STORAGE_MANAGER_MANAGER_ID);
     if (storageManager_ == nullptr) {
         TAG_LOGE(AAFwkTag::URIPERMMGR, "ConnectManager failed");
@@ -307,17 +318,17 @@ int UriPermissionManagerStubImpl::GrantUriPermissionImpl(const Uri &uri, unsigne
         TAG_LOGE(AAFwkTag::URIPERMMGR, "failed to CreateShareFile.");
         return INNER_ERR;
     }
-    AddTempUriPermission(uriStr, flag, callerTokenId, targetTokenId, autoRemove);
+    AddTempUriPermission(uriStr, flag, callerTokenId, targetTokenId, abilityId);
     SendEvent(callerTokenId, targetTokenId, uriStr);
     return ERR_OK;
 }
 
 int UriPermissionManagerStubImpl::GrantSingleUriPermission(const Uri &uri, unsigned int flag, uint32_t callerTokenId,
-    uint32_t targetTokenId, uint32_t autoRemove)
+    uint32_t targetTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR,
-        "uri is %{private}s, callerTokenId is %{public}u, targetTokenId is %{public}u, autoRemove is %{public}u",
-        uri.ToString().c_str(), callerTokenId, targetTokenId, autoRemove);
+        "uri is %{private}s, callerTokenId is %{public}u, targetTokenId is %{public}u, abilityId is %{public}d",
+        uri.ToString().c_str(), callerTokenId, targetTokenId, abilityId);
     if (!CheckUriTypeIsValid(uri)) {
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Check uri type failed, uri is %{private}s", uri.ToString().c_str());
         return ERR_CODE_INVALID_URI_TYPE;
@@ -328,13 +339,13 @@ int UriPermissionManagerStubImpl::GrantSingleUriPermission(const Uri &uri, unsig
             uri.ToString().c_str(), callerTokenId);
         return CHECK_PERMISSION_FAILED;
     }
-    return GrantUriPermissionImpl(uri, flag, callerTokenId, targetTokenId, autoRemove);
+    return GrantUriPermissionImpl(uri, flag, callerTokenId, targetTokenId, abilityId);
 }
 
 int UriPermissionManagerStubImpl::GrantBatchUriPermissionImpl(const std::vector<std::string> &uriVec,
-    unsigned int flag, TokenId callerTokenId, TokenId targetTokenId, uint32_t autoRemove)
+    unsigned int flag, TokenId callerTokenId, TokenId targetTokenId, int32_t abilityId)
 {
-    TAG_LOGI(AAFwkTag::URIPERMMGR, "callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}i,"
+    TAG_LOGI(AAFwkTag::URIPERMMGR,"callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}i,"
         "list size is %{public}zu", callerTokenId, targetTokenId, flag, uriVec.size());
     ConnectManager(storageManager_, STORAGE_MANAGER_MANAGER_ID);
     if (storageManager_ == nullptr) {
@@ -359,7 +370,7 @@ int UriPermissionManagerStubImpl::GrantBatchUriPermissionImpl(const std::vector<
             TAG_LOGE(AAFwkTag::URIPERMMGR, "failed to CreateShareFile.");
             continue;
         }
-        AddTempUriPermission(uriVec[i], flag, callerTokenId, targetTokenId, autoRemove);
+        AddTempUriPermission(uriVec[i], flag, callerTokenId, targetTokenId, abilityId);
         if (needSendEvent) {
             eventInfo.uri = uriVec[i];
             EventReport::SendKeyEvent(EventName::GRANT_URI_PERMISSION, HiSysEventType::BEHAVIOR, eventInfo);
@@ -374,11 +385,11 @@ int UriPermissionManagerStubImpl::GrantBatchUriPermissionImpl(const std::vector<
 }
 
 int UriPermissionManagerStubImpl::GrantBatchUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
-    uint32_t callerTokenId, uint32_t targetTokenId, uint32_t autoRemove)
+    uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR,
-        "callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}u, autoRemove is %{public}u.",
-        callerTokenId, targetTokenId, flag, autoRemove);
+        "callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}u, abilityId is %{public}u.",
+        callerTokenId, targetTokenId, flag, abilityId);
     TokenIdPermission tokenIdPermission(callerTokenId);
     std::vector<std::string> uriStrVec = {};
     for (const auto &uri : uriVec) {
@@ -396,11 +407,11 @@ int UriPermissionManagerStubImpl::GrantBatchUriPermission(const std::vector<Uri>
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Valid uri list is empty.");
         return INNER_ERR;
     }
-    return GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, autoRemove);
+    return GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, abilityId);
 }
 
 int32_t UriPermissionManagerStubImpl::GrantBatchUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
-    uint32_t callerTokenId, uint32_t targetTokenId, uint32_t autoRemove)
+    uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}u.",
         callerTokenId, targetTokenId, flag);
@@ -416,11 +427,11 @@ int32_t UriPermissionManagerStubImpl::GrantBatchUriPermissionPrivileged(const st
         TAG_LOGE(AAFwkTag::URIPERMMGR, "Valid uri list is empty.");
         return ERR_CODE_INVALID_URI_TYPE;
     }
-    return GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, autoRemove);
+    return GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, abilityId);
 }
 
 int32_t UriPermissionManagerStubImpl::GrantBatchUriPermissionFor2In1Privileged(const std::vector<Uri> &uriVec,
-    uint32_t flag, uint32_t callerTokenId, uint32_t targetTokenId, uint32_t autoRemove)
+    uint32_t flag, uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "callerTokenId is %{public}u, targetTokenId is %{public}u, flag is %{public}u.",
         callerTokenId, targetTokenId, flag);
@@ -450,7 +461,7 @@ int32_t UriPermissionManagerStubImpl::GrantBatchUriPermissionFor2In1Privileged(c
     }
 
     if (!uriStrVec.empty()) {
-        auto ret = GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, autoRemove);
+        auto ret = GrantBatchUriPermissionImpl(uriStrVec, flag, callerTokenId, targetTokenId, abilityId);
         if (docsVec.empty()) {
             return ret;
         }
@@ -461,33 +472,43 @@ int32_t UriPermissionManagerStubImpl::GrantBatchUriPermissionFor2In1Privileged(c
     return ERR_OK;
 }
 
-void UriPermissionManagerStubImpl::RevokeUriPermission(const TokenId tokenId)
+void UriPermissionManagerStubImpl::RemoveUriRecord(std::vector<std::string> &uriList, const TokenId tokenId,
+    int32_t abilityId)
 {
-    TAG_LOGI(AAFwkTag::URIPERMMGR, "Start to remove uri permission, tokenId is %{public}u", tokenId);
+    std::lock_guard<std::mutex> guard(mutex_);
+    for (auto iter = uriMap_.begin(); iter != uriMap_.end();) {
+        auto& list = iter->second;
+        for (auto it = list.begin(); it != list.end(); it++) {
+            if (it->targetTokenId != tokenId || !it->RemoveAbilityId(abilityId) || !it->autoRemove) {
+                continue;
+            }
+            if (!it->IsEmptyAbilityId()) {
+                TAG_LOGD(AAFwkTag::URIPERMMGR, "Remove an abilityId.");
+                return;
+            }
+            TAG_LOGI(AAFwkTag::URIPERMMGR, "Erase an info form list.");
+            list.erase(it);
+            uriList.emplace_back(iter->first);
+            return;
+        }
+        if (list.empty()) {
+            uriMap_.erase(iter++);
+            continue;
+        }
+        ++iter;
+    }
+}
+
+void UriPermissionManagerStubImpl::RevokeUriPermission(const TokenId tokenId, int32_t abilityId)
+{
+    TAG_LOGI(AAFwkTag::URIPERMMGR,
+        "Start to remove uri permission, tokenId is %{public}u, abilityId is %{public}d", tokenId, abilityId);
     if (!IsFoundationCall()) {
         TAG_LOGE(AAFwkTag::URIPERMMGR, "No permission to revoke uri permission.");
         return;
     }
     std::vector<std::string> uriList;
-    {
-        std::lock_guard<std::mutex> guard(mutex_);
-        for (auto iter = uriMap_.begin(); iter != uriMap_.end();) {
-            auto& list = iter->second;
-            for (auto it = list.begin(); it != list.end(); it++) {
-                if (it->targetTokenId == tokenId && it->autoRemove) {
-                    TAG_LOGI(AAFwkTag::URIPERMMGR, "Erase an info form list.");
-                    list.erase(it);
-                    uriList.emplace_back(iter->first);
-                    break;
-                }
-            }
-            if (list.empty()) {
-                uriMap_.erase(iter++);
-                continue;
-            }
-            iter++;
-        }
-    }
+    RemoveUriRecord(uriList, tokenId, abilityId);
     if (!uriList.empty()) {
         DeleteShareFile(tokenId, uriList);
     }
@@ -739,7 +760,8 @@ int32_t UriPermissionManagerStubImpl::GetCurrentAccountId() const
 }
 
 int UriPermissionManagerStubImpl::GrantUriPermissionFor2In1Inner(const std::vector<Uri> &uriVec, unsigned int flag,
-    const std::string &targetBundleName, int32_t appIndex, bool isSystemAppCall, uint32_t initiatorTokenId)
+    const std::string &targetBundleName, int32_t appIndex, bool isSystemAppCall, uint32_t initiatorTokenId,
+    int32_t abilityId)
 {
     TAG_LOGI(AAFwkTag::URIPERMMGR, "UriVec size is %{public}zu, targetBundleName is %{public}s",
         uriVec.size(), targetBundleName.c_str());

test/unittest/uri_permission_impl_test/uri_permission_impl_test.cpp

@@ -329,13 +329,13 @@ HWTEST_F(UriPermissionImplTest, Upms_VerifyUriPermission_001, TestSize.Level1)
     auto flagRead = 1;
     auto flagWrite = 2;
     
-    upms->AddTempUriPermission(uri, flagRead, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(uri, flagRead, callerTokenId, targetTokenId, 0);
     auto ret = upms->VerifyUriPermission(Uri(uri), flagRead, targetTokenId);
     ASSERT_EQ(ret, true);
     ret = upms->VerifyUriPermission(Uri(uri), flagWrite, targetTokenId);
     ASSERT_EQ(ret, false);
     
-    upms->AddTempUriPermission(uri, flagWrite, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(uri, flagWrite, callerTokenId, targetTokenId, 0);
     ret = upms->VerifyUriPermission(Uri(uri), flagRead, targetTokenId);
     ASSERT_EQ(ret, true);
     ret = upms->VerifyUriPermission(Uri(uri), flagWrite, targetTokenId);
@@ -411,14 +411,14 @@ HWTEST_F(UriPermissionImplTest, Upms_CheckUriPermission_001, TestSize.Level1)
     ASSERT_EQ(ret, false);
 
     // read
-    upms->AddTempUriPermission(mediaPhotoUri.ToString(), flagRead, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(mediaPhotoUri.ToString(), flagRead, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(mediaPhotoUri, flagRead, tokenIdPermission);
     ASSERT_EQ(ret, true);
     ret = upms->CheckUriPermission(mediaPhotoUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, false);
     
     // write
-    upms->AddTempUriPermission(mediaPhotoUri.ToString(), flagWrite, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(mediaPhotoUri.ToString(), flagWrite, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(mediaPhotoUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, true);
     MyFlag::permissionProxyAuthorization_ = false;
@@ -473,14 +473,14 @@ HWTEST_F(UriPermissionImplTest, Upms_CheckUriPermission_002, TestSize.Level1)
     ASSERT_EQ(ret, false);
 
     // read
-    upms->AddTempUriPermission(mediaAudioUri.ToString(), flagRead, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(mediaAudioUri.ToString(), flagRead, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(mediaAudioUri, flagRead, tokenIdPermission);
     ASSERT_EQ(ret, true);
     ret = upms->CheckUriPermission(mediaAudioUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, false);
     
     // write
-    upms->AddTempUriPermission(mediaAudioUri.ToString(), flagWrite, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(mediaAudioUri.ToString(), flagWrite, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(mediaAudioUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, true);
     MyFlag::permissionProxyAuthorization_ = false;
@@ -526,14 +526,14 @@ HWTEST_F(UriPermissionImplTest, Upms_CheckUriPermission_003, TestSize.Level1)
     ASSERT_EQ(ret, false);
 
     // read
-    upms->AddTempUriPermission(docsUri.ToString(), flagRead, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(docsUri.ToString(), flagRead, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(docsUri, flagRead, tokenIdPermission);
     ASSERT_EQ(ret, true);
     ret = upms->CheckUriPermission(docsUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, false);
     
     // write
-    upms->AddTempUriPermission(docsUri.ToString(), flagWrite, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(docsUri.ToString(), flagWrite, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(docsUri, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, true);
     MyFlag::permissionProxyAuthorization_ = false;
@@ -578,14 +578,14 @@ HWTEST_F(UriPermissionImplTest, Upms_CheckUriPermission_004, TestSize.Level1)
     ASSERT_EQ(ret, false);
     
     // read
-    upms->AddTempUriPermission(uri1.ToString(), flagRead, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(uri1.ToString(), flagRead, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(uri1, flagRead, tokenIdPermission);
     ASSERT_EQ(ret, true);
     ret = upms->CheckUriPermission(uri1, flagWrite, tokenIdPermission);
     ASSERT_EQ(ret, false);
     
     // write
-    upms->AddTempUriPermission(uri1.ToString(), flagWrite, callerTokenId, targetTokenId, false);
+    upms->AddTempUriPermission(uri1.ToString(), flagWrite, callerTokenId, targetTokenId, 0);
     ret = upms->CheckUriPermission(uri1, flagRead, tokenIdPermission);
     ASSERT_EQ(ret, true);
     ret = upms->CheckUriPermission(uri1, flagWrite, tokenIdPermission);