1 /*
2 * Copyright (c) 2024 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 "napi_context_helper.h"
17
18 #include <cstring>
19 #include <uv.h>
20
21 #include "napi_common_ability.h"
22 #include "ability_util.h"
23 #include "ability_process.h"
24 #include "directory_ex.h"
25 #include "feature_ability_common.h"
26 #include "file_ex.h"
27 #include "hilog_tag_wrapper.h"
28 #include "js_napi_common_ability.h"
29 #include "permission_list_state.h"
30 #include "securec.h"
31
32 using namespace OHOS::AAFwk;
33 using namespace OHOS::AppExecFwk;
34 using namespace OHOS::AbilityRuntime;
35
36 namespace OHOS {
37 namespace AppExecFwk {
38 const std::string NAPI_CONTEXT_FILE_SEPARATOR = std::string("/");
39 const std::string NAPI_CONTEXT_DATABASE = std::string("database");
40 const std::string NAPI_CONTEXT_PREFERENCES = std::string("preferences");
41
42 #ifdef SUPPORT_GRAPHICS
GetJSAbilityObject(napi_env env)43 static Ability* GetJSAbilityObject(napi_env env)
44 {
45 napi_value global = nullptr;
46 NAPI_CALL(env, napi_get_global(env, &global));
47
48 napi_value abilityObj = nullptr;
49 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
50
51 Ability *ability = nullptr;
52 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
53 return ability;
54 }
55
SetShowOnLockScreenAsyncCompleteCB(napi_env env,ShowOnLockScreenCB * showOnLockScreenCB)56 void SetShowOnLockScreenAsyncCompleteCB(napi_env env, ShowOnLockScreenCB *showOnLockScreenCB)
57 {
58 TAG_LOGD(AAFwkTag::JSNAPI, "called");
59 if (showOnLockScreenCB == nullptr) {
60 TAG_LOGE(AAFwkTag::JSNAPI, "null showOnLockScreenCB");
61 return;
62 }
63
64 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
65 if (showOnLockScreenCB->cbBase.ability == nullptr) {
66 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
67 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
68 } else {
69 #ifdef SUPPORT_SCREEN
70 showOnLockScreenCB->cbBase.ability->SetShowOnLockScreen(showOnLockScreenCB->isShow);
71 #endif
72 }
73
74 napi_value callback = nullptr, undefined = nullptr, callResult = nullptr;
75 napi_value result[ARGS_TWO] = {nullptr};
76 napi_get_undefined(env, &undefined);
77 result[PARAM0] = GetCallbackErrorValue(env, showOnLockScreenCB->cbBase.errCode);
78 napi_get_null(env, &result[PARAM1]);
79 napi_get_reference_value(env, showOnLockScreenCB->cbBase.cbInfo.callback, &callback);
80 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
81
82 if (showOnLockScreenCB->cbBase.cbInfo.callback != nullptr) {
83 napi_delete_reference(env, showOnLockScreenCB->cbBase.cbInfo.callback);
84 }
85 napi_delete_async_work(env, showOnLockScreenCB->cbBase.asyncWork);
86 delete showOnLockScreenCB;
87 showOnLockScreenCB = nullptr;
88 }
89
SetShowOnLockScreenAsync(napi_env env,napi_value * args,ShowOnLockScreenCB * showOnLockScreenCB)90 napi_value SetShowOnLockScreenAsync(napi_env env, napi_value *args, ShowOnLockScreenCB *showOnLockScreenCB)
91 {
92 TAG_LOGD(AAFwkTag::JSNAPI, "called");
93 if (showOnLockScreenCB == nullptr) {
94 TAG_LOGE(AAFwkTag::JSNAPI, "null showOnLockScreenCB");
95 return nullptr;
96 }
97
98 napi_valuetype valuetypeParam1 = napi_undefined;
99 NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetypeParam1));
100 if (valuetypeParam1 != napi_function) {
101 TAG_LOGE(AAFwkTag::JSNAPI, "error type");
102 return nullptr;
103 }
104
105 NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &showOnLockScreenCB->cbBase.cbInfo.callback));
106
107 auto res = napi_send_event(env,
108 [env, showOnLockScreenCB] () {SetShowOnLockScreenAsyncCompleteCB(env, showOnLockScreenCB);},
109 napi_eprio_immediate);
110 if (res != napi_status::napi_ok) {
111 TAG_LOGE(AAFwkTag::JSNAPI, "napi_send_event failed");
112 }
113 napi_value result = nullptr;
114 NAPI_CALL(env, napi_get_null(env, &result));
115
116 return result;
117 }
118
SetShowOnLockScreenAsyncCB(napi_env env,ShowOnLockScreenCB * showOnLockScreenCB)119 static void SetShowOnLockScreenAsyncCB(napi_env env, ShowOnLockScreenCB *showOnLockScreenCB)
120 {
121 showOnLockScreenCB->cbBase.errCode = NO_ERROR;
122 if (showOnLockScreenCB->cbBase.ability == nullptr) {
123 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
124 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
125 } else {
126 #ifdef SUPPORT_SCREEN
127 showOnLockScreenCB->cbBase.ability->SetShowOnLockScreen(showOnLockScreenCB->isShow);
128 #endif
129 }
130
131 napi_value result = GetCallbackErrorValue(env, showOnLockScreenCB->cbBase.errCode);
132 if (showOnLockScreenCB->cbBase.errCode == NO_ERROR) {
133 napi_resolve_deferred(env, showOnLockScreenCB->cbBase.deferred, result);
134 } else {
135 napi_reject_deferred(env, showOnLockScreenCB->cbBase.deferred, result);
136 }
137
138 delete showOnLockScreenCB;
139 showOnLockScreenCB = nullptr;
140 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
141 }
142
SetShowOnLockScreenPromise(napi_env env,ShowOnLockScreenCB * cbData)143 napi_value SetShowOnLockScreenPromise(napi_env env, ShowOnLockScreenCB *cbData)
144 {
145 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
146 if (cbData == nullptr) {
147 TAG_LOGE(AAFwkTag::JSNAPI, "null cbData");
148 return nullptr;
149 }
150
151 napi_deferred deferred;
152 napi_value promise = nullptr;
153 napi_create_promise(env, &deferred, &promise);
154 cbData->cbBase.deferred = deferred;
155
156 auto res = napi_send_event(env,
157 [env, cbData] () {SetShowOnLockScreenAsyncCB(env, cbData);},
158 napi_eprio_immediate);
159 if (res != napi_status::napi_ok) {
160 TAG_LOGE(AAFwkTag::JSNAPI, "napi_send_event failed");
161 }
162 TAG_LOGI(AAFwkTag::JSNAPI, "promise end");
163 return promise;
164 }
165
SetWakeUpScreenAsyncCompleteCB(napi_env env,SetWakeUpScreenCB * setWakeUpScreenCB)166 static void SetWakeUpScreenAsyncCompleteCB(napi_env env, SetWakeUpScreenCB *setWakeUpScreenCB)
167 {
168 TAG_LOGI(AAFwkTag::JSNAPI, "called");
169 if (setWakeUpScreenCB == nullptr) {
170 TAG_LOGE(AAFwkTag::JSNAPI, "null setWakeUpScreenCB");
171 return;
172 }
173
174 do {
175 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
176 if (setWakeUpScreenCB->cbBase.ability == nullptr) {
177 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
178 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
179 break;
180 }
181 #ifdef SUPPORT_SCREEN
182 setWakeUpScreenCB->cbBase.ability->SetWakeUpScreen(setWakeUpScreenCB->wakeUp);
183 #endif
184 } while (false);
185
186 napi_value callback = nullptr;
187 napi_value undefined = nullptr;
188 napi_value callResult = nullptr;
189 napi_value result[ARGS_TWO] = {nullptr};
190 napi_get_undefined(env, &undefined);
191 result[PARAM0] = GetCallbackErrorValue(env, setWakeUpScreenCB->cbBase.errCode);
192 napi_get_null(env, &result[PARAM1]);
193 napi_get_reference_value(env, setWakeUpScreenCB->cbBase.cbInfo.callback, &callback);
194 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
195
196 if (setWakeUpScreenCB->cbBase.cbInfo.callback != nullptr) {
197 napi_delete_reference(env, setWakeUpScreenCB->cbBase.cbInfo.callback);
198 }
199 napi_delete_async_work(env, setWakeUpScreenCB->cbBase.asyncWork);
200 delete setWakeUpScreenCB;
201 setWakeUpScreenCB = nullptr;
202 }
203
204
SetWakeUpScreenAsync(napi_env env,napi_value * args,SetWakeUpScreenCB * cbData)205 static napi_value SetWakeUpScreenAsync(napi_env env, napi_value *args, SetWakeUpScreenCB *cbData)
206 {
207 TAG_LOGI(AAFwkTag::JSNAPI, "called");
208 if (cbData == nullptr || args == nullptr) {
209 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
210 return nullptr;
211 }
212
213 napi_valuetype valuetypeParam0 = napi_undefined;
214 napi_valuetype valuetypeParam1 = napi_undefined;
215 NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetypeParam0));
216 NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetypeParam1));
217 if (valuetypeParam0 != napi_boolean || valuetypeParam1 != napi_function) {
218 TAG_LOGE(AAFwkTag::JSNAPI, "error type");
219 return nullptr;
220 }
221 NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &cbData->cbBase.cbInfo.callback));
222
223 auto res = napi_send_event(env,
224 [env, cbData] () {SetWakeUpScreenAsyncCompleteCB(env, cbData);},
225 napi_eprio_high);
226 if (res != napi_status::napi_ok) {
227 TAG_LOGE(AAFwkTag::JSNAPI, "napi_send_event failed");
228 }
229 napi_value result = nullptr;
230 NAPI_CALL(env, napi_get_null(env, &result));
231 return result;
232 }
233
SetWakeUpScreenAsyncCB(napi_env env,SetWakeUpScreenCB * setWakeUpScreenCB)234 static void SetWakeUpScreenAsyncCB(napi_env env, SetWakeUpScreenCB *setWakeUpScreenCB)
235 {
236 TAG_LOGI(AAFwkTag::JSNAPI, "complete called");
237 setWakeUpScreenCB->cbBase.errCode = NO_ERROR;
238 if (setWakeUpScreenCB->cbBase.ability == nullptr) {
239 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
240 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
241 } else {
242 #ifdef SUPPORT_SCREEN
243 setWakeUpScreenCB->cbBase.ability->SetWakeUpScreen(setWakeUpScreenCB->wakeUp);
244 #endif
245 }
246 napi_value result = GetCallbackErrorValue(env, setWakeUpScreenCB->cbBase.errCode);
247 if (setWakeUpScreenCB->cbBase.errCode == NO_ERROR) {
248 napi_resolve_deferred(env, setWakeUpScreenCB->cbBase.deferred, result);
249 } else {
250 napi_reject_deferred(env, setWakeUpScreenCB->cbBase.deferred, result);
251 }
252
253 delete setWakeUpScreenCB;
254 setWakeUpScreenCB = nullptr;
255 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
256 }
257
SetWakeUpScreenPromise(napi_env env,SetWakeUpScreenCB * cbData)258 napi_value SetWakeUpScreenPromise(napi_env env, SetWakeUpScreenCB *cbData)
259 {
260 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
261 if (cbData == nullptr) {
262 TAG_LOGE(AAFwkTag::JSNAPI, "null cbData");
263 return nullptr;
264 }
265 napi_deferred deferred;
266 napi_value promise = nullptr;
267 napi_create_promise(env, &deferred, &promise);
268 cbData->cbBase.deferred = deferred;
269
270 auto res = napi_send_event(env,
271 [env, cbData] () {SetWakeUpScreenAsyncCB(env, cbData);},
272 napi_eprio_high);
273 if (res != napi_status::napi_ok) {
274 TAG_LOGE(AAFwkTag::JSNAPI, "napi_send_event failed");
275 }
276 return promise;
277 }
278
SetWakeUpScreenWrap(napi_env env,napi_callback_info info,SetWakeUpScreenCB * cbData)279 napi_value SetWakeUpScreenWrap(napi_env env, napi_callback_info info, SetWakeUpScreenCB *cbData)
280 {
281 TAG_LOGI(AAFwkTag::JSNAPI, "called");
282 if (cbData == nullptr) {
283 TAG_LOGE(AAFwkTag::JSNAPI, "null cbData");
284 return nullptr;
285 }
286
287 size_t argcAsync = 2;
288 const size_t argStdValue = 2;
289 const size_t argPromise = 1;
290 napi_value args[ARGS_MAX_COUNT] = {nullptr};
291
292 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
293 if (argcAsync != argStdValue && argcAsync != argPromise) {
294 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
295 return nullptr;
296 }
297
298 if (!UnwrapBoolFromJS2(env, args[PARAM0], cbData->wakeUp)) {
299 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapBoolFromJS2(wakeUp) run error");
300 return nullptr;
301 }
302
303 napi_value global = nullptr;
304 NAPI_CALL(env, napi_get_global(env, &global));
305
306 napi_value abilityObj = nullptr;
307 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
308
309 Ability *ability = nullptr;
310 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
311
312 cbData->cbBase.ability = ability;
313 napi_value ret = nullptr;
314 if (argcAsync == argStdValue) {
315 ret = SetWakeUpScreenAsync(env, args, cbData);
316 } else {
317 ret = SetWakeUpScreenPromise(env, cbData);
318 }
319 return ret;
320 }
321
UnwrapSetDisplayOrientation(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)322 bool UnwrapSetDisplayOrientation(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
323 {
324 TAG_LOGD(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
325
326 const size_t argcMax = 2;
327 if (argc > argcMax || argc < argcMax - 1) {
328 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
329 return false;
330 }
331
332 if (argc == argcMax) {
333 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
334 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
335 return false;
336 }
337 }
338
339 int orientation = 0;
340 if (!UnwrapInt32FromJS2(env, argv[PARAM0], orientation)) {
341 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
342 return false;
343 }
344
345 int maxRange = 3;
346 if (orientation < 0 || orientation > maxRange) {
347 TAG_LOGE(AAFwkTag::JSNAPI, "wrong parameter range");
348 return false;
349 }
350
351 asyncCallbackInfo->param.paramArgs.PutIntValue("orientation", orientation);
352 return true;
353 }
354
SetDisplayOrientationExecuteCallbackWork(napi_env env,void * data)355 void SetDisplayOrientationExecuteCallbackWork(napi_env env, void *data)
356 {
357 TAG_LOGD(AAFwkTag::JSNAPI, "called");
358 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
359 if (asyncCallbackInfo == nullptr) {
360 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
361 return;
362 }
363
364 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
365 asyncCallbackInfo->native_data.data_type = NVT_NONE;
366 if (asyncCallbackInfo->ability == nullptr) {
367 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
368 return;
369 }
370 #ifdef SUPPORT_SCREEN
371 int orientation = asyncCallbackInfo->param.paramArgs.GetIntValue("orientation");
372 asyncCallbackInfo->ability->SetDisplayOrientation(orientation);
373 #endif
374 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
375 }
376
NAPI_SetDisplayOrientationWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)377 napi_value NAPI_SetDisplayOrientationWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
378 {
379 TAG_LOGD(AAFwkTag::JSNAPI, "called");
380 size_t argc = ARGS_MAX_COUNT;
381 napi_value args[ARGS_MAX_COUNT] = {nullptr};
382 napi_value jsthis = nullptr;
383 void *data = nullptr;
384
385 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
386
387 if (!UnwrapSetDisplayOrientation(env, argc, args, asyncCallbackInfo)) {
388 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapSetDisplayOrientation fail");
389 return nullptr;
390 }
391
392 AsyncParamEx asyncParamEx;
393 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
394 asyncParamEx.resource = "NAPI_SetDisplayOrientationCallback";
395 asyncParamEx.execute = SetDisplayOrientationExecuteCallbackWork;
396 asyncParamEx.complete = CompleteAsyncCallbackWork;
397
398 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
399 } else {
400 asyncParamEx.resource = "NAPI_SetDisplayOrientationPromise";
401 asyncParamEx.execute = SetDisplayOrientationExecuteCallbackWork;
402 asyncParamEx.complete = CompletePromiseCallbackWork;
403
404 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
405 }
406 }
407
NAPI_SetShowOnLockScreen(napi_env env,napi_callback_info info)408 napi_value NAPI_SetShowOnLockScreen(napi_env env, napi_callback_info info)
409 {
410 #ifdef SUPPORT_GRAPHICS
411 TAG_LOGI(AAFwkTag::JSNAPI, "called");
412
413 size_t argc = 2;
414 const size_t argcAsync = 2, argcPromise = 1;
415 napi_value args[ARGS_MAX_COUNT] = {nullptr};
416
417 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
418 if (argc != argcAsync && argc != argcPromise) {
419 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
420 return nullptr;
421 }
422
423 napi_valuetype valuetypeParam0 = napi_undefined;
424 NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetypeParam0));
425 if (valuetypeParam0 != napi_boolean) {
426 TAG_LOGE(AAFwkTag::JSNAPI, "error type");
427 return nullptr;
428 }
429
430 ShowOnLockScreenCB *showOnLockScreenCB = new ShowOnLockScreenCB();
431 showOnLockScreenCB->cbBase.cbInfo.env = env;
432 showOnLockScreenCB->cbBase.abilityType = AbilityType::PAGE;
433 if (!UnwrapBoolFromJS2(env, args[PARAM0], showOnLockScreenCB->isShow)) {
434 TAG_LOGE(AAFwkTag::JSNAPI, "unwrapBoolFromJS2 error");
435 delete showOnLockScreenCB;
436 showOnLockScreenCB = nullptr;
437 return nullptr;
438 }
439
440 showOnLockScreenCB->cbBase.ability = GetJSAbilityObject(env);
441 napi_value ret = nullptr;
442 if (argc == argcAsync) {
443 ret = SetShowOnLockScreenAsync(env, args, showOnLockScreenCB);
444 } else {
445 ret = SetShowOnLockScreenPromise(env, showOnLockScreenCB);
446 }
447
448 if (ret == nullptr) {
449 TAG_LOGE(AAFwkTag::JSNAPI, "SetShowOnLockScreenWrap failed");
450 delete showOnLockScreenCB;
451 showOnLockScreenCB = nullptr;
452 ret = WrapVoidToJS(env);
453 }
454 return ret;
455 #else
456 return nullptr;
457 #endif
458 }
459 #endif
460
UnwrapParamVerifySelfPermission(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)461 bool UnwrapParamVerifySelfPermission(
462 napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
463 {
464 TAG_LOGI(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
465
466 const size_t argcMax = 2;
467 if (argc > argcMax || argc < argcMax - 1) {
468 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
469 return false;
470 }
471
472 if (argc == argcMax) {
473 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
474 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
475 return false;
476 }
477 }
478
479 std::string permission("");
480 if (!UnwrapStringFromJS2(env, argv[PARAM0], permission)) {
481 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
482 return false;
483 }
484
485 asyncCallbackInfo->param.paramArgs.PutStringValue("permission", permission);
486 return true;
487 }
488
VerifySelfPermissionExecuteCallbackWork(napi_env env,void * data)489 void VerifySelfPermissionExecuteCallbackWork(napi_env env, void *data)
490 {
491 TAG_LOGI(AAFwkTag::JSNAPI, "called");
492
493 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
494 if (asyncCallbackInfo == nullptr) {
495 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
496 return;
497 }
498
499 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
500 asyncCallbackInfo->native_data.data_type = NVT_NONE;
501
502 if (asyncCallbackInfo->ability == nullptr) {
503 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
504 return;
505 }
506
507 asyncCallbackInfo->native_data.data_type = NVT_INT32;
508 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifySelfPermission(
509 asyncCallbackInfo->param.paramArgs.GetStringValue("permission"));
510 }
511
NAPI_VerifySelfPermissionWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)512 napi_value NAPI_VerifySelfPermissionWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
513 {
514 TAG_LOGI(AAFwkTag::JSNAPI, "called");
515 size_t argc = ARGS_MAX_COUNT;
516 napi_value args[ARGS_MAX_COUNT] = {nullptr};
517 napi_value jsthis = nullptr;
518 void *data = nullptr;
519
520 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
521
522 if (!UnwrapParamVerifySelfPermission(env, argc, args, asyncCallbackInfo)) {
523 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapParamVerifySelfPermission fail");
524 return nullptr;
525 }
526
527 AsyncParamEx asyncParamEx;
528 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
529 asyncParamEx.resource = "NAPI_VerifySelfPermissionCallback";
530 asyncParamEx.execute = VerifySelfPermissionExecuteCallbackWork;
531 asyncParamEx.complete = CompleteAsyncCallbackWork;
532
533 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
534 } else {
535 asyncParamEx.resource = "NAPI_VerifySelfPermissionPromise";
536 asyncParamEx.execute = VerifySelfPermissionExecuteCallbackWork;
537 asyncParamEx.complete = CompletePromiseCallbackWork;
538
539 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
540 }
541 }
542
UnwrapRequestPermissionsFromUser(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)543 bool UnwrapRequestPermissionsFromUser(
544 napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
545 {
546 TAG_LOGI(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
547
548 const size_t argcMax = 3;
549 if (argc > argcMax || argc < argcMax - 1) {
550 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
551 return false;
552 }
553
554 if (argc == argcMax) {
555 if (!CreateAsyncCallback(env, argv[PARAM2], asyncCallbackInfo)) {
556 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM2] invalid");
557 return false;
558 }
559 }
560
561 std::vector<std::string> permissionList;
562 if (!UnwrapArrayStringFromJS(env, argv[PARAM0], permissionList)) {
563 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
564 return false;
565 }
566
567 int requestCode = 0;
568 if (!UnwrapInt32FromJS2(env, argv[PARAM1], requestCode)) {
569 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
570 return false;
571 }
572
573 asyncCallbackInfo->param.paramArgs.PutIntValue("requestCode", requestCode);
574 asyncCallbackInfo->param.paramArgs.PutStringValueArray("permissionList", permissionList);
575 return true;
576 }
577
RequestPermissionsFromUserExecuteCallbackWork(napi_env env,void * data)578 void RequestPermissionsFromUserExecuteCallbackWork(napi_env env, void *data)
579 {
580 TAG_LOGI(AAFwkTag::JSNAPI, "called");
581 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
582 if (asyncCallbackInfo == nullptr) {
583 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
584 return;
585 }
586
587 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
588 if (asyncCallbackInfo->ability == nullptr) {
589 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
590 return;
591 }
592
593 CallAbilityPermissionParam permissionParam;
594 permissionParam.requestCode = asyncCallbackInfo->param.paramArgs.GetIntValue("requestCode");
595 asyncCallbackInfo->param.paramArgs.GetStringValueArray("permissionList", permissionParam.permission_list);
596 if (permissionParam.permission_list.size() == 0) {
597 asyncCallbackInfo->error_code = NAPI_ERR_PARAM_INVALID;
598 return;
599 }
600
601 AbilityProcess::GetInstance()->RequestPermissionsFromUser(
602 asyncCallbackInfo->ability, permissionParam, asyncCallbackInfo->cbInfo);
603 }
604
RequestPermissionsFromUserCompleteAsyncCallbackWork(napi_env env,napi_status status,void * data)605 void RequestPermissionsFromUserCompleteAsyncCallbackWork(napi_env env, napi_status status, void *data)
606 {
607 TAG_LOGI(AAFwkTag::JSNAPI, "called");
608
609 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
610 if (asyncCallbackInfo == nullptr) {
611 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
612 return;
613 }
614
615 if (asyncCallbackInfo->error_code != NAPI_ERR_NO_ERROR) {
616 napi_value callback = nullptr;
617 napi_value undefined = nullptr;
618 napi_get_undefined(env, &undefined);
619 napi_value callResult = nullptr;
620 napi_value revParam[ARGS_TWO] = {nullptr};
621
622 revParam[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->error_code);
623 revParam[PARAM1] = WrapVoidToJS(env);
624
625 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
626 napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
627 napi_call_function(env, undefined, callback, ARGS_TWO, revParam, &callResult);
628 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
629 } else if (asyncCallbackInfo->cbInfo.deferred != nullptr) {
630 napi_reject_deferred(env, asyncCallbackInfo->cbInfo.deferred, revParam[PARAM0]);
631 }
632 }
633
634 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
635 delete asyncCallbackInfo;
636 asyncCallbackInfo = nullptr;
637 }
638
NAPI_RequestPermissionsFromUserWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)639 napi_value NAPI_RequestPermissionsFromUserWrap(
640 napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
641 {
642 TAG_LOGD(AAFwkTag::JSNAPI, "called");
643 size_t argc = ARGS_MAX_COUNT;
644 napi_value args[ARGS_MAX_COUNT] = {nullptr};
645 napi_value jsthis = nullptr;
646 void *data = nullptr;
647
648 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
649
650 if (!UnwrapRequestPermissionsFromUser(env, argc, args, asyncCallbackInfo)) {
651 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapRequestPermissionsFromUser failed");
652 return nullptr;
653 }
654
655 AsyncParamEx asyncParamEx;
656 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
657 asyncParamEx.resource = "NAPI_RequestPermissionsFromUserCallback";
658 asyncParamEx.execute = RequestPermissionsFromUserExecuteCallbackWork;
659 asyncParamEx.complete = RequestPermissionsFromUserCompleteAsyncCallbackWork;
660
661 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
662 } else {
663 napi_deferred deferred = nullptr;
664 napi_value promise = nullptr;
665 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
666 asyncCallbackInfo->cbInfo.deferred = deferred;
667
668 napi_value resourceName = nullptr;
669 NAPI_CALL(env, napi_create_string_latin1(env, "NAPI_RequestPermissionsFromUserPromise",
670 NAPI_AUTO_LENGTH, &resourceName));
671 NAPI_CALL(env,
672 napi_create_async_work(env,
673 nullptr,
674 resourceName,
675 RequestPermissionsFromUserExecuteCallbackWork,
676 RequestPermissionsFromUserCompleteAsyncCallbackWork,
677 static_cast<void *>(asyncCallbackInfo),
678 &asyncCallbackInfo->asyncWork));
679
680 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
681
682 return promise;
683 }
684 }
685
GetAppInfoExecuteCB(napi_env env,void * data)686 void GetAppInfoExecuteCB(napi_env env, void *data)
687 {
688 TAG_LOGI(AAFwkTag::JSNAPI, "called");
689 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
690 appInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
691
692 if (appInfoCB->cbBase.ability == nullptr) {
693 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
694 appInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
695 return;
696 }
697
698 std::shared_ptr<ApplicationInfo> appInfoPtr = appInfoCB->cbBase.ability->GetApplicationInfo();
699 if (appInfoPtr != nullptr) {
700 appInfoCB->appInfo = *appInfoPtr;
701 } else {
702 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoPtr");
703 appInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
704 }
705 TAG_LOGI(AAFwkTag::JSNAPI, "end");
706 }
707
GetAppInfoAsyncCompleteCB(napi_env env,napi_status status,void * data)708 void GetAppInfoAsyncCompleteCB(napi_env env, napi_status status, void *data)
709 {
710 TAG_LOGI(AAFwkTag::JSNAPI, "called");
711 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
712 napi_value callback = nullptr;
713 napi_value undefined = nullptr;
714 napi_value result[ARGS_TWO] = {nullptr};
715 napi_value callResult = nullptr;
716 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
717 result[PARAM0] = GetCallbackErrorValue(env, appInfoCB->cbBase.errCode);
718 if (appInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
719 result[PARAM1] = WrapAppInfo(env, appInfoCB->appInfo);
720 } else {
721 result[PARAM1] = WrapUndefinedToJS(env);
722 }
723 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appInfoCB->cbBase.cbInfo.callback, &callback));
724 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
725
726 if (appInfoCB->cbBase.cbInfo.callback != nullptr) {
727 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appInfoCB->cbBase.cbInfo.callback));
728 }
729 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appInfoCB->cbBase.asyncWork));
730 delete appInfoCB;
731 appInfoCB = nullptr;
732 TAG_LOGI(AAFwkTag::JSNAPI, "end");
733 }
734
GetApplicationInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AppInfoCB * appInfoCB)735 napi_value GetApplicationInfoAsync(napi_env env, napi_value *args, const size_t argCallback, AppInfoCB *appInfoCB)
736 {
737 TAG_LOGI(AAFwkTag::JSNAPI, "called");
738 if (args == nullptr || appInfoCB == nullptr) {
739 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
740 return nullptr;
741 }
742 napi_value resourceName = nullptr;
743 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
744
745 napi_valuetype valuetype = napi_undefined;
746 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
747 if (valuetype == napi_function) {
748 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appInfoCB->cbBase.cbInfo.callback));
749 }
750 NAPI_CALL(env,
751 napi_create_async_work(env,
752 nullptr,
753 resourceName,
754 GetAppInfoExecuteCB,
755 GetAppInfoAsyncCompleteCB,
756 static_cast<void *>(appInfoCB),
757 &appInfoCB->cbBase.asyncWork));
758 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
759 napi_value result = nullptr;
760 NAPI_CALL(env, napi_get_null(env, &result));
761 TAG_LOGI(AAFwkTag::JSNAPI, "end");
762 return result;
763 }
764
GetAppInfoPromiseCompleteCB(napi_env env,napi_status status,void * data)765 void GetAppInfoPromiseCompleteCB(napi_env env, napi_status status, void *data)
766 {
767 TAG_LOGI(AAFwkTag::JSNAPI, "called");
768 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
769 if (appInfoCB == nullptr) {
770 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
771 return;
772 }
773
774 napi_value result = nullptr;
775 if (appInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
776 result = WrapAppInfo(env, appInfoCB->appInfo);
777 napi_resolve_deferred(env, appInfoCB->cbBase.deferred, result);
778 } else {
779 result = GetCallbackErrorValue(env, appInfoCB->cbBase.errCode);
780 napi_reject_deferred(env, appInfoCB->cbBase.deferred, result);
781 }
782
783 napi_delete_async_work(env, appInfoCB->cbBase.asyncWork);
784 delete appInfoCB;
785 appInfoCB = nullptr;
786 TAG_LOGI(AAFwkTag::JSNAPI, "end");
787 }
788
GetApplicationInfoPromise(napi_env env,AppInfoCB * appInfoCB)789 napi_value GetApplicationInfoPromise(napi_env env, AppInfoCB *appInfoCB)
790 {
791 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
792 if (appInfoCB == nullptr) {
793 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
794 return nullptr;
795 }
796 napi_value resourceName = nullptr;
797 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
798 napi_deferred deferred;
799 napi_value promise = nullptr;
800 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
801 appInfoCB->cbBase.deferred = deferred;
802
803 NAPI_CALL(env,
804 napi_create_async_work(env,
805 nullptr,
806 resourceName,
807 GetAppInfoExecuteCB,
808 GetAppInfoPromiseCompleteCB,
809 static_cast<void *>(appInfoCB),
810 &appInfoCB->cbBase.asyncWork));
811 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
812 TAG_LOGI(AAFwkTag::JSNAPI, "end");
813 return promise;
814 }
815
GetApplicationInfoWrap(napi_env env,napi_callback_info info,AppInfoCB * appInfoCB)816 napi_value GetApplicationInfoWrap(napi_env env, napi_callback_info info, AppInfoCB *appInfoCB)
817 {
818 TAG_LOGI(AAFwkTag::JSNAPI, "called");
819 if (appInfoCB == nullptr) {
820 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
821 return nullptr;
822 }
823
824 size_t argcAsync = 1;
825 const size_t argcPromise = 0;
826 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
827 napi_value args[ARGS_MAX_COUNT] = {nullptr};
828 napi_value ret = nullptr;
829
830 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
831 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
832 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
833 return nullptr;
834 }
835
836 if (argcAsync > argcPromise) {
837 ret = GetApplicationInfoAsync(env, args, 0, appInfoCB);
838 } else {
839 ret = GetApplicationInfoPromise(env, appInfoCB);
840 }
841 TAG_LOGI(AAFwkTag::JSNAPI, "end");
842 return ret;
843 }
844
CreateAppInfoCBInfo(napi_env env)845 AppInfoCB *CreateAppInfoCBInfo(napi_env env)
846 {
847 TAG_LOGI(AAFwkTag::JSNAPI, "called");
848 napi_value global = nullptr;
849 NAPI_CALL(env, napi_get_global(env, &global));
850
851 napi_value abilityObj = nullptr;
852 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
853
854 Ability *ability = nullptr;
855 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
856
857 AppInfoCB *appInfoCB = new (std::nothrow) AppInfoCB;
858 if (appInfoCB == nullptr) {
859 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
860 return nullptr;
861 }
862 appInfoCB->cbBase.cbInfo.env = env;
863 appInfoCB->cbBase.asyncWork = nullptr;
864 appInfoCB->cbBase.deferred = nullptr;
865 appInfoCB->cbBase.ability = ability;
866 appInfoCB->cbBase.abilityType = AbilityType::UNKNOWN;
867 appInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
868
869 TAG_LOGI(AAFwkTag::JSNAPI, "end");
870 return appInfoCB;
871 }
872
NAPI_VerifySelfPermission(napi_env env,napi_callback_info info)873 napi_value NAPI_VerifySelfPermission(napi_env env, napi_callback_info info)
874 {
875 TAG_LOGI(AAFwkTag::JSNAPI, "called");
876
877 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
878 if (asyncCallbackInfo == nullptr) {
879 return nullptr;
880 }
881
882 napi_value rev = NAPI_VerifySelfPermissionWrap(env, info, asyncCallbackInfo);
883 if (rev == nullptr) {
884 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
885 rev = WrapVoidToJS(env);
886 }
887 return rev;
888 }
889
NAPI_RequestPermissionsFromUser(napi_env env,napi_callback_info info)890 napi_value NAPI_RequestPermissionsFromUser(napi_env env, napi_callback_info info)
891 {
892 TAG_LOGI(AAFwkTag::JSNAPI, "called");
893
894 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
895 if (asyncCallbackInfo == nullptr) {
896 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
897 return WrapVoidToJS(env);
898 }
899
900 napi_value rev = NAPI_RequestPermissionsFromUserWrap(env, info, asyncCallbackInfo);
901 if (rev == nullptr) {
902 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
903 rev = WrapVoidToJS(env);
904 }
905 return rev;
906 }
907
NAPI_GetFilesDir(napi_env env,napi_callback_info info)908 napi_value NAPI_GetFilesDir(napi_env env, napi_callback_info info)
909 {
910 TAG_LOGI(AAFwkTag::JSNAPI, "called");
911 return NAPI_GetFilesDirCommon(env, info, AbilityType::PAGE);
912 }
913
NAPI_GetOrCreateDistributedDir(napi_env env,napi_callback_info info)914 napi_value NAPI_GetOrCreateDistributedDir(napi_env env, napi_callback_info info)
915 {
916 TAG_LOGI(AAFwkTag::JSNAPI, "called");
917 return NAPI_GetOrCreateDistributedDirCommon(env, info, AbilityType::PAGE);
918 }
919
NAPI_GetCacheDir(napi_env env,napi_callback_info info)920 napi_value NAPI_GetCacheDir(napi_env env, napi_callback_info info)
921 {
922 TAG_LOGI(AAFwkTag::JSNAPI, "called");
923 return NAPI_GetCacheDirCommon(env, info, AbilityType::PAGE);
924 }
925
NAPI_GetCtxAppType(napi_env env,napi_callback_info info)926 napi_value NAPI_GetCtxAppType(napi_env env, napi_callback_info info)
927 {
928 TAG_LOGI(AAFwkTag::JSNAPI, "called");
929 return NAPI_GetAppTypeCommon(env, info, AbilityType::PAGE);
930 }
931
NAPI_GetCtxHapModuleInfo(napi_env env,napi_callback_info info)932 napi_value NAPI_GetCtxHapModuleInfo(napi_env env, napi_callback_info info)
933 {
934 TAG_LOGI(AAFwkTag::JSNAPI, "called");
935 return NAPI_GetHapModuleInfoCommon(env, info, AbilityType::PAGE);
936 }
937
NAPI_GetAppVersionInfo(napi_env env,napi_callback_info info)938 napi_value NAPI_GetAppVersionInfo(napi_env env, napi_callback_info info)
939 {
940 TAG_LOGI(AAFwkTag::JSNAPI, "called");
941 return NAPI_GetAppVersionInfoCommon(env, info, AbilityType::PAGE);
942 }
943
NAPI_GetApplicationContext(napi_env env,napi_callback_info info)944 napi_value NAPI_GetApplicationContext(napi_env env, napi_callback_info info)
945 {
946 TAG_LOGI(AAFwkTag::JSNAPI, "called");
947 return NAPI_GetContextCommon(env, info, AbilityType::PAGE);
948 }
949
NAPI_GetCtxAbilityInfo(napi_env env,napi_callback_info info)950 napi_value NAPI_GetCtxAbilityInfo(napi_env env, napi_callback_info info)
951 {
952 TAG_LOGI(AAFwkTag::JSNAPI, "called");
953 return NAPI_GetAbilityInfoCommon(env, info, AbilityType::PAGE);
954 }
955
UnwrapVerifyPermissionOptions(napi_env env,napi_value argv,AsyncJSCallbackInfo * asyncCallbackInfo)956 bool UnwrapVerifyPermissionOptions(napi_env env, napi_value argv, AsyncJSCallbackInfo *asyncCallbackInfo)
957 {
958 TAG_LOGI(AAFwkTag::JSNAPI, "called");
959 if (asyncCallbackInfo == nullptr) {
960 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
961 return false;
962 }
963
964 if (!IsTypeForNapiValue(env, argv, napi_object)) {
965 TAG_LOGI(AAFwkTag::JSNAPI, "wrong param type");
966 return false;
967 }
968
969 int value = 0;
970 if (UnwrapInt32ByPropertyName(env, argv, "pid", value)) {
971 asyncCallbackInfo->param.paramArgs.PutIntValue("pid", value);
972 }
973
974 value = 0;
975 if (UnwrapInt32ByPropertyName(env, argv, "uid", value)) {
976 asyncCallbackInfo->param.paramArgs.PutIntValue("uid", value);
977 }
978 return true;
979 }
980
UnwrapParamVerifyPermission(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)981 bool UnwrapParamVerifyPermission(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
982 {
983 TAG_LOGI(AAFwkTag::JSNAPI, "argc=%{public}zu", argc);
984
985 const size_t argcMax = ARGS_THREE;
986 if (argc > argcMax || argc < 1) {
987 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
988 return false;
989 }
990
991 std::string permission("");
992 if (!UnwrapStringFromJS2(env, argv[PARAM0], permission)) {
993 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM0]");
994 return false;
995 }
996 asyncCallbackInfo->param.paramArgs.PutStringValue("permission", permission);
997
998 if (argc == argcMax) {
999 if (!CreateAsyncCallback(env, argv[PARAM2], asyncCallbackInfo)) {
1000 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM2]");
1001 return false;
1002 }
1003
1004 if (!UnwrapVerifyPermissionOptions(env, argv[PARAM1], asyncCallbackInfo)) {
1005 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM1]");
1006 return false;
1007 }
1008 } else if (argc == ARGS_TWO) {
1009 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
1010 if (!UnwrapVerifyPermissionOptions(env, argv[PARAM1], asyncCallbackInfo)) {
1011 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM1]");
1012 return false;
1013 }
1014 }
1015 } else if (argc == ARGS_ONE) {
1016 asyncCallbackInfo->cbInfo.callback = nullptr;
1017 } else {
1018 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
1019 return false;
1020 }
1021 return true;
1022 }
1023
VerifyPermissionExecuteCallback(napi_env env,void * data)1024 void VerifyPermissionExecuteCallback(napi_env env, void *data)
1025 {
1026 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1027
1028 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
1029 if (asyncCallbackInfo == nullptr) {
1030 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1031 return;
1032 }
1033
1034 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1035 asyncCallbackInfo->native_data.data_type = NVT_NONE;
1036
1037 if (asyncCallbackInfo->ability == nullptr) {
1038 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
1039 return;
1040 }
1041
1042 std::string permission(asyncCallbackInfo->param.paramArgs.GetStringValue("permission").c_str());
1043 bool hasUid = asyncCallbackInfo->param.paramArgs.HasKey("uid");
1044 int pid = asyncCallbackInfo->param.paramArgs.GetIntValue("pid");
1045 int uid = asyncCallbackInfo->param.paramArgs.GetIntValue("uid");
1046
1047 asyncCallbackInfo->native_data.data_type = NVT_INT32;
1048
1049 if (hasUid) {
1050 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifyPermission(permission, pid, uid);
1051 } else {
1052 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifySelfPermission(permission);
1053 }
1054 }
1055
NAPI_VerifyPermissionWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)1056 napi_value NAPI_VerifyPermissionWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
1057 {
1058 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1059 size_t argc = ARGS_MAX_COUNT;
1060 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1061 napi_value jsthis = nullptr;
1062 void *data = nullptr;
1063
1064 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1065
1066 if (!UnwrapParamVerifyPermission(env, argc, args, asyncCallbackInfo)) {
1067 TAG_LOGI(AAFwkTag::JSNAPI, "unwrapParamVerifyPermission failed");
1068 return nullptr;
1069 }
1070
1071 AsyncParamEx asyncParamEx;
1072 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1073 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1074 asyncParamEx.resource = "NAPI_VerifyPermissionCallback";
1075 asyncParamEx.execute = VerifyPermissionExecuteCallback;
1076 asyncParamEx.complete = CompleteAsyncCallbackWork;
1077
1078 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1079 } else {
1080 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1081 asyncParamEx.resource = "NAPI_VerifyPermissionPromise";
1082 asyncParamEx.execute = VerifyPermissionExecuteCallback;
1083 asyncParamEx.complete = CompletePromiseCallbackWork;
1084
1085 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1086 }
1087 }
1088
NAPI_VerifyPermission(napi_env env,napi_callback_info info)1089 napi_value NAPI_VerifyPermission(napi_env env, napi_callback_info info)
1090 {
1091 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1092 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
1093 if (asyncCallbackInfo == nullptr) {
1094 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1095 return WrapVoidToJS(env);
1096 }
1097
1098 napi_value rev = NAPI_VerifyPermissionWrap(env, info, asyncCallbackInfo);
1099 if (rev == nullptr) {
1100 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
1101 rev = WrapVoidToJS(env);
1102 }
1103 return rev;
1104 }
1105
GetBundleNameExecuteCallback(napi_env env,void * data)1106 void GetBundleNameExecuteCallback(napi_env env, void *data)
1107 {
1108 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1109 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
1110 if (asyncCallbackInfo == nullptr) {
1111 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1112 return;
1113 }
1114
1115 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1116 asyncCallbackInfo->native_data.data_type = NVT_NONE;
1117 if (asyncCallbackInfo->ability == nullptr) {
1118 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1119 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
1120 return;
1121 }
1122
1123 asyncCallbackInfo->native_data.data_type = NVT_STRING;
1124 asyncCallbackInfo->native_data.str_value = asyncCallbackInfo->ability->GetBundleName();
1125 TAG_LOGI(AAFwkTag::JSNAPI, "bundleName=%{public}s",
1126 asyncCallbackInfo->native_data.str_value.c_str());
1127 }
1128
NAPI_GetBundleNameWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)1129 napi_value NAPI_GetBundleNameWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
1130 {
1131 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1132 size_t argc = ARGS_MAX_COUNT;
1133 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1134 napi_value jsthis = nullptr;
1135 void *data = nullptr;
1136
1137 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1138
1139 if (argc > ARGS_ONE) {
1140 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
1141 return nullptr;
1142 }
1143
1144 if (argc == ARGS_ONE) {
1145 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
1146 TAG_LOGI(AAFwkTag::JSNAPI, "invalid args[PARAM0]");
1147 return nullptr;
1148 }
1149 }
1150
1151 AsyncParamEx asyncParamEx;
1152 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1153 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1154 asyncParamEx.resource = "NAPI_GetBundleNameCallback";
1155 asyncParamEx.execute = GetBundleNameExecuteCallback;
1156 asyncParamEx.complete = CompleteAsyncCallbackWork;
1157
1158 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1159 } else {
1160 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1161 asyncParamEx.resource = "NAPI_GetBundleNamePromise";
1162 asyncParamEx.execute = GetBundleNameExecuteCallback;
1163 asyncParamEx.complete = CompletePromiseCallbackWork;
1164
1165 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1166 }
1167 }
1168
WrapProcessInfo(napi_env env,ProcessInfoCB * processInfoCB)1169 napi_value WrapProcessInfo(napi_env env, ProcessInfoCB *processInfoCB)
1170 {
1171 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1172 if (processInfoCB == nullptr) {
1173 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1174 return nullptr;
1175 }
1176 napi_value result = nullptr;
1177 napi_value proValue = nullptr;
1178 NAPI_CALL(env, napi_create_object(env, &result));
1179 NAPI_CALL(env, napi_create_int32(env, processInfoCB->pid, &proValue));
1180 NAPI_CALL(env, napi_set_named_property(env, result, "pid", proValue));
1181
1182 NAPI_CALL(env, napi_create_string_utf8(env, processInfoCB->processName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1183 NAPI_CALL(env, napi_set_named_property(env, result, "processName", proValue));
1184 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1185 return result;
1186 }
1187
GetProcessInfoExecuteCB(napi_env env,void * data)1188 void GetProcessInfoExecuteCB(napi_env env, void *data)
1189 {
1190 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
1191 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1192 if (processInfoCB == nullptr) {
1193 return;
1194 }
1195
1196 processInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1197 if (processInfoCB->cbBase.ability == nullptr) {
1198 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1199 processInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1200 return;
1201 }
1202
1203 std::shared_ptr<ProcessInfo> processInfoPtr = processInfoCB->cbBase.ability->GetProcessInfo();
1204 if (processInfoPtr != nullptr) {
1205 processInfoCB->processName = processInfoPtr->GetProcessName();
1206 processInfoCB->pid = processInfoPtr->GetPid();
1207 } else {
1208 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoPtr");
1209 processInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1210 }
1211 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
1212 }
1213
GetProcessInfoAsyncCompleteCB(napi_env env,napi_status status,void * data)1214 void GetProcessInfoAsyncCompleteCB(napi_env env, napi_status status, void *data)
1215 {
1216 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1217 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1218 napi_value callback = nullptr;
1219 napi_value undefined = nullptr;
1220 napi_value result[ARGS_TWO] = {nullptr};
1221 napi_value callResult = nullptr;
1222 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1223 result[PARAM0] = GetCallbackErrorValue(env, processInfoCB->cbBase.errCode);
1224 if (processInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1225 result[PARAM1] = WrapProcessInfo(env, processInfoCB);
1226 } else {
1227 result[PARAM1] = WrapUndefinedToJS(env);
1228 }
1229
1230 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, processInfoCB->cbBase.cbInfo.callback, &callback));
1231 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1232
1233 if (processInfoCB->cbBase.cbInfo.callback != nullptr) {
1234 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, processInfoCB->cbBase.cbInfo.callback));
1235 }
1236 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, processInfoCB->cbBase.asyncWork));
1237 delete processInfoCB;
1238 processInfoCB = nullptr;
1239 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1240 }
1241
GetProcessInfoAsync(napi_env env,napi_value * args,const size_t argCallback,ProcessInfoCB * processInfoCB)1242 napi_value GetProcessInfoAsync(napi_env env, napi_value *args, const size_t argCallback, ProcessInfoCB *processInfoCB)
1243 {
1244 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1245 if (args == nullptr || processInfoCB == nullptr) {
1246 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1247 return nullptr;
1248 }
1249 napi_value resourceName = nullptr;
1250 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1251
1252 napi_valuetype valuetype = napi_undefined;
1253 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1254 if (valuetype == napi_function) {
1255 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &processInfoCB->cbBase.cbInfo.callback));
1256 }
1257 NAPI_CALL(env,
1258 napi_create_async_work(env,
1259 nullptr,
1260 resourceName,
1261 GetProcessInfoExecuteCB,
1262 GetProcessInfoAsyncCompleteCB,
1263 static_cast<void *>(processInfoCB),
1264 &processInfoCB->cbBase.asyncWork));
1265 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1266 napi_value result = nullptr;
1267 NAPI_CALL(env, napi_get_null(env, &result));
1268 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1269 return result;
1270 }
1271
GetProcessInfoPromiseCompleteCB(napi_env env,napi_status status,void * data)1272 void GetProcessInfoPromiseCompleteCB(napi_env env, napi_status status, void *data)
1273 {
1274 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1275 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1276 napi_value result = nullptr;
1277 if (processInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1278 result = WrapProcessInfo(env, processInfoCB);
1279 napi_resolve_deferred(env, processInfoCB->cbBase.deferred, result);
1280 } else {
1281 result = GetCallbackErrorValue(env, processInfoCB->cbBase.errCode);
1282 napi_reject_deferred(env, processInfoCB->cbBase.deferred, result);
1283 }
1284
1285 napi_delete_async_work(env, processInfoCB->cbBase.asyncWork);
1286 delete processInfoCB;
1287 processInfoCB = nullptr;
1288 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1289 }
1290
GetProcessInfoPromise(napi_env env,ProcessInfoCB * processInfoCB)1291 napi_value GetProcessInfoPromise(napi_env env, ProcessInfoCB *processInfoCB)
1292 {
1293 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1294 if (processInfoCB == nullptr) {
1295 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1296 return nullptr;
1297 }
1298 napi_value resourceName = nullptr;
1299 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1300 napi_deferred deferred;
1301 napi_value promise = nullptr;
1302 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1303 processInfoCB->cbBase.deferred = deferred;
1304
1305 NAPI_CALL(env,
1306 napi_create_async_work(env,
1307 nullptr,
1308 resourceName,
1309 GetProcessInfoExecuteCB,
1310 GetProcessInfoPromiseCompleteCB,
1311 static_cast<void *>(processInfoCB),
1312 &processInfoCB->cbBase.asyncWork));
1313 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1314 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1315 return promise;
1316 }
1317
GetProcessInfoWrap(napi_env env,napi_callback_info info,ProcessInfoCB * processInfoCB)1318 napi_value GetProcessInfoWrap(napi_env env, napi_callback_info info, ProcessInfoCB *processInfoCB)
1319 {
1320 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1321 if (processInfoCB == nullptr) {
1322 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1323 return nullptr;
1324 }
1325
1326 size_t argcAsync = 1;
1327 const size_t argcPromise = 0;
1328 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1329 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1330 napi_value ret = nullptr;
1331
1332 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1333 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1334 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1335 return nullptr;
1336 }
1337
1338 if (argcAsync > argcPromise) {
1339 ret = GetProcessInfoAsync(env, args, 0, processInfoCB);
1340 } else {
1341 ret = GetProcessInfoPromise(env, processInfoCB);
1342 }
1343 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1344 return ret;
1345 }
1346
CreateProcessInfoCBInfo(napi_env env)1347 ProcessInfoCB *CreateProcessInfoCBInfo(napi_env env)
1348 {
1349 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1350 napi_value global = nullptr;
1351 NAPI_CALL(env, napi_get_global(env, &global));
1352
1353 napi_value abilityObj = nullptr;
1354 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1355
1356 Ability *ability = nullptr;
1357 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1358
1359 ProcessInfoCB *processInfoCB = new (std::nothrow) ProcessInfoCB;
1360 if (processInfoCB == nullptr) {
1361 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1362 return nullptr;
1363 }
1364 processInfoCB->cbBase.cbInfo.env = env;
1365 processInfoCB->cbBase.asyncWork = nullptr;
1366 processInfoCB->cbBase.deferred = nullptr;
1367 processInfoCB->cbBase.ability = ability;
1368
1369 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1370 return processInfoCB;
1371 }
1372
CreateElementNameCBInfo(napi_env env)1373 ElementNameCB *CreateElementNameCBInfo(napi_env env)
1374 {
1375 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1376 napi_value global = nullptr;
1377 NAPI_CALL(env, napi_get_global(env, &global));
1378
1379 napi_value abilityObj = nullptr;
1380 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1381
1382 Ability *ability = nullptr;
1383 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1384
1385 ElementNameCB *elementNameCB = new (std::nothrow) ElementNameCB;
1386 if (elementNameCB == nullptr) {
1387 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1388 return nullptr;
1389 }
1390 elementNameCB->cbBase.cbInfo.env = env;
1391 elementNameCB->cbBase.asyncWork = nullptr;
1392 elementNameCB->cbBase.deferred = nullptr;
1393 elementNameCB->cbBase.ability = ability;
1394
1395 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1396 return elementNameCB;
1397 }
1398
WrapElementName(napi_env env,const ElementNameCB * elementNameCB)1399 napi_value WrapElementName(napi_env env, const ElementNameCB *elementNameCB)
1400 {
1401 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1402 if (elementNameCB == nullptr) {
1403 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1404 return nullptr;
1405 }
1406 napi_value result = nullptr;
1407 napi_value proValue = nullptr;
1408 NAPI_CALL(env, napi_create_object(env, &result));
1409 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->abilityName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1410 NAPI_CALL(env, napi_set_named_property(env, result, "abilityName", proValue));
1411
1412 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->bundleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1413 NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", proValue));
1414
1415 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->deviceId.c_str(), NAPI_AUTO_LENGTH, &proValue));
1416 NAPI_CALL(env, napi_set_named_property(env, result, "deviceId", proValue));
1417
1418 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->shortName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1419 NAPI_CALL(env, napi_set_named_property(env, result, "shortName", proValue));
1420
1421 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->uri.c_str(), NAPI_AUTO_LENGTH, &proValue));
1422 NAPI_CALL(env, napi_set_named_property(env, result, "uri", proValue));
1423 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1424 return result;
1425 }
1426
GetElementNameExecuteCB(napi_env env,void * data)1427 void GetElementNameExecuteCB(napi_env env, void *data)
1428 {
1429 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
1430 if (data == nullptr) {
1431 TAG_LOGE(AAFwkTag::JSNAPI, "null data");
1432 return;
1433 }
1434 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1435 if (elementNameCB == nullptr) {
1436 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1437 return;
1438 }
1439
1440 elementNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1441 if (elementNameCB->cbBase.ability == nullptr) {
1442 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1443 elementNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1444 return;
1445 }
1446
1447 std::shared_ptr<ElementName> elementName = elementNameCB->cbBase.ability->GetElementName();
1448 if (elementName != nullptr) {
1449 elementNameCB->deviceId = elementName->GetDeviceID();
1450 elementNameCB->bundleName = elementName->GetBundleName();
1451 elementNameCB->abilityName = elementName->GetAbilityName();
1452 elementNameCB->uri = elementNameCB->cbBase.ability->GetWant()->GetUriString();
1453 elementNameCB->shortName = "";
1454 } else {
1455 elementNameCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1456 }
1457 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1458 }
1459
GetElementNameAsyncCompleteCB(napi_env env,napi_status status,void * data)1460 void GetElementNameAsyncCompleteCB(napi_env env, napi_status status, void *data)
1461 {
1462 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1463 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1464 napi_value callback = nullptr;
1465 napi_value undefined = nullptr;
1466 napi_value result[ARGS_TWO] = {nullptr};
1467 napi_value callResult = nullptr;
1468 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1469 result[PARAM0] = GetCallbackErrorValue(env, elementNameCB->cbBase.errCode);
1470 if (elementNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1471 result[PARAM1] = WrapElementName(env, elementNameCB);
1472 } else {
1473 result[PARAM1] = WrapUndefinedToJS(env);
1474 }
1475 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, elementNameCB->cbBase.cbInfo.callback, &callback));
1476 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1477
1478 if (elementNameCB->cbBase.cbInfo.callback != nullptr) {
1479 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, elementNameCB->cbBase.cbInfo.callback));
1480 }
1481 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, elementNameCB->cbBase.asyncWork));
1482 delete elementNameCB;
1483 elementNameCB = nullptr;
1484 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1485 }
1486
GetElementNamePromiseCompleteCB(napi_env env,napi_status status,void * data)1487 void GetElementNamePromiseCompleteCB(napi_env env, napi_status status, void *data)
1488 {
1489 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1490 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1491 napi_value result = nullptr;
1492 if (elementNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1493 result = WrapElementName(env, elementNameCB);
1494 napi_resolve_deferred(env, elementNameCB->cbBase.deferred, result);
1495 } else {
1496 result = GetCallbackErrorValue(env, elementNameCB->cbBase.errCode);
1497 napi_reject_deferred(env, elementNameCB->cbBase.deferred, result);
1498 }
1499
1500 napi_delete_async_work(env, elementNameCB->cbBase.asyncWork);
1501 delete elementNameCB;
1502 elementNameCB = nullptr;
1503 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1504 }
1505
GetElementNamePromise(napi_env env,ElementNameCB * elementNameCB)1506 napi_value GetElementNamePromise(napi_env env, ElementNameCB *elementNameCB)
1507 {
1508 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1509 if (elementNameCB == nullptr) {
1510 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1511 return nullptr;
1512 }
1513 napi_value resourceName = nullptr;
1514 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1515 napi_deferred deferred;
1516 napi_value promise = nullptr;
1517 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1518 elementNameCB->cbBase.deferred = deferred;
1519
1520 NAPI_CALL(env,
1521 napi_create_async_work(env,
1522 nullptr,
1523 resourceName,
1524 GetElementNameExecuteCB,
1525 GetElementNamePromiseCompleteCB,
1526 static_cast<void *>(elementNameCB),
1527 &elementNameCB->cbBase.asyncWork));
1528 NAPI_CALL(env, napi_queue_async_work_with_qos(env, elementNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1529 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1530 return promise;
1531 }
1532
GetElementNameAsync(napi_env env,napi_value * args,const size_t argCallback,ElementNameCB * elementNameCB)1533 napi_value GetElementNameAsync(napi_env env, napi_value *args, const size_t argCallback, ElementNameCB *elementNameCB)
1534 {
1535 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1536 if (args == nullptr || elementNameCB == nullptr) {
1537 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1538 return nullptr;
1539 }
1540 napi_value resourceName = nullptr;
1541 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1542
1543 napi_valuetype valuetype = napi_undefined;
1544 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1545 if (valuetype == napi_function) {
1546 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &elementNameCB->cbBase.cbInfo.callback));
1547 }
1548 NAPI_CALL(env,
1549 napi_create_async_work(env,
1550 nullptr,
1551 resourceName,
1552 GetElementNameExecuteCB,
1553 GetElementNameAsyncCompleteCB,
1554 static_cast<void *>(elementNameCB),
1555 &elementNameCB->cbBase.asyncWork));
1556 NAPI_CALL(env, napi_queue_async_work_with_qos(env, elementNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1557 napi_value result = nullptr;
1558 NAPI_CALL(env, napi_get_null(env, &result));
1559 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1560 return result;
1561 }
1562
GetElementNameWrap(napi_env env,napi_callback_info info,ElementNameCB * elementNameCB)1563 napi_value GetElementNameWrap(napi_env env, napi_callback_info info, ElementNameCB *elementNameCB)
1564 {
1565 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1566 if (elementNameCB == nullptr) {
1567 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1568 return nullptr;
1569 }
1570
1571 size_t argcAsync = 1;
1572 const size_t argcPromise = 0;
1573 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1574 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1575 napi_value ret = nullptr;
1576
1577 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1578 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1579 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1580 return nullptr;
1581 }
1582
1583 if (argcAsync > argcPromise) {
1584 ret = GetElementNameAsync(env, args, 0, elementNameCB);
1585 } else {
1586 ret = GetElementNamePromise(env, elementNameCB);
1587 }
1588 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1589 return ret;
1590 }
1591
CreateProcessNameCBInfo(napi_env env)1592 ProcessNameCB *CreateProcessNameCBInfo(napi_env env)
1593 {
1594 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1595 napi_value global = nullptr;
1596 NAPI_CALL(env, napi_get_global(env, &global));
1597
1598 napi_value abilityObj = nullptr;
1599 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1600
1601 Ability *ability = nullptr;
1602 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1603
1604 ProcessNameCB *processNameCB = new (std::nothrow) ProcessNameCB;
1605 if (processNameCB == nullptr) {
1606 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1607 return nullptr;
1608 }
1609 processNameCB->cbBase.cbInfo.env = env;
1610 processNameCB->cbBase.asyncWork = nullptr;
1611 processNameCB->cbBase.deferred = nullptr;
1612 processNameCB->cbBase.ability = ability;
1613
1614 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1615 return processNameCB;
1616 }
1617
GetProcessNameExecuteCB(napi_env env,void * data)1618 void GetProcessNameExecuteCB(napi_env env, void *data)
1619 {
1620 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1621 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1622 if (processNameCB == nullptr) {
1623 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1624 return;
1625 }
1626
1627 processNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1628 if (processNameCB->cbBase.ability == nullptr) {
1629 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1630 processNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1631 return;
1632 }
1633
1634 processNameCB->processName = processNameCB->cbBase.ability->GetProcessName();
1635 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1636 }
1637
WrapProcessName(napi_env env,const ProcessNameCB * processNameCB)1638 napi_value WrapProcessName(napi_env env, const ProcessNameCB *processNameCB)
1639 {
1640 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1641 if (processNameCB == nullptr) {
1642 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1643 return nullptr;
1644 }
1645 napi_value result = nullptr;
1646 NAPI_CALL(env, napi_create_string_utf8(env, processNameCB->processName.c_str(), NAPI_AUTO_LENGTH, &result));
1647 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1648 return result;
1649 }
1650
GetProcessNameAsyncCompleteCB(napi_env env,napi_status status,void * data)1651 void GetProcessNameAsyncCompleteCB(napi_env env, napi_status status, void *data)
1652 {
1653 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1654 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1655 napi_value callback = nullptr;
1656 napi_value undefined = nullptr;
1657 napi_value result[ARGS_TWO] = {nullptr};
1658 napi_value callResult = nullptr;
1659 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1660 result[PARAM0] = GetCallbackErrorValue(env, processNameCB->cbBase.errCode);
1661 if (processNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1662 result[PARAM1] = WrapProcessName(env, processNameCB);
1663 } else {
1664 result[PARAM1] = WrapUndefinedToJS(env);
1665 }
1666 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, processNameCB->cbBase.cbInfo.callback, &callback));
1667 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1668
1669 if (processNameCB->cbBase.cbInfo.callback != nullptr) {
1670 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, processNameCB->cbBase.cbInfo.callback));
1671 }
1672 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, processNameCB->cbBase.asyncWork));
1673 delete processNameCB;
1674 processNameCB = nullptr;
1675 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1676 }
1677
GetProcessNamePromiseCompleteCB(napi_env env,napi_status status,void * data)1678 void GetProcessNamePromiseCompleteCB(napi_env env, napi_status status, void *data)
1679 {
1680 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1681 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1682 napi_value result = nullptr;
1683 if (processNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1684 result = WrapProcessName(env, processNameCB);
1685 napi_resolve_deferred(env, processNameCB->cbBase.deferred, result);
1686 } else {
1687 result = GetCallbackErrorValue(env, processNameCB->cbBase.errCode);
1688 napi_reject_deferred(env, processNameCB->cbBase.deferred, result);
1689 }
1690
1691 napi_delete_async_work(env, processNameCB->cbBase.asyncWork);
1692 delete processNameCB;
1693 processNameCB = nullptr;
1694 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1695 }
1696
GetProcessNameAsync(napi_env env,napi_value * args,const size_t argCallback,ProcessNameCB * processNameCB)1697 napi_value GetProcessNameAsync(napi_env env, napi_value *args, const size_t argCallback, ProcessNameCB *processNameCB)
1698 {
1699 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1700 if (args == nullptr || processNameCB == nullptr) {
1701 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1702 return nullptr;
1703 }
1704 napi_value resourceName = nullptr;
1705 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1706
1707 napi_valuetype valuetype = napi_undefined;
1708 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1709 if (valuetype == napi_function) {
1710 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &processNameCB->cbBase.cbInfo.callback));
1711 }
1712 NAPI_CALL(env,
1713 napi_create_async_work(env,
1714 nullptr,
1715 resourceName,
1716 GetProcessNameExecuteCB,
1717 GetProcessNameAsyncCompleteCB,
1718 static_cast<void *>(processNameCB),
1719 &processNameCB->cbBase.asyncWork));
1720 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1721 napi_value result = nullptr;
1722 NAPI_CALL(env, napi_get_null(env, &result));
1723 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1724 return result;
1725 }
1726
GetProcessNamePromise(napi_env env,ProcessNameCB * processNameCB)1727 napi_value GetProcessNamePromise(napi_env env, ProcessNameCB *processNameCB)
1728 {
1729 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1730 if (processNameCB == nullptr) {
1731 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1732 return nullptr;
1733 }
1734 napi_value resourceName = nullptr;
1735 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1736 napi_deferred deferred;
1737 napi_value promise = nullptr;
1738 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1739 processNameCB->cbBase.deferred = deferred;
1740
1741 NAPI_CALL(env,
1742 napi_create_async_work(env,
1743 nullptr,
1744 resourceName,
1745 GetProcessNameExecuteCB,
1746 GetProcessNamePromiseCompleteCB,
1747 static_cast<void *>(processNameCB),
1748 &processNameCB->cbBase.asyncWork));
1749 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1750 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1751 return promise;
1752 }
1753
GetProcessNameWrap(napi_env env,napi_callback_info info,ProcessNameCB * processNameCB)1754 napi_value GetProcessNameWrap(napi_env env, napi_callback_info info, ProcessNameCB *processNameCB)
1755 {
1756 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1757 if (processNameCB == nullptr) {
1758 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1759 return nullptr;
1760 }
1761
1762 size_t argcAsync = 1;
1763 const size_t argcPromise = 0;
1764 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1765 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1766 napi_value ret = nullptr;
1767
1768 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1769 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1770 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1771 return nullptr;
1772 }
1773
1774 if (argcAsync > argcPromise) {
1775 ret = GetProcessNameAsync(env, args, 0, processNameCB);
1776 } else {
1777 ret = GetProcessNamePromise(env, processNameCB);
1778 }
1779 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1780 return ret;
1781 }
1782
CreateGetDatabaseDirCBInfo(napi_env env)1783 DatabaseDirCB *CreateGetDatabaseDirCBInfo(napi_env env)
1784 {
1785 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1786 napi_value global = nullptr;
1787 NAPI_CALL(env, napi_get_global(env, &global));
1788
1789 napi_value abilityObj = nullptr;
1790 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1791
1792 Ability *ability = nullptr;
1793 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1794
1795 DatabaseDirCB *getDatabaseDirCB = new (std::nothrow) DatabaseDirCB;
1796 if (getDatabaseDirCB == nullptr) {
1797 TAG_LOGE(AAFwkTag::JSNAPI, "null getDatabaseDirCB");
1798 return nullptr;
1799 }
1800 getDatabaseDirCB->cbBase.cbInfo.env = env;
1801 getDatabaseDirCB->cbBase.asyncWork = nullptr;
1802 getDatabaseDirCB->cbBase.deferred = nullptr;
1803 getDatabaseDirCB->cbBase.ability = ability;
1804
1805 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1806 return getDatabaseDirCB;
1807 }
1808
GetDatabaseDirWrap(napi_env env,napi_callback_info info,DatabaseDirCB * getDatabaseDirCB)1809 napi_value GetDatabaseDirWrap(napi_env env, napi_callback_info info, DatabaseDirCB *getDatabaseDirCB)
1810 {
1811 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1812 if (getDatabaseDirCB == nullptr) {
1813 TAG_LOGE(AAFwkTag::JSNAPI, "null getDatabaseDirCB");
1814 return nullptr;
1815 }
1816
1817 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1818 if (getDatabaseDirCB->cbBase.ability == nullptr) {
1819 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1820 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1821 return nullptr;
1822 }
1823
1824 std::string abilityName = getDatabaseDirCB->cbBase.ability->GetAbilityInfo()->name;
1825 std::string dataDir = getDatabaseDirCB->cbBase.ability->GetAbilityInfo()->applicationInfo.dataDir;
1826 std::shared_ptr<HapModuleInfo> hap = getDatabaseDirCB->cbBase.ability->GetHapModuleInfo();
1827 std::string moduleName = (hap != nullptr) ? hap->name : std::string();
1828 std::string dataDirWithModuleName = dataDir + NAPI_CONTEXT_FILE_SEPARATOR + moduleName;
1829 TAG_LOGI(AAFwkTag::JSNAPI, "dataDir:%{public}s moduleName:%{public}s abilityName:%{public}s",
1830 dataDir.c_str(),
1831 moduleName.c_str(),
1832 abilityName.c_str());
1833
1834 // if dataDirWithModuleName is not exits, do nothing and return.
1835 if (!OHOS::FileExists(dataDirWithModuleName)) {
1836 getDatabaseDirCB->dataBaseDir = "";
1837 TAG_LOGI(AAFwkTag::JSNAPI, "dirWithModuleName:%{public}s",
1838 dataDirWithModuleName.c_str());
1839 } else {
1840 getDatabaseDirCB->dataBaseDir = dataDirWithModuleName + NAPI_CONTEXT_FILE_SEPARATOR + abilityName +
1841 NAPI_CONTEXT_FILE_SEPARATOR + NAPI_CONTEXT_DATABASE;
1842 TAG_LOGI(AAFwkTag::JSNAPI, "dataBaseDir:%{public}s",
1843 getDatabaseDirCB->dataBaseDir.c_str());
1844 if (!OHOS::FileExists(getDatabaseDirCB->dataBaseDir)) {
1845 TAG_LOGE(AAFwkTag::JSNAPI, "dir not exits, create dir");
1846 OHOS::ForceCreateDirectory(getDatabaseDirCB->dataBaseDir);
1847 OHOS::ChangeModeDirectory(getDatabaseDirCB->dataBaseDir, MODE);
1848 }
1849 }
1850 napi_value result = nullptr;
1851 NAPI_CALL(env, napi_create_string_utf8(env, getDatabaseDirCB->dataBaseDir.c_str(), NAPI_AUTO_LENGTH, &result));
1852
1853 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1854 return result;
1855 }
1856
CreateGetPreferencesDirCBInfo(napi_env env)1857 PreferencesDirCB *CreateGetPreferencesDirCBInfo(napi_env env)
1858 {
1859 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1860 napi_value global = nullptr;
1861 NAPI_CALL(env, napi_get_global(env, &global));
1862
1863 napi_value abilityObj = nullptr;
1864 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1865
1866 Ability *ability = nullptr;
1867 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1868
1869 PreferencesDirCB *getPreferencesDirCB = new (std::nothrow) PreferencesDirCB;
1870 if (getPreferencesDirCB == nullptr) {
1871 TAG_LOGE(AAFwkTag::JSNAPI, "null getPreferencesDirCB");
1872 return nullptr;
1873 }
1874 getPreferencesDirCB->cbBase.cbInfo.env = env;
1875 getPreferencesDirCB->cbBase.asyncWork = nullptr;
1876 getPreferencesDirCB->cbBase.deferred = nullptr;
1877 getPreferencesDirCB->cbBase.ability = ability;
1878
1879 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1880 return getPreferencesDirCB;
1881 }
1882
GetPreferencesDirWrap(napi_env env,napi_callback_info info,PreferencesDirCB * getPreferencesDirCB)1883 napi_value GetPreferencesDirWrap(napi_env env, napi_callback_info info, PreferencesDirCB *getPreferencesDirCB)
1884 {
1885 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1886 if (getPreferencesDirCB == nullptr) {
1887 TAG_LOGE(AAFwkTag::JSNAPI, "null getPreferencesDirCB");
1888 return nullptr;
1889 }
1890
1891 getPreferencesDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1892 if (getPreferencesDirCB->cbBase.ability == nullptr) {
1893 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1894 getPreferencesDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1895 return nullptr;
1896 }
1897
1898 std::string abilityName = getPreferencesDirCB->cbBase.ability->GetAbilityInfo()->name;
1899 std::string dataDir = getPreferencesDirCB->cbBase.ability->GetAbilityInfo()->applicationInfo.dataDir;
1900 std::shared_ptr<HapModuleInfo> hap = getPreferencesDirCB->cbBase.ability->GetHapModuleInfo();
1901 std::string moduleName = (hap != nullptr) ? hap->name : std::string();
1902 std::string dataDirWithModuleName = dataDir + NAPI_CONTEXT_FILE_SEPARATOR + moduleName;
1903 TAG_LOGI(AAFwkTag::JSNAPI, "dataDir:%{public}s moduleName:%{public}s abilityName:%{public}s",
1904 dataDir.c_str(),
1905 moduleName.c_str(),
1906 abilityName.c_str());
1907
1908 // if dataDirWithModuleName is not exits, do nothing and return.
1909 if (!OHOS::FileExists(dataDirWithModuleName)) {
1910 getPreferencesDirCB->preferencesDir = "";
1911 TAG_LOGI(AAFwkTag::JSNAPI, "dirWithModuleName:%{public}s", dataDirWithModuleName.c_str());
1912 } else {
1913 getPreferencesDirCB->preferencesDir = dataDirWithModuleName + NAPI_CONTEXT_FILE_SEPARATOR + abilityName +
1914 NAPI_CONTEXT_FILE_SEPARATOR + NAPI_CONTEXT_PREFERENCES;
1915 TAG_LOGI(AAFwkTag::JSNAPI, "preferencesDir:%{public}s", getPreferencesDirCB->preferencesDir.c_str());
1916 if (!OHOS::FileExists(getPreferencesDirCB->preferencesDir)) {
1917 TAG_LOGI(AAFwkTag::JSNAPI, "create");
1918 OHOS::ForceCreateDirectory(getPreferencesDirCB->preferencesDir);
1919 OHOS::ChangeModeDirectory(getPreferencesDirCB->preferencesDir, MODE);
1920 }
1921 }
1922 napi_value result = nullptr;
1923 NAPI_CALL(
1924 env, napi_create_string_utf8(env, getPreferencesDirCB->preferencesDir.c_str(), NAPI_AUTO_LENGTH, &result));
1925
1926 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1927 return result;
1928 }
1929 } // namespace AppExecFwk
1930 } // namespace OHOS