1 /*
2 * Copyright (c) 2021-2022 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.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
ContextConstructor(napi_env env,napi_callback_info info)42 napi_value ContextConstructor(napi_env env, napi_callback_info info)
43 {
44 napi_value jsthis = nullptr;
45 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
46
47 napi_value value = nullptr;
48 NAPI_CALL(env, napi_get_boolean(env, false, &value));
49
50 napi_property_descriptor desc[] = {
51 DECLARE_NAPI_PROPERTY("stageMode", value),
52 };
53 NAPI_CALL(env, napi_define_properties(env, jsthis, sizeof(desc) / sizeof(desc[0]), desc));
54
55 return jsthis;
56 }
57
58 #ifdef SUPPORT_GRAPHICS
GetJSAbilityObject(napi_env env)59 static Ability* GetJSAbilityObject(napi_env env)
60 {
61 napi_value global = nullptr;
62 NAPI_CALL(env, napi_get_global(env, &global));
63
64 napi_value abilityObj = nullptr;
65 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
66
67 Ability *ability = nullptr;
68 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
69 return ability;
70 }
71
SetShowOnLockScreenAsyncCompleteCB(napi_env env,napi_status status,void * data)72 static void SetShowOnLockScreenAsyncCompleteCB(napi_env env, napi_status status, void *data)
73 {
74 TAG_LOGD(AAFwkTag::JSNAPI, "called");
75 ShowOnLockScreenCB *showOnLockScreenCB = static_cast<ShowOnLockScreenCB *>(data);
76 if (showOnLockScreenCB == nullptr) {
77 TAG_LOGE(AAFwkTag::JSNAPI, "input param is nullptr");
78 return;
79 }
80
81 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
82 if (showOnLockScreenCB->cbBase.ability == nullptr) {
83 TAG_LOGE(AAFwkTag::JSNAPI, "input param is nullptr");
84 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
85 } else {
86 showOnLockScreenCB->cbBase.ability->SetShowOnLockScreen(showOnLockScreenCB->isShow);
87 }
88
89 napi_value callback = nullptr, undefined = nullptr, callResult = nullptr;
90 napi_value result[ARGS_TWO] = {nullptr};
91 napi_get_undefined(env, &undefined);
92 result[PARAM0] = GetCallbackErrorValue(env, showOnLockScreenCB->cbBase.errCode);
93 napi_get_null(env, &result[PARAM1]);
94 napi_get_reference_value(env, showOnLockScreenCB->cbBase.cbInfo.callback, &callback);
95 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
96
97 if (showOnLockScreenCB->cbBase.cbInfo.callback != nullptr) {
98 napi_delete_reference(env, showOnLockScreenCB->cbBase.cbInfo.callback);
99 }
100 napi_delete_async_work(env, showOnLockScreenCB->cbBase.asyncWork);
101 delete showOnLockScreenCB;
102 showOnLockScreenCB = nullptr;
103 }
104
SetShowOnLockScreenAsync(napi_env env,napi_value * args,ShowOnLockScreenCB * showOnLockScreenCB)105 static napi_value SetShowOnLockScreenAsync(napi_env env, napi_value *args, ShowOnLockScreenCB *showOnLockScreenCB)
106 {
107 TAG_LOGD(AAFwkTag::JSNAPI, "called");
108 if (showOnLockScreenCB == nullptr) {
109 TAG_LOGE(AAFwkTag::JSNAPI, "input param is nullptr");
110 return nullptr;
111 }
112
113 napi_valuetype valuetypeParam1 = napi_undefined;
114 NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetypeParam1));
115 if (valuetypeParam1 != napi_function) {
116 TAG_LOGE(AAFwkTag::JSNAPI, "error, params is error type");
117 return nullptr;
118 }
119
120 NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &showOnLockScreenCB->cbBase.cbInfo.callback));
121
122 napi_value resourceName = nullptr;
123 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
124
125 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName,
126 [](napi_env env, void *data) {
127 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
128 },
129 SetShowOnLockScreenAsyncCompleteCB,
130 static_cast<void *>(showOnLockScreenCB),
131 &showOnLockScreenCB->cbBase.asyncWork));
132 NAPI_CALL(env, napi_queue_async_work_with_qos(env, showOnLockScreenCB->cbBase.asyncWork, napi_qos_user_initiated));
133 napi_value result = nullptr;
134 NAPI_CALL(env, napi_get_null(env, &result));
135
136 return result;
137 }
138
SetShowOnLockScreenPromise(napi_env env,ShowOnLockScreenCB * cbData)139 napi_value SetShowOnLockScreenPromise(napi_env env, ShowOnLockScreenCB *cbData)
140 {
141 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
142 if (cbData == nullptr) {
143 TAG_LOGE(AAFwkTag::JSNAPI, "null cbData");
144 return nullptr;
145 }
146 napi_value resourceName = nullptr;
147 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
148
149 napi_deferred deferred;
150 napi_value promise = nullptr;
151 napi_create_promise(env, &deferred, &promise);
152 cbData->cbBase.deferred = deferred;
153
154 napi_create_async_work(
155 env,
156 nullptr,
157 resourceName,
158 [](napi_env env, void *data) {
159 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
160 },
161 [](napi_env env, napi_status status, void *data) {
162 ShowOnLockScreenCB *showOnLockScreenCB = static_cast<ShowOnLockScreenCB *>(data);
163 showOnLockScreenCB->cbBase.errCode = NO_ERROR;
164 if (showOnLockScreenCB->cbBase.ability == nullptr) {
165 TAG_LOGE(AAFwkTag::JSNAPI, "input param is nullptr");
166 showOnLockScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
167 } else {
168 showOnLockScreenCB->cbBase.ability->SetShowOnLockScreen(showOnLockScreenCB->isShow);
169 }
170
171 napi_value result = GetCallbackErrorValue(env, showOnLockScreenCB->cbBase.errCode);
172 if (showOnLockScreenCB->cbBase.errCode == NO_ERROR) {
173 napi_resolve_deferred(env, showOnLockScreenCB->cbBase.deferred, result);
174 } else {
175 napi_reject_deferred(env, showOnLockScreenCB->cbBase.deferred, result);
176 }
177
178 napi_delete_async_work(env, showOnLockScreenCB->cbBase.asyncWork);
179 delete showOnLockScreenCB;
180 showOnLockScreenCB = nullptr;
181 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
182 },
183 static_cast<void *>(cbData),
184 &cbData->cbBase.asyncWork);
185 napi_queue_async_work_with_qos(env, cbData->cbBase.asyncWork, napi_qos_user_initiated);
186 TAG_LOGI(AAFwkTag::JSNAPI, "promise end");
187 return promise;
188 }
189
NAPI_SetDisplayOrientationWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)190 napi_value NAPI_SetDisplayOrientationWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
191 {
192 TAG_LOGD(AAFwkTag::JSNAPI, "called");
193 size_t argc = ARGS_MAX_COUNT;
194 napi_value args[ARGS_MAX_COUNT] = {nullptr};
195 napi_value jsthis = nullptr;
196 void *data = nullptr;
197
198 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
199
200 if (!UnwrapSetDisplayOrientation(env, argc, args, asyncCallbackInfo)) {
201 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapSetDisplayOrientation fail");
202 return nullptr;
203 }
204
205 AsyncParamEx asyncParamEx;
206 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
207 asyncParamEx.resource = "NAPI_SetDisplayOrientationCallback";
208 asyncParamEx.execute = SetDisplayOrientationExecuteCallbackWork;
209 asyncParamEx.complete = CompleteAsyncCallbackWork;
210
211 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
212 } else {
213 asyncParamEx.resource = "NAPI_SetDisplayOrientationPromise";
214 asyncParamEx.execute = SetDisplayOrientationExecuteCallbackWork;
215 asyncParamEx.complete = CompletePromiseCallbackWork;
216
217 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
218 }
219 }
220
SetDisplayOrientationExecuteCallbackWork(napi_env env,void * data)221 void SetDisplayOrientationExecuteCallbackWork(napi_env env, void *data)
222 {
223 TAG_LOGD(AAFwkTag::JSNAPI, "called");
224 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
225 if (asyncCallbackInfo == nullptr) {
226 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
227 return;
228 }
229
230 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
231 asyncCallbackInfo->native_data.data_type = NVT_NONE;
232 if (asyncCallbackInfo->ability == nullptr) {
233 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
234 return;
235 }
236
237 int orientation = asyncCallbackInfo->param.paramArgs.GetIntValue("orientation");
238 asyncCallbackInfo->ability->SetDisplayOrientation(orientation);
239 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
240 }
241
UnwrapSetDisplayOrientation(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)242 bool UnwrapSetDisplayOrientation(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
243 {
244 TAG_LOGD(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
245
246 const size_t argcMax = 2;
247 if (argc > argcMax || argc < argcMax - 1) {
248 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
249 return false;
250 }
251
252 if (argc == argcMax) {
253 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
254 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
255 return false;
256 }
257 }
258
259 int orientation = 0;
260 if (!UnwrapInt32FromJS2(env, argv[PARAM0], orientation)) {
261 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
262 return false;
263 }
264
265 int maxRange = 3;
266 if (orientation < 0 || orientation > maxRange) {
267 TAG_LOGE(AAFwkTag::JSNAPI, "wrong parameter range");
268 return false;
269 }
270
271 asyncCallbackInfo->param.paramArgs.PutIntValue("orientation", orientation);
272 return true;
273 }
274
SetWakeUpScreenAsyncCompleteCB(napi_env env,napi_status status,void * data)275 static void SetWakeUpScreenAsyncCompleteCB(napi_env env, napi_status status, void *data)
276 {
277 TAG_LOGI(AAFwkTag::JSNAPI, "called");
278 SetWakeUpScreenCB *setWakeUpScreenCB = static_cast<SetWakeUpScreenCB *>(data);
279 if (setWakeUpScreenCB == nullptr) {
280 TAG_LOGE(AAFwkTag::JSNAPI, "null callback");
281 return;
282 }
283
284 do {
285 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
286 if (setWakeUpScreenCB->cbBase.ability == nullptr) {
287 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
288 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
289 break;
290 }
291
292 setWakeUpScreenCB->cbBase.ability->SetWakeUpScreen(setWakeUpScreenCB->wakeUp);
293 } while (false);
294
295 napi_value callback = nullptr;
296 napi_value undefined = nullptr;
297 napi_value callResult = nullptr;
298 napi_value result[ARGS_TWO] = {nullptr};
299 napi_get_undefined(env, &undefined);
300 result[PARAM0] = GetCallbackErrorValue(env, setWakeUpScreenCB->cbBase.errCode);
301 napi_get_null(env, &result[PARAM1]);
302 napi_get_reference_value(env, setWakeUpScreenCB->cbBase.cbInfo.callback, &callback);
303 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
304
305 if (setWakeUpScreenCB->cbBase.cbInfo.callback != nullptr) {
306 napi_delete_reference(env, setWakeUpScreenCB->cbBase.cbInfo.callback);
307 }
308 napi_delete_async_work(env, setWakeUpScreenCB->cbBase.asyncWork);
309 delete setWakeUpScreenCB;
310 setWakeUpScreenCB = nullptr;
311 }
312
SetWakeUpScreenAsync(napi_env env,napi_value * args,SetWakeUpScreenCB * cbData)313 static napi_value SetWakeUpScreenAsync(napi_env env, napi_value *args, SetWakeUpScreenCB *cbData)
314 {
315 TAG_LOGI(AAFwkTag::JSNAPI, "called");
316 if (cbData == nullptr || args == nullptr) {
317 TAG_LOGE(AAFwkTag::JSNAPI, "input param is nullptr");
318 return nullptr;
319 }
320
321 napi_valuetype valuetypeParam0 = napi_undefined;
322 napi_valuetype valuetypeParam1 = napi_undefined;
323 NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetypeParam0));
324 NAPI_CALL(env, napi_typeof(env, args[PARAM1], &valuetypeParam1));
325 if (valuetypeParam0 != napi_boolean || valuetypeParam1 != napi_function) {
326 TAG_LOGE(AAFwkTag::JSNAPI, "Params is error type");
327 return nullptr;
328 }
329 NAPI_CALL(env, napi_create_reference(env, args[PARAM1], 1, &cbData->cbBase.cbInfo.callback));
330
331 napi_value resourceName = nullptr;
332 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
333
334 NAPI_CALL(env,
335 napi_create_async_work(
336 env,
337 nullptr,
338 resourceName,
339 [](napi_env env, void *data) {
340 TAG_LOGI(AAFwkTag::JSNAPI, "execute called");
341 },
342 SetWakeUpScreenAsyncCompleteCB,
343 static_cast<void *>(cbData),
344 &cbData->cbBase.asyncWork));
345 NAPI_CALL(env, napi_queue_async_work(env, cbData->cbBase.asyncWork));
346 napi_value result = nullptr;
347 NAPI_CALL(env, napi_get_null(env, &result));
348 return result;
349 }
350
SetWakeUpScreenPromise(napi_env env,SetWakeUpScreenCB * cbData)351 napi_value SetWakeUpScreenPromise(napi_env env, SetWakeUpScreenCB *cbData)
352 {
353 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
354 if (cbData == nullptr) {
355 TAG_LOGE(AAFwkTag::JSNAPI, "null cbData");
356 return nullptr;
357 }
358 napi_value resourceName = nullptr;
359 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
360 napi_deferred deferred;
361 napi_value promise = nullptr;
362 napi_create_promise(env, &deferred, &promise);
363 cbData->cbBase.deferred = deferred;
364
365 napi_create_async_work(
366 env,
367 nullptr,
368 resourceName,
369 [](napi_env env, void *data) {
370 TAG_LOGI(AAFwkTag::JSNAPI, "execute called");
371 },
372 [](napi_env env, napi_status status, void *data) {
373 TAG_LOGI(AAFwkTag::JSNAPI, "complete called");
374 SetWakeUpScreenCB *setWakeUpScreenCB = static_cast<SetWakeUpScreenCB *>(data);
375 setWakeUpScreenCB->cbBase.errCode = NO_ERROR;
376 if (setWakeUpScreenCB->cbBase.ability == nullptr) {
377 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
378 setWakeUpScreenCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
379 } else {
380 setWakeUpScreenCB->cbBase.ability->SetWakeUpScreen(setWakeUpScreenCB->wakeUp);
381 }
382 napi_value result = GetCallbackErrorValue(env, setWakeUpScreenCB->cbBase.errCode);
383 if (setWakeUpScreenCB->cbBase.errCode == NO_ERROR) {
384 napi_resolve_deferred(env, setWakeUpScreenCB->cbBase.deferred, result);
385 } else {
386 napi_reject_deferred(env, setWakeUpScreenCB->cbBase.deferred, result);
387 }
388
389 napi_delete_async_work(env, setWakeUpScreenCB->cbBase.asyncWork);
390 delete setWakeUpScreenCB;
391 setWakeUpScreenCB = nullptr;
392 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
393 },
394 static_cast<void *>(cbData),
395 &cbData->cbBase.asyncWork);
396 napi_queue_async_work(env, cbData->cbBase.asyncWork);
397 return promise;
398 }
399
SetWakeUpScreenWrap(napi_env env,napi_callback_info info,SetWakeUpScreenCB * cbData)400 static napi_value SetWakeUpScreenWrap(napi_env env, napi_callback_info info, SetWakeUpScreenCB *cbData)
401 {
402 TAG_LOGI(AAFwkTag::JSNAPI, "called");
403 if (cbData == nullptr) {
404 TAG_LOGE(AAFwkTag::JSNAPI, "input param cbData is nullptr");
405 return nullptr;
406 }
407
408 size_t argcAsync = 2;
409 const size_t argStdValue = 2;
410 const size_t argPromise = 1;
411 napi_value args[ARGS_MAX_COUNT] = {nullptr};
412
413 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
414 if (argcAsync != argStdValue && argcAsync != argPromise) {
415 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
416 return nullptr;
417 }
418
419 if (!UnwrapBoolFromJS2(env, args[PARAM0], cbData->wakeUp)) {
420 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapBoolFromJS2(wakeUp) run error");
421 return nullptr;
422 }
423
424 napi_value global = nullptr;
425 NAPI_CALL(env, napi_get_global(env, &global));
426
427 napi_value abilityObj = nullptr;
428 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
429
430 Ability *ability = nullptr;
431 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
432
433 cbData->cbBase.ability = ability;
434 napi_value ret = nullptr;
435 if (argcAsync == argStdValue) {
436 ret = SetWakeUpScreenAsync(env, args, cbData);
437 } else {
438 ret = SetWakeUpScreenPromise(env, cbData);
439 }
440 return ret;
441 }
442 #endif
443
NAPI_SetShowOnLockScreen(napi_env env,napi_callback_info info)444 napi_value NAPI_SetShowOnLockScreen(napi_env env, napi_callback_info info)
445 {
446 #ifdef SUPPORT_GRAPHICS
447 TAG_LOGI(AAFwkTag::JSNAPI, "called");
448
449 size_t argc = 2;
450 const size_t argcAsync = 2, argcPromise = 1;
451 napi_value args[ARGS_MAX_COUNT] = {nullptr};
452
453 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
454 if (argc != argcAsync && argc != argcPromise) {
455 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
456 return nullptr;
457 }
458
459 napi_valuetype valuetypeParam0 = napi_undefined;
460 NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valuetypeParam0));
461 if (valuetypeParam0 != napi_boolean) {
462 TAG_LOGE(AAFwkTag::JSNAPI, "error, params is error type");
463 return nullptr;
464 }
465
466 ShowOnLockScreenCB *showOnLockScreenCB = new ShowOnLockScreenCB();
467 showOnLockScreenCB->cbBase.cbInfo.env = env;
468 showOnLockScreenCB->cbBase.abilityType = AbilityType::PAGE;
469 if (!UnwrapBoolFromJS2(env, args[PARAM0], showOnLockScreenCB->isShow)) {
470 TAG_LOGE(AAFwkTag::JSNAPI, "error, unwrapBoolFromJS2 error");
471 delete showOnLockScreenCB;
472 showOnLockScreenCB = nullptr;
473 return nullptr;
474 }
475
476 showOnLockScreenCB->cbBase.ability = GetJSAbilityObject(env);
477 napi_value ret = nullptr;
478 if (argc == argcAsync) {
479 ret = SetShowOnLockScreenAsync(env, args, showOnLockScreenCB);
480 } else {
481 ret = SetShowOnLockScreenPromise(env, showOnLockScreenCB);
482 }
483
484 if (ret == nullptr) {
485 TAG_LOGE(AAFwkTag::JSNAPI, "SetShowOnLockScreenWrap failed");
486 delete showOnLockScreenCB;
487 showOnLockScreenCB = nullptr;
488 ret = WrapVoidToJS(env);
489 }
490 return ret;
491 #else
492 return nullptr;
493 #endif
494 }
495
UnwrapParamVerifySelfPermission(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)496 bool UnwrapParamVerifySelfPermission(
497 napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
498 {
499 TAG_LOGI(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
500
501 const size_t argcMax = 2;
502 if (argc > argcMax || argc < argcMax - 1) {
503 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
504 return false;
505 }
506
507 if (argc == argcMax) {
508 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
509 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
510 return false;
511 }
512 }
513
514 std::string permission("");
515 if (!UnwrapStringFromJS2(env, argv[PARAM0], permission)) {
516 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
517 return false;
518 }
519
520 asyncCallbackInfo->param.paramArgs.PutStringValue("permission", permission);
521 return true;
522 }
523
VerifySelfPermissionExecuteCallbackWork(napi_env env,void * data)524 void VerifySelfPermissionExecuteCallbackWork(napi_env env, void *data)
525 {
526 TAG_LOGI(AAFwkTag::JSNAPI, "called");
527
528 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
529 if (asyncCallbackInfo == nullptr) {
530 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
531 return;
532 }
533
534 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
535 asyncCallbackInfo->native_data.data_type = NVT_NONE;
536
537 if (asyncCallbackInfo->ability == nullptr) {
538 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
539 return;
540 }
541
542 asyncCallbackInfo->native_data.data_type = NVT_INT32;
543 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifySelfPermission(
544 asyncCallbackInfo->param.paramArgs.GetStringValue("permission"));
545 }
546
NAPI_VerifySelfPermissionWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)547 napi_value NAPI_VerifySelfPermissionWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
548 {
549 TAG_LOGI(AAFwkTag::JSNAPI, "called");
550 size_t argc = ARGS_MAX_COUNT;
551 napi_value args[ARGS_MAX_COUNT] = {nullptr};
552 napi_value jsthis = nullptr;
553 void *data = nullptr;
554
555 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
556
557 if (!UnwrapParamVerifySelfPermission(env, argc, args, asyncCallbackInfo)) {
558 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapParamVerifySelfPermission fail");
559 return nullptr;
560 }
561
562 AsyncParamEx asyncParamEx;
563 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
564 asyncParamEx.resource = "NAPI_VerifySelfPermissionCallback";
565 asyncParamEx.execute = VerifySelfPermissionExecuteCallbackWork;
566 asyncParamEx.complete = CompleteAsyncCallbackWork;
567
568 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
569 } else {
570 asyncParamEx.resource = "NAPI_VerifySelfPermissionPromise";
571 asyncParamEx.execute = VerifySelfPermissionExecuteCallbackWork;
572 asyncParamEx.complete = CompletePromiseCallbackWork;
573
574 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
575 }
576 }
577
NAPI_VerifySelfPermission(napi_env env,napi_callback_info info)578 napi_value NAPI_VerifySelfPermission(napi_env env, napi_callback_info info)
579 {
580 TAG_LOGI(AAFwkTag::JSNAPI, "called");
581
582 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
583 if (asyncCallbackInfo == nullptr) {
584 return nullptr;
585 }
586
587 napi_value rev = NAPI_VerifySelfPermissionWrap(env, info, asyncCallbackInfo);
588 if (rev == nullptr) {
589 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
590 rev = WrapVoidToJS(env);
591 }
592 return rev;
593 }
594
UnwrapRequestPermissionsFromUser(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)595 bool UnwrapRequestPermissionsFromUser(
596 napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
597 {
598 TAG_LOGI(AAFwkTag::JSNAPI, "called, argc=%{public}zu", argc);
599
600 const size_t argcMax = 3;
601 if (argc > argcMax || argc < argcMax - 1) {
602 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
603 return false;
604 }
605
606 if (argc == argcMax) {
607 if (!CreateAsyncCallback(env, argv[PARAM2], asyncCallbackInfo)) {
608 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM2] invalid");
609 return false;
610 }
611 }
612
613 std::vector<std::string> permissionList;
614 if (!UnwrapArrayStringFromJS(env, argv[PARAM0], permissionList)) {
615 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM0] invalid");
616 return false;
617 }
618
619 int requestCode = 0;
620 if (!UnwrapInt32FromJS2(env, argv[PARAM1], requestCode)) {
621 TAG_LOGE(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
622 return false;
623 }
624
625 asyncCallbackInfo->param.paramArgs.PutIntValue("requestCode", requestCode);
626 asyncCallbackInfo->param.paramArgs.PutStringValueArray("permissionList", permissionList);
627 return true;
628 }
629
RequestPermissionsFromUserExecuteCallbackWork(napi_env env,void * data)630 void RequestPermissionsFromUserExecuteCallbackWork(napi_env env, void *data)
631 {
632 TAG_LOGI(AAFwkTag::JSNAPI, "called");
633 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
634 if (asyncCallbackInfo == nullptr) {
635 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
636 return;
637 }
638
639 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
640 if (asyncCallbackInfo->ability == nullptr) {
641 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
642 return;
643 }
644
645 CallAbilityPermissionParam permissionParam;
646 permissionParam.requestCode = asyncCallbackInfo->param.paramArgs.GetIntValue("requestCode");
647 asyncCallbackInfo->param.paramArgs.GetStringValueArray("permissionList", permissionParam.permission_list);
648 if (permissionParam.permission_list.size() == 0) {
649 asyncCallbackInfo->error_code = NAPI_ERR_PARAM_INVALID;
650 return;
651 }
652
653 AbilityProcess::GetInstance()->RequestPermissionsFromUser(
654 asyncCallbackInfo->ability, permissionParam, asyncCallbackInfo->cbInfo);
655 }
656
RequestPermissionsFromUserCompleteAsyncCallbackWork(napi_env env,napi_status status,void * data)657 void RequestPermissionsFromUserCompleteAsyncCallbackWork(napi_env env, napi_status status, void *data)
658 {
659 TAG_LOGI(AAFwkTag::JSNAPI, "called");
660
661 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
662 if (asyncCallbackInfo == nullptr) {
663 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
664 return;
665 }
666
667 if (asyncCallbackInfo->error_code != NAPI_ERR_NO_ERROR) {
668 napi_value callback = nullptr;
669 napi_value undefined = nullptr;
670 napi_get_undefined(env, &undefined);
671 napi_value callResult = nullptr;
672 napi_value revParam[ARGS_TWO] = {nullptr};
673
674 revParam[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->error_code);
675 revParam[PARAM1] = WrapVoidToJS(env);
676
677 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
678 napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
679 napi_call_function(env, undefined, callback, ARGS_TWO, revParam, &callResult);
680 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
681 } else if (asyncCallbackInfo->cbInfo.deferred != nullptr) {
682 napi_reject_deferred(env, asyncCallbackInfo->cbInfo.deferred, revParam[PARAM0]);
683 }
684 }
685
686 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
687 delete asyncCallbackInfo;
688 asyncCallbackInfo = nullptr;
689 }
690
NAPI_RequestPermissionsFromUserWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)691 napi_value NAPI_RequestPermissionsFromUserWrap(
692 napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
693 {
694 TAG_LOGD(AAFwkTag::JSNAPI, "called");
695 size_t argc = ARGS_MAX_COUNT;
696 napi_value args[ARGS_MAX_COUNT] = {nullptr};
697 napi_value jsthis = nullptr;
698 void *data = nullptr;
699
700 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
701
702 if (!UnwrapRequestPermissionsFromUser(env, argc, args, asyncCallbackInfo)) {
703 TAG_LOGE(AAFwkTag::JSNAPI, "UnwrapRequestPermissionsFromUser failed");
704 return nullptr;
705 }
706
707 AsyncParamEx asyncParamEx;
708 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
709 asyncParamEx.resource = "NAPI_RequestPermissionsFromUserCallback";
710 asyncParamEx.execute = RequestPermissionsFromUserExecuteCallbackWork;
711 asyncParamEx.complete = RequestPermissionsFromUserCompleteAsyncCallbackWork;
712
713 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
714 } else {
715 napi_deferred deferred = nullptr;
716 napi_value promise = nullptr;
717 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
718 asyncCallbackInfo->cbInfo.deferred = deferred;
719
720 napi_value resourceName = nullptr;
721 NAPI_CALL(env, napi_create_string_latin1(env, "NAPI_RequestPermissionsFromUserPromise",
722 NAPI_AUTO_LENGTH, &resourceName));
723 NAPI_CALL(env,
724 napi_create_async_work(env,
725 nullptr,
726 resourceName,
727 RequestPermissionsFromUserExecuteCallbackWork,
728 RequestPermissionsFromUserCompleteAsyncCallbackWork,
729 static_cast<void *>(asyncCallbackInfo),
730 &asyncCallbackInfo->asyncWork));
731
732 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated));
733
734 return promise;
735 }
736 }
737
NAPI_RequestPermissionsFromUser(napi_env env,napi_callback_info info)738 napi_value NAPI_RequestPermissionsFromUser(napi_env env, napi_callback_info info)
739 {
740 TAG_LOGI(AAFwkTag::JSNAPI, "called");
741
742 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
743 if (asyncCallbackInfo == nullptr) {
744 TAG_LOGI(AAFwkTag::JSNAPI, "create callbackInfo failed");
745 return WrapVoidToJS(env);
746 }
747
748 napi_value rev = NAPI_RequestPermissionsFromUserWrap(env, info, asyncCallbackInfo);
749 if (rev == nullptr) {
750 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
751 rev = WrapVoidToJS(env);
752 }
753 return rev;
754 }
755
756 struct OnRequestPermissionsData {
757 int requestCode = 0;
758 std::vector<std::string> permissions;
759 std::vector<int> grantResults;
760 uv_work_t uvWork{};
761 NapiAsyncTask *napiAsyncTask = nullptr;
762 napi_env env = nullptr;
763
~OnRequestPermissionsDataOHOS::AppExecFwk::OnRequestPermissionsData764 ~OnRequestPermissionsData()
765 {
766 if (napiAsyncTask) {
767 delete napiAsyncTask;
768 }
769 }
770
WorkCallbackOHOS::AppExecFwk::OnRequestPermissionsData771 static void WorkCallback(uv_work_t* work)
772 {
773 TAG_LOGI(AAFwkTag::JSNAPI, "called");
774 }
775
AfterWorkCallbackOHOS::AppExecFwk::OnRequestPermissionsData776 static void AfterWorkCallback(uv_work_t* work, int status)
777 {
778 TAG_LOGD(AAFwkTag::JSNAPI, "called");
779 if (work == nullptr) {
780 TAG_LOGE(AAFwkTag::JSNAPI, "null work");
781 return;
782 }
783 if (work->data == nullptr) {
784 TAG_LOGE(AAFwkTag::JSNAPI, "null data");
785 return;
786 }
787 std::unique_ptr<OnRequestPermissionsData> data{static_cast<OnRequestPermissionsData *>(work->data)};
788 auto env = data->env;
789 napi_handle_scope scope = nullptr;
790 napi_open_handle_scope(env, &scope);
791 napi_value object = nullptr;
792 napi_create_object(env, &object);
793 napi_set_named_property(env, object, "requestCode", CreateJsValue(env, data->requestCode));
794 napi_set_named_property(env, object, "permissions", CreateNativeArray(env, data->permissions));
795 napi_set_named_property(env, object, "authResults", CreateNativeArray(env, data->grantResults));
796 data->napiAsyncTask->Resolve(env, object);
797 napi_close_handle_scope(env, scope);
798 }
799 };
800
801 EXTERN_C_START
CallOnRequestPermissionsFromUserResult(int requestCode,const std::vector<std::string> & permissions,const std::vector<int> & grantResults,CallbackInfo callbackInfo)802 void CallOnRequestPermissionsFromUserResult(int requestCode, const std::vector<std::string> &permissions,
803 const std::vector<int> &grantResults, CallbackInfo callbackInfo)
804 {
805 TAG_LOGI(AAFwkTag::JSNAPI, "called");
806 if (permissions.empty()) {
807 TAG_LOGE(AAFwkTag::JSNAPI, "empty permissions");
808 return;
809 }
810 if (permissions.size() != grantResults.size()) {
811 TAG_LOGE(AAFwkTag::JSNAPI, "permissions size not match");
812 return;
813 }
814 if (callbackInfo.env == nullptr) {
815 TAG_LOGE(AAFwkTag::JSNAPI, "null env");
816 return;
817 }
818 if (callbackInfo.napiAsyncTask == nullptr) {
819 TAG_LOGE(AAFwkTag::JSNAPI, "null napiAsyncTask");
820 return;
821 }
822
823 uv_loop_t *loop = nullptr;
824 napi_get_uv_event_loop(callbackInfo.env, &loop);
825 if (loop == nullptr) {
826 TAG_LOGE(AAFwkTag::JSNAPI, "null loop");
827 return;
828 }
829
830 auto reqData = std::make_unique<OnRequestPermissionsData>();
831 reqData->permissions = permissions;
832 reqData->grantResults = grantResults;
833 reqData->requestCode = requestCode;
834 reqData->env = callbackInfo.env;
835 reqData->napiAsyncTask = callbackInfo.napiAsyncTask;
836 reqData->uvWork.data = static_cast<void *>(reqData.get());
837
838 int rev = uv_queue_work_with_qos(loop, &(reqData->uvWork),
839 OnRequestPermissionsData::WorkCallback, OnRequestPermissionsData::AfterWorkCallback, uv_qos_user_initiated);
840 if (rev == 0) {
841 (void)reqData.release();
842 }
843 }
844 EXTERN_C_END
845
NAPI_GetFilesDir(napi_env env,napi_callback_info info)846 napi_value NAPI_GetFilesDir(napi_env env, napi_callback_info info)
847 {
848 TAG_LOGI(AAFwkTag::JSNAPI, "called");
849 return NAPI_GetFilesDirCommon(env, info, AbilityType::PAGE);
850 }
851
NAPI_GetOrCreateDistributedDir(napi_env env,napi_callback_info info)852 napi_value NAPI_GetOrCreateDistributedDir(napi_env env, napi_callback_info info)
853 {
854 TAG_LOGI(AAFwkTag::JSNAPI, "called");
855 return NAPI_GetOrCreateDistributedDirCommon(env, info, AbilityType::PAGE);
856 }
857
NAPI_GetCacheDir(napi_env env,napi_callback_info info)858 napi_value NAPI_GetCacheDir(napi_env env, napi_callback_info info)
859 {
860 TAG_LOGI(AAFwkTag::JSNAPI, "called");
861 return NAPI_GetCacheDirCommon(env, info, AbilityType::PAGE);
862 }
863
NAPI_GetCtxAppType(napi_env env,napi_callback_info info)864 napi_value NAPI_GetCtxAppType(napi_env env, napi_callback_info info)
865 {
866 TAG_LOGI(AAFwkTag::JSNAPI, "called");
867 return NAPI_GetAppTypeCommon(env, info, AbilityType::PAGE);
868 }
869
NAPI_GetCtxHapModuleInfo(napi_env env,napi_callback_info info)870 napi_value NAPI_GetCtxHapModuleInfo(napi_env env, napi_callback_info info)
871 {
872 TAG_LOGI(AAFwkTag::JSNAPI, "called");
873 return NAPI_GetHapModuleInfoCommon(env, info, AbilityType::PAGE);
874 }
875
NAPI_GetAppVersionInfo(napi_env env,napi_callback_info info)876 napi_value NAPI_GetAppVersionInfo(napi_env env, napi_callback_info info)
877 {
878 TAG_LOGI(AAFwkTag::JSNAPI, "called");
879 return NAPI_GetAppVersionInfoCommon(env, info, AbilityType::PAGE);
880 }
881
NAPI_GetApplicationContext(napi_env env,napi_callback_info info)882 napi_value NAPI_GetApplicationContext(napi_env env, napi_callback_info info)
883 {
884 TAG_LOGI(AAFwkTag::JSNAPI, "called");
885 return NAPI_GetContextCommon(env, info, AbilityType::PAGE);
886 }
887
NAPI_GetCtxAbilityInfo(napi_env env,napi_callback_info info)888 napi_value NAPI_GetCtxAbilityInfo(napi_env env, napi_callback_info info)
889 {
890 TAG_LOGI(AAFwkTag::JSNAPI, "called");
891 return NAPI_GetAbilityInfoCommon(env, info, AbilityType::PAGE);
892 }
893
UnwrapVerifyPermissionOptions(napi_env env,napi_value argv,AsyncJSCallbackInfo * asyncCallbackInfo)894 bool UnwrapVerifyPermissionOptions(napi_env env, napi_value argv, AsyncJSCallbackInfo *asyncCallbackInfo)
895 {
896 TAG_LOGI(AAFwkTag::JSNAPI, "called");
897 if (asyncCallbackInfo == nullptr) {
898 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
899 return false;
900 }
901
902 if (!IsTypeForNapiValue(env, argv, napi_object)) {
903 TAG_LOGI(AAFwkTag::JSNAPI, "wrong param type");
904 return false;
905 }
906
907 int value = 0;
908 if (UnwrapInt32ByPropertyName(env, argv, "pid", value)) {
909 asyncCallbackInfo->param.paramArgs.PutIntValue("pid", value);
910 }
911
912 value = 0;
913 if (UnwrapInt32ByPropertyName(env, argv, "uid", value)) {
914 asyncCallbackInfo->param.paramArgs.PutIntValue("uid", value);
915 }
916 return true;
917 }
918
UnwrapParamVerifyPermission(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)919 bool UnwrapParamVerifyPermission(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
920 {
921 TAG_LOGI(AAFwkTag::JSNAPI, "argc=%{public}zu", argc);
922
923 const size_t argcMax = ARGS_THREE;
924 if (argc > argcMax || argc < 1) {
925 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
926 return false;
927 }
928
929 std::string permission("");
930 if (!UnwrapStringFromJS2(env, argv[PARAM0], permission)) {
931 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM0]");
932 return false;
933 }
934 asyncCallbackInfo->param.paramArgs.PutStringValue("permission", permission);
935
936 if (argc == argcMax) {
937 if (!CreateAsyncCallback(env, argv[PARAM2], asyncCallbackInfo)) {
938 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM2]");
939 return false;
940 }
941
942 if (!UnwrapVerifyPermissionOptions(env, argv[PARAM1], asyncCallbackInfo)) {
943 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM1]");
944 return false;
945 }
946 } else if (argc == ARGS_TWO) {
947 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
948 if (!UnwrapVerifyPermissionOptions(env, argv[PARAM1], asyncCallbackInfo)) {
949 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argv[PARAM1]");
950 return false;
951 }
952 }
953 } else if (argc == ARGS_ONE) {
954 asyncCallbackInfo->cbInfo.callback = nullptr;
955 } else {
956 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
957 return false;
958 }
959 return true;
960 }
961
VerifyPermissionExecuteCallback(napi_env env,void * data)962 void VerifyPermissionExecuteCallback(napi_env env, void *data)
963 {
964 TAG_LOGI(AAFwkTag::JSNAPI, "called");
965
966 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
967 if (asyncCallbackInfo == nullptr) {
968 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
969 return;
970 }
971
972 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
973 asyncCallbackInfo->native_data.data_type = NVT_NONE;
974
975 if (asyncCallbackInfo->ability == nullptr) {
976 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
977 return;
978 }
979
980 std::string permission(asyncCallbackInfo->param.paramArgs.GetStringValue("permission").c_str());
981 bool hasUid = asyncCallbackInfo->param.paramArgs.HasKey("uid");
982 int pid = asyncCallbackInfo->param.paramArgs.GetIntValue("pid");
983 int uid = asyncCallbackInfo->param.paramArgs.GetIntValue("uid");
984
985 asyncCallbackInfo->native_data.data_type = NVT_INT32;
986
987 if (hasUid) {
988 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifyPermission(permission, pid, uid);
989 } else {
990 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->VerifySelfPermission(permission);
991 }
992 }
993
NAPI_VerifyPermissionWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)994 napi_value NAPI_VerifyPermissionWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
995 {
996 TAG_LOGI(AAFwkTag::JSNAPI, "called");
997 size_t argc = ARGS_MAX_COUNT;
998 napi_value args[ARGS_MAX_COUNT] = {nullptr};
999 napi_value jsthis = nullptr;
1000 void *data = nullptr;
1001
1002 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1003
1004 if (!UnwrapParamVerifyPermission(env, argc, args, asyncCallbackInfo)) {
1005 TAG_LOGI(AAFwkTag::JSNAPI, "unwrapParamVerifyPermission failed");
1006 return nullptr;
1007 }
1008
1009 AsyncParamEx asyncParamEx;
1010 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1011 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1012 asyncParamEx.resource = "NAPI_VerifyPermissionCallback";
1013 asyncParamEx.execute = VerifyPermissionExecuteCallback;
1014 asyncParamEx.complete = CompleteAsyncCallbackWork;
1015
1016 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1017 } else {
1018 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1019 asyncParamEx.resource = "NAPI_VerifyPermissionPromise";
1020 asyncParamEx.execute = VerifyPermissionExecuteCallback;
1021 asyncParamEx.complete = CompletePromiseCallbackWork;
1022
1023 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1024 }
1025 }
1026
NAPI_VerifyPermission(napi_env env,napi_callback_info info)1027 napi_value NAPI_VerifyPermission(napi_env env, napi_callback_info info)
1028 {
1029 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1030 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
1031 if (asyncCallbackInfo == nullptr) {
1032 TAG_LOGI(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1033 return WrapVoidToJS(env);
1034 }
1035
1036 napi_value rev = NAPI_VerifyPermissionWrap(env, info, asyncCallbackInfo);
1037 if (rev == nullptr) {
1038 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
1039 rev = WrapVoidToJS(env);
1040 }
1041 return rev;
1042 }
1043
GetAppInfoExecuteCB(napi_env env,void * data)1044 void GetAppInfoExecuteCB(napi_env env, void *data)
1045 {
1046 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1047 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
1048 appInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1049
1050 if (appInfoCB->cbBase.ability == nullptr) {
1051 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1052 appInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1053 return;
1054 }
1055
1056 std::shared_ptr<ApplicationInfo> appInfoPtr = appInfoCB->cbBase.ability->GetApplicationInfo();
1057 if (appInfoPtr != nullptr) {
1058 appInfoCB->appInfo = *appInfoPtr;
1059 } else {
1060 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoPtr");
1061 appInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1062 }
1063 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1064 }
1065
GetAppInfoAsyncCompleteCB(napi_env env,napi_status status,void * data)1066 void GetAppInfoAsyncCompleteCB(napi_env env, napi_status status, void *data)
1067 {
1068 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1069 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
1070 napi_value callback = nullptr;
1071 napi_value undefined = nullptr;
1072 napi_value result[ARGS_TWO] = {nullptr};
1073 napi_value callResult = nullptr;
1074 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1075 result[PARAM0] = GetCallbackErrorValue(env, appInfoCB->cbBase.errCode);
1076 if (appInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1077 result[PARAM1] = WrapAppInfo(env, appInfoCB->appInfo);
1078 } else {
1079 result[PARAM1] = WrapUndefinedToJS(env);
1080 }
1081 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appInfoCB->cbBase.cbInfo.callback, &callback));
1082 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1083
1084 if (appInfoCB->cbBase.cbInfo.callback != nullptr) {
1085 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appInfoCB->cbBase.cbInfo.callback));
1086 }
1087 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appInfoCB->cbBase.asyncWork));
1088 delete appInfoCB;
1089 appInfoCB = nullptr;
1090 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1091 }
1092
GetApplicationInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AppInfoCB * appInfoCB)1093 napi_value GetApplicationInfoAsync(napi_env env, napi_value *args, const size_t argCallback, AppInfoCB *appInfoCB)
1094 {
1095 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1096 if (args == nullptr || appInfoCB == nullptr) {
1097 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1098 return nullptr;
1099 }
1100 napi_value resourceName = nullptr;
1101 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1102
1103 napi_valuetype valuetype = napi_undefined;
1104 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1105 if (valuetype == napi_function) {
1106 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appInfoCB->cbBase.cbInfo.callback));
1107 }
1108 NAPI_CALL(env,
1109 napi_create_async_work(env,
1110 nullptr,
1111 resourceName,
1112 GetAppInfoExecuteCB,
1113 GetAppInfoAsyncCompleteCB,
1114 static_cast<void *>(appInfoCB),
1115 &appInfoCB->cbBase.asyncWork));
1116 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1117 napi_value result = nullptr;
1118 NAPI_CALL(env, napi_get_null(env, &result));
1119 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1120 return result;
1121 }
1122
GetAppInfoPromiseCompleteCB(napi_env env,napi_status status,void * data)1123 void GetAppInfoPromiseCompleteCB(napi_env env, napi_status status, void *data)
1124 {
1125 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1126 AppInfoCB *appInfoCB = static_cast<AppInfoCB *>(data);
1127 if (appInfoCB == nullptr) {
1128 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1129 return;
1130 }
1131
1132 napi_value result = nullptr;
1133 if (appInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1134 result = WrapAppInfo(env, appInfoCB->appInfo);
1135 napi_resolve_deferred(env, appInfoCB->cbBase.deferred, result);
1136 } else {
1137 result = GetCallbackErrorValue(env, appInfoCB->cbBase.errCode);
1138 napi_reject_deferred(env, appInfoCB->cbBase.deferred, result);
1139 }
1140
1141 napi_delete_async_work(env, appInfoCB->cbBase.asyncWork);
1142 delete appInfoCB;
1143 appInfoCB = nullptr;
1144 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1145 }
1146
GetApplicationInfoPromise(napi_env env,AppInfoCB * appInfoCB)1147 napi_value GetApplicationInfoPromise(napi_env env, AppInfoCB *appInfoCB)
1148 {
1149 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1150 if (appInfoCB == nullptr) {
1151 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1152 return nullptr;
1153 }
1154 napi_value resourceName = nullptr;
1155 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1156 napi_deferred deferred;
1157 napi_value promise = nullptr;
1158 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1159 appInfoCB->cbBase.deferred = deferred;
1160
1161 NAPI_CALL(env,
1162 napi_create_async_work(env,
1163 nullptr,
1164 resourceName,
1165 GetAppInfoExecuteCB,
1166 GetAppInfoPromiseCompleteCB,
1167 static_cast<void *>(appInfoCB),
1168 &appInfoCB->cbBase.asyncWork));
1169 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1170 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1171 return promise;
1172 }
1173
GetApplicationInfoWrap(napi_env env,napi_callback_info info,AppInfoCB * appInfoCB)1174 napi_value GetApplicationInfoWrap(napi_env env, napi_callback_info info, AppInfoCB *appInfoCB)
1175 {
1176 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1177 if (appInfoCB == nullptr) {
1178 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1179 return nullptr;
1180 }
1181
1182 size_t argcAsync = 1;
1183 const size_t argcPromise = 0;
1184 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1185 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1186 napi_value ret = nullptr;
1187
1188 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1189 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1190 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1191 return nullptr;
1192 }
1193
1194 if (argcAsync > argcPromise) {
1195 ret = GetApplicationInfoAsync(env, args, 0, appInfoCB);
1196 } else {
1197 ret = GetApplicationInfoPromise(env, appInfoCB);
1198 }
1199 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1200 return ret;
1201 }
1202
CreateAppInfoCBInfo(napi_env env)1203 AppInfoCB *CreateAppInfoCBInfo(napi_env env)
1204 {
1205 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1206 napi_value global = nullptr;
1207 NAPI_CALL(env, napi_get_global(env, &global));
1208
1209 napi_value abilityObj = nullptr;
1210 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1211
1212 Ability *ability = nullptr;
1213 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1214
1215 AppInfoCB *appInfoCB = new (std::nothrow) AppInfoCB;
1216 if (appInfoCB == nullptr) {
1217 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1218 return nullptr;
1219 }
1220 appInfoCB->cbBase.cbInfo.env = env;
1221 appInfoCB->cbBase.asyncWork = nullptr;
1222 appInfoCB->cbBase.deferred = nullptr;
1223 appInfoCB->cbBase.ability = ability;
1224 appInfoCB->cbBase.abilityType = AbilityType::UNKNOWN;
1225 appInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1226
1227 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1228 return appInfoCB;
1229 }
1230
GetBundleNameExecuteCallback(napi_env env,void * data)1231 void GetBundleNameExecuteCallback(napi_env env, void *data)
1232 {
1233 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1234 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
1235 if (asyncCallbackInfo == nullptr) {
1236 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1237 return;
1238 }
1239
1240 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1241 asyncCallbackInfo->native_data.data_type = NVT_NONE;
1242 if (asyncCallbackInfo->ability == nullptr) {
1243 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1244 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
1245 return;
1246 }
1247
1248 asyncCallbackInfo->native_data.data_type = NVT_STRING;
1249 asyncCallbackInfo->native_data.str_value = asyncCallbackInfo->ability->GetBundleName();
1250 TAG_LOGI(AAFwkTag::JSNAPI, "bundleName=%{public}s",
1251 asyncCallbackInfo->native_data.str_value.c_str());
1252 }
1253
NAPI_GetBundleNameWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)1254 napi_value NAPI_GetBundleNameWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
1255 {
1256 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1257 size_t argc = ARGS_MAX_COUNT;
1258 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1259 napi_value jsthis = nullptr;
1260 void *data = nullptr;
1261
1262 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1263
1264 if (argc > ARGS_ONE) {
1265 TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
1266 return nullptr;
1267 }
1268
1269 if (argc == ARGS_ONE) {
1270 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
1271 TAG_LOGI(AAFwkTag::JSNAPI, "invalid args[PARAM0]");
1272 return nullptr;
1273 }
1274 }
1275
1276 AsyncParamEx asyncParamEx;
1277 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1278 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1279 asyncParamEx.resource = "NAPI_GetBundleNameCallback";
1280 asyncParamEx.execute = GetBundleNameExecuteCallback;
1281 asyncParamEx.complete = CompleteAsyncCallbackWork;
1282
1283 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1284 } else {
1285 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1286 asyncParamEx.resource = "NAPI_GetBundleNamePromise";
1287 asyncParamEx.execute = GetBundleNameExecuteCallback;
1288 asyncParamEx.complete = CompletePromiseCallbackWork;
1289
1290 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1291 }
1292 }
1293
WrapProcessInfo(napi_env env,ProcessInfoCB * processInfoCB)1294 napi_value WrapProcessInfo(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 result = nullptr;
1302 napi_value proValue = nullptr;
1303 NAPI_CALL(env, napi_create_object(env, &result));
1304 NAPI_CALL(env, napi_create_int32(env, processInfoCB->pid, &proValue));
1305 NAPI_CALL(env, napi_set_named_property(env, result, "pid", proValue));
1306
1307 NAPI_CALL(env, napi_create_string_utf8(env, processInfoCB->processName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1308 NAPI_CALL(env, napi_set_named_property(env, result, "processName", proValue));
1309 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1310 return result;
1311 }
1312
GetProcessInfoExecuteCB(napi_env env,void * data)1313 void GetProcessInfoExecuteCB(napi_env env, void *data)
1314 {
1315 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
1316 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1317 if (processInfoCB == nullptr) {
1318 return;
1319 }
1320
1321 processInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1322 if (processInfoCB->cbBase.ability == nullptr) {
1323 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1324 processInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1325 return;
1326 }
1327
1328 std::shared_ptr<ProcessInfo> processInfoPtr = processInfoCB->cbBase.ability->GetProcessInfo();
1329 if (processInfoPtr != nullptr) {
1330 processInfoCB->processName = processInfoPtr->GetProcessName();
1331 processInfoCB->pid = processInfoPtr->GetPid();
1332 } else {
1333 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoPtr");
1334 processInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1335 }
1336 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
1337 }
1338
GetProcessInfoAsyncCompleteCB(napi_env env,napi_status status,void * data)1339 void GetProcessInfoAsyncCompleteCB(napi_env env, napi_status status, void *data)
1340 {
1341 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1342 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1343 napi_value callback = nullptr;
1344 napi_value undefined = nullptr;
1345 napi_value result[ARGS_TWO] = {nullptr};
1346 napi_value callResult = nullptr;
1347 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1348 result[PARAM0] = GetCallbackErrorValue(env, processInfoCB->cbBase.errCode);
1349 if (processInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1350 result[PARAM1] = WrapProcessInfo(env, processInfoCB);
1351 } else {
1352 result[PARAM1] = WrapUndefinedToJS(env);
1353 }
1354
1355 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, processInfoCB->cbBase.cbInfo.callback, &callback));
1356 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1357
1358 if (processInfoCB->cbBase.cbInfo.callback != nullptr) {
1359 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, processInfoCB->cbBase.cbInfo.callback));
1360 }
1361 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, processInfoCB->cbBase.asyncWork));
1362 delete processInfoCB;
1363 processInfoCB = nullptr;
1364 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1365 }
1366
GetProcessInfoAsync(napi_env env,napi_value * args,const size_t argCallback,ProcessInfoCB * processInfoCB)1367 napi_value GetProcessInfoAsync(napi_env env, napi_value *args, const size_t argCallback, ProcessInfoCB *processInfoCB)
1368 {
1369 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1370 if (args == nullptr || processInfoCB == nullptr) {
1371 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1372 return nullptr;
1373 }
1374 napi_value resourceName = nullptr;
1375 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1376
1377 napi_valuetype valuetype = napi_undefined;
1378 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1379 if (valuetype == napi_function) {
1380 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &processInfoCB->cbBase.cbInfo.callback));
1381 }
1382 NAPI_CALL(env,
1383 napi_create_async_work(env,
1384 nullptr,
1385 resourceName,
1386 GetProcessInfoExecuteCB,
1387 GetProcessInfoAsyncCompleteCB,
1388 static_cast<void *>(processInfoCB),
1389 &processInfoCB->cbBase.asyncWork));
1390 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1391 napi_value result = nullptr;
1392 NAPI_CALL(env, napi_get_null(env, &result));
1393 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1394 return result;
1395 }
1396
GetProcessInfoPromiseCompleteCB(napi_env env,napi_status status,void * data)1397 void GetProcessInfoPromiseCompleteCB(napi_env env, napi_status status, void *data)
1398 {
1399 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1400 ProcessInfoCB *processInfoCB = static_cast<ProcessInfoCB *>(data);
1401 napi_value result = nullptr;
1402 if (processInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1403 result = WrapProcessInfo(env, processInfoCB);
1404 napi_resolve_deferred(env, processInfoCB->cbBase.deferred, result);
1405 } else {
1406 result = GetCallbackErrorValue(env, processInfoCB->cbBase.errCode);
1407 napi_reject_deferred(env, processInfoCB->cbBase.deferred, result);
1408 }
1409
1410 napi_delete_async_work(env, processInfoCB->cbBase.asyncWork);
1411 delete processInfoCB;
1412 processInfoCB = nullptr;
1413 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1414 }
1415
GetProcessInfoPromise(napi_env env,ProcessInfoCB * processInfoCB)1416 napi_value GetProcessInfoPromise(napi_env env, ProcessInfoCB *processInfoCB)
1417 {
1418 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1419 if (processInfoCB == nullptr) {
1420 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1421 return nullptr;
1422 }
1423 napi_value resourceName = nullptr;
1424 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1425 napi_deferred deferred;
1426 napi_value promise = nullptr;
1427 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1428 processInfoCB->cbBase.deferred = deferred;
1429
1430 NAPI_CALL(env,
1431 napi_create_async_work(env,
1432 nullptr,
1433 resourceName,
1434 GetProcessInfoExecuteCB,
1435 GetProcessInfoPromiseCompleteCB,
1436 static_cast<void *>(processInfoCB),
1437 &processInfoCB->cbBase.asyncWork));
1438 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1439 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1440 return promise;
1441 }
1442
GetProcessInfoWrap(napi_env env,napi_callback_info info,ProcessInfoCB * processInfoCB)1443 napi_value GetProcessInfoWrap(napi_env env, napi_callback_info info, ProcessInfoCB *processInfoCB)
1444 {
1445 TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1446 if (processInfoCB == nullptr) {
1447 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1448 return nullptr;
1449 }
1450
1451 size_t argcAsync = 1;
1452 const size_t argcPromise = 0;
1453 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1454 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1455 napi_value ret = nullptr;
1456
1457 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1458 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1459 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1460 return nullptr;
1461 }
1462
1463 if (argcAsync > argcPromise) {
1464 ret = GetProcessInfoAsync(env, args, 0, processInfoCB);
1465 } else {
1466 ret = GetProcessInfoPromise(env, processInfoCB);
1467 }
1468 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1469 return ret;
1470 }
1471
CreateProcessInfoCBInfo(napi_env env)1472 ProcessInfoCB *CreateProcessInfoCBInfo(napi_env env)
1473 {
1474 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1475 napi_value global = nullptr;
1476 NAPI_CALL(env, napi_get_global(env, &global));
1477
1478 napi_value abilityObj = nullptr;
1479 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1480
1481 Ability *ability = nullptr;
1482 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1483
1484 ProcessInfoCB *processInfoCB = new (std::nothrow) ProcessInfoCB;
1485 if (processInfoCB == nullptr) {
1486 TAG_LOGE(AAFwkTag::JSNAPI, "null processInfoCB");
1487 return nullptr;
1488 }
1489 processInfoCB->cbBase.cbInfo.env = env;
1490 processInfoCB->cbBase.asyncWork = nullptr;
1491 processInfoCB->cbBase.deferred = nullptr;
1492 processInfoCB->cbBase.ability = ability;
1493
1494 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1495 return processInfoCB;
1496 }
1497
CreateElementNameCBInfo(napi_env env)1498 ElementNameCB *CreateElementNameCBInfo(napi_env env)
1499 {
1500 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1501 napi_value global = nullptr;
1502 NAPI_CALL(env, napi_get_global(env, &global));
1503
1504 napi_value abilityObj = nullptr;
1505 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1506
1507 Ability *ability = nullptr;
1508 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1509
1510 ElementNameCB *elementNameCB = new (std::nothrow) ElementNameCB;
1511 if (elementNameCB == nullptr) {
1512 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1513 return nullptr;
1514 }
1515 elementNameCB->cbBase.cbInfo.env = env;
1516 elementNameCB->cbBase.asyncWork = nullptr;
1517 elementNameCB->cbBase.deferred = nullptr;
1518 elementNameCB->cbBase.ability = ability;
1519
1520 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1521 return elementNameCB;
1522 }
1523
WrapElementName(napi_env env,const ElementNameCB * elementNameCB)1524 napi_value WrapElementName(napi_env env, const ElementNameCB *elementNameCB)
1525 {
1526 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1527 if (elementNameCB == nullptr) {
1528 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1529 return nullptr;
1530 }
1531 napi_value result = nullptr;
1532 napi_value proValue = nullptr;
1533 NAPI_CALL(env, napi_create_object(env, &result));
1534 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->abilityName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1535 NAPI_CALL(env, napi_set_named_property(env, result, "abilityName", proValue));
1536
1537 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->bundleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1538 NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", proValue));
1539
1540 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->deviceId.c_str(), NAPI_AUTO_LENGTH, &proValue));
1541 NAPI_CALL(env, napi_set_named_property(env, result, "deviceId", proValue));
1542
1543 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->shortName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1544 NAPI_CALL(env, napi_set_named_property(env, result, "shortName", proValue));
1545
1546 NAPI_CALL(env, napi_create_string_utf8(env, elementNameCB->uri.c_str(), NAPI_AUTO_LENGTH, &proValue));
1547 NAPI_CALL(env, napi_set_named_property(env, result, "uri", proValue));
1548 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1549 return result;
1550 }
1551
GetElementNameExecuteCB(napi_env env,void * data)1552 void GetElementNameExecuteCB(napi_env env, void *data)
1553 {
1554 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
1555 if (data == nullptr) {
1556 TAG_LOGE(AAFwkTag::JSNAPI, "null data");
1557 return;
1558 }
1559 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1560 if (elementNameCB == nullptr) {
1561 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1562 return;
1563 }
1564
1565 elementNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1566 if (elementNameCB->cbBase.ability == nullptr) {
1567 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1568 elementNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1569 return;
1570 }
1571
1572 std::shared_ptr<ElementName> elementName = elementNameCB->cbBase.ability->GetElementName();
1573 if (elementName != nullptr) {
1574 elementNameCB->deviceId = elementName->GetDeviceID();
1575 elementNameCB->bundleName = elementName->GetBundleName();
1576 elementNameCB->abilityName = elementName->GetAbilityName();
1577 elementNameCB->uri = elementNameCB->cbBase.ability->GetWant()->GetUriString();
1578 elementNameCB->shortName = "";
1579 } else {
1580 elementNameCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1581 }
1582 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1583 }
1584
GetElementNameAsyncCompleteCB(napi_env env,napi_status status,void * data)1585 void GetElementNameAsyncCompleteCB(napi_env env, napi_status status, void *data)
1586 {
1587 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1588 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1589 napi_value callback = nullptr;
1590 napi_value undefined = nullptr;
1591 napi_value result[ARGS_TWO] = {nullptr};
1592 napi_value callResult = nullptr;
1593 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1594 result[PARAM0] = GetCallbackErrorValue(env, elementNameCB->cbBase.errCode);
1595 if (elementNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1596 result[PARAM1] = WrapElementName(env, elementNameCB);
1597 } else {
1598 result[PARAM1] = WrapUndefinedToJS(env);
1599 }
1600 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, elementNameCB->cbBase.cbInfo.callback, &callback));
1601 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1602
1603 if (elementNameCB->cbBase.cbInfo.callback != nullptr) {
1604 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, elementNameCB->cbBase.cbInfo.callback));
1605 }
1606 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, elementNameCB->cbBase.asyncWork));
1607 delete elementNameCB;
1608 elementNameCB = nullptr;
1609 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1610 }
1611
GetElementNamePromiseCompleteCB(napi_env env,napi_status status,void * data)1612 void GetElementNamePromiseCompleteCB(napi_env env, napi_status status, void *data)
1613 {
1614 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1615 ElementNameCB *elementNameCB = static_cast<ElementNameCB *>(data);
1616 napi_value result = nullptr;
1617 if (elementNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1618 result = WrapElementName(env, elementNameCB);
1619 napi_resolve_deferred(env, elementNameCB->cbBase.deferred, result);
1620 } else {
1621 result = GetCallbackErrorValue(env, elementNameCB->cbBase.errCode);
1622 napi_reject_deferred(env, elementNameCB->cbBase.deferred, result);
1623 }
1624
1625 napi_delete_async_work(env, elementNameCB->cbBase.asyncWork);
1626 delete elementNameCB;
1627 elementNameCB = nullptr;
1628 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1629 }
1630
GetElementNamePromise(napi_env env,ElementNameCB * elementNameCB)1631 napi_value GetElementNamePromise(napi_env env, ElementNameCB *elementNameCB)
1632 {
1633 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1634 if (elementNameCB == nullptr) {
1635 TAG_LOGE(AAFwkTag::JSNAPI, "null elementNameCB");
1636 return nullptr;
1637 }
1638 napi_value resourceName = nullptr;
1639 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1640 napi_deferred deferred;
1641 napi_value promise = nullptr;
1642 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1643 elementNameCB->cbBase.deferred = deferred;
1644
1645 NAPI_CALL(env,
1646 napi_create_async_work(env,
1647 nullptr,
1648 resourceName,
1649 GetElementNameExecuteCB,
1650 GetElementNamePromiseCompleteCB,
1651 static_cast<void *>(elementNameCB),
1652 &elementNameCB->cbBase.asyncWork));
1653 NAPI_CALL(env, napi_queue_async_work_with_qos(env, elementNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1654 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1655 return promise;
1656 }
1657
GetElementNameAsync(napi_env env,napi_value * args,const size_t argCallback,ElementNameCB * elementNameCB)1658 napi_value GetElementNameAsync(napi_env env, napi_value *args, const size_t argCallback, ElementNameCB *elementNameCB)
1659 {
1660 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1661 if (args == nullptr || elementNameCB == nullptr) {
1662 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1663 return nullptr;
1664 }
1665 napi_value resourceName = nullptr;
1666 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1667
1668 napi_valuetype valuetype = napi_undefined;
1669 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1670 if (valuetype == napi_function) {
1671 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &elementNameCB->cbBase.cbInfo.callback));
1672 }
1673 NAPI_CALL(env,
1674 napi_create_async_work(env,
1675 nullptr,
1676 resourceName,
1677 GetElementNameExecuteCB,
1678 GetElementNameAsyncCompleteCB,
1679 static_cast<void *>(elementNameCB),
1680 &elementNameCB->cbBase.asyncWork));
1681 NAPI_CALL(env, napi_queue_async_work_with_qos(env, elementNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1682 napi_value result = nullptr;
1683 NAPI_CALL(env, napi_get_null(env, &result));
1684 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1685 return result;
1686 }
1687
GetElementNameWrap(napi_env env,napi_callback_info info,ElementNameCB * elementNameCB)1688 napi_value GetElementNameWrap(napi_env env, napi_callback_info info, ElementNameCB *elementNameCB)
1689 {
1690 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1691 if (elementNameCB == nullptr) {
1692 TAG_LOGE(AAFwkTag::JSNAPI, "null appInfoCB");
1693 return nullptr;
1694 }
1695
1696 size_t argcAsync = 1;
1697 const size_t argcPromise = 0;
1698 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1699 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1700 napi_value ret = nullptr;
1701
1702 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1703 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1704 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1705 return nullptr;
1706 }
1707
1708 if (argcAsync > argcPromise) {
1709 ret = GetElementNameAsync(env, args, 0, elementNameCB);
1710 } else {
1711 ret = GetElementNamePromise(env, elementNameCB);
1712 }
1713 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1714 return ret;
1715 }
1716
CreateProcessNameCBInfo(napi_env env)1717 ProcessNameCB *CreateProcessNameCBInfo(napi_env env)
1718 {
1719 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1720 napi_value global = nullptr;
1721 NAPI_CALL(env, napi_get_global(env, &global));
1722
1723 napi_value abilityObj = nullptr;
1724 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1725
1726 Ability *ability = nullptr;
1727 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1728
1729 ProcessNameCB *processNameCB = new (std::nothrow) ProcessNameCB;
1730 if (processNameCB == nullptr) {
1731 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1732 return nullptr;
1733 }
1734 processNameCB->cbBase.cbInfo.env = env;
1735 processNameCB->cbBase.asyncWork = nullptr;
1736 processNameCB->cbBase.deferred = nullptr;
1737 processNameCB->cbBase.ability = ability;
1738
1739 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1740 return processNameCB;
1741 }
1742
GetProcessNameExecuteCB(napi_env env,void * data)1743 void GetProcessNameExecuteCB(napi_env env, void *data)
1744 {
1745 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1746 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1747 if (processNameCB == nullptr) {
1748 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1749 return;
1750 }
1751
1752 processNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1753 if (processNameCB->cbBase.ability == nullptr) {
1754 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1755 processNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1756 return;
1757 }
1758
1759 processNameCB->processName = processNameCB->cbBase.ability->GetProcessName();
1760 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1761 }
1762
WrapProcessName(napi_env env,const ProcessNameCB * processNameCB)1763 napi_value WrapProcessName(napi_env env, const ProcessNameCB *processNameCB)
1764 {
1765 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1766 if (processNameCB == nullptr) {
1767 TAG_LOGE(AAFwkTag::JSNAPI, "%{public}s, Invalid param(processNameCB == nullptr)", __func__);
1768 return nullptr;
1769 }
1770 napi_value result = nullptr;
1771 NAPI_CALL(env, napi_create_string_utf8(env, processNameCB->processName.c_str(), NAPI_AUTO_LENGTH, &result));
1772 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1773 return result;
1774 }
1775
GetProcessNameAsyncCompleteCB(napi_env env,napi_status status,void * data)1776 void GetProcessNameAsyncCompleteCB(napi_env env, napi_status status, void *data)
1777 {
1778 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1779 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1780 napi_value callback = nullptr;
1781 napi_value undefined = nullptr;
1782 napi_value result[ARGS_TWO] = {nullptr};
1783 napi_value callResult = nullptr;
1784 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1785 result[PARAM0] = GetCallbackErrorValue(env, processNameCB->cbBase.errCode);
1786 if (processNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1787 result[PARAM1] = WrapProcessName(env, processNameCB);
1788 } else {
1789 result[PARAM1] = WrapUndefinedToJS(env);
1790 }
1791 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, processNameCB->cbBase.cbInfo.callback, &callback));
1792 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1793
1794 if (processNameCB->cbBase.cbInfo.callback != nullptr) {
1795 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, processNameCB->cbBase.cbInfo.callback));
1796 }
1797 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, processNameCB->cbBase.asyncWork));
1798 delete processNameCB;
1799 processNameCB = nullptr;
1800 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1801 }
1802
GetProcessNamePromiseCompleteCB(napi_env env,napi_status status,void * data)1803 void GetProcessNamePromiseCompleteCB(napi_env env, napi_status status, void *data)
1804 {
1805 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1806 ProcessNameCB *processNameCB = static_cast<ProcessNameCB *>(data);
1807 napi_value result = nullptr;
1808 if (processNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1809 result = WrapProcessName(env, processNameCB);
1810 napi_resolve_deferred(env, processNameCB->cbBase.deferred, result);
1811 } else {
1812 result = GetCallbackErrorValue(env, processNameCB->cbBase.errCode);
1813 napi_reject_deferred(env, processNameCB->cbBase.deferred, result);
1814 }
1815
1816 napi_delete_async_work(env, processNameCB->cbBase.asyncWork);
1817 delete processNameCB;
1818 processNameCB = nullptr;
1819 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1820 }
1821
GetProcessNameAsync(napi_env env,napi_value * args,const size_t argCallback,ProcessNameCB * processNameCB)1822 napi_value GetProcessNameAsync(napi_env env, napi_value *args, const size_t argCallback, ProcessNameCB *processNameCB)
1823 {
1824 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1825 if (args == nullptr || processNameCB == nullptr) {
1826 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1827 return nullptr;
1828 }
1829 napi_value resourceName = nullptr;
1830 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1831
1832 napi_valuetype valuetype = napi_undefined;
1833 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1834 if (valuetype == napi_function) {
1835 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &processNameCB->cbBase.cbInfo.callback));
1836 }
1837 NAPI_CALL(env,
1838 napi_create_async_work(env,
1839 nullptr,
1840 resourceName,
1841 GetProcessNameExecuteCB,
1842 GetProcessNameAsyncCompleteCB,
1843 static_cast<void *>(processNameCB),
1844 &processNameCB->cbBase.asyncWork));
1845 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1846 napi_value result = nullptr;
1847 NAPI_CALL(env, napi_get_null(env, &result));
1848 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1849 return result;
1850 }
1851
GetProcessNamePromise(napi_env env,ProcessNameCB * processNameCB)1852 napi_value GetProcessNamePromise(napi_env env, ProcessNameCB *processNameCB)
1853 {
1854 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1855 if (processNameCB == nullptr) {
1856 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1857 return nullptr;
1858 }
1859 napi_value resourceName = nullptr;
1860 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1861 napi_deferred deferred;
1862 napi_value promise = nullptr;
1863 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1864 processNameCB->cbBase.deferred = deferred;
1865
1866 NAPI_CALL(env,
1867 napi_create_async_work(env,
1868 nullptr,
1869 resourceName,
1870 GetProcessNameExecuteCB,
1871 GetProcessNamePromiseCompleteCB,
1872 static_cast<void *>(processNameCB),
1873 &processNameCB->cbBase.asyncWork));
1874 NAPI_CALL(env, napi_queue_async_work_with_qos(env, processNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1875 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1876 return promise;
1877 }
1878
GetProcessNameWrap(napi_env env,napi_callback_info info,ProcessNameCB * processNameCB)1879 napi_value GetProcessNameWrap(napi_env env, napi_callback_info info, ProcessNameCB *processNameCB)
1880 {
1881 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1882 if (processNameCB == nullptr) {
1883 TAG_LOGE(AAFwkTag::JSNAPI, "null processNameCB");
1884 return nullptr;
1885 }
1886
1887 size_t argcAsync = 1;
1888 const size_t argcPromise = 0;
1889 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1890 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1891 napi_value ret = nullptr;
1892
1893 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1894 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1895 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1896 return nullptr;
1897 }
1898
1899 if (argcAsync > argcPromise) {
1900 ret = GetProcessNameAsync(env, args, 0, processNameCB);
1901 } else {
1902 ret = GetProcessNamePromise(env, processNameCB);
1903 }
1904 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1905 return ret;
1906 }
1907
CreateCallingBundleCBInfo(napi_env env)1908 CallingBundleCB *CreateCallingBundleCBInfo(napi_env env)
1909 {
1910 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1911 napi_value global = nullptr;
1912 NAPI_CALL(env, napi_get_global(env, &global));
1913
1914 napi_value abilityObj = nullptr;
1915 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1916
1917 Ability *ability = nullptr;
1918 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1919
1920 CallingBundleCB *callingBundleCB = new (std::nothrow) CallingBundleCB;
1921 if (callingBundleCB == nullptr) {
1922 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
1923 return nullptr;
1924 }
1925 callingBundleCB->cbBase.cbInfo.env = env;
1926 callingBundleCB->cbBase.asyncWork = nullptr;
1927 callingBundleCB->cbBase.deferred = nullptr;
1928 callingBundleCB->cbBase.ability = ability;
1929
1930 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1931 return callingBundleCB;
1932 }
1933
GetCallingBundleExecuteCB(napi_env env,void * data)1934 void GetCallingBundleExecuteCB(napi_env env, void *data)
1935 {
1936 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
1937 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
1938 if (callingBundleCB == nullptr) {
1939 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
1940 return;
1941 }
1942
1943 callingBundleCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1944 if (callingBundleCB->cbBase.ability == nullptr) {
1945 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1946 callingBundleCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1947 return;
1948 }
1949
1950 callingBundleCB->callingBundleName = callingBundleCB->cbBase.ability->GetCallingBundle();
1951 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
1952 }
1953
WrapCallingBundle(napi_env env,const CallingBundleCB * callingBundleCB)1954 napi_value WrapCallingBundle(napi_env env, const CallingBundleCB *callingBundleCB)
1955 {
1956 TAG_LOGI(AAFwkTag::JSNAPI, "called");
1957 if (callingBundleCB == nullptr) {
1958 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
1959 return nullptr;
1960 }
1961 napi_value result = nullptr;
1962 NAPI_CALL(env, napi_create_string_utf8(env, callingBundleCB->callingBundleName.c_str(), NAPI_AUTO_LENGTH, &result));
1963 TAG_LOGI(AAFwkTag::JSNAPI, "end");
1964 return result;
1965 }
1966
GetCallingBundleAsyncCompleteCB(napi_env env,napi_status status,void * data)1967 void GetCallingBundleAsyncCompleteCB(napi_env env, napi_status status, void *data)
1968 {
1969 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1970 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
1971 napi_value callback = nullptr;
1972 napi_value undefined = nullptr;
1973 napi_value result[ARGS_TWO] = {nullptr};
1974 napi_value callResult = nullptr;
1975 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1976 result[PARAM0] = GetCallbackErrorValue(env, callingBundleCB->cbBase.errCode);
1977 if (callingBundleCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1978 result[PARAM1] = WrapCallingBundle(env, callingBundleCB);
1979 } else {
1980 result[PARAM1] = WrapUndefinedToJS(env);
1981 }
1982 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callingBundleCB->cbBase.cbInfo.callback, &callback));
1983 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1984
1985 if (callingBundleCB->cbBase.cbInfo.callback != nullptr) {
1986 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, callingBundleCB->cbBase.cbInfo.callback));
1987 }
1988 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, callingBundleCB->cbBase.asyncWork));
1989 delete callingBundleCB;
1990 callingBundleCB = nullptr;
1991 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
1992 }
1993
GetCallingBundlePromiseCompleteCB(napi_env env,napi_status status,void * data)1994 void GetCallingBundlePromiseCompleteCB(napi_env env, napi_status status, void *data)
1995 {
1996 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
1997 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
1998 napi_value result = nullptr;
1999 if (callingBundleCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2000 result = WrapCallingBundle(env, callingBundleCB);
2001 napi_resolve_deferred(env, callingBundleCB->cbBase.deferred, result);
2002 } else {
2003 result = GetCallbackErrorValue(env, callingBundleCB->cbBase.errCode);
2004 napi_reject_deferred(env, callingBundleCB->cbBase.deferred, result);
2005 }
2006
2007 napi_delete_async_work(env, callingBundleCB->cbBase.asyncWork);
2008 delete callingBundleCB;
2009 callingBundleCB = nullptr;
2010 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
2011 }
2012
GetCallingBundleAsync(napi_env env,napi_value * args,const size_t argCallback,CallingBundleCB * callingBundleCB)2013 napi_value GetCallingBundleAsync(
2014 napi_env env, napi_value *args, const size_t argCallback, CallingBundleCB *callingBundleCB)
2015 {
2016 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2017 if (args == nullptr || callingBundleCB == nullptr) {
2018 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
2019 return nullptr;
2020 }
2021 napi_value resourceName = nullptr;
2022 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2023
2024 napi_valuetype valuetype = napi_undefined;
2025 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
2026 if (valuetype == napi_function) {
2027 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &callingBundleCB->cbBase.cbInfo.callback));
2028 }
2029 NAPI_CALL(env,
2030 napi_create_async_work(env,
2031 nullptr,
2032 resourceName,
2033 GetCallingBundleExecuteCB,
2034 GetCallingBundleAsyncCompleteCB,
2035 static_cast<void *>(callingBundleCB),
2036 &callingBundleCB->cbBase.asyncWork));
2037 NAPI_CALL(env, napi_queue_async_work_with_qos(env, callingBundleCB->cbBase.asyncWork, napi_qos_user_initiated));
2038 napi_value result = nullptr;
2039 NAPI_CALL(env, napi_get_null(env, &result));
2040 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2041 return result;
2042 }
2043
GetCallingBundlePromise(napi_env env,CallingBundleCB * callingBundleCB)2044 napi_value GetCallingBundlePromise(napi_env env, CallingBundleCB *callingBundleCB)
2045 {
2046 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
2047 if (callingBundleCB == nullptr) {
2048 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
2049 return nullptr;
2050 }
2051 napi_value resourceName = nullptr;
2052 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2053 napi_deferred deferred;
2054 napi_value promise = nullptr;
2055 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2056 callingBundleCB->cbBase.deferred = deferred;
2057
2058 NAPI_CALL(env,
2059 napi_create_async_work(env,
2060 nullptr,
2061 resourceName,
2062 GetCallingBundleExecuteCB,
2063 GetCallingBundlePromiseCompleteCB,
2064 static_cast<void *>(callingBundleCB),
2065 &callingBundleCB->cbBase.asyncWork));
2066 NAPI_CALL(env, napi_queue_async_work_with_qos(env, callingBundleCB->cbBase.asyncWork, napi_qos_user_initiated));
2067 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2068 return promise;
2069 }
2070
GetCallingBundleWrap(napi_env env,napi_callback_info info,CallingBundleCB * callingBundleCB)2071 napi_value GetCallingBundleWrap(napi_env env, napi_callback_info info, CallingBundleCB *callingBundleCB)
2072 {
2073 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2074 if (callingBundleCB == nullptr) {
2075 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
2076 return nullptr;
2077 }
2078
2079 size_t argcAsync = 1;
2080 const size_t argcPromise = 0;
2081 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2082 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2083 napi_value ret = nullptr;
2084
2085 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2086 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
2087 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
2088 return nullptr;
2089 }
2090
2091 if (argcAsync > argcPromise) {
2092 ret = GetCallingBundleAsync(env, args, 0, callingBundleCB);
2093 } else {
2094 ret = GetCallingBundlePromise(env, callingBundleCB);
2095 }
2096 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2097 return ret;
2098 }
2099
CreateGetOrCreateLocalDirCBInfo(napi_env env)2100 GetOrCreateLocalDirCB *CreateGetOrCreateLocalDirCBInfo(napi_env env)
2101 {
2102 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2103 napi_value global = nullptr;
2104 NAPI_CALL(env, napi_get_global(env, &global));
2105
2106 napi_value abilityObj = nullptr;
2107 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
2108
2109 Ability *ability = nullptr;
2110 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
2111
2112 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = new (std::nothrow) GetOrCreateLocalDirCB;
2113 if (getOrCreateLocalDirCB == nullptr) {
2114 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
2115 return nullptr;
2116 }
2117 getOrCreateLocalDirCB->cbBase.cbInfo.env = env;
2118 getOrCreateLocalDirCB->cbBase.asyncWork = nullptr;
2119 getOrCreateLocalDirCB->cbBase.deferred = nullptr;
2120 getOrCreateLocalDirCB->cbBase.ability = ability;
2121
2122 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2123 return getOrCreateLocalDirCB;
2124 }
2125
GetOrCreateLocalDirExecuteCB(napi_env env,void * data)2126 void GetOrCreateLocalDirExecuteCB(napi_env env, void *data)
2127 {
2128 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
2129 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
2130 if (getOrCreateLocalDirCB == nullptr) {
2131 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
2132 return;
2133 }
2134
2135 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2136 if (getOrCreateLocalDirCB->cbBase.ability == nullptr ||
2137 getOrCreateLocalDirCB->cbBase.ability->GetAbilityContext() == nullptr) {
2138 TAG_LOGE(AAFwkTag::JSNAPI, "null ability or abilityContext");
2139 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
2140 return;
2141 }
2142
2143 getOrCreateLocalDirCB->rootDir = getOrCreateLocalDirCB->cbBase.ability->GetAbilityContext()->GetBaseDir();
2144 TAG_LOGI(AAFwkTag::JSNAPI, "GetDir rootDir:%{public}s",
2145 getOrCreateLocalDirCB->rootDir.c_str());
2146 if (!OHOS::FileExists(getOrCreateLocalDirCB->rootDir)) {
2147 TAG_LOGI(AAFwkTag::JSNAPI, "dir not exits, create dir");
2148 OHOS::ForceCreateDirectory(getOrCreateLocalDirCB->rootDir);
2149 OHOS::ChangeModeDirectory(getOrCreateLocalDirCB->rootDir, MODE);
2150 }
2151 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
2152 }
2153
WrapGetOrCreateLocalDir(napi_env env,const GetOrCreateLocalDirCB * getOrCreateLocalDirCB)2154 napi_value WrapGetOrCreateLocalDir(napi_env env, const GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
2155 {
2156 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2157 if (getOrCreateLocalDirCB == nullptr) {
2158 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
2159 return nullptr;
2160 }
2161 napi_value result = nullptr;
2162 NAPI_CALL(env, napi_create_string_utf8(env, getOrCreateLocalDirCB->rootDir.c_str(), NAPI_AUTO_LENGTH, &result));
2163 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2164 return result;
2165 }
2166
GetOrCreateLocalDirAsyncCompleteCB(napi_env env,napi_status status,void * data)2167 void GetOrCreateLocalDirAsyncCompleteCB(napi_env env, napi_status status, void *data)
2168 {
2169 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
2170 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
2171 napi_value callback = nullptr;
2172 napi_value undefined = nullptr;
2173 napi_value result[ARGS_TWO] = {nullptr};
2174 napi_value callResult = nullptr;
2175 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2176 result[PARAM0] = GetCallbackErrorValue(env, getOrCreateLocalDirCB->cbBase.errCode);
2177 if (getOrCreateLocalDirCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2178 result[PARAM1] = WrapGetOrCreateLocalDir(env, getOrCreateLocalDirCB);
2179 } else {
2180 result[PARAM1] = WrapUndefinedToJS(env);
2181 }
2182 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, getOrCreateLocalDirCB->cbBase.cbInfo.callback, &callback));
2183 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
2184
2185 if (getOrCreateLocalDirCB->cbBase.cbInfo.callback != nullptr) {
2186 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, getOrCreateLocalDirCB->cbBase.cbInfo.callback));
2187 }
2188 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
2189 delete getOrCreateLocalDirCB;
2190 getOrCreateLocalDirCB = nullptr;
2191 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
2192 }
2193
GetOrCreateLocalDirPromiseCompleteCB(napi_env env,napi_status status,void * data)2194 void GetOrCreateLocalDirPromiseCompleteCB(napi_env env, napi_status status, void *data)
2195 {
2196 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
2197 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
2198 napi_value result = nullptr;
2199 if (getOrCreateLocalDirCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2200 result = WrapGetOrCreateLocalDir(env, getOrCreateLocalDirCB);
2201 napi_resolve_deferred(env, getOrCreateLocalDirCB->cbBase.deferred, result);
2202 } else {
2203 result = GetCallbackErrorValue(env, getOrCreateLocalDirCB->cbBase.errCode);
2204 napi_reject_deferred(env, getOrCreateLocalDirCB->cbBase.deferred, result);
2205 }
2206
2207 napi_delete_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork);
2208 delete getOrCreateLocalDirCB;
2209 getOrCreateLocalDirCB = nullptr;
2210 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
2211 }
2212
GetOrCreateLocalDirAsync(napi_env env,napi_value * args,const size_t argCallback,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)2213 napi_value GetOrCreateLocalDirAsync(
2214 napi_env env, napi_value *args, const size_t argCallback, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
2215 {
2216 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2217 if (args == nullptr || getOrCreateLocalDirCB == nullptr) {
2218 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
2219 return nullptr;
2220 }
2221 napi_value resourceName = nullptr;
2222 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2223
2224 napi_valuetype valuetype = napi_undefined;
2225 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
2226 if (valuetype == napi_function) {
2227 NAPI_CALL(
2228 env, napi_create_reference(env, args[argCallback], 1, &getOrCreateLocalDirCB->cbBase.cbInfo.callback));
2229 }
2230 NAPI_CALL(env,
2231 napi_create_async_work(env,
2232 nullptr,
2233 resourceName,
2234 GetOrCreateLocalDirExecuteCB,
2235 GetOrCreateLocalDirAsyncCompleteCB,
2236 static_cast<void *>(getOrCreateLocalDirCB),
2237 &getOrCreateLocalDirCB->cbBase.asyncWork));
2238 NAPI_CALL(env, napi_queue_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
2239 napi_value result = nullptr;
2240 NAPI_CALL(env, napi_get_null(env, &result));
2241 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2242 return result;
2243 }
2244
GetOrCreateLocalDirPromise(napi_env env,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)2245 napi_value GetOrCreateLocalDirPromise(napi_env env, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
2246 {
2247 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
2248 if (getOrCreateLocalDirCB == nullptr) {
2249 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
2250 return nullptr;
2251 }
2252 napi_value resourceName = nullptr;
2253 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2254 napi_deferred deferred;
2255 napi_value promise = nullptr;
2256 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2257 getOrCreateLocalDirCB->cbBase.deferred = deferred;
2258
2259 NAPI_CALL(env,
2260 napi_create_async_work(env,
2261 nullptr,
2262 resourceName,
2263 GetOrCreateLocalDirExecuteCB,
2264 GetOrCreateLocalDirPromiseCompleteCB,
2265 static_cast<void *>(getOrCreateLocalDirCB),
2266 &getOrCreateLocalDirCB->cbBase.asyncWork));
2267 NAPI_CALL(env, napi_queue_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
2268 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2269 return promise;
2270 }
2271
GetOrCreateLocalDirWrap(napi_env env,napi_callback_info info,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)2272 napi_value GetOrCreateLocalDirWrap(napi_env env, napi_callback_info info, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
2273 {
2274 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2275 if (getOrCreateLocalDirCB == nullptr) {
2276 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
2277 return nullptr;
2278 }
2279
2280 size_t argcAsync = 1;
2281 const size_t argcPromise = 0;
2282 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2283 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2284 napi_value ret = nullptr;
2285
2286 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2287 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
2288 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
2289 return nullptr;
2290 }
2291
2292 if (argcAsync > argcPromise) {
2293 ret = GetOrCreateLocalDirAsync(env, args, 0, getOrCreateLocalDirCB);
2294 } else {
2295 ret = GetOrCreateLocalDirPromise(env, getOrCreateLocalDirCB);
2296 }
2297 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2298 return ret;
2299 }
2300
NAPI_GetBundleName(napi_env env,napi_callback_info info)2301 napi_value NAPI_GetBundleName(napi_env env, napi_callback_info info)
2302 {
2303 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2304 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
2305 if (asyncCallbackInfo == nullptr) {
2306 TAG_LOGE(AAFwkTag::JSNAPI, "create callbackInfo failed");
2307 return WrapVoidToJS(env);
2308 }
2309
2310 napi_value ret = NAPI_GetBundleNameWrap(env, info, asyncCallbackInfo);
2311 if (ret == nullptr) {
2312 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2313 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
2314 ret = WrapVoidToJS(env);
2315 }
2316 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2317 return ret;
2318 }
2319
NAPI_GetApplicationInfo(napi_env env,napi_callback_info info)2320 napi_value NAPI_GetApplicationInfo(napi_env env, napi_callback_info info)
2321 {
2322 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2323 AppInfoCB *appInfoCB = CreateAppInfoCBInfo(env);
2324 if (appInfoCB == nullptr) {
2325 return WrapVoidToJS(env);
2326 }
2327
2328 napi_value ret = GetApplicationInfoWrap(env, info, appInfoCB);
2329 if (ret == nullptr) {
2330 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2331 if (appInfoCB != nullptr) {
2332 delete appInfoCB;
2333 appInfoCB = nullptr;
2334 }
2335 ret = WrapVoidToJS(env);
2336 }
2337 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2338 return ret;
2339 }
2340
NAPI_GetProcessInfo(napi_env env,napi_callback_info info)2341 napi_value NAPI_GetProcessInfo(napi_env env, napi_callback_info info)
2342 {
2343 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2344 ProcessInfoCB *processInfoCB = CreateProcessInfoCBInfo(env);
2345 if (processInfoCB == nullptr) {
2346 return WrapVoidToJS(env);
2347 }
2348
2349 processInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2350 napi_value ret = GetProcessInfoWrap(env, info, processInfoCB);
2351 if (ret == nullptr) {
2352 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2353 if (processInfoCB != nullptr) {
2354 delete processInfoCB;
2355 processInfoCB = nullptr;
2356 }
2357 ret = WrapVoidToJS(env);
2358 }
2359 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2360 return ret;
2361 }
2362
NAPI_GetElementName(napi_env env,napi_callback_info info)2363 napi_value NAPI_GetElementName(napi_env env, napi_callback_info info)
2364 {
2365 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2366 ElementNameCB *elementNameCB = CreateElementNameCBInfo(env);
2367 if (elementNameCB == nullptr) {
2368 return WrapVoidToJS(env);
2369 }
2370
2371 elementNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2372 napi_value ret = GetElementNameWrap(env, info, elementNameCB);
2373 if (ret == nullptr) {
2374 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2375 if (elementNameCB != nullptr) {
2376 delete elementNameCB;
2377 elementNameCB = nullptr;
2378 }
2379 ret = WrapVoidToJS(env);
2380 }
2381 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2382 return ret;
2383 }
2384
NAPI_GetProcessName(napi_env env,napi_callback_info info)2385 napi_value NAPI_GetProcessName(napi_env env, napi_callback_info info)
2386 {
2387 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2388 ProcessNameCB *processNameCB = CreateProcessNameCBInfo(env);
2389 if (processNameCB == nullptr) {
2390 return WrapVoidToJS(env);
2391 }
2392
2393 processNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2394 napi_value ret = GetProcessNameWrap(env, info, processNameCB);
2395 if (ret == nullptr) {
2396 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2397 if (processNameCB != nullptr) {
2398 delete processNameCB;
2399 processNameCB = nullptr;
2400 }
2401 ret = WrapVoidToJS(env);
2402 }
2403 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2404 return ret;
2405 }
2406
NAPI_GetCallingBundle(napi_env env,napi_callback_info info)2407 napi_value NAPI_GetCallingBundle(napi_env env, napi_callback_info info)
2408 {
2409 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2410 CallingBundleCB *callingBundleCB = CreateCallingBundleCBInfo(env);
2411 if (callingBundleCB == nullptr) {
2412 return WrapVoidToJS(env);
2413 }
2414
2415 callingBundleCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2416 napi_value ret = GetCallingBundleWrap(env, info, callingBundleCB);
2417 if (ret == nullptr) {
2418 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2419 if (callingBundleCB != nullptr) {
2420 delete callingBundleCB;
2421 callingBundleCB = nullptr;
2422 }
2423 ret = WrapVoidToJS(env);
2424 }
2425 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2426 return ret;
2427 }
2428
NAPI_GetOrCreateLocalDir(napi_env env,napi_callback_info info)2429 napi_value NAPI_GetOrCreateLocalDir(napi_env env, napi_callback_info info)
2430 {
2431 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2432 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = CreateGetOrCreateLocalDirCBInfo(env);
2433 if (getOrCreateLocalDirCB == nullptr) {
2434 return WrapVoidToJS(env);
2435 }
2436
2437 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2438 napi_value ret = GetOrCreateLocalDirWrap(env, info, getOrCreateLocalDirCB);
2439 if (ret == nullptr) {
2440 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2441 if (getOrCreateLocalDirCB != nullptr) {
2442 delete getOrCreateLocalDirCB;
2443 getOrCreateLocalDirCB = nullptr;
2444 }
2445 ret = WrapVoidToJS(env);
2446 }
2447 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2448 return ret;
2449 }
2450
CreateGetDatabaseDirCBInfo(napi_env env)2451 DatabaseDirCB *CreateGetDatabaseDirCBInfo(napi_env env)
2452 {
2453 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2454 napi_value global = nullptr;
2455 NAPI_CALL(env, napi_get_global(env, &global));
2456
2457 napi_value abilityObj = nullptr;
2458 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
2459
2460 Ability *ability = nullptr;
2461 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
2462
2463 DatabaseDirCB *getDatabaseDirCB = new (std::nothrow) DatabaseDirCB;
2464 if (getDatabaseDirCB == nullptr) {
2465 TAG_LOGE(AAFwkTag::JSNAPI, "null getDatabaseDirCB");
2466 return nullptr;
2467 }
2468 getDatabaseDirCB->cbBase.cbInfo.env = env;
2469 getDatabaseDirCB->cbBase.asyncWork = nullptr;
2470 getDatabaseDirCB->cbBase.deferred = nullptr;
2471 getDatabaseDirCB->cbBase.ability = ability;
2472
2473 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2474 return getDatabaseDirCB;
2475 }
2476
GetDatabaseDirWrap(napi_env env,napi_callback_info info,DatabaseDirCB * getDatabaseDirCB)2477 napi_value GetDatabaseDirWrap(napi_env env, napi_callback_info info, DatabaseDirCB *getDatabaseDirCB)
2478 {
2479 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2480 if (getDatabaseDirCB == nullptr) {
2481 TAG_LOGE(AAFwkTag::JSNAPI, "null getDatabaseDirCB");
2482 return nullptr;
2483 }
2484
2485 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2486 if (getDatabaseDirCB->cbBase.ability == nullptr) {
2487 TAG_LOGE(AAFwkTag::JSNAPI, "NAPI_GetDatabaseDir, ability == nullptr");
2488 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
2489 return nullptr;
2490 }
2491
2492 std::string abilityName = getDatabaseDirCB->cbBase.ability->GetAbilityInfo()->name;
2493 std::string dataDir = getDatabaseDirCB->cbBase.ability->GetAbilityInfo()->applicationInfo.dataDir;
2494 std::shared_ptr<HapModuleInfo> hap = getDatabaseDirCB->cbBase.ability->GetHapModuleInfo();
2495 std::string moduleName = (hap != nullptr) ? hap->name : std::string();
2496 std::string dataDirWithModuleName = dataDir + NAPI_CONTEXT_FILE_SEPARATOR + moduleName;
2497 TAG_LOGI(AAFwkTag::JSNAPI, "dataDir:%{public}s moduleName:%{public}s abilityName:%{public}s",
2498 dataDir.c_str(),
2499 moduleName.c_str(),
2500 abilityName.c_str());
2501
2502 // if dataDirWithModuleName is not exits, do nothing and return.
2503 if (!OHOS::FileExists(dataDirWithModuleName)) {
2504 getDatabaseDirCB->dataBaseDir = "";
2505 TAG_LOGI(AAFwkTag::JSNAPI, "dirWithModuleName not exits:%{public}s",
2506 dataDirWithModuleName.c_str());
2507 } else {
2508 getDatabaseDirCB->dataBaseDir = dataDirWithModuleName + NAPI_CONTEXT_FILE_SEPARATOR + abilityName +
2509 NAPI_CONTEXT_FILE_SEPARATOR + NAPI_CONTEXT_DATABASE;
2510 TAG_LOGI(AAFwkTag::JSNAPI, "GetDir dataBaseDir:%{public}s",
2511 getDatabaseDirCB->dataBaseDir.c_str());
2512 if (!OHOS::FileExists(getDatabaseDirCB->dataBaseDir)) {
2513 TAG_LOGE(AAFwkTag::JSNAPI, "dir not exits, create dir");
2514 OHOS::ForceCreateDirectory(getDatabaseDirCB->dataBaseDir);
2515 OHOS::ChangeModeDirectory(getDatabaseDirCB->dataBaseDir, MODE);
2516 }
2517 }
2518 napi_value result = nullptr;
2519 NAPI_CALL(env, napi_create_string_utf8(env, getDatabaseDirCB->dataBaseDir.c_str(), NAPI_AUTO_LENGTH, &result));
2520
2521 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2522 return result;
2523 }
2524
NAPI_GetDatabaseDirSync(napi_env env,napi_callback_info info)2525 napi_value NAPI_GetDatabaseDirSync(napi_env env, napi_callback_info info)
2526 {
2527 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2528 DatabaseDirCB *getDatabaseDirCB = CreateGetDatabaseDirCBInfo(env);
2529 if (getDatabaseDirCB == nullptr) {
2530 return WrapVoidToJS(env);
2531 }
2532
2533 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2534 napi_value ret = GetDatabaseDirWrap(env, info, getDatabaseDirCB);
2535
2536 delete getDatabaseDirCB;
2537 getDatabaseDirCB = nullptr;
2538
2539 if (ret == nullptr) {
2540 ret = WrapVoidToJS(env);
2541 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2542 } else {
2543 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2544 }
2545 return ret;
2546 }
2547
CreateGetPreferencesDirCBInfo(napi_env env)2548 PreferencesDirCB *CreateGetPreferencesDirCBInfo(napi_env env)
2549 {
2550 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2551 napi_value global = nullptr;
2552 NAPI_CALL(env, napi_get_global(env, &global));
2553
2554 napi_value abilityObj = nullptr;
2555 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
2556
2557 Ability *ability = nullptr;
2558 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
2559
2560 PreferencesDirCB *getPreferencesDirCB = new (std::nothrow) PreferencesDirCB;
2561 if (getPreferencesDirCB == nullptr) {
2562 TAG_LOGE(AAFwkTag::JSNAPI, "null getPreferencesDirCB");
2563 return nullptr;
2564 }
2565 getPreferencesDirCB->cbBase.cbInfo.env = env;
2566 getPreferencesDirCB->cbBase.asyncWork = nullptr;
2567 getPreferencesDirCB->cbBase.deferred = nullptr;
2568 getPreferencesDirCB->cbBase.ability = ability;
2569
2570 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2571 return getPreferencesDirCB;
2572 }
2573
GetPreferencesDirWrap(napi_env env,napi_callback_info info,PreferencesDirCB * getPreferencesDirCB)2574 napi_value GetPreferencesDirWrap(napi_env env, napi_callback_info info, PreferencesDirCB *getPreferencesDirCB)
2575 {
2576 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2577 if (getPreferencesDirCB == nullptr) {
2578 TAG_LOGE(AAFwkTag::JSNAPI, "null getPreferencesDirCB");
2579 return nullptr;
2580 }
2581
2582 getPreferencesDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2583 if (getPreferencesDirCB->cbBase.ability == nullptr) {
2584 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
2585 getPreferencesDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
2586 return nullptr;
2587 }
2588
2589 std::string abilityName = getPreferencesDirCB->cbBase.ability->GetAbilityInfo()->name;
2590 std::string dataDir = getPreferencesDirCB->cbBase.ability->GetAbilityInfo()->applicationInfo.dataDir;
2591 std::shared_ptr<HapModuleInfo> hap = getPreferencesDirCB->cbBase.ability->GetHapModuleInfo();
2592 std::string moduleName = (hap != nullptr) ? hap->name : std::string();
2593 std::string dataDirWithModuleName = dataDir + NAPI_CONTEXT_FILE_SEPARATOR + moduleName;
2594 TAG_LOGI(AAFwkTag::JSNAPI, "dataDir:%{public}s moduleName:%{public}s abilityName:%{public}s",
2595 dataDir.c_str(),
2596 moduleName.c_str(),
2597 abilityName.c_str());
2598
2599 // if dataDirWithModuleName is not exits, do nothing and return.
2600 if (!OHOS::FileExists(dataDirWithModuleName)) {
2601 getPreferencesDirCB->preferencesDir = "";
2602 TAG_LOGI(AAFwkTag::JSNAPI, "dirWithModuleName not exist:%{public}s", dataDirWithModuleName.c_str());
2603 } else {
2604 getPreferencesDirCB->preferencesDir = dataDirWithModuleName + NAPI_CONTEXT_FILE_SEPARATOR + abilityName +
2605 NAPI_CONTEXT_FILE_SEPARATOR + NAPI_CONTEXT_PREFERENCES;
2606 TAG_LOGI(AAFwkTag::JSNAPI, "preferencesDir:%{public}s", getPreferencesDirCB->preferencesDir.c_str());
2607 if (!OHOS::FileExists(getPreferencesDirCB->preferencesDir)) {
2608 TAG_LOGI(AAFwkTag::JSNAPI, "dir not exist, create");
2609 OHOS::ForceCreateDirectory(getPreferencesDirCB->preferencesDir);
2610 OHOS::ChangeModeDirectory(getPreferencesDirCB->preferencesDir, MODE);
2611 }
2612 }
2613 napi_value result = nullptr;
2614 NAPI_CALL(
2615 env, napi_create_string_utf8(env, getPreferencesDirCB->preferencesDir.c_str(), NAPI_AUTO_LENGTH, &result));
2616
2617 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2618 return result;
2619 }
2620
NAPI_GetPreferencesDirSync(napi_env env,napi_callback_info info)2621 napi_value NAPI_GetPreferencesDirSync(napi_env env, napi_callback_info info)
2622 {
2623 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2624 PreferencesDirCB *preferencesDirCB = CreateGetPreferencesDirCBInfo(env);
2625 if (preferencesDirCB == nullptr) {
2626 return WrapVoidToJS(env);
2627 }
2628
2629 preferencesDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2630 napi_value ret = GetPreferencesDirWrap(env, info, preferencesDirCB);
2631
2632 delete preferencesDirCB;
2633 preferencesDirCB = nullptr;
2634
2635 if (ret == nullptr) {
2636 ret = WrapVoidToJS(env);
2637 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
2638 } else {
2639 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2640 }
2641 return ret;
2642 }
2643
NAPI_IsUpdatingConfigurations(napi_env env,napi_callback_info info)2644 napi_value NAPI_IsUpdatingConfigurations(napi_env env, napi_callback_info info)
2645 {
2646 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2647 return NAPI_IsUpdatingConfigurationsCommon(env, info, AbilityType::PAGE);
2648 }
2649
NAPI_GetExternalCacheDir(napi_env env,napi_callback_info info)2650 napi_value NAPI_GetExternalCacheDir(napi_env env, napi_callback_info info)
2651 {
2652 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2653 return NAPI_GetExternalCacheDirCommon(env, info, AbilityType::PAGE);
2654 }
2655
NAPI_PrintDrawnCompleted(napi_env env,napi_callback_info info)2656 napi_value NAPI_PrintDrawnCompleted(napi_env env, napi_callback_info info)
2657 {
2658 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2659 return NAPI_PrintDrawnCompletedCommon(env, info, AbilityType::PAGE);
2660 }
2661
NAPI_SetDisplayOrientation(napi_env env,napi_callback_info info)2662 napi_value NAPI_SetDisplayOrientation(napi_env env, napi_callback_info info)
2663 {
2664 #ifdef SUPPORT_GRAPHICS
2665 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2666
2667 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
2668 if (asyncCallbackInfo == nullptr) {
2669 TAG_LOGW(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
2670 return WrapVoidToJS(env);
2671 }
2672
2673 napi_value rev = NAPI_SetDisplayOrientationWrap(env, info, asyncCallbackInfo);
2674 if (rev == nullptr) {
2675 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
2676 rev = WrapVoidToJS(env);
2677 }
2678 return rev;
2679 #else
2680 return WrapVoidToJS(env);
2681 #endif
2682 }
2683
NAPI_GetDisplayOrientation(napi_env env,napi_callback_info info)2684 napi_value NAPI_GetDisplayOrientation(napi_env env, napi_callback_info info)
2685 {
2686 #ifdef SUPPORT_GRAPHICS
2687 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2688 return NAPI_GetDisplayOrientationCommon(env, info, AbilityType::PAGE);
2689 #else
2690 return 0;
2691 #endif
2692 }
2693
ContextPermissionInit(napi_env env,napi_value exports)2694 napi_value ContextPermissionInit(napi_env env, napi_value exports)
2695 {
2696 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2697
2698 napi_property_descriptor properties[] = {
2699 DECLARE_NAPI_FUNCTION("verifySelfPermission", NAPI_VerifySelfPermission),
2700 DECLARE_NAPI_FUNCTION("requestPermissionsFromUser", NAPI_RequestPermissionsFromUser),
2701 DECLARE_NAPI_FUNCTION("getBundleName", NAPI_GetBundleName),
2702 DECLARE_NAPI_FUNCTION("verifyPermission", NAPI_VerifyPermission),
2703 DECLARE_NAPI_FUNCTION("getApplicationInfo", NAPI_GetApplicationInfo),
2704 DECLARE_NAPI_FUNCTION("getProcessInfo", NAPI_GetProcessInfo),
2705 DECLARE_NAPI_FUNCTION("getElementName", NAPI_GetElementName),
2706 DECLARE_NAPI_FUNCTION("getProcessName", NAPI_GetProcessName),
2707 DECLARE_NAPI_FUNCTION("getCallingBundle", NAPI_GetCallingBundle),
2708 DECLARE_NAPI_FUNCTION("getOrCreateLocalDir", NAPI_GetOrCreateLocalDir),
2709 DECLARE_NAPI_FUNCTION("getFilesDir", NAPI_GetFilesDir),
2710 DECLARE_NAPI_FUNCTION("isUpdatingConfigurations", NAPI_IsUpdatingConfigurations),
2711 DECLARE_NAPI_FUNCTION("printDrawnCompleted", NAPI_PrintDrawnCompleted),
2712 DECLARE_NAPI_FUNCTION("getDatabaseDirSync", NAPI_GetDatabaseDirSync),
2713 DECLARE_NAPI_FUNCTION("getPreferencesDirSync", NAPI_GetPreferencesDirSync),
2714 DECLARE_NAPI_FUNCTION("getCacheDir", NAPI_GetCacheDir),
2715 DECLARE_NAPI_FUNCTION("getAppType", NAPI_GetCtxAppType),
2716 DECLARE_NAPI_FUNCTION("getHapModuleInfo", NAPI_GetCtxHapModuleInfo),
2717 DECLARE_NAPI_FUNCTION("getAppVersionInfo", NAPI_GetAppVersionInfo),
2718 DECLARE_NAPI_FUNCTION("getApplicationContext", NAPI_GetApplicationContext),
2719 DECLARE_NAPI_FUNCTION("getAbilityInfo", NAPI_GetCtxAbilityInfo),
2720 DECLARE_NAPI_FUNCTION("setShowOnLockScreen", NAPI_SetShowOnLockScreen),
2721 DECLARE_NAPI_FUNCTION("getOrCreateDistributedDir", NAPI_GetOrCreateDistributedDir),
2722 DECLARE_NAPI_FUNCTION("setWakeUpScreen", NAPI_SetWakeUpScreen),
2723 DECLARE_NAPI_FUNCTION("setDisplayOrientation", NAPI_SetDisplayOrientation),
2724 DECLARE_NAPI_FUNCTION("getDisplayOrientation", NAPI_GetDisplayOrientation),
2725 DECLARE_NAPI_FUNCTION("getExternalCacheDir", NAPI_GetExternalCacheDir),
2726 };
2727 napi_value constructor;
2728 NAPI_CALL(env,
2729 napi_define_class(env,
2730 "context",
2731 NAPI_AUTO_LENGTH,
2732 ContextConstructor,
2733 nullptr,
2734 sizeof(properties) / sizeof(*properties),
2735 properties,
2736 &constructor));
2737 NAPI_CALL(env, SetGlobalClassContext(env, constructor));
2738 return exports;
2739 }
2740
NAPI_SetWakeUpScreen(napi_env env,napi_callback_info info)2741 napi_value NAPI_SetWakeUpScreen(napi_env env, napi_callback_info info)
2742 {
2743 #ifdef SUPPORT_GRAPHICS
2744 TAG_LOGI(AAFwkTag::JSNAPI, "called");
2745 SetWakeUpScreenCB *setWakeUpScreenCB = new (std::nothrow) SetWakeUpScreenCB;
2746 if (setWakeUpScreenCB == nullptr) {
2747 TAG_LOGE(AAFwkTag::JSNAPI, "null setWakeUpScreenCB");
2748 return WrapVoidToJS(env);
2749 }
2750 setWakeUpScreenCB->cbBase.cbInfo.env = env;
2751 setWakeUpScreenCB->cbBase.abilityType = AbilityType::PAGE;
2752 napi_value ret = SetWakeUpScreenWrap(env, info, setWakeUpScreenCB);
2753 if (ret == nullptr) {
2754 if (setWakeUpScreenCB != nullptr) {
2755 delete setWakeUpScreenCB;
2756 setWakeUpScreenCB = nullptr;
2757 }
2758 TAG_LOGE(AAFwkTag::JSNAPI, "setWakeUpScreenCB run failed, delete resource");
2759 ret = WrapVoidToJS(env);
2760 }
2761 TAG_LOGI(AAFwkTag::JSNAPI, "end");
2762 return ret;
2763 #else
2764 return nullptr;
2765 #endif
2766 }
2767
2768 class NapiJsContext : public JsNapiCommon {
2769 public:
2770 NapiJsContext() = default;
2771 virtual ~NapiJsContext() = default;
2772
Finalizer(napi_env env,void * data,void * hint)2773 static void Finalizer(napi_env env, void *data, void *hint)
2774 {
2775 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2776 std::unique_ptr<NapiJsContext>(static_cast<NapiJsContext*>(data));
2777 };
2778
2779 static napi_value JsRequestPermissionsFromUser(napi_env env, napi_callback_info info);
2780 static napi_value JsGetBundleName(napi_env env, napi_callback_info info);
2781 static napi_value JsVerifyPermission(napi_env env, napi_callback_info info);
2782 static napi_value JsGetApplicationInfo(napi_env env, napi_callback_info info);
2783 static napi_value JsGetProcessInfo(napi_env env, napi_callback_info info);
2784 static napi_value JsGetElementName(napi_env env, napi_callback_info info);
2785 static napi_value JsGetProcessName(napi_env env, napi_callback_info info);
2786 static napi_value JsGetCallingBundle(napi_env env, napi_callback_info info);
2787 static napi_value JsGetOrCreateLocalDir(napi_env env, napi_callback_info info);
2788 static napi_value JsGetFilesDir(napi_env env, napi_callback_info info);
2789 static napi_value JsIsUpdatingConfigurations(napi_env env, napi_callback_info info);
2790 static napi_value JsPrintDrawnCompleted(napi_env env, napi_callback_info info);
2791 static napi_value JsGetCacheDir(napi_env env, napi_callback_info info);
2792 static napi_value JsGetCtxAppType(napi_env env, napi_callback_info info);
2793 static napi_value JsGetCtxHapModuleInfo(napi_env env, napi_callback_info info);
2794 static napi_value JsGetAppVersionInfo(napi_env env, napi_callback_info info);
2795 static napi_value JsGetApplicationContext(napi_env env, napi_callback_info info);
2796 static napi_value JsGetCtxAbilityInfo(napi_env env, napi_callback_info info);
2797 static napi_value JsSetShowOnLockScreen(napi_env env, napi_callback_info info);
2798 static napi_value JsGetOrCreateDistributedDir(napi_env env, napi_callback_info info);
2799 static napi_value JsSetWakeUpScreen(napi_env env, napi_callback_info info);
2800 static napi_value JsSetDisplayOrientation(napi_env env, napi_callback_info info);
2801 static napi_value JsGetDisplayOrientation(napi_env env, napi_callback_info info);
2802 static napi_value JsGetExternalCacheDir(napi_env env, napi_callback_info info);
2803
2804 bool DataInit(napi_env env);
2805
2806 private:
2807 #ifdef SUPPORT_GRAPHICS
2808 napi_value OnSetShowOnLockScreen(napi_env env, napi_callback_info info);
2809 napi_value OnSetWakeUpScreen(napi_env env, napi_callback_info info);
2810 napi_value OnSetDisplayOrientation(napi_env env, napi_callback_info info);
2811 #endif
2812
2813 napi_value OnRequestPermissionsFromUser(napi_env env, napi_callback_info info);
2814 napi_value OnGetBundleName(napi_env env, napi_callback_info info);
2815 napi_value OnVerifyPermission(napi_env env, napi_callback_info info);
2816 napi_value OnGetApplicationInfo(napi_env env, napi_callback_info info);
2817 napi_value OnGetProcessInfo(napi_env env, napi_callback_info info);
2818 napi_value OnGetElementName(napi_env env, napi_callback_info info);
2819 napi_value OnGetProcessName(napi_env env, napi_callback_info info);
2820 napi_value OnGetCallingBundle(napi_env env, napi_callback_info info);
2821 napi_value OnGetOrCreateLocalDir(napi_env env, napi_callback_info info);
2822 };
2823
BindNapiJSContextFunction(napi_env env,napi_value object)2824 static bool BindNapiJSContextFunction(napi_env env, napi_value object)
2825 {
2826 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2827 if (object == nullptr) {
2828 TAG_LOGE(AAFwkTag::JSNAPI, "input params error");
2829 return false;
2830 }
2831 const char* moduleName = "context";
2832 BindNativeFunction(
2833 env, object, "requestPermissionsFromUser", moduleName, NapiJsContext::JsRequestPermissionsFromUser);
2834 BindNativeFunction(env, object, "getBundleName", moduleName, NapiJsContext::JsGetBundleName);
2835 BindNativeFunction(env, object, "verifyPermission", moduleName, NapiJsContext::JsVerifyPermission);
2836 BindNativeFunction(env, object, "getApplicationInfo", moduleName, NapiJsContext::JsGetApplicationInfo);
2837 BindNativeFunction(env, object, "getProcessInfo", moduleName, NapiJsContext::JsGetProcessInfo);
2838 BindNativeFunction(env, object, "getElementName", moduleName, NapiJsContext::JsGetElementName);
2839 BindNativeFunction(env, object, "getProcessName", moduleName, NapiJsContext::JsGetProcessName);
2840 BindNativeFunction(env, object, "getCallingBundle", moduleName, NapiJsContext::JsGetCallingBundle);
2841 BindNativeFunction(env, object, "getOrCreateLocalDir", moduleName, NapiJsContext::JsGetOrCreateLocalDir);
2842 BindNativeFunction(env, object, "getFilesDir", moduleName, NapiJsContext::JsGetFilesDir);
2843 BindNativeFunction(env, object, "isUpdatingConfigurations", moduleName, NapiJsContext::JsIsUpdatingConfigurations);
2844 BindNativeFunction(env, object, "printDrawnCompleted", moduleName, NapiJsContext::JsPrintDrawnCompleted);
2845 BindNativeFunction(env, object, "getCacheDir", moduleName, NapiJsContext::JsGetCacheDir);
2846 BindNativeFunction(env, object, "getAppType", moduleName, NapiJsContext::JsGetCtxAppType);
2847 BindNativeFunction(env, object, "getHapModuleInfo", moduleName, NapiJsContext::JsGetCtxHapModuleInfo);
2848 BindNativeFunction(env, object, "getAppVersionInfo", moduleName, NapiJsContext::JsGetAppVersionInfo);
2849 BindNativeFunction(env, object, "getApplicationContext", moduleName, NapiJsContext::JsGetApplicationContext);
2850 BindNativeFunction(env, object, "getAbilityInfo", moduleName, NapiJsContext::JsGetCtxAbilityInfo);
2851 BindNativeFunction(env, object, "setShowOnLockScreen", moduleName, NapiJsContext::JsSetShowOnLockScreen);
2852 BindNativeFunction(env, object, "getOrCreateDistributedDir", moduleName,
2853 NapiJsContext::JsGetOrCreateDistributedDir);
2854 BindNativeFunction(env, object, "setWakeUpScreen", moduleName, NapiJsContext::JsSetWakeUpScreen);
2855 BindNativeFunction(env, object, "setDisplayOrientation", moduleName, NapiJsContext::JsSetDisplayOrientation);
2856 BindNativeFunction(env, object, "getDisplayOrientation", moduleName, NapiJsContext::JsGetDisplayOrientation);
2857 BindNativeFunction(env, object, "getExternalCacheDir", moduleName, NapiJsContext::JsGetExternalCacheDir);
2858
2859 return true;
2860 }
2861
ConstructNapiJSContext(napi_env env)2862 static napi_value ConstructNapiJSContext(napi_env env)
2863 {
2864 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2865 napi_value objContext = nullptr;
2866 napi_create_object(env, &objContext);
2867 if (objContext == nullptr) {
2868 TAG_LOGE(AAFwkTag::JSNAPI, "CreateObject failed");
2869 return nullptr;
2870 }
2871 auto jsClass = std::make_unique<NapiJsContext>();
2872 if (!jsClass->DataInit(env)) {
2873 TAG_LOGE(AAFwkTag::JSNAPI, "NapiJsContext init failed");
2874 return nullptr;
2875 }
2876 napi_wrap(env, objContext, jsClass.release(), NapiJsContext::Finalizer, nullptr, nullptr);
2877 napi_set_named_property(env, objContext, "stageMode", CreateJsValue(env, false));
2878 if (!BindNapiJSContextFunction(env, objContext)) {
2879 TAG_LOGE(AAFwkTag::JSNAPI, "bind func failed");
2880 return nullptr;
2881 }
2882
2883 return objContext;
2884 }
2885
CreateNapiJSContext(napi_env env)2886 napi_value CreateNapiJSContext(napi_env env)
2887 {
2888 TAG_LOGD(AAFwkTag::JSNAPI, "called");
2889 auto jsObj = ConstructNapiJSContext(env);
2890 if (jsObj == nullptr) {
2891 TAG_LOGE(AAFwkTag::JSNAPI, "Construct Context failed");
2892 return CreateJsUndefined(env);
2893 }
2894
2895 return jsObj;
2896 }
2897
JsRequestPermissionsFromUser(napi_env env,napi_callback_info info)2898 napi_value NapiJsContext::JsRequestPermissionsFromUser(napi_env env, napi_callback_info info)
2899 {
2900 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2901 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2902
2903 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2904 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2905
2906 return object->OnRequestPermissionsFromUser(env, info);
2907 }
2908
JsGetBundleName(napi_env env,napi_callback_info info)2909 napi_value NapiJsContext::JsGetBundleName(napi_env env, napi_callback_info info)
2910 {
2911 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
2912 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2913
2914 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2915 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2916
2917 return object->OnGetBundleName(env, info);
2918 }
2919
JsVerifyPermission(napi_env env,napi_callback_info info)2920 napi_value NapiJsContext::JsVerifyPermission(napi_env env, napi_callback_info info)
2921 {
2922 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
2923 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2924
2925 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2926 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2927
2928 return object->OnVerifyPermission(env, info);
2929 }
2930
JsGetApplicationInfo(napi_env env,napi_callback_info info)2931 napi_value NapiJsContext::JsGetApplicationInfo(napi_env env, napi_callback_info info)
2932 {
2933 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
2934 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2935
2936 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2937 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2938
2939 return object->OnGetApplicationInfo(env, info);
2940 }
2941
JsGetProcessInfo(napi_env env,napi_callback_info info)2942 napi_value NapiJsContext::JsGetProcessInfo(napi_env env, napi_callback_info info)
2943 {
2944 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2945 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2946
2947 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2948 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2949
2950 return object->OnGetProcessInfo(env, info);
2951 }
2952
JsGetElementName(napi_env env,napi_callback_info info)2953 napi_value NapiJsContext::JsGetElementName(napi_env env, napi_callback_info info)
2954 {
2955 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2956 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2957
2958 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2959 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2960
2961 return object->OnGetElementName(env, info);
2962 }
2963
JsGetProcessName(napi_env env,napi_callback_info info)2964 napi_value NapiJsContext::JsGetProcessName(napi_env env, napi_callback_info info)
2965 {
2966 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2967 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2968
2969 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2970 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2971
2972 return object->OnGetProcessName(env, info);
2973 }
2974
JsGetCallingBundle(napi_env env,napi_callback_info info)2975 napi_value NapiJsContext::JsGetCallingBundle(napi_env env, napi_callback_info info)
2976 {
2977 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2978 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2979
2980 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2981 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2982
2983 return object->OnGetCallingBundle(env, info);
2984 }
2985
JsGetOrCreateLocalDir(napi_env env,napi_callback_info info)2986 napi_value NapiJsContext::JsGetOrCreateLocalDir(napi_env env, napi_callback_info info)
2987 {
2988 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
2989 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
2990
2991 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
2992 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
2993
2994 return object->OnGetOrCreateLocalDir(env, info);
2995 }
2996
JsGetFilesDir(napi_env env,napi_callback_info info)2997 napi_value NapiJsContext::JsGetFilesDir(napi_env env, napi_callback_info info)
2998 {
2999 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3000 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3001
3002 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3003 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3004
3005 return object->JsNapiCommon::JsGetFilesDir(env, info, AbilityType::PAGE);
3006 }
3007
JsIsUpdatingConfigurations(napi_env env,napi_callback_info info)3008 napi_value NapiJsContext::JsIsUpdatingConfigurations(napi_env env, napi_callback_info info)
3009 {
3010 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3011 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3012
3013 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3014 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3015
3016 return object->JsNapiCommon::JsIsUpdatingConfigurations(env, info, AbilityType::PAGE);
3017 }
3018
JsPrintDrawnCompleted(napi_env env,napi_callback_info info)3019 napi_value NapiJsContext::JsPrintDrawnCompleted(napi_env env, napi_callback_info info)
3020 {
3021 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3022 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3023
3024 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3025 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3026
3027 return object->JsNapiCommon::JsPrintDrawnCompleted(env, info, AbilityType::PAGE);
3028 }
3029
JsGetCacheDir(napi_env env,napi_callback_info info)3030 napi_value NapiJsContext::JsGetCacheDir(napi_env env, napi_callback_info info)
3031 {
3032 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3033 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3034
3035 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3036 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3037
3038 return object->JsNapiCommon::JsGetCacheDir(env, info, AbilityType::PAGE);
3039 }
3040
JsGetCtxAppType(napi_env env,napi_callback_info info)3041 napi_value NapiJsContext::JsGetCtxAppType(napi_env env, napi_callback_info info)
3042 {
3043 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3044 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3045
3046 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3047 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3048
3049 return object->JsNapiCommon::JsGetCtxAppType(env, info, AbilityType::PAGE);
3050 }
3051
JsGetCtxHapModuleInfo(napi_env env,napi_callback_info info)3052 napi_value NapiJsContext::JsGetCtxHapModuleInfo(napi_env env, napi_callback_info info)
3053 {
3054 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3055 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3056
3057 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3058 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3059
3060 return object->JsNapiCommon::JsGetCtxHapModuleInfo(env, info, AbilityType::PAGE);
3061 }
3062
JsGetAppVersionInfo(napi_env env,napi_callback_info info)3063 napi_value NapiJsContext::JsGetAppVersionInfo(napi_env env, napi_callback_info info)
3064 {
3065 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3066 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3067
3068 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3069 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3070
3071 return object->JsNapiCommon::JsGetAppVersionInfo(env, info, AbilityType::PAGE);
3072 }
3073
JsGetApplicationContext(napi_env env,napi_callback_info info)3074 napi_value NapiJsContext::JsGetApplicationContext(napi_env env, napi_callback_info info)
3075 {
3076 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3077 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3078
3079 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3080 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3081
3082 return object->JsNapiCommon::JsGetContext(env, info, AbilityType::PAGE);
3083 }
3084
JsGetCtxAbilityInfo(napi_env env,napi_callback_info info)3085 napi_value NapiJsContext::JsGetCtxAbilityInfo(napi_env env, napi_callback_info info)
3086 {
3087 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3088 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3089
3090 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3091 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3092
3093 return object->JsNapiCommon::JsGetCtxAbilityInfo(env, info, AbilityType::PAGE);
3094 }
3095
JsSetShowOnLockScreen(napi_env env,napi_callback_info info)3096 napi_value NapiJsContext::JsSetShowOnLockScreen(napi_env env, napi_callback_info info)
3097 {
3098 #ifdef SUPPORT_GRAPHICS
3099 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3100 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3101
3102 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3103 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3104
3105 return object->OnSetShowOnLockScreen(env, info);
3106 #else
3107 return nullptr;
3108 #endif
3109 }
3110
JsGetOrCreateDistributedDir(napi_env env,napi_callback_info info)3111 napi_value NapiJsContext::JsGetOrCreateDistributedDir(napi_env env, napi_callback_info info)
3112 {
3113 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3114 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3115
3116 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3117 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3118
3119 return object->JsNapiCommon::JsGetOrCreateDistributedDir(env, info, AbilityType::PAGE);
3120 }
3121
JsSetWakeUpScreen(napi_env env,napi_callback_info info)3122 napi_value NapiJsContext::JsSetWakeUpScreen(napi_env env, napi_callback_info info)
3123 {
3124 #ifdef SUPPORT_GRAPHICS
3125 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3126 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3127
3128 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3129 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3130
3131 return object->OnSetWakeUpScreen(env, info);
3132 #else
3133 return nullptr;
3134 #endif
3135 }
3136
JsSetDisplayOrientation(napi_env env,napi_callback_info info)3137 napi_value NapiJsContext::JsSetDisplayOrientation(napi_env env, napi_callback_info info)
3138 {
3139 #ifdef SUPPORT_GRAPHICS
3140 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3141 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3142
3143 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3144 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3145
3146 return object->OnSetDisplayOrientation(env, info);
3147 #else
3148 return nullptr;
3149 #endif
3150 }
3151
JsGetDisplayOrientation(napi_env env,napi_callback_info info)3152 napi_value NapiJsContext::JsGetDisplayOrientation(napi_env env, napi_callback_info info)
3153 {
3154 #ifdef SUPPORT_GRAPHICS
3155 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3156 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3157
3158 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3159 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3160
3161 return object->JsNapiCommon::JsGetDisplayOrientation(env, info, AbilityType::PAGE);
3162 #else
3163 return nullptr;
3164 #endif
3165 }
3166
JsGetExternalCacheDir(napi_env env,napi_callback_info info)3167 napi_value NapiJsContext::JsGetExternalCacheDir(napi_env env, napi_callback_info info)
3168 {
3169 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
3170 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
3171
3172 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
3173 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
3174
3175 return object->JsNapiCommon::JsGetExternalCacheDir(env, info, AbilityType::PAGE);
3176 }
3177
DataInit(napi_env env)3178 bool NapiJsContext::DataInit(napi_env env)
3179 {
3180 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3181 napi_value global = nullptr;
3182 napi_value abilityObj = nullptr;
3183 TAG_LOGI(AAFwkTag::JSNAPI, "Get Ability to start");
3184 NAPI_CALL_BASE(env, napi_get_global(env, &global), false);
3185 NAPI_CALL_BASE(env, napi_get_named_property(env, global, "ability", &abilityObj), false);
3186 napi_status status = napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability_));
3187 if (status != napi_ok) {
3188 TAG_LOGW(AAFwkTag::JSNAPI, "Failed to get external ability info");
3189 }
3190 TAG_LOGD(AAFwkTag::JSNAPI, "end");
3191
3192 return true;
3193 }
3194
OnRequestPermissionsFromUser(napi_env env,napi_callback_info info)3195 napi_value NapiJsContext::OnRequestPermissionsFromUser(napi_env env, napi_callback_info info)
3196 {
3197 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3198 size_t argc = ARGS_MAX_COUNT;
3199 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3200 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3201 if (argc == ARGS_ZERO || argc > ARGS_THREE) {
3202 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3203 return CreateJsUndefined(env);
3204 }
3205 CallAbilityPermissionParam permissionParam;
3206 if (!GetStringsValue(env, argv[PARAM0], permissionParam.permission_list)) {
3207 TAG_LOGE(AAFwkTag::JSNAPI, "input params string error");
3208 return CreateJsUndefined(env);
3209 }
3210
3211 if (!ConvertFromJsValue(env, argv[PARAM1], permissionParam.requestCode)) {
3212 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
3213 return CreateJsUndefined(env);
3214 }
3215
3216 auto callback = argc == ARGS_THREE ? argv[PARAM2] : nullptr;
3217 napi_value result = nullptr;
3218 auto napiAsyncTask =
3219 AbilityRuntime::CreateAsyncTaskWithLastParam(env, callback, nullptr, nullptr, &result).release();
3220
3221 int32_t errorCode = NAPI_ERR_NO_ERROR;
3222 if (ability_ == nullptr) {
3223 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3224 errorCode = NAPI_ERR_ACE_ABILITY;
3225 }
3226
3227 if (permissionParam.permission_list.size() == 0) {
3228 TAG_LOGE(AAFwkTag::JSNAPI, "permission_list size is 0");
3229 errorCode = NAPI_ERR_PARAM_INVALID;
3230 }
3231
3232 if (errorCode != NAPI_ERR_NO_ERROR) {
3233 napi_value errorValue = CreateJsError(env, errorCode, ConvertErrorCode(errorCode));
3234 napiAsyncTask->Reject(env, errorValue);
3235 delete napiAsyncTask;
3236 napiAsyncTask = nullptr;
3237 } else {
3238 CallbackInfo callbackInfo;
3239 callbackInfo.env = env;
3240 callbackInfo.napiAsyncTask = napiAsyncTask;
3241 AbilityProcess::GetInstance()->RequestPermissionsFromUser(ability_, permissionParam, callbackInfo);
3242 }
3243
3244 return result;
3245 }
3246
OnGetBundleName(napi_env env,napi_callback_info info)3247 napi_value NapiJsContext::OnGetBundleName(napi_env env, napi_callback_info info)
3248 {
3249 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3250 size_t argc = ARGS_MAX_COUNT;
3251 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3252 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3253 if (argc > ARGS_ONE) {
3254 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3255 return CreateJsNull(env);
3256 }
3257
3258 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3259 std::shared_ptr<JsBundleName> bundleName = std::make_shared<JsBundleName>();
3260 auto execute = [obj = this, name = bundleName, value = errorVal] () {
3261 if (obj->ability_ == nullptr) {
3262 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3263 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3264 return;
3265 }
3266 if (name == nullptr) {
3267 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3268 TAG_LOGE(AAFwkTag::JSNAPI, "task execute wrong, name is nullptr");
3269 return;
3270 }
3271 name->name = obj->ability_->GetBundleName();
3272 };
3273 auto complete = [obj = this, name = bundleName, value = errorVal]
3274 (napi_env env, NapiAsyncTask &task, int32_t status) {
3275 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
3276 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3277 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3278 TAG_LOGD(AAFwkTag::JSNAPI, "task execute error, name is nullptr or NAPI_ERR_ABILITY_CALL_INVALID");
3279 return;
3280 }
3281 task.Resolve(env, CreateJsValue(env, name->name));
3282 };
3283
3284 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3285 napi_value result = nullptr;
3286 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetBundleName",
3287 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3288
3289 return result;
3290 }
3291
OnVerifyPermission(napi_env env,napi_callback_info info)3292 napi_value NapiJsContext::OnVerifyPermission(napi_env env, napi_callback_info info)
3293 {
3294 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3295 size_t argc = ARGS_MAX_COUNT;
3296 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3297 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3298 if (argc == ARGS_ZERO || argc > ARGS_THREE) {
3299 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3300 return CreateJsNull(env);
3301 }
3302
3303 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3304 std::string permission("");
3305 if (!ConvertFromJsValue(env, argv[PARAM0], permission)) {
3306 TAG_LOGE(AAFwkTag::JSNAPI, "input params string error");
3307 return CreateJsNull(env);
3308 }
3309 JsPermissionOptions options;
3310 bool flagCall = UnwarpVerifyPermissionParams(env, info, options);
3311 auto execute = [obj = this, permission, options, value = errorVal] () {
3312 if (obj->ability_ == nullptr) {
3313 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3314 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3315 return;
3316 }
3317 if (options.uidFlag) {
3318 *value = obj->ability_->VerifyPermission(permission, options.pid, options.uid);
3319 } else {
3320 *value = obj->ability_->VerifySelfPermission(permission);
3321 }
3322 };
3323 auto complete = [obj = this, value = errorVal] (napi_env env, NapiAsyncTask &task, int32_t status) {
3324 if (*value == static_cast<int32_t>(NAPI_ERR_ACE_ABILITY)) {
3325 task.Reject(env, CreateJsError(env, *value, obj->ConvertErrorCode(*value)));
3326 return;
3327 }
3328 task.Resolve(env, CreateJsValue(env, *value));
3329 };
3330
3331 auto callback = flagCall ? ((argc == ARGS_TWO) ? argv[PARAM1] : argv[PARAM2]) : nullptr;
3332 napi_value result = nullptr;
3333 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetBundleName",
3334 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3335
3336 return result;
3337 }
3338
OnGetApplicationInfo(napi_env env,napi_callback_info info)3339 napi_value NapiJsContext::OnGetApplicationInfo(napi_env env, napi_callback_info info)
3340 {
3341 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3342 size_t argc = ARGS_MAX_COUNT;
3343 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3344 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3345 if (argc > ARGS_ONE) {
3346 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3347 return CreateJsUndefined(env);
3348 }
3349
3350 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3351 std::shared_ptr<JsApplicationInfo> infoData = std::make_shared<JsApplicationInfo>();
3352 auto execute = [obj = this, info = infoData, value = errorVal] () {
3353 if (obj->ability_ == nullptr) {
3354 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3355 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3356 return;
3357 }
3358 auto getInfo = obj->ability_->GetApplicationInfo();
3359 if (getInfo != nullptr && info != nullptr) {
3360 info->appInfo = *getInfo;
3361 } else {
3362 TAG_LOGE(AAFwkTag::JSNAPI, "GetApplicationInfo return nullptr");
3363 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3364 }
3365 };
3366 auto complete = [obj = this, info = infoData, value = errorVal]
3367 (napi_env env, NapiAsyncTask &task, int32_t status) {
3368 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
3369 TAG_LOGD(AAFwkTag::JSNAPI, "errorVal is 0 or JsHapModuleInfo is null");
3370 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3371 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3372 return;
3373 }
3374 task.Resolve(env, obj->CreateAppInfo(env, info->appInfo));
3375 };
3376
3377 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3378 napi_value result = nullptr;
3379 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetApplicationInfo",
3380 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3381
3382 return result;
3383 }
3384
OnGetProcessInfo(napi_env env,napi_callback_info info)3385 napi_value NapiJsContext::OnGetProcessInfo(napi_env env, napi_callback_info info)
3386 {
3387 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3388 size_t argc = ARGS_MAX_COUNT;
3389 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3390 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3391 if (argc > ARGS_ONE) {
3392 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3393 return CreateJsUndefined(env);
3394 }
3395
3396 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3397 std::shared_ptr<JsProcessInfo> processInfo = std::make_shared<JsProcessInfo>();
3398 auto execute = [obj = this, data = processInfo, value = errorVal] () {
3399 if (obj->ability_ == nullptr) {
3400 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3401 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3402 return;
3403 }
3404 auto getInfo = obj->ability_->GetProcessInfo();
3405 if (getInfo != nullptr && data != nullptr) {
3406 data->processName = getInfo->GetProcessName();
3407 data->pid = getInfo->GetPid();
3408 } else {
3409 TAG_LOGE(AAFwkTag::JSNAPI, "GetProcessInfo return nullptr");
3410 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3411 }
3412 };
3413 auto complete = [obj = this, info = processInfo, value = errorVal]
3414 (napi_env env, NapiAsyncTask &task, int32_t status) {
3415 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
3416 auto ecode = info == nullptr ? (NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3417 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3418 return;
3419 }
3420 task.Resolve(env, obj->CreateProcessInfo(env, info));
3421 };
3422
3423 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3424 napi_value result = nullptr;
3425 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetProcessInfo",
3426 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3427
3428 return result;
3429 }
3430
OnGetElementName(napi_env env,napi_callback_info info)3431 napi_value NapiJsContext::OnGetElementName(napi_env env, napi_callback_info info)
3432 {
3433 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3434 size_t argc = ARGS_MAX_COUNT;
3435 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3436 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3437 if (argc > ARGS_ONE) {
3438 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3439 return CreateJsUndefined(env);
3440 }
3441
3442 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3443 std::shared_ptr<JsElementName> elementName = std::make_shared<JsElementName>();
3444 auto execute = [obj = this, data = elementName, value = errorVal] () {
3445 if (obj->ability_ == nullptr) {
3446 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3447 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3448 return;
3449 }
3450 auto elementName = obj->ability_->GetElementName();
3451 if (elementName != nullptr && data != nullptr) {
3452 data->deviceId = elementName->GetDeviceID();
3453 data->bundleName = elementName->GetBundleName();
3454 data->abilityName = elementName->GetAbilityName();
3455 data->uri = obj->ability_->GetWant()->GetUriString();
3456 data->shortName = "";
3457 } else {
3458 TAG_LOGE(AAFwkTag::JSNAPI, "GetElementName return nullptr");
3459 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3460 }
3461 };
3462 auto complete = [obj = this, ename = elementName, value = errorVal]
3463 (napi_env env, NapiAsyncTask &task, int32_t status) {
3464 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || ename == nullptr) {
3465 auto ecode = ename == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3466 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3467 return;
3468 }
3469 task.Resolve(env, obj->CreateElementName(env, ename));
3470 };
3471
3472 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3473 napi_value result = nullptr;
3474 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetElementName",
3475 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3476
3477 return result;
3478 }
3479
OnGetProcessName(napi_env env,napi_callback_info info)3480 napi_value NapiJsContext::OnGetProcessName(napi_env env, napi_callback_info info)
3481 {
3482 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3483 size_t argc = ARGS_MAX_COUNT;
3484 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3485 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3486 if (argc > ARGS_ONE) {
3487 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3488 return CreateJsUndefined(env);
3489 }
3490
3491 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3492 std::shared_ptr<JsProcessName> processName = std::make_shared<JsProcessName>();
3493 auto execute = [obj = this, name = processName, value = errorVal] () {
3494 if (obj->ability_ == nullptr) {
3495 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3496 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3497 return;
3498 }
3499 if (name == nullptr) {
3500 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3501 TAG_LOGE(AAFwkTag::JSNAPI, "task execute error, name is null");
3502 return;
3503 }
3504 name->name = obj->ability_->GetProcessName();
3505 };
3506 auto complete = [obj = this, name = processName, value = errorVal]
3507 (napi_env env, NapiAsyncTask &task, int32_t status) {
3508 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
3509 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3510 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3511 TAG_LOGD(AAFwkTag::JSNAPI, "task execute error, name is nullptr or NAPI_ERR_ABILITY_CALL_INVALID");
3512 return;
3513 }
3514 task.Resolve(env, CreateJsValue(env, name->name));
3515 };
3516
3517 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3518 napi_value result = nullptr;
3519 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetProcessName",
3520 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3521
3522 return result;
3523 }
3524
OnGetCallingBundle(napi_env env,napi_callback_info info)3525 napi_value NapiJsContext::OnGetCallingBundle(napi_env env, napi_callback_info info)
3526 {
3527 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3528 size_t argc = ARGS_MAX_COUNT;
3529 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3530 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3531 if (argc > ARGS_ONE) {
3532 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3533 return CreateJsUndefined(env);
3534 }
3535
3536 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3537 std::shared_ptr<JsCallingBundleName> callingBundleName = std::make_shared<JsCallingBundleName>();
3538 auto execute = [obj = this, name = callingBundleName, value = errorVal] () {
3539 if (obj->ability_ == nullptr) {
3540 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3541 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3542 return;
3543 }
3544 if (name == nullptr) {
3545 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3546 TAG_LOGE(AAFwkTag::JSNAPI, "task execute error, name is nullptr");
3547 return;
3548 }
3549 name->name = obj->ability_->GetCallingBundle();
3550 };
3551 auto complete = [obj = this, name = callingBundleName, value = errorVal]
3552 (napi_env env, NapiAsyncTask &task, int32_t status) {
3553 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
3554 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3555 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3556 return;
3557 }
3558 task.Resolve(env, CreateJsValue(env, name->name));
3559 };
3560
3561 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3562 napi_value result = nullptr;
3563 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetCallingBundle",
3564 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3565
3566 return result;
3567 }
3568
OnGetOrCreateLocalDir(napi_env env,napi_callback_info info)3569 napi_value NapiJsContext::OnGetOrCreateLocalDir(napi_env env, napi_callback_info info)
3570 {
3571 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3572 size_t argc = ARGS_MAX_COUNT;
3573 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3574 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3575 if (argc > ARGS_ONE) {
3576 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3577 return CreateJsUndefined(env);
3578 }
3579
3580 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3581 std::shared_ptr<JsOrCreateLocalDir> createDir = std::make_shared<JsOrCreateLocalDir>();
3582 auto execute = [obj = this, dir = createDir, value = errorVal] () {
3583 if (obj->ability_ == nullptr) {
3584 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
3585 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
3586 return;
3587 }
3588 auto context = obj->ability_->GetAbilityContext();
3589 if (context == nullptr || dir == nullptr) {
3590 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
3591 TAG_LOGE(AAFwkTag::JSNAPI, "task execute error, the ability context is nullptr");
3592 return;
3593 }
3594 dir->name = context->GetBaseDir();
3595 if (!OHOS::FileExists(dir->name)) {
3596 TAG_LOGI(AAFwkTag::JSNAPI, "dir is not exits, create dir");
3597 OHOS::ForceCreateDirectory(dir->name);
3598 OHOS::ChangeModeDirectory(dir->name, MODE);
3599 }
3600 };
3601 auto complete = [obj = this, dir = createDir, value = errorVal]
3602 (napi_env env, NapiAsyncTask &task, int32_t status) {
3603 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || dir == nullptr) {
3604 TAG_LOGD(AAFwkTag::JSNAPI, "errorVal is error or JsCacheDir is nullptr");
3605 auto ecode = dir == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
3606 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
3607 return;
3608 }
3609 task.Resolve(env, CreateJsValue(env, dir->name));
3610 };
3611 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
3612 napi_value result = nullptr;
3613 NapiAsyncTask::Schedule("NapiJsContext::OnGetOrCreateLocalDir",
3614 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
3615
3616 return result;
3617 }
3618
OnSetShowOnLockScreen(napi_env env,napi_callback_info info)3619 napi_value NapiJsContext::OnSetShowOnLockScreen(napi_env env, napi_callback_info info)
3620 {
3621 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3622 size_t argc = ARGS_MAX_COUNT;
3623 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3624 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3625 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
3626 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3627 return CreateJsUndefined(env);
3628 }
3629
3630 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
3631 bool isShow = false;
3632 if (!ConvertFromJsValue(env, argv[PARAM0], isShow)) {
3633 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
3634 return CreateJsUndefined(env);
3635 }
3636 auto complete = [obj = this, isShow, value = errorVal]
3637 (napi_env env, NapiAsyncTask &task, int32_t status) {
3638 if (obj->ability_ == nullptr) {
3639 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
3640 return;
3641 }
3642 obj->ability_->SetShowOnLockScreen(isShow);
3643 task.Resolve(env, CreateJsUndefined(env));
3644 };
3645
3646 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
3647 napi_value result = nullptr;
3648 NapiAsyncTask::Schedule("NapiJsContext::OnSetShowOnLockScreen",
3649 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
3650
3651 return result;
3652 }
3653
OnSetWakeUpScreen(napi_env env,napi_callback_info info)3654 napi_value NapiJsContext::OnSetWakeUpScreen(napi_env env, napi_callback_info info)
3655 {
3656 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3657 size_t argc = ARGS_MAX_COUNT;
3658 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3659 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3660 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
3661 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3662 return CreateJsUndefined(env);
3663 }
3664
3665 bool wakeUp = false;
3666 if (!ConvertFromJsValue(env, argv[PARAM0], wakeUp)) {
3667 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
3668 return CreateJsUndefined(env);
3669 }
3670 auto complete = [obj = this, wakeUp]
3671 (napi_env env, NapiAsyncTask &task, int32_t status) {
3672 if (obj->ability_ == nullptr) {
3673 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
3674 return;
3675 }
3676 obj->ability_->SetWakeUpScreen(wakeUp);
3677 task.Resolve(env, CreateJsUndefined(env));
3678 };
3679
3680 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
3681 napi_value result = nullptr;
3682 NapiAsyncTask::Schedule("NapiJsContext::OnSetWakeUpScreen",
3683 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
3684
3685 return result;
3686 }
3687
OnSetDisplayOrientation(napi_env env,napi_callback_info info)3688 napi_value NapiJsContext::OnSetDisplayOrientation(napi_env env, napi_callback_info info)
3689 {
3690 TAG_LOGD(AAFwkTag::JSNAPI, "called");
3691 size_t argc = ARGS_MAX_COUNT;
3692 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
3693 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
3694 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
3695 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
3696 return CreateJsUndefined(env);
3697 }
3698
3699 int32_t orientation = 0;
3700 if (!ConvertFromJsValue(env, argv[PARAM0], orientation)) {
3701 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
3702 return CreateJsUndefined(env);
3703 }
3704
3705 int32_t maxRange = 3;
3706 if (orientation < 0 || orientation > maxRange) {
3707 TAG_LOGE(AAFwkTag::JSNAPI, "wrong parameter orientation : %{public}d", orientation);
3708 return CreateJsNull(env);
3709 }
3710 auto complete = [obj = this, orientationData = orientation]
3711 (napi_env env, NapiAsyncTask &task, int32_t status) {
3712 if (obj->ability_ == nullptr) {
3713 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
3714 return;
3715 }
3716 obj->ability_->SetDisplayOrientation(orientationData);
3717 task.Resolve(env, CreateJsUndefined(env));
3718 };
3719
3720 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
3721 napi_value result = nullptr;
3722 NapiAsyncTask::ScheduleHighQos("NapiJsContext::SetDisplayOrientation",
3723 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
3724
3725 return result;
3726 }
3727 } // namespace AppExecFwk
3728 } // namespace OHOS
3729