• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "js_uri_perm_mgr.h"
17 
18 #include "ability_business_error.h"
19 #include "ability_manager_errors.h"
20 #include "ability_runtime_error_util.h"
21 #include "hilog_tag_wrapper.h"
22 #include "ipc_skeleton.h"
23 #include "js_error_utils.h"
24 #include "napi_common_util.h"
25 #include "parameters.h"
26 #include "tokenid_kit.h"
27 #include "uri.h"
28 #include "uri_permission_manager_client.h"
29 
30 namespace OHOS {
31 namespace AbilityRuntime {
32 namespace {
33 constexpr int32_t ERR_OK = 0;
34 constexpr int32_t ARG_COUNT_TWO = 2;
35 constexpr int32_t ARG_COUNT_THREE = 3;
36 constexpr int32_t ARG_COUNT_FOUR = 4;
37 constexpr int32_t ARG_INDEX_ZERO = 0;
38 constexpr int32_t ARG_INDEX_ONE = 1;
39 constexpr int32_t ARG_INDEX_TWO = 2;
40 constexpr int32_t ARG_INDEX_THREE = 3;
41 
42 struct UriPermissionParam {
43     std::string uriStr;
44     int32_t flag = 0;
45     std::string bundleName;
46     int32_t appIndex = 0;
47     bool hasAppIndex = false;
48     std::string key;
49     int32_t callerTokenId = 0;
50     int32_t targetTokenId = 0;
51 };
52 
ResolveGrantUriPermissionTask(napi_env env,NapiAsyncTask & task,int32_t errCode)53 static void ResolveGrantUriPermissionTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
54 {
55     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveGrantUriPermissionTask");
56     if (errCode == ERR_OK) {
57         task.ResolveWithNoError(env, CreateJsUndefined(env));
58         return;
59     }
60     if (errCode == AAFwk::CHECK_PERMISSION_FAILED || errCode == AAFwk::ERR_CODE_INVALID_URI_FLAG ||
61         errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE || errCode == AAFwk::ERR_CODE_GRANT_URI_PERMISSION) {
62         task.Reject(env, CreateJsErrorByNativeErr(env, errCode, "ohos.permission.PROXY_AUTHORIZATION_URI"));
63         return;
64     }
65     task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER));
66     return;
67 }
68 
ResolveGrantUriPermissionWithAppIndexTask(napi_env env,NapiAsyncTask & task,int32_t errCode)69 static void ResolveGrantUriPermissionWithAppIndexTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
70 {
71     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveGrantUriPermissionWithAppIndexTask");
72     if (errCode == ERR_OK) {
73         task.ResolveWithNoError(env, CreateJsUndefined(env));
74         return;
75     }
76     if (errCode == AAFwk::CHECK_PERMISSION_FAILED || errCode == AAFwk::ERR_CODE_INVALID_URI_FLAG ||
77         errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE || errCode == AAFwk::ERR_CODE_GRANT_URI_PERMISSION ||
78         errCode == AAFwk::ERR_GET_TARGET_BUNDLE_INFO_FAILED) {
79         task.Reject(env, CreateJsErrorByNativeErr(env, errCode, "ohos.permission.PROXY_AUTHORIZATION_URI"));
80         return;
81     }
82     task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER));
83     return;
84 }
85 
ResolveRevokeUriPermissionTask(napi_env env,NapiAsyncTask & task,int32_t errCode)86 static void ResolveRevokeUriPermissionTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
87 {
88     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveRevokeUriPermissionTask");
89     if (errCode == ERR_OK) {
90         task.ResolveWithNoError(env, CreateJsUndefined(env));
91         return;
92     }
93     if (errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE || errCode == AAFwk::ERR_CODE_GRANT_URI_PERMISSION) {
94         task.Reject(env, CreateJsErrorByNativeErr(env, errCode));
95         return;
96     }
97     task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER));
98     return;
99 }
100 
ResolveRevokeUriPermissionWithAppIndexTask(napi_env env,NapiAsyncTask & task,int32_t errCode)101 static void ResolveRevokeUriPermissionWithAppIndexTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
102 {
103     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveRevokeUriPermissionWithAppIndexTask");
104     if (errCode == ERR_OK) {
105         task.ResolveWithNoError(env, CreateJsUndefined(env));
106         return;
107     }
108     if (errCode == AAFwk::ERR_CODE_INVALID_URI_TYPE || errCode == AAFwk::ERR_CODE_GRANT_URI_PERMISSION ||
109         errCode == AAFwk::ERR_GET_TARGET_BUNDLE_INFO_FAILED) {
110         task.Reject(env, CreateJsErrorByNativeErr(env, errCode));
111         return;
112     }
113     task.Reject(env, CreateJsError(env, AbilityErrorCode::ERROR_CODE_INNER));
114     return;
115 }
116 
ResolveGrantUriPermissionByKeyAsCallerTask(napi_env env,NapiAsyncTask & task,int32_t errCode)117 static void ResolveGrantUriPermissionByKeyAsCallerTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
118 {
119     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveGrantUriPermissionByKeyAsCallerTask");
120     if (errCode == ERR_OK) {
121         task.ResolveWithNoError(env, CreateJsUndefined(env));
122         return;
123     }
124     task.Reject(env, CreateJsErrorByNativeErr(env, errCode, "ohos.permission.GRANT_URI_PERMISSION_AS_CALLER"));
125     return;
126 }
127 
ResolveGrantUriPermissionByKeyTask(napi_env env,NapiAsyncTask & task,int32_t errCode)128 static void ResolveGrantUriPermissionByKeyTask(napi_env env, NapiAsyncTask &task, int32_t errCode)
129 {
130     TAG_LOGI(AAFwkTag::URIPERMMGR, "ResolveGrantUriPermissionByKeyTask");
131     if (errCode == ERR_OK) {
132         task.ResolveWithNoError(env, CreateJsUndefined(env));
133         return;
134     }
135     task.Reject(env, CreateJsErrorByNativeErr(env, errCode, ""));
136     return;
137 }
138 
ParseGrantUriPermissionParams(napi_env env,const NapiCallbackInfo & info,UriPermissionParam & param)139 static bool ParseGrantUriPermissionParams(napi_env env, const NapiCallbackInfo &info, UriPermissionParam &param)
140 {
141     // only support 3 or 4 params
142     if (info.argc < ARG_COUNT_THREE) {
143         TAG_LOGE(AAFwkTag::URIPERMMGR, "too few parameters");
144         ThrowTooFewParametersError(env);
145         return false;
146     }
147     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[0], param.uriStr)) {
148         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid uriStr");
149         ThrowInvalidParamError(env, "Parse param uri failed, uri must be string.");
150         return false;
151     }
152     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[1], param.flag)) {
153         TAG_LOGE(AAFwkTag::URIPERMMGR, "flag invalid.");
154         ThrowInvalidParamError(env, "Parse param flag failed, flag must be number.");
155         return false;
156     }
157     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[ARG_COUNT_TWO], param.bundleName)) {
158         TAG_LOGE(AAFwkTag::URIPERMMGR, "targetBundleName invalid");
159         ThrowInvalidParamError(env, "Parse param targetBundleName failed, targetBundleName must be string.");
160         return false;
161     }
162     if (info.argc >= ARG_COUNT_FOUR) {
163         // process param index or callback
164         if (CheckTypeForNapiValue(env, info.argv[ARG_COUNT_THREE], napi_function)) {
165             return true;
166         }
167         if (!CheckTypeForNapiValue(env, info.argv[ARG_COUNT_THREE], napi_number) ||
168             !OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_COUNT_THREE], param.appIndex)) {
169             TAG_LOGE(AAFwkTag::URIPERMMGR, "appIndex invalid");
170             ThrowInvalidParamError(env, "Parse param appCloneIndex failed, appCloneIndex must be number.");
171             return false;
172         }
173         if (param.appIndex < 0) {
174             ThrowInvalidParamError(env, "Param appCloneIndex is invalid, the value less than 0.");
175             return false;
176         }
177         param.hasAppIndex = true;
178     }
179     return true;
180 }
181 
ParseRevokeUriPermissionParams(napi_env env,const NapiCallbackInfo & info,UriPermissionParam & param)182 static bool ParseRevokeUriPermissionParams(napi_env env, const NapiCallbackInfo &info, UriPermissionParam &param)
183 {
184     // only support 2 or 3 params
185     if (info.argc < ARG_COUNT_TWO) {
186         TAG_LOGE(AAFwkTag::URIPERMMGR, "Invalid args");
187         ThrowTooFewParametersError(env);
188         return false;
189     }
190     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[0], param.uriStr)) {
191         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid uriStr");
192         ThrowInvalidParamError(env, "Parse param uri failed, uri must be string.");
193         return false;
194     }
195     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[1], param.bundleName)) {
196         TAG_LOGE(AAFwkTag::URIPERMMGR, "bundleName invalid");
197         ThrowInvalidParamError(env, "Parse param bundleName failed, bundleName must be string.");
198         return false;
199     }
200     if (info.argc >= ARG_COUNT_THREE) {
201         // process param index or callback
202         if (CheckTypeForNapiValue(env, info.argv[ARG_COUNT_TWO], napi_function)) {
203             return true;
204         }
205         if (!CheckTypeForNapiValue(env, info.argv[ARG_COUNT_TWO], napi_number) ||
206             !OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_COUNT_TWO], param.appIndex)) {
207             TAG_LOGE(AAFwkTag::URIPERMMGR, "appCloneIndex invalid");
208             ThrowInvalidParamError(env, "Parse param appCloneIndex failed, appCloneIndex must be number.");
209             return false;
210         }
211         if (param.appIndex < 0) {
212             ThrowInvalidParamError(env, "Param appCloneIndex is invalid, the value less than 0.");
213             return false;
214         }
215         param.hasAppIndex = true;
216     }
217     return true;
218 }
219 
ParseGrantUriPermissionByKeyParams(napi_env env,const NapiCallbackInfo & info,UriPermissionParam & param)220 static bool ParseGrantUriPermissionByKeyParams(napi_env env, const NapiCallbackInfo &info,
221     UriPermissionParam &param)
222 {
223     // key, flag, callerTokenId, targetTokenId
224     if (info.argc < ARG_COUNT_THREE) {
225         TAG_LOGE(AAFwkTag::URIPERMMGR, "Too few args");
226         ThrowTooFewParametersError(env);
227         return false;
228     }
229     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[ARG_INDEX_ZERO], param.key)) {
230         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid key");
231         ThrowInvalidParamError(env, "Failed to parse param key, key must be string.");
232         return false;
233     }
234     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_INDEX_ONE], param.flag)) {
235         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid flag");
236         ThrowInvalidParamError(env, "Failed to parse param flag, flag must be number.");
237         return false;
238     }
239     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_INDEX_TWO], param.targetTokenId)) {
240         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid targetTokenId");
241         ThrowInvalidParamError(env, "Failed to parse param targetTokenId, targetTokenId must be number.");
242         return false;
243     }
244     return true;
245 }
246 
ParseGrantUriPermissionByKeyAsCallerParams(napi_env env,const NapiCallbackInfo & info,UriPermissionParam & param)247 static bool ParseGrantUriPermissionByKeyAsCallerParams(napi_env env, const NapiCallbackInfo &info,
248     UriPermissionParam &param)
249 {
250     // key, flag, callerTokenId, targetTokenId
251     if (info.argc < ARG_COUNT_FOUR) {
252         TAG_LOGE(AAFwkTag::URIPERMMGR, "Too few args");
253         ThrowTooFewParametersError(env);
254         return false;
255     }
256     if (!OHOS::AppExecFwk::UnwrapStringFromJS2(env, info.argv[ARG_INDEX_ZERO], param.key)) {
257         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid key");
258         ThrowInvalidParamError(env, "Failed to parse param key, key must be string.");
259         return false;
260     }
261     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_INDEX_ONE], param.flag)) {
262         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid flag");
263         ThrowInvalidParamError(env, "Failed to parse param flag, flag must be number.");
264         return false;
265     }
266     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_INDEX_TWO], param.callerTokenId)) {
267         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid callerTokenId");
268         ThrowInvalidParamError(env, "Failed to parse param callerTokenId, callerTokenId must be number.");
269         return false;
270     }
271     if (!OHOS::AppExecFwk::UnwrapInt32FromJS2(env, info.argv[ARG_INDEX_THREE], param.targetTokenId)) {
272         TAG_LOGE(AAFwkTag::URIPERMMGR, "invalid targetTokenId");
273         ThrowInvalidParamError(env, "Failed to Parse param targetTokenId, targetTokenId must be number.");
274         return false;
275     }
276     return true;
277 }
278 }
279 class JsUriPermMgr {
280 public:
281     JsUriPermMgr() = default;
282     ~JsUriPermMgr() = default;
283 
Finalizer(napi_env env,void * data,void * hint)284     static void Finalizer(napi_env env, void* data, void* hint)
285     {
286         TAG_LOGI(AAFwkTag::URIPERMMGR, "call");
287         std::unique_ptr<JsUriPermMgr>(static_cast<JsUriPermMgr*>(data));
288     }
289 
GrantUriPermission(napi_env env,napi_callback_info info)290     static napi_value GrantUriPermission(napi_env env, napi_callback_info info)
291     {
292         GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnGrantUriPermission);
293     }
294 
RevokeUriPermission(napi_env env,napi_callback_info info)295     static napi_value RevokeUriPermission(napi_env env, napi_callback_info info)
296     {
297         GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnRevokeUriPermission);
298     }
299 
GrantUriPermissionByKeyAsCaller(napi_env env,napi_callback_info info)300     static napi_value GrantUriPermissionByKeyAsCaller(napi_env env, napi_callback_info info)
301     {
302         GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnGrantUriPermissionByKeyAsCaller);
303     }
304 
GrantUriPermissionByKey(napi_env env,napi_callback_info info)305     static napi_value GrantUriPermissionByKey(napi_env env, napi_callback_info info)
306     {
307         GET_NAPI_INFO_AND_CALL(env, info, JsUriPermMgr, OnGrantUriPermissionByKey);
308     }
309 
310 private:
OnGrantUriPermission(napi_env env,NapiCallbackInfo & info)311     napi_value OnGrantUriPermission(napi_env env, NapiCallbackInfo& info)
312     {
313         TAG_LOGD(AAFwkTag::URIPERMMGR, "start");
314         UriPermissionParam param;
315         if (!ParseGrantUriPermissionParams(env, info, param)) {
316             return CreateJsUndefined(env);
317         }
318         auto selfToken = IPCSkeleton::GetSelfTokenID();
319         if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
320             TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app");
321             ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP);
322             return CreateJsUndefined(env);
323         }
324         auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
325         NapiAsyncTask::ExecuteCallback execute =
326             [param, innerErrCode]() {
327                 Uri uri(param.uriStr);
328                 *innerErrCode = AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermission(uri,
329                     param.flag, param.bundleName, param.appIndex);
330         };
331         NapiAsyncTask::CompleteCallback complete =
332         [param, innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
333             if (*innerErrCode != ERR_OK) {
334                 TAG_LOGE(AAFwkTag::URIPERMMGR, "GrantUriPermission ret: %{public}d", *innerErrCode);
335             }
336             if (param.hasAppIndex) {
337                 return ResolveGrantUriPermissionWithAppIndexTask(env, task, *innerErrCode);
338             }
339             return ResolveGrantUriPermissionTask(env, task, *innerErrCode);
340         };
341         napi_value lastParam = (info.argc >= ARG_COUNT_FOUR && !param.hasAppIndex) ?
342             info.argv[ARG_COUNT_THREE] : nullptr;
343         napi_value result = nullptr;
344         NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnGrantUriPermission",
345             env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
346         return result;
347     }
348 
OnGrantUriPermissionByKey(napi_env env,const NapiCallbackInfo & info)349     napi_value OnGrantUriPermissionByKey(napi_env env, const NapiCallbackInfo &info)
350     {
351         TAG_LOGD(AAFwkTag::URIPERMMGR, "OnGrantUriPermissionByKey start");
352         UriPermissionParam param;
353         if (!ParseGrantUriPermissionByKeyParams(env, info, param)) {
354             return CreateJsUndefined(env);
355         }
356         auto selfToken = IPCSkeleton::GetSelfTokenID();
357         if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
358             TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app");
359             ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP);
360             return CreateJsUndefined(env);
361         }
362         auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
363         NapiAsyncTask::ExecuteCallback execute =
364             [param, innerErrCode]() {
365                 *innerErrCode = AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermissionByKey(
366                     param.key, param.flag, param.targetTokenId);
367         };
368         NapiAsyncTask::CompleteCallback complete =
369         [innerErrCode](napi_env env, NapiAsyncTask &task, int32_t status) {
370             if (*innerErrCode != ERR_OK) {
371                 TAG_LOGE(AAFwkTag::URIPERMMGR, "GrantUriPermissionByKey fail:%{public}d", *innerErrCode);
372             }
373             ResolveGrantUriPermissionByKeyTask(env, task, *innerErrCode);
374         };
375         napi_value result = nullptr;
376         NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnGrantUriPermissionByKey",
377             env, CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
378         return result;
379     }
380 
OnGrantUriPermissionByKeyAsCaller(napi_env env,const NapiCallbackInfo & info)381     napi_value OnGrantUriPermissionByKeyAsCaller(napi_env env, const NapiCallbackInfo& info)
382     {
383         TAG_LOGD(AAFwkTag::URIPERMMGR, "OnGrantUriPermissionByKeyAsCaller start");
384         UriPermissionParam param;
385         if (!ParseGrantUriPermissionByKeyAsCallerParams(env, info, param)) {
386             return CreateJsUndefined(env);
387         }
388         auto selfToken = IPCSkeleton::GetSelfTokenID();
389         if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
390             TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app");
391             ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP);
392             return CreateJsUndefined(env);
393         }
394         auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
395         NapiAsyncTask::ExecuteCallback execute =
396             [param, innerErrCode]() {
397                 *innerErrCode = AAFwk::UriPermissionManagerClient::GetInstance().GrantUriPermissionByKeyAsCaller(
398                     param.key, param.flag, param.callerTokenId, param.targetTokenId);
399         };
400         NapiAsyncTask::CompleteCallback complete =
401         [innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
402             if (*innerErrCode != ERR_OK) {
403                 TAG_LOGE(AAFwkTag::URIPERMMGR, "GrantUriPermissionByKeyAsCaller fail:%{public}d", *innerErrCode);
404             }
405             ResolveGrantUriPermissionByKeyAsCallerTask(env, task, *innerErrCode);
406         };
407         napi_value result = nullptr;
408         NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnGrantUriPermissionByKeyAsCaller",
409             env, CreateAsyncTaskWithLastParam(env, nullptr, std::move(execute), std::move(complete), &result));
410         return result;
411     }
412 
OnRevokeUriPermission(napi_env env,NapiCallbackInfo & info)413     napi_value OnRevokeUriPermission(napi_env env, NapiCallbackInfo& info)
414     {
415         TAG_LOGD(AAFwkTag::URIPERMMGR, "start");
416         UriPermissionParam param;
417         if (!ParseRevokeUriPermissionParams(env, info, param)) {
418             return CreateJsUndefined(env);
419         }
420         auto selfToken = IPCSkeleton::GetSelfTokenID();
421         if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(selfToken)) {
422             TAG_LOGE(AAFwkTag::URIPERMMGR, "app not system-app");
423             ThrowError(env, AbilityErrorCode::ERROR_CODE_NOT_SYSTEM_APP);
424             return CreateJsUndefined(env);
425         }
426         auto innerErrCode = std::make_shared<ErrCode>(ERR_OK);
427         NapiAsyncTask::ExecuteCallback execute = [param, innerErrCode]() {
428             Uri uri(param.uriStr);
429             *innerErrCode = AAFwk::UriPermissionManagerClient::GetInstance().RevokeUriPermissionManually(uri,
430                 param.bundleName, param.appIndex);
431         };
432         NapiAsyncTask::CompleteCallback complete =
433         [param, innerErrCode](napi_env env, NapiAsyncTask& task, int32_t status) {
434             if (*innerErrCode != ERR_OK) {
435                 TAG_LOGE(AAFwkTag::URIPERMMGR, "RevokeUriPermissionManually ret: %{public}d", *innerErrCode);
436             }
437             if (param.hasAppIndex) {
438                 return ResolveRevokeUriPermissionWithAppIndexTask(env, task, *innerErrCode);
439             }
440             return ResolveRevokeUriPermissionTask(env, task, *innerErrCode);
441         };
442         napi_value lastParam = (info.argc >= ARG_COUNT_THREE && !param.hasAppIndex) ?
443             info.argv[ARG_COUNT_TWO] : nullptr;
444         napi_value result = nullptr;
445         NapiAsyncTask::ScheduleHighQos("JsUriPermMgr::OnRevokeUriPermission",
446             env, CreateAsyncTaskWithLastParam(env, lastParam, std::move(execute), std::move(complete), &result));
447         return result;
448     }
449 };
450 
CreateJsUriPermMgr(napi_env env,napi_value exportObj)451 napi_value CreateJsUriPermMgr(napi_env env, napi_value exportObj)
452 {
453     TAG_LOGD(AAFwkTag::URIPERMMGR, "call");
454     if (env == nullptr || exportObj == nullptr) {
455         TAG_LOGI(AAFwkTag::URIPERMMGR, "Invalid param");
456         return nullptr;
457     }
458 
459     std::unique_ptr<JsUriPermMgr> jsUriPermMgr = std::make_unique<JsUriPermMgr>();
460     napi_wrap(env, exportObj, jsUriPermMgr.release(), JsUriPermMgr::Finalizer, nullptr, nullptr);
461 
462     const char *moduleName = "JsUriPermMgr";
463     BindNativeFunction(env, exportObj, "grantUriPermission", moduleName, JsUriPermMgr::GrantUriPermission);
464     BindNativeFunction(env, exportObj, "revokeUriPermission", moduleName, JsUriPermMgr::RevokeUriPermission);
465     BindNativeFunction(env, exportObj, "grantUriPermissionByKey", moduleName, JsUriPermMgr::GrantUriPermissionByKey);
466     BindNativeFunction(env, exportObj, "grantUriPermissionByKeyAsCaller", moduleName,
467         JsUriPermMgr::GrantUriPermissionByKeyAsCaller);
468     return CreateJsUndefined(env);
469 }
470 }  // namespace AbilityRuntime
471 }  // namespace OHOS
472