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