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