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