1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_context.h"
17
18 #include <cstring>
19 #include <uv.h>
20
21 #include "napi_common_ability.h"
22 #include "napi_context_helper.h"
23 #include "ability_util.h"
24 #include "ability_process.h"
25 #include "directory_ex.h"
26 #include "feature_ability_common.h"
27 #include "file_ex.h"
28 #include "hilog_tag_wrapper.h"
29 #include "js_napi_common_ability.h"
30 #include "permission_list_state.h"
31 #include "securec.h"
32
33 using namespace OHOS::AAFwk;
34 using namespace OHOS::AppExecFwk;
35 using namespace OHOS::AbilityRuntime;
36
37 namespace OHOS {
38 namespace AppExecFwk {
ContextConstructor(napi_env env,napi_callback_info info)39 napi_value ContextConstructor(napi_env env, napi_callback_info info)
40 {
41 napi_value jsthis = nullptr;
42 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
43
44 napi_value value = nullptr;
45 NAPI_CALL(env, napi_get_boolean(env, false, &value));
46
47 napi_property_descriptor desc[] = {
48 DECLARE_NAPI_PROPERTY("stageMode", value),
49 };
50 NAPI_CALL(env, napi_define_properties(env, jsthis, sizeof(desc) / sizeof(desc[0]), desc));
51
52 return jsthis;
53 }
54
55 struct OnRequestPermissionsData {
56 int requestCode = 0;
57 std::vector<std::string> permissions;
58 std::vector<int> grantResults;
59 uv_work_t uvWork{};
60 NapiAsyncTask *napiAsyncTask = nullptr;
61 napi_env env = nullptr;
62
~OnRequestPermissionsDataOHOS::AppExecFwk::OnRequestPermissionsData63 ~OnRequestPermissionsData()
64 {
65 if (napiAsyncTask) {
66 delete napiAsyncTask;
67 }
68 }
69
WorkCallbackOHOS::AppExecFwk::OnRequestPermissionsData70 static void WorkCallback(uv_work_t* work)
71 {
72 TAG_LOGI(AAFwkTag::JSNAPI, "called");
73 }
74
AfterWorkCallbackOHOS::AppExecFwk::OnRequestPermissionsData75 static void AfterWorkCallback(uv_work_t* work, int status)
76 {
77 TAG_LOGD(AAFwkTag::JSNAPI, "called");
78 if (work == nullptr) {
79 TAG_LOGE(AAFwkTag::JSNAPI, "null work");
80 return;
81 }
82 if (work->data == nullptr) {
83 TAG_LOGE(AAFwkTag::JSNAPI, "null data");
84 return;
85 }
86 std::unique_ptr<OnRequestPermissionsData> data{static_cast<OnRequestPermissionsData *>(work->data)};
87 auto env = data->env;
88 napi_handle_scope scope = nullptr;
89 napi_open_handle_scope(env, &scope);
90 napi_value object = nullptr;
91 napi_create_object(env, &object);
92 napi_set_named_property(env, object, "requestCode", CreateJsValue(env, data->requestCode));
93 napi_set_named_property(env, object, "permissions", CreateNativeArray(env, data->permissions));
94 napi_set_named_property(env, object, "authResults", CreateNativeArray(env, data->grantResults));
95 data->napiAsyncTask->Resolve(env, object);
96 napi_close_handle_scope(env, scope);
97 }
98 };
99
100 EXTERN_C_START
CallOnRequestPermissionsFromUserResult(int requestCode,const std::vector<std::string> & permissions,const std::vector<int> & grantResults,CallbackInfo callbackInfo)101 void CallOnRequestPermissionsFromUserResult(int requestCode, const std::vector<std::string> &permissions,
102 const std::vector<int> &grantResults, CallbackInfo callbackInfo)
103 {
104 TAG_LOGI(AAFwkTag::JSNAPI, "called");
105 if (permissions.empty()) {
106 TAG_LOGE(AAFwkTag::JSNAPI, "empty permissions");
107 return;
108 }
109 if (permissions.size() != grantResults.size()) {
110 TAG_LOGE(AAFwkTag::JSNAPI, "permissions size not match");
111 return;
112 }
113 if (callbackInfo.env == nullptr) {
114 TAG_LOGE(AAFwkTag::JSNAPI, "null env");
115 return;
116 }
117 if (callbackInfo.napiAsyncTask == nullptr) {
118 TAG_LOGE(AAFwkTag::JSNAPI, "null napiAsyncTask");
119 return;
120 }
121
122 uv_loop_t *loop = nullptr;
123 napi_get_uv_event_loop(callbackInfo.env, &loop);
124 if (loop == nullptr) {
125 TAG_LOGE(AAFwkTag::JSNAPI, "null loop");
126 return;
127 }
128
129 auto reqData = std::make_unique<OnRequestPermissionsData>();
130 reqData->permissions = permissions;
131 reqData->grantResults = grantResults;
132 reqData->requestCode = requestCode;
133 reqData->env = callbackInfo.env;
134 reqData->napiAsyncTask = callbackInfo.napiAsyncTask;
135 reqData->uvWork.data = static_cast<void *>(reqData.get());
136
137 int rev = uv_queue_work_with_qos(loop, &(reqData->uvWork),
138 OnRequestPermissionsData::WorkCallback, OnRequestPermissionsData::AfterWorkCallback, uv_qos_user_initiated);
139 if (rev == 0) {
140 (void)reqData.release();
141 }
142 }
143 EXTERN_C_END
144
CreateCallingBundleCBInfo(napi_env env)145 CallingBundleCB *CreateCallingBundleCBInfo(napi_env env)
146 {
147 TAG_LOGI(AAFwkTag::JSNAPI, "called");
148 napi_value global = nullptr;
149 NAPI_CALL(env, napi_get_global(env, &global));
150
151 napi_value abilityObj = nullptr;
152 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
153
154 Ability *ability = nullptr;
155 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
156
157 CallingBundleCB *callingBundleCB = new (std::nothrow) CallingBundleCB;
158 if (callingBundleCB == nullptr) {
159 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
160 return nullptr;
161 }
162 callingBundleCB->cbBase.cbInfo.env = env;
163 callingBundleCB->cbBase.asyncWork = nullptr;
164 callingBundleCB->cbBase.deferred = nullptr;
165 callingBundleCB->cbBase.ability = ability;
166
167 TAG_LOGI(AAFwkTag::JSNAPI, "end");
168 return callingBundleCB;
169 }
170
GetCallingBundleExecuteCB(napi_env env,void * data)171 void GetCallingBundleExecuteCB(napi_env env, void *data)
172 {
173 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
174 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
175 if (callingBundleCB == nullptr) {
176 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
177 return;
178 }
179
180 callingBundleCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
181 if (callingBundleCB->cbBase.ability == nullptr) {
182 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
183 callingBundleCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
184 return;
185 }
186
187 callingBundleCB->callingBundleName = callingBundleCB->cbBase.ability->GetCallingBundle();
188 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
189 }
190
WrapCallingBundle(napi_env env,const CallingBundleCB * callingBundleCB)191 napi_value WrapCallingBundle(napi_env env, const CallingBundleCB *callingBundleCB)
192 {
193 TAG_LOGI(AAFwkTag::JSNAPI, "called");
194 if (callingBundleCB == nullptr) {
195 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
196 return nullptr;
197 }
198 napi_value result = nullptr;
199 NAPI_CALL(env, napi_create_string_utf8(env, callingBundleCB->callingBundleName.c_str(), NAPI_AUTO_LENGTH, &result));
200 TAG_LOGI(AAFwkTag::JSNAPI, "end");
201 return result;
202 }
203
GetCallingBundleAsyncCompleteCB(napi_env env,napi_status status,void * data)204 void GetCallingBundleAsyncCompleteCB(napi_env env, napi_status status, void *data)
205 {
206 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
207 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
208 napi_value callback = nullptr;
209 napi_value undefined = nullptr;
210 napi_value result[ARGS_TWO] = {nullptr};
211 napi_value callResult = nullptr;
212 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
213 result[PARAM0] = GetCallbackErrorValue(env, callingBundleCB->cbBase.errCode);
214 if (callingBundleCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
215 result[PARAM1] = WrapCallingBundle(env, callingBundleCB);
216 } else {
217 result[PARAM1] = WrapUndefinedToJS(env);
218 }
219 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callingBundleCB->cbBase.cbInfo.callback, &callback));
220 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
221
222 if (callingBundleCB->cbBase.cbInfo.callback != nullptr) {
223 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, callingBundleCB->cbBase.cbInfo.callback));
224 }
225 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, callingBundleCB->cbBase.asyncWork));
226 delete callingBundleCB;
227 callingBundleCB = nullptr;
228 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
229 }
230
GetCallingBundlePromiseCompleteCB(napi_env env,napi_status status,void * data)231 void GetCallingBundlePromiseCompleteCB(napi_env env, napi_status status, void *data)
232 {
233 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
234 CallingBundleCB *callingBundleCB = static_cast<CallingBundleCB *>(data);
235 napi_value result = nullptr;
236 if (callingBundleCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
237 result = WrapCallingBundle(env, callingBundleCB);
238 napi_resolve_deferred(env, callingBundleCB->cbBase.deferred, result);
239 } else {
240 result = GetCallbackErrorValue(env, callingBundleCB->cbBase.errCode);
241 napi_reject_deferred(env, callingBundleCB->cbBase.deferred, result);
242 }
243
244 napi_delete_async_work(env, callingBundleCB->cbBase.asyncWork);
245 delete callingBundleCB;
246 callingBundleCB = nullptr;
247 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
248 }
249
GetCallingBundleAsync(napi_env env,napi_value * args,const size_t argCallback,CallingBundleCB * callingBundleCB)250 napi_value GetCallingBundleAsync(
251 napi_env env, napi_value *args, const size_t argCallback, CallingBundleCB *callingBundleCB)
252 {
253 TAG_LOGI(AAFwkTag::JSNAPI, "called");
254 if (args == nullptr || callingBundleCB == nullptr) {
255 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
256 return nullptr;
257 }
258 napi_value resourceName = nullptr;
259 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
260
261 napi_valuetype valuetype = napi_undefined;
262 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
263 if (valuetype == napi_function) {
264 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &callingBundleCB->cbBase.cbInfo.callback));
265 }
266 NAPI_CALL(env,
267 napi_create_async_work(env,
268 nullptr,
269 resourceName,
270 GetCallingBundleExecuteCB,
271 GetCallingBundleAsyncCompleteCB,
272 static_cast<void *>(callingBundleCB),
273 &callingBundleCB->cbBase.asyncWork));
274 NAPI_CALL(env, napi_queue_async_work_with_qos(env, callingBundleCB->cbBase.asyncWork, napi_qos_user_initiated));
275 napi_value result = nullptr;
276 NAPI_CALL(env, napi_get_null(env, &result));
277 TAG_LOGI(AAFwkTag::JSNAPI, "end");
278 return result;
279 }
280
GetCallingBundlePromise(napi_env env,CallingBundleCB * callingBundleCB)281 napi_value GetCallingBundlePromise(napi_env env, CallingBundleCB *callingBundleCB)
282 {
283 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
284 if (callingBundleCB == nullptr) {
285 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
286 return nullptr;
287 }
288 napi_value resourceName = nullptr;
289 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
290 napi_deferred deferred;
291 napi_value promise = nullptr;
292 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
293 callingBundleCB->cbBase.deferred = deferred;
294
295 NAPI_CALL(env,
296 napi_create_async_work(env,
297 nullptr,
298 resourceName,
299 GetCallingBundleExecuteCB,
300 GetCallingBundlePromiseCompleteCB,
301 static_cast<void *>(callingBundleCB),
302 &callingBundleCB->cbBase.asyncWork));
303 NAPI_CALL(env, napi_queue_async_work_with_qos(env, callingBundleCB->cbBase.asyncWork, napi_qos_user_initiated));
304 TAG_LOGI(AAFwkTag::JSNAPI, "end");
305 return promise;
306 }
307
GetCallingBundleWrap(napi_env env,napi_callback_info info,CallingBundleCB * callingBundleCB)308 napi_value GetCallingBundleWrap(napi_env env, napi_callback_info info, CallingBundleCB *callingBundleCB)
309 {
310 TAG_LOGI(AAFwkTag::JSNAPI, "called");
311 if (callingBundleCB == nullptr) {
312 TAG_LOGE(AAFwkTag::JSNAPI, "null callingBundleCB");
313 return nullptr;
314 }
315
316 size_t argcAsync = 1;
317 const size_t argcPromise = 0;
318 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
319 napi_value args[ARGS_MAX_COUNT] = {nullptr};
320 napi_value ret = nullptr;
321
322 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
323 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
324 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
325 return nullptr;
326 }
327
328 if (argcAsync > argcPromise) {
329 ret = GetCallingBundleAsync(env, args, 0, callingBundleCB);
330 } else {
331 ret = GetCallingBundlePromise(env, callingBundleCB);
332 }
333 TAG_LOGI(AAFwkTag::JSNAPI, "end");
334 return ret;
335 }
336
CreateGetOrCreateLocalDirCBInfo(napi_env env)337 GetOrCreateLocalDirCB *CreateGetOrCreateLocalDirCBInfo(napi_env env)
338 {
339 TAG_LOGI(AAFwkTag::JSNAPI, "called");
340 napi_value global = nullptr;
341 NAPI_CALL(env, napi_get_global(env, &global));
342
343 napi_value abilityObj = nullptr;
344 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
345
346 Ability *ability = nullptr;
347 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
348
349 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = new (std::nothrow) GetOrCreateLocalDirCB;
350 if (getOrCreateLocalDirCB == nullptr) {
351 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
352 return nullptr;
353 }
354 getOrCreateLocalDirCB->cbBase.cbInfo.env = env;
355 getOrCreateLocalDirCB->cbBase.asyncWork = nullptr;
356 getOrCreateLocalDirCB->cbBase.deferred = nullptr;
357 getOrCreateLocalDirCB->cbBase.ability = ability;
358
359 TAG_LOGI(AAFwkTag::JSNAPI, "end");
360 return getOrCreateLocalDirCB;
361 }
362
GetOrCreateLocalDirExecuteCB(napi_env env,void * data)363 void GetOrCreateLocalDirExecuteCB(napi_env env, void *data)
364 {
365 TAG_LOGI(AAFwkTag::JSNAPI, "execute");
366 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
367 if (getOrCreateLocalDirCB == nullptr) {
368 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
369 return;
370 }
371
372 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
373 if (getOrCreateLocalDirCB->cbBase.ability == nullptr ||
374 getOrCreateLocalDirCB->cbBase.ability->GetAbilityContext() == nullptr) {
375 TAG_LOGE(AAFwkTag::JSNAPI, "null ability or abilityContext");
376 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
377 return;
378 }
379
380 getOrCreateLocalDirCB->rootDir = getOrCreateLocalDirCB->cbBase.ability->GetAbilityContext()->GetBaseDir();
381 TAG_LOGI(AAFwkTag::JSNAPI, "rootDir:%{public}s",
382 getOrCreateLocalDirCB->rootDir.c_str());
383 if (!OHOS::FileExists(getOrCreateLocalDirCB->rootDir)) {
384 TAG_LOGI(AAFwkTag::JSNAPI, "create dir");
385 OHOS::ForceCreateDirectory(getOrCreateLocalDirCB->rootDir);
386 OHOS::ChangeModeDirectory(getOrCreateLocalDirCB->rootDir, MODE);
387 }
388 TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
389 }
390
WrapGetOrCreateLocalDir(napi_env env,const GetOrCreateLocalDirCB * getOrCreateLocalDirCB)391 napi_value WrapGetOrCreateLocalDir(napi_env env, const GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
392 {
393 TAG_LOGI(AAFwkTag::JSNAPI, "called");
394 if (getOrCreateLocalDirCB == nullptr) {
395 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
396 return nullptr;
397 }
398 napi_value result = nullptr;
399 NAPI_CALL(env, napi_create_string_utf8(env, getOrCreateLocalDirCB->rootDir.c_str(), NAPI_AUTO_LENGTH, &result));
400 TAG_LOGI(AAFwkTag::JSNAPI, "end");
401 return result;
402 }
403
GetOrCreateLocalDirAsyncCompleteCB(napi_env env,napi_status status,void * data)404 void GetOrCreateLocalDirAsyncCompleteCB(napi_env env, napi_status status, void *data)
405 {
406 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
407 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
408 napi_value callback = nullptr;
409 napi_value undefined = nullptr;
410 napi_value result[ARGS_TWO] = {nullptr};
411 napi_value callResult = nullptr;
412 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
413 result[PARAM0] = GetCallbackErrorValue(env, getOrCreateLocalDirCB->cbBase.errCode);
414 if (getOrCreateLocalDirCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
415 result[PARAM1] = WrapGetOrCreateLocalDir(env, getOrCreateLocalDirCB);
416 } else {
417 result[PARAM1] = WrapUndefinedToJS(env);
418 }
419 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, getOrCreateLocalDirCB->cbBase.cbInfo.callback, &callback));
420 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
421
422 if (getOrCreateLocalDirCB->cbBase.cbInfo.callback != nullptr) {
423 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, getOrCreateLocalDirCB->cbBase.cbInfo.callback));
424 }
425 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
426 delete getOrCreateLocalDirCB;
427 getOrCreateLocalDirCB = nullptr;
428 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
429 }
430
GetOrCreateLocalDirPromiseCompleteCB(napi_env env,napi_status status,void * data)431 void GetOrCreateLocalDirPromiseCompleteCB(napi_env env, napi_status status, void *data)
432 {
433 TAG_LOGI(AAFwkTag::JSNAPI, "complete");
434 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = static_cast<GetOrCreateLocalDirCB *>(data);
435 napi_value result = nullptr;
436 if (getOrCreateLocalDirCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
437 result = WrapGetOrCreateLocalDir(env, getOrCreateLocalDirCB);
438 napi_resolve_deferred(env, getOrCreateLocalDirCB->cbBase.deferred, result);
439 } else {
440 result = GetCallbackErrorValue(env, getOrCreateLocalDirCB->cbBase.errCode);
441 napi_reject_deferred(env, getOrCreateLocalDirCB->cbBase.deferred, result);
442 }
443
444 napi_delete_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork);
445 delete getOrCreateLocalDirCB;
446 getOrCreateLocalDirCB = nullptr;
447 TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
448 }
449
GetOrCreateLocalDirAsync(napi_env env,napi_value * args,const size_t argCallback,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)450 napi_value GetOrCreateLocalDirAsync(
451 napi_env env, napi_value *args, const size_t argCallback, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
452 {
453 TAG_LOGI(AAFwkTag::JSNAPI, "called");
454 if (args == nullptr || getOrCreateLocalDirCB == nullptr) {
455 TAG_LOGE(AAFwkTag::JSNAPI, "null param");
456 return nullptr;
457 }
458 napi_value resourceName = nullptr;
459 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
460
461 napi_valuetype valuetype = napi_undefined;
462 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
463 if (valuetype == napi_function) {
464 NAPI_CALL(
465 env, napi_create_reference(env, args[argCallback], 1, &getOrCreateLocalDirCB->cbBase.cbInfo.callback));
466 }
467 NAPI_CALL(env,
468 napi_create_async_work(env,
469 nullptr,
470 resourceName,
471 GetOrCreateLocalDirExecuteCB,
472 GetOrCreateLocalDirAsyncCompleteCB,
473 static_cast<void *>(getOrCreateLocalDirCB),
474 &getOrCreateLocalDirCB->cbBase.asyncWork));
475 NAPI_CALL(env, napi_queue_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
476 napi_value result = nullptr;
477 NAPI_CALL(env, napi_get_null(env, &result));
478 TAG_LOGI(AAFwkTag::JSNAPI, "end");
479 return result;
480 }
481
GetOrCreateLocalDirPromise(napi_env env,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)482 napi_value GetOrCreateLocalDirPromise(napi_env env, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
483 {
484 TAG_LOGI(AAFwkTag::JSNAPI, "promise");
485 if (getOrCreateLocalDirCB == nullptr) {
486 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
487 return nullptr;
488 }
489 napi_value resourceName = nullptr;
490 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
491 napi_deferred deferred;
492 napi_value promise = nullptr;
493 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
494 getOrCreateLocalDirCB->cbBase.deferred = deferred;
495
496 NAPI_CALL(env,
497 napi_create_async_work(env,
498 nullptr,
499 resourceName,
500 GetOrCreateLocalDirExecuteCB,
501 GetOrCreateLocalDirPromiseCompleteCB,
502 static_cast<void *>(getOrCreateLocalDirCB),
503 &getOrCreateLocalDirCB->cbBase.asyncWork));
504 NAPI_CALL(env, napi_queue_async_work(env, getOrCreateLocalDirCB->cbBase.asyncWork));
505 TAG_LOGI(AAFwkTag::JSNAPI, "end");
506 return promise;
507 }
508
GetOrCreateLocalDirWrap(napi_env env,napi_callback_info info,GetOrCreateLocalDirCB * getOrCreateLocalDirCB)509 napi_value GetOrCreateLocalDirWrap(napi_env env, napi_callback_info info, GetOrCreateLocalDirCB *getOrCreateLocalDirCB)
510 {
511 TAG_LOGI(AAFwkTag::JSNAPI, "called");
512 if (getOrCreateLocalDirCB == nullptr) {
513 TAG_LOGE(AAFwkTag::JSNAPI, "null getOrCreateLocalDirCB");
514 return nullptr;
515 }
516
517 size_t argcAsync = 1;
518 const size_t argcPromise = 0;
519 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
520 napi_value args[ARGS_MAX_COUNT] = {nullptr};
521 napi_value ret = nullptr;
522
523 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
524 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
525 TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
526 return nullptr;
527 }
528
529 if (argcAsync > argcPromise) {
530 ret = GetOrCreateLocalDirAsync(env, args, 0, getOrCreateLocalDirCB);
531 } else {
532 ret = GetOrCreateLocalDirPromise(env, getOrCreateLocalDirCB);
533 }
534 TAG_LOGI(AAFwkTag::JSNAPI, "end");
535 return ret;
536 }
537
NAPI_GetBundleName(napi_env env,napi_callback_info info)538 napi_value NAPI_GetBundleName(napi_env env, napi_callback_info info)
539 {
540 TAG_LOGI(AAFwkTag::JSNAPI, "called");
541 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
542 if (asyncCallbackInfo == nullptr) {
543 TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
544 return WrapVoidToJS(env);
545 }
546
547 napi_value ret = NAPI_GetBundleNameWrap(env, info, asyncCallbackInfo);
548 if (ret == nullptr) {
549 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
550 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
551 ret = WrapVoidToJS(env);
552 }
553 TAG_LOGI(AAFwkTag::JSNAPI, "end");
554 return ret;
555 }
556
NAPI_GetApplicationInfo(napi_env env,napi_callback_info info)557 napi_value NAPI_GetApplicationInfo(napi_env env, napi_callback_info info)
558 {
559 TAG_LOGI(AAFwkTag::JSNAPI, "called");
560 AppInfoCB *appInfoCB = CreateAppInfoCBInfo(env);
561 if (appInfoCB == nullptr) {
562 return WrapVoidToJS(env);
563 }
564
565 napi_value ret = GetApplicationInfoWrap(env, info, appInfoCB);
566 if (ret == nullptr) {
567 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
568 if (appInfoCB != nullptr) {
569 delete appInfoCB;
570 appInfoCB = nullptr;
571 }
572 ret = WrapVoidToJS(env);
573 }
574 TAG_LOGI(AAFwkTag::JSNAPI, "end");
575 return ret;
576 }
577
NAPI_GetProcessInfo(napi_env env,napi_callback_info info)578 napi_value NAPI_GetProcessInfo(napi_env env, napi_callback_info info)
579 {
580 TAG_LOGI(AAFwkTag::JSNAPI, "called");
581 ProcessInfoCB *processInfoCB = CreateProcessInfoCBInfo(env);
582 if (processInfoCB == nullptr) {
583 return WrapVoidToJS(env);
584 }
585
586 processInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
587 napi_value ret = GetProcessInfoWrap(env, info, processInfoCB);
588 if (ret == nullptr) {
589 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
590 if (processInfoCB != nullptr) {
591 delete processInfoCB;
592 processInfoCB = nullptr;
593 }
594 ret = WrapVoidToJS(env);
595 }
596 TAG_LOGI(AAFwkTag::JSNAPI, "end");
597 return ret;
598 }
599
NAPI_GetElementName(napi_env env,napi_callback_info info)600 napi_value NAPI_GetElementName(napi_env env, napi_callback_info info)
601 {
602 TAG_LOGI(AAFwkTag::JSNAPI, "called");
603 ElementNameCB *elementNameCB = CreateElementNameCBInfo(env);
604 if (elementNameCB == nullptr) {
605 return WrapVoidToJS(env);
606 }
607
608 elementNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
609 napi_value ret = GetElementNameWrap(env, info, elementNameCB);
610 if (ret == nullptr) {
611 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
612 if (elementNameCB != nullptr) {
613 delete elementNameCB;
614 elementNameCB = nullptr;
615 }
616 ret = WrapVoidToJS(env);
617 }
618 TAG_LOGI(AAFwkTag::JSNAPI, "end");
619 return ret;
620 }
621
NAPI_GetProcessName(napi_env env,napi_callback_info info)622 napi_value NAPI_GetProcessName(napi_env env, napi_callback_info info)
623 {
624 TAG_LOGI(AAFwkTag::JSNAPI, "called");
625 ProcessNameCB *processNameCB = CreateProcessNameCBInfo(env);
626 if (processNameCB == nullptr) {
627 return WrapVoidToJS(env);
628 }
629
630 processNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
631 napi_value ret = GetProcessNameWrap(env, info, processNameCB);
632 if (ret == nullptr) {
633 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
634 if (processNameCB != nullptr) {
635 delete processNameCB;
636 processNameCB = nullptr;
637 }
638 ret = WrapVoidToJS(env);
639 }
640 TAG_LOGI(AAFwkTag::JSNAPI, "end");
641 return ret;
642 }
643
NAPI_GetCallingBundle(napi_env env,napi_callback_info info)644 napi_value NAPI_GetCallingBundle(napi_env env, napi_callback_info info)
645 {
646 TAG_LOGI(AAFwkTag::JSNAPI, "called");
647 CallingBundleCB *callingBundleCB = CreateCallingBundleCBInfo(env);
648 if (callingBundleCB == nullptr) {
649 return WrapVoidToJS(env);
650 }
651
652 callingBundleCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
653 napi_value ret = GetCallingBundleWrap(env, info, callingBundleCB);
654 if (ret == nullptr) {
655 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
656 if (callingBundleCB != nullptr) {
657 delete callingBundleCB;
658 callingBundleCB = nullptr;
659 }
660 ret = WrapVoidToJS(env);
661 }
662 TAG_LOGI(AAFwkTag::JSNAPI, "end");
663 return ret;
664 }
665
NAPI_GetOrCreateLocalDir(napi_env env,napi_callback_info info)666 napi_value NAPI_GetOrCreateLocalDir(napi_env env, napi_callback_info info)
667 {
668 TAG_LOGI(AAFwkTag::JSNAPI, "called");
669 GetOrCreateLocalDirCB *getOrCreateLocalDirCB = CreateGetOrCreateLocalDirCBInfo(env);
670 if (getOrCreateLocalDirCB == nullptr) {
671 return WrapVoidToJS(env);
672 }
673
674 getOrCreateLocalDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
675 napi_value ret = GetOrCreateLocalDirWrap(env, info, getOrCreateLocalDirCB);
676 if (ret == nullptr) {
677 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
678 if (getOrCreateLocalDirCB != nullptr) {
679 delete getOrCreateLocalDirCB;
680 getOrCreateLocalDirCB = nullptr;
681 }
682 ret = WrapVoidToJS(env);
683 }
684 TAG_LOGI(AAFwkTag::JSNAPI, "end");
685 return ret;
686 }
687
NAPI_GetDatabaseDirSync(napi_env env,napi_callback_info info)688 napi_value NAPI_GetDatabaseDirSync(napi_env env, napi_callback_info info)
689 {
690 TAG_LOGI(AAFwkTag::JSNAPI, "called");
691 DatabaseDirCB *getDatabaseDirCB = CreateGetDatabaseDirCBInfo(env);
692 if (getDatabaseDirCB == nullptr) {
693 return WrapVoidToJS(env);
694 }
695
696 getDatabaseDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
697 napi_value ret = GetDatabaseDirWrap(env, info, getDatabaseDirCB);
698
699 delete getDatabaseDirCB;
700 getDatabaseDirCB = nullptr;
701
702 if (ret == nullptr) {
703 ret = WrapVoidToJS(env);
704 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
705 } else {
706 TAG_LOGI(AAFwkTag::JSNAPI, "end");
707 }
708 return ret;
709 }
710
NAPI_GetPreferencesDirSync(napi_env env,napi_callback_info info)711 napi_value NAPI_GetPreferencesDirSync(napi_env env, napi_callback_info info)
712 {
713 TAG_LOGI(AAFwkTag::JSNAPI, "called");
714 PreferencesDirCB *preferencesDirCB = CreateGetPreferencesDirCBInfo(env);
715 if (preferencesDirCB == nullptr) {
716 return WrapVoidToJS(env);
717 }
718
719 preferencesDirCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
720 napi_value ret = GetPreferencesDirWrap(env, info, preferencesDirCB);
721
722 delete preferencesDirCB;
723 preferencesDirCB = nullptr;
724
725 if (ret == nullptr) {
726 ret = WrapVoidToJS(env);
727 TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
728 } else {
729 TAG_LOGI(AAFwkTag::JSNAPI, "end");
730 }
731 return ret;
732 }
733
NAPI_IsUpdatingConfigurations(napi_env env,napi_callback_info info)734 napi_value NAPI_IsUpdatingConfigurations(napi_env env, napi_callback_info info)
735 {
736 TAG_LOGI(AAFwkTag::JSNAPI, "called");
737 return NAPI_IsUpdatingConfigurationsCommon(env, info, AbilityType::PAGE);
738 }
739
NAPI_GetExternalCacheDir(napi_env env,napi_callback_info info)740 napi_value NAPI_GetExternalCacheDir(napi_env env, napi_callback_info info)
741 {
742 TAG_LOGD(AAFwkTag::JSNAPI, "called");
743 return NAPI_GetExternalCacheDirCommon(env, info, AbilityType::PAGE);
744 }
745
NAPI_PrintDrawnCompleted(napi_env env,napi_callback_info info)746 napi_value NAPI_PrintDrawnCompleted(napi_env env, napi_callback_info info)
747 {
748 TAG_LOGI(AAFwkTag::JSNAPI, "called");
749 return NAPI_PrintDrawnCompletedCommon(env, info, AbilityType::PAGE);
750 }
751
NAPI_SetDisplayOrientation(napi_env env,napi_callback_info info)752 napi_value NAPI_SetDisplayOrientation(napi_env env, napi_callback_info info)
753 {
754 #ifdef SUPPORT_GRAPHICS
755 TAG_LOGD(AAFwkTag::JSNAPI, "called");
756
757 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
758 if (asyncCallbackInfo == nullptr) {
759 TAG_LOGW(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
760 return WrapVoidToJS(env);
761 }
762
763 napi_value rev = NAPI_SetDisplayOrientationWrap(env, info, asyncCallbackInfo);
764 if (rev == nullptr) {
765 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
766 rev = WrapVoidToJS(env);
767 }
768 return rev;
769 #else
770 return WrapVoidToJS(env);
771 #endif
772 }
773
NAPI_GetDisplayOrientation(napi_env env,napi_callback_info info)774 napi_value NAPI_GetDisplayOrientation(napi_env env, napi_callback_info info)
775 {
776 #ifdef SUPPORT_GRAPHICS
777 TAG_LOGD(AAFwkTag::JSNAPI, "called");
778 return NAPI_GetDisplayOrientationCommon(env, info, AbilityType::PAGE);
779 #else
780 return 0;
781 #endif
782 }
783
ContextPermissionInit(napi_env env,napi_value exports)784 napi_value ContextPermissionInit(napi_env env, napi_value exports)
785 {
786 TAG_LOGI(AAFwkTag::JSNAPI, "called");
787
788 napi_property_descriptor properties[] = {
789 DECLARE_NAPI_FUNCTION("verifySelfPermission", NAPI_VerifySelfPermission),
790 DECLARE_NAPI_FUNCTION("requestPermissionsFromUser", NAPI_RequestPermissionsFromUser),
791 DECLARE_NAPI_FUNCTION("getBundleName", NAPI_GetBundleName),
792 DECLARE_NAPI_FUNCTION("verifyPermission", NAPI_VerifyPermission),
793 DECLARE_NAPI_FUNCTION("getApplicationInfo", NAPI_GetApplicationInfo),
794 DECLARE_NAPI_FUNCTION("getProcessInfo", NAPI_GetProcessInfo),
795 DECLARE_NAPI_FUNCTION("getElementName", NAPI_GetElementName),
796 DECLARE_NAPI_FUNCTION("getProcessName", NAPI_GetProcessName),
797 DECLARE_NAPI_FUNCTION("getCallingBundle", NAPI_GetCallingBundle),
798 DECLARE_NAPI_FUNCTION("getOrCreateLocalDir", NAPI_GetOrCreateLocalDir),
799 DECLARE_NAPI_FUNCTION("getFilesDir", NAPI_GetFilesDir),
800 DECLARE_NAPI_FUNCTION("isUpdatingConfigurations", NAPI_IsUpdatingConfigurations),
801 DECLARE_NAPI_FUNCTION("printDrawnCompleted", NAPI_PrintDrawnCompleted),
802 DECLARE_NAPI_FUNCTION("getDatabaseDirSync", NAPI_GetDatabaseDirSync),
803 DECLARE_NAPI_FUNCTION("getPreferencesDirSync", NAPI_GetPreferencesDirSync),
804 DECLARE_NAPI_FUNCTION("getCacheDir", NAPI_GetCacheDir),
805 DECLARE_NAPI_FUNCTION("getAppType", NAPI_GetCtxAppType),
806 DECLARE_NAPI_FUNCTION("getHapModuleInfo", NAPI_GetCtxHapModuleInfo),
807 DECLARE_NAPI_FUNCTION("getAppVersionInfo", NAPI_GetAppVersionInfo),
808 DECLARE_NAPI_FUNCTION("getApplicationContext", NAPI_GetApplicationContext),
809 DECLARE_NAPI_FUNCTION("getAbilityInfo", NAPI_GetCtxAbilityInfo),
810 DECLARE_NAPI_FUNCTION("setShowOnLockScreen", NAPI_SetShowOnLockScreen),
811 DECLARE_NAPI_FUNCTION("getOrCreateDistributedDir", NAPI_GetOrCreateDistributedDir),
812 DECLARE_NAPI_FUNCTION("setWakeUpScreen", NAPI_SetWakeUpScreen),
813 DECLARE_NAPI_FUNCTION("setDisplayOrientation", NAPI_SetDisplayOrientation),
814 DECLARE_NAPI_FUNCTION("getDisplayOrientation", NAPI_GetDisplayOrientation),
815 DECLARE_NAPI_FUNCTION("getExternalCacheDir", NAPI_GetExternalCacheDir),
816 };
817 napi_value constructor;
818 NAPI_CALL(env,
819 napi_define_class(env,
820 "context",
821 NAPI_AUTO_LENGTH,
822 ContextConstructor,
823 nullptr,
824 sizeof(properties) / sizeof(*properties),
825 properties,
826 &constructor));
827 NAPI_CALL(env, SetGlobalClassContext(env, constructor));
828 return exports;
829 }
830
NAPI_SetWakeUpScreen(napi_env env,napi_callback_info info)831 napi_value NAPI_SetWakeUpScreen(napi_env env, napi_callback_info info)
832 {
833 #ifdef SUPPORT_GRAPHICS
834 TAG_LOGI(AAFwkTag::JSNAPI, "called");
835 SetWakeUpScreenCB *setWakeUpScreenCB = new (std::nothrow) SetWakeUpScreenCB;
836 if (setWakeUpScreenCB == nullptr) {
837 TAG_LOGE(AAFwkTag::JSNAPI, "null setWakeUpScreenCB");
838 return WrapVoidToJS(env);
839 }
840 setWakeUpScreenCB->cbBase.cbInfo.env = env;
841 setWakeUpScreenCB->cbBase.abilityType = AbilityType::PAGE;
842 napi_value ret = SetWakeUpScreenWrap(env, info, setWakeUpScreenCB);
843 if (ret == nullptr) {
844 if (setWakeUpScreenCB != nullptr) {
845 delete setWakeUpScreenCB;
846 setWakeUpScreenCB = nullptr;
847 }
848 TAG_LOGE(AAFwkTag::JSNAPI, "setWakeUpScreenCB failed");
849 ret = WrapVoidToJS(env);
850 }
851 TAG_LOGI(AAFwkTag::JSNAPI, "end");
852 return ret;
853 #else
854 return nullptr;
855 #endif
856 }
857
858 class NapiJsContext : public JsNapiCommon {
859 public:
860 NapiJsContext() = default;
861 virtual ~NapiJsContext() = default;
862
Finalizer(napi_env env,void * data,void * hint)863 static void Finalizer(napi_env env, void *data, void *hint)
864 {
865 TAG_LOGD(AAFwkTag::JSNAPI, "called");
866 std::unique_ptr<NapiJsContext>(static_cast<NapiJsContext*>(data));
867 };
868
869 static napi_value JsRequestPermissionsFromUser(napi_env env, napi_callback_info info);
870 static napi_value JsGetBundleName(napi_env env, napi_callback_info info);
871 static napi_value JsVerifyPermission(napi_env env, napi_callback_info info);
872 static napi_value JsGetApplicationInfo(napi_env env, napi_callback_info info);
873 static napi_value JsGetProcessInfo(napi_env env, napi_callback_info info);
874 static napi_value JsGetElementName(napi_env env, napi_callback_info info);
875 static napi_value JsGetProcessName(napi_env env, napi_callback_info info);
876 static napi_value JsGetCallingBundle(napi_env env, napi_callback_info info);
877 static napi_value JsGetOrCreateLocalDir(napi_env env, napi_callback_info info);
878 static napi_value JsGetFilesDir(napi_env env, napi_callback_info info);
879 static napi_value JsIsUpdatingConfigurations(napi_env env, napi_callback_info info);
880 static napi_value JsPrintDrawnCompleted(napi_env env, napi_callback_info info);
881 static napi_value JsGetCacheDir(napi_env env, napi_callback_info info);
882 static napi_value JsGetCtxAppType(napi_env env, napi_callback_info info);
883 static napi_value JsGetCtxHapModuleInfo(napi_env env, napi_callback_info info);
884 static napi_value JsGetAppVersionInfo(napi_env env, napi_callback_info info);
885 static napi_value JsGetApplicationContext(napi_env env, napi_callback_info info);
886 static napi_value JsGetCtxAbilityInfo(napi_env env, napi_callback_info info);
887 static napi_value JsSetShowOnLockScreen(napi_env env, napi_callback_info info);
888 static napi_value JsGetOrCreateDistributedDir(napi_env env, napi_callback_info info);
889 static napi_value JsSetWakeUpScreen(napi_env env, napi_callback_info info);
890 static napi_value JsSetDisplayOrientation(napi_env env, napi_callback_info info);
891 static napi_value JsGetDisplayOrientation(napi_env env, napi_callback_info info);
892 static napi_value JsGetExternalCacheDir(napi_env env, napi_callback_info info);
893
894 bool DataInit(napi_env env);
895
896 private:
897 #ifdef SUPPORT_GRAPHICS
898 napi_value OnSetShowOnLockScreen(napi_env env, napi_callback_info info);
899 napi_value OnSetWakeUpScreen(napi_env env, napi_callback_info info);
900 napi_value OnSetDisplayOrientation(napi_env env, napi_callback_info info);
901 #endif
902
903 napi_value OnRequestPermissionsFromUser(napi_env env, napi_callback_info info);
904 napi_value OnGetBundleName(napi_env env, napi_callback_info info);
905 napi_value OnVerifyPermission(napi_env env, napi_callback_info info);
906 napi_value OnGetApplicationInfo(napi_env env, napi_callback_info info);
907 napi_value OnGetProcessInfo(napi_env env, napi_callback_info info);
908 napi_value OnGetElementName(napi_env env, napi_callback_info info);
909 napi_value OnGetProcessName(napi_env env, napi_callback_info info);
910 napi_value OnGetCallingBundle(napi_env env, napi_callback_info info);
911 napi_value OnGetOrCreateLocalDir(napi_env env, napi_callback_info info);
912 };
913
BindNapiJSContextFunction(napi_env env,napi_value object)914 static bool BindNapiJSContextFunction(napi_env env, napi_value object)
915 {
916 TAG_LOGD(AAFwkTag::JSNAPI, "called");
917 if (object == nullptr) {
918 TAG_LOGE(AAFwkTag::JSNAPI, "null object");
919 return false;
920 }
921 const char* moduleName = "context";
922 BindNativeFunction(
923 env, object, "requestPermissionsFromUser", moduleName, NapiJsContext::JsRequestPermissionsFromUser);
924 BindNativeFunction(env, object, "getBundleName", moduleName, NapiJsContext::JsGetBundleName);
925 BindNativeFunction(env, object, "verifyPermission", moduleName, NapiJsContext::JsVerifyPermission);
926 BindNativeFunction(env, object, "getApplicationInfo", moduleName, NapiJsContext::JsGetApplicationInfo);
927 BindNativeFunction(env, object, "getProcessInfo", moduleName, NapiJsContext::JsGetProcessInfo);
928 BindNativeFunction(env, object, "getElementName", moduleName, NapiJsContext::JsGetElementName);
929 BindNativeFunction(env, object, "getProcessName", moduleName, NapiJsContext::JsGetProcessName);
930 BindNativeFunction(env, object, "getCallingBundle", moduleName, NapiJsContext::JsGetCallingBundle);
931 BindNativeFunction(env, object, "getOrCreateLocalDir", moduleName, NapiJsContext::JsGetOrCreateLocalDir);
932 BindNativeFunction(env, object, "getFilesDir", moduleName, NapiJsContext::JsGetFilesDir);
933 BindNativeFunction(env, object, "isUpdatingConfigurations", moduleName, NapiJsContext::JsIsUpdatingConfigurations);
934 BindNativeFunction(env, object, "printDrawnCompleted", moduleName, NapiJsContext::JsPrintDrawnCompleted);
935 BindNativeFunction(env, object, "getCacheDir", moduleName, NapiJsContext::JsGetCacheDir);
936 BindNativeFunction(env, object, "getAppType", moduleName, NapiJsContext::JsGetCtxAppType);
937 BindNativeFunction(env, object, "getHapModuleInfo", moduleName, NapiJsContext::JsGetCtxHapModuleInfo);
938 BindNativeFunction(env, object, "getAppVersionInfo", moduleName, NapiJsContext::JsGetAppVersionInfo);
939 BindNativeFunction(env, object, "getApplicationContext", moduleName, NapiJsContext::JsGetApplicationContext);
940 BindNativeFunction(env, object, "getAbilityInfo", moduleName, NapiJsContext::JsGetCtxAbilityInfo);
941 BindNativeFunction(env, object, "setShowOnLockScreen", moduleName, NapiJsContext::JsSetShowOnLockScreen);
942 BindNativeFunction(env, object, "getOrCreateDistributedDir", moduleName,
943 NapiJsContext::JsGetOrCreateDistributedDir);
944 BindNativeFunction(env, object, "setWakeUpScreen", moduleName, NapiJsContext::JsSetWakeUpScreen);
945 BindNativeFunction(env, object, "setDisplayOrientation", moduleName, NapiJsContext::JsSetDisplayOrientation);
946 BindNativeFunction(env, object, "getDisplayOrientation", moduleName, NapiJsContext::JsGetDisplayOrientation);
947 BindNativeFunction(env, object, "getExternalCacheDir", moduleName, NapiJsContext::JsGetExternalCacheDir);
948
949 return true;
950 }
951
ConstructNapiJSContext(napi_env env)952 static napi_value ConstructNapiJSContext(napi_env env)
953 {
954 TAG_LOGD(AAFwkTag::JSNAPI, "called");
955 napi_value objContext = nullptr;
956 napi_create_object(env, &objContext);
957 if (objContext == nullptr) {
958 TAG_LOGE(AAFwkTag::JSNAPI, "null objContext");
959 return nullptr;
960 }
961 auto jsClass = std::make_unique<NapiJsContext>();
962 if (!jsClass->DataInit(env)) {
963 TAG_LOGE(AAFwkTag::JSNAPI, "NapiJsContext init failed");
964 return nullptr;
965 }
966 napi_wrap(env, objContext, jsClass.release(), NapiJsContext::Finalizer, nullptr, nullptr);
967 napi_set_named_property(env, objContext, "stageMode", CreateJsValue(env, false));
968 if (!BindNapiJSContextFunction(env, objContext)) {
969 TAG_LOGE(AAFwkTag::JSNAPI, "bind func failed");
970 return nullptr;
971 }
972
973 return objContext;
974 }
975
CreateNapiJSContext(napi_env env)976 napi_value CreateNapiJSContext(napi_env env)
977 {
978 TAG_LOGD(AAFwkTag::JSNAPI, "called");
979 auto jsObj = ConstructNapiJSContext(env);
980 if (jsObj == nullptr) {
981 TAG_LOGE(AAFwkTag::JSNAPI, "null obj");
982 return CreateJsUndefined(env);
983 }
984
985 return jsObj;
986 }
987
JsRequestPermissionsFromUser(napi_env env,napi_callback_info info)988 napi_value NapiJsContext::JsRequestPermissionsFromUser(napi_env env, napi_callback_info info)
989 {
990 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
991 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
992
993 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
994 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
995
996 return object->OnRequestPermissionsFromUser(env, info);
997 }
998
JsGetBundleName(napi_env env,napi_callback_info info)999 napi_value NapiJsContext::JsGetBundleName(napi_env env, napi_callback_info info)
1000 {
1001 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
1002 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1003
1004 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1005 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1006
1007 return object->OnGetBundleName(env, info);
1008 }
1009
JsVerifyPermission(napi_env env,napi_callback_info info)1010 napi_value NapiJsContext::JsVerifyPermission(napi_env env, napi_callback_info info)
1011 {
1012 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
1013 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1014
1015 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1016 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1017
1018 return object->OnVerifyPermission(env, info);
1019 }
1020
JsGetApplicationInfo(napi_env env,napi_callback_info info)1021 napi_value NapiJsContext::JsGetApplicationInfo(napi_env env, napi_callback_info info)
1022 {
1023 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters engine is nullptr");
1024 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1025
1026 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1027 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1028
1029 return object->OnGetApplicationInfo(env, info);
1030 }
1031
JsGetProcessInfo(napi_env env,napi_callback_info info)1032 napi_value NapiJsContext::JsGetProcessInfo(napi_env env, napi_callback_info info)
1033 {
1034 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1035 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1036
1037 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1038 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1039
1040 return object->OnGetProcessInfo(env, info);
1041 }
1042
JsGetElementName(napi_env env,napi_callback_info info)1043 napi_value NapiJsContext::JsGetElementName(napi_env env, napi_callback_info info)
1044 {
1045 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1046 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1047
1048 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1049 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1050
1051 return object->OnGetElementName(env, info);
1052 }
1053
JsGetProcessName(napi_env env,napi_callback_info info)1054 napi_value NapiJsContext::JsGetProcessName(napi_env env, napi_callback_info info)
1055 {
1056 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1057 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1058
1059 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1060 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1061
1062 return object->OnGetProcessName(env, info);
1063 }
1064
JsGetCallingBundle(napi_env env,napi_callback_info info)1065 napi_value NapiJsContext::JsGetCallingBundle(napi_env env, napi_callback_info info)
1066 {
1067 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1068 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1069
1070 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1071 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1072
1073 return object->OnGetCallingBundle(env, info);
1074 }
1075
JsGetOrCreateLocalDir(napi_env env,napi_callback_info info)1076 napi_value NapiJsContext::JsGetOrCreateLocalDir(napi_env env, napi_callback_info info)
1077 {
1078 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1079 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1080
1081 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1082 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1083
1084 return object->OnGetOrCreateLocalDir(env, info);
1085 }
1086
JsGetFilesDir(napi_env env,napi_callback_info info)1087 napi_value NapiJsContext::JsGetFilesDir(napi_env env, napi_callback_info info)
1088 {
1089 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1090 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1091
1092 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1093 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1094
1095 return object->JsNapiCommon::JsGetFilesDir(env, info, AbilityType::PAGE);
1096 }
1097
JsIsUpdatingConfigurations(napi_env env,napi_callback_info info)1098 napi_value NapiJsContext::JsIsUpdatingConfigurations(napi_env env, napi_callback_info info)
1099 {
1100 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1101 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1102
1103 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1104 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1105
1106 return object->JsNapiCommon::JsIsUpdatingConfigurations(env, info, AbilityType::PAGE);
1107 }
1108
JsPrintDrawnCompleted(napi_env env,napi_callback_info info)1109 napi_value NapiJsContext::JsPrintDrawnCompleted(napi_env env, napi_callback_info info)
1110 {
1111 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1112 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1113
1114 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1115 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1116
1117 return object->JsNapiCommon::JsPrintDrawnCompleted(env, info, AbilityType::PAGE);
1118 }
1119
JsGetCacheDir(napi_env env,napi_callback_info info)1120 napi_value NapiJsContext::JsGetCacheDir(napi_env env, napi_callback_info info)
1121 {
1122 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1123 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1124
1125 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1126 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1127
1128 return object->JsNapiCommon::JsGetCacheDir(env, info, AbilityType::PAGE);
1129 }
1130
JsGetCtxAppType(napi_env env,napi_callback_info info)1131 napi_value NapiJsContext::JsGetCtxAppType(napi_env env, napi_callback_info info)
1132 {
1133 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1134 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1135
1136 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1137 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1138
1139 return object->JsNapiCommon::JsGetCtxAppType(env, info, AbilityType::PAGE);
1140 }
1141
JsGetCtxHapModuleInfo(napi_env env,napi_callback_info info)1142 napi_value NapiJsContext::JsGetCtxHapModuleInfo(napi_env env, napi_callback_info info)
1143 {
1144 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1145 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1146
1147 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1148 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1149
1150 return object->JsNapiCommon::JsGetCtxHapModuleInfo(env, info, AbilityType::PAGE);
1151 }
1152
JsGetAppVersionInfo(napi_env env,napi_callback_info info)1153 napi_value NapiJsContext::JsGetAppVersionInfo(napi_env env, napi_callback_info info)
1154 {
1155 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1156 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1157
1158 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1159 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1160
1161 return object->JsNapiCommon::JsGetAppVersionInfo(env, info, AbilityType::PAGE);
1162 }
1163
JsGetApplicationContext(napi_env env,napi_callback_info info)1164 napi_value NapiJsContext::JsGetApplicationContext(napi_env env, napi_callback_info info)
1165 {
1166 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1167 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1168
1169 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1170 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1171
1172 return object->JsNapiCommon::JsGetContext(env, info, AbilityType::PAGE);
1173 }
1174
JsGetCtxAbilityInfo(napi_env env,napi_callback_info info)1175 napi_value NapiJsContext::JsGetCtxAbilityInfo(napi_env env, napi_callback_info info)
1176 {
1177 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1178 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1179
1180 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1181 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1182
1183 return object->JsNapiCommon::JsGetCtxAbilityInfo(env, info, AbilityType::PAGE);
1184 }
1185
JsSetShowOnLockScreen(napi_env env,napi_callback_info info)1186 napi_value NapiJsContext::JsSetShowOnLockScreen(napi_env env, napi_callback_info info)
1187 {
1188 #ifdef SUPPORT_GRAPHICS
1189 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1190 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1191
1192 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1193 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1194
1195 return object->OnSetShowOnLockScreen(env, info);
1196 #else
1197 return nullptr;
1198 #endif
1199 }
1200
JsGetOrCreateDistributedDir(napi_env env,napi_callback_info info)1201 napi_value NapiJsContext::JsGetOrCreateDistributedDir(napi_env env, napi_callback_info info)
1202 {
1203 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1204 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1205
1206 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1207 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1208
1209 return object->JsNapiCommon::JsGetOrCreateDistributedDir(env, info, AbilityType::PAGE);
1210 }
1211
JsSetWakeUpScreen(napi_env env,napi_callback_info info)1212 napi_value NapiJsContext::JsSetWakeUpScreen(napi_env env, napi_callback_info info)
1213 {
1214 #ifdef SUPPORT_GRAPHICS
1215 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1216 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1217
1218 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1219 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1220
1221 return object->OnSetWakeUpScreen(env, info);
1222 #else
1223 return nullptr;
1224 #endif
1225 }
1226
JsSetDisplayOrientation(napi_env env,napi_callback_info info)1227 napi_value NapiJsContext::JsSetDisplayOrientation(napi_env env, napi_callback_info info)
1228 {
1229 #ifdef SUPPORT_GRAPHICS
1230 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1231 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1232
1233 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1234 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1235
1236 return object->OnSetDisplayOrientation(env, info);
1237 #else
1238 return nullptr;
1239 #endif
1240 }
1241
JsGetDisplayOrientation(napi_env env,napi_callback_info info)1242 napi_value NapiJsContext::JsGetDisplayOrientation(napi_env env, napi_callback_info info)
1243 {
1244 #ifdef SUPPORT_GRAPHICS
1245 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1246 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1247
1248 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1249 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1250
1251 return object->JsNapiCommon::JsGetDisplayOrientation(env, info, AbilityType::PAGE);
1252 #else
1253 return nullptr;
1254 #endif
1255 }
1256
JsGetExternalCacheDir(napi_env env,napi_callback_info info)1257 napi_value NapiJsContext::JsGetExternalCacheDir(napi_env env, napi_callback_info info)
1258 {
1259 CHECK_POINTER_AND_RETURN_LOG(env, nullptr, "but input parameters env is nullptr");
1260 CHECK_POINTER_AND_RETURN_LOG(info, nullptr, "but input parameters info is nullptr");
1261
1262 auto object = CheckParamsAndGetThis<NapiJsContext>(env, info);
1263 CHECK_POINTER_AND_RETURN_LOG(object, CreateJsUndefined(env), "CheckParamsAndGetThis return nullptr");
1264
1265 return object->JsNapiCommon::JsGetExternalCacheDir(env, info, AbilityType::PAGE);
1266 }
1267
DataInit(napi_env env)1268 bool NapiJsContext::DataInit(napi_env env)
1269 {
1270 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1271 napi_value global = nullptr;
1272 napi_value abilityObj = nullptr;
1273 TAG_LOGI(AAFwkTag::JSNAPI, "Get Ability to start");
1274 NAPI_CALL_BASE(env, napi_get_global(env, &global), false);
1275 NAPI_CALL_BASE(env, napi_get_named_property(env, global, "ability", &abilityObj), false);
1276 napi_status status = napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability_));
1277 if (status != napi_ok) {
1278 TAG_LOGW(AAFwkTag::JSNAPI, "Failed to get external ability info");
1279 }
1280 TAG_LOGD(AAFwkTag::JSNAPI, "end");
1281
1282 return true;
1283 }
1284
OnRequestPermissionsFromUser(napi_env env,napi_callback_info info)1285 napi_value NapiJsContext::OnRequestPermissionsFromUser(napi_env env, napi_callback_info info)
1286 {
1287 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1288 size_t argc = ARGS_MAX_COUNT;
1289 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1290 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1291 if (argc == ARGS_ZERO || argc > ARGS_THREE) {
1292 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1293 return CreateJsUndefined(env);
1294 }
1295 CallAbilityPermissionParam permissionParam;
1296 if (!GetStringsValue(env, argv[PARAM0], permissionParam.permission_list)) {
1297 TAG_LOGE(AAFwkTag::JSNAPI, "input params string error");
1298 return CreateJsUndefined(env);
1299 }
1300
1301 if (!ConvertFromJsValue(env, argv[PARAM1], permissionParam.requestCode)) {
1302 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
1303 return CreateJsUndefined(env);
1304 }
1305
1306 auto callback = argc == ARGS_THREE ? argv[PARAM2] : nullptr;
1307 napi_value result = nullptr;
1308 auto napiAsyncTask =
1309 AbilityRuntime::CreateAsyncTaskWithLastParam(env, callback, nullptr, nullptr, &result).release();
1310
1311 int32_t errorCode = NAPI_ERR_NO_ERROR;
1312 if (ability_ == nullptr) {
1313 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1314 errorCode = NAPI_ERR_ACE_ABILITY;
1315 }
1316
1317 if (permissionParam.permission_list.size() == 0) {
1318 TAG_LOGE(AAFwkTag::JSNAPI, "permission_list size is 0");
1319 errorCode = NAPI_ERR_PARAM_INVALID;
1320 }
1321
1322 if (errorCode != NAPI_ERR_NO_ERROR) {
1323 napi_value errorValue = CreateJsError(env, errorCode, ConvertErrorCode(errorCode));
1324 napiAsyncTask->Reject(env, errorValue);
1325 delete napiAsyncTask;
1326 napiAsyncTask = nullptr;
1327 } else {
1328 CallbackInfo callbackInfo;
1329 callbackInfo.env = env;
1330 callbackInfo.napiAsyncTask = napiAsyncTask;
1331 AbilityProcess::GetInstance()->RequestPermissionsFromUser(ability_, permissionParam, callbackInfo);
1332 }
1333
1334 return result;
1335 }
1336
OnGetBundleName(napi_env env,napi_callback_info info)1337 napi_value NapiJsContext::OnGetBundleName(napi_env env, napi_callback_info info)
1338 {
1339 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1340 size_t argc = ARGS_MAX_COUNT;
1341 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1342 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1343 if (argc > ARGS_ONE) {
1344 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1345 return CreateJsNull(env);
1346 }
1347
1348 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1349 std::shared_ptr<JsBundleName> bundleName = std::make_shared<JsBundleName>();
1350 auto execute = [obj = this, name = bundleName, value = errorVal] () {
1351 if (obj->ability_ == nullptr) {
1352 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1353 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1354 return;
1355 }
1356 if (name == nullptr) {
1357 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1358 TAG_LOGE(AAFwkTag::JSNAPI, "null name");
1359 return;
1360 }
1361 name->name = obj->ability_->GetBundleName();
1362 };
1363 auto complete = [obj = this, name = bundleName, value = errorVal]
1364 (napi_env env, NapiAsyncTask &task, int32_t status) {
1365 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
1366 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1367 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1368 TAG_LOGD(AAFwkTag::JSNAPI, "task execute error, name is nullptr or NAPI_ERR_ABILITY_CALL_INVALID");
1369 return;
1370 }
1371 task.Resolve(env, CreateJsValue(env, name->name));
1372 };
1373
1374 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1375 napi_value result = nullptr;
1376 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetBundleName",
1377 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1378
1379 return result;
1380 }
1381
OnVerifyPermission(napi_env env,napi_callback_info info)1382 napi_value NapiJsContext::OnVerifyPermission(napi_env env, napi_callback_info info)
1383 {
1384 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1385 size_t argc = ARGS_MAX_COUNT;
1386 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1387 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1388 if (argc == ARGS_ZERO || argc > ARGS_THREE) {
1389 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1390 return CreateJsNull(env);
1391 }
1392
1393 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1394 std::string permission("");
1395 if (!ConvertFromJsValue(env, argv[PARAM0], permission)) {
1396 TAG_LOGE(AAFwkTag::JSNAPI, "input params string error");
1397 return CreateJsNull(env);
1398 }
1399 JsPermissionOptions options;
1400 bool flagCall = UnwrapVerifyPermissionParams(env, info, options);
1401 auto execute = [obj = this, permission, options, value = errorVal] () {
1402 if (obj->ability_ == nullptr) {
1403 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1404 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1405 return;
1406 }
1407 if (options.uidFlag) {
1408 *value = obj->ability_->VerifyPermission(permission, options.pid, options.uid);
1409 } else {
1410 *value = obj->ability_->VerifySelfPermission(permission);
1411 }
1412 };
1413 auto complete = [obj = this, value = errorVal] (napi_env env, NapiAsyncTask &task, int32_t status) {
1414 if (*value == static_cast<int32_t>(NAPI_ERR_ACE_ABILITY)) {
1415 task.Reject(env, CreateJsError(env, *value, obj->ConvertErrorCode(*value)));
1416 return;
1417 }
1418 task.Resolve(env, CreateJsValue(env, *value));
1419 };
1420
1421 auto callback = flagCall ? ((argc == ARGS_TWO) ? argv[PARAM1] : argv[PARAM2]) : nullptr;
1422 napi_value result = nullptr;
1423 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetBundleName",
1424 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1425
1426 return result;
1427 }
1428
OnGetApplicationInfo(napi_env env,napi_callback_info info)1429 napi_value NapiJsContext::OnGetApplicationInfo(napi_env env, napi_callback_info info)
1430 {
1431 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1432 size_t argc = ARGS_MAX_COUNT;
1433 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1434 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1435 if (argc > ARGS_ONE) {
1436 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1437 return CreateJsUndefined(env);
1438 }
1439
1440 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1441 std::shared_ptr<JsApplicationInfo> infoData = std::make_shared<JsApplicationInfo>();
1442 auto execute = [obj = this, info = infoData, value = errorVal] () {
1443 if (obj->ability_ == nullptr) {
1444 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1445 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1446 return;
1447 }
1448 auto getInfo = obj->ability_->GetApplicationInfo();
1449 if (getInfo != nullptr && info != nullptr) {
1450 info->appInfo = *getInfo;
1451 } else {
1452 TAG_LOGE(AAFwkTag::JSNAPI, "GetApplicationInfo return nullptr");
1453 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1454 }
1455 };
1456 auto complete = [obj = this, info = infoData, value = errorVal]
1457 (napi_env env, NapiAsyncTask &task, int32_t status) {
1458 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
1459 TAG_LOGD(AAFwkTag::JSNAPI, "errorVal is 0 or JsHapModuleInfo is null");
1460 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1461 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1462 return;
1463 }
1464 task.Resolve(env, obj->CreateAppInfo(env, info->appInfo));
1465 };
1466
1467 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1468 napi_value result = nullptr;
1469 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetApplicationInfo",
1470 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1471
1472 return result;
1473 }
1474
OnGetProcessInfo(napi_env env,napi_callback_info info)1475 napi_value NapiJsContext::OnGetProcessInfo(napi_env env, napi_callback_info info)
1476 {
1477 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1478 size_t argc = ARGS_MAX_COUNT;
1479 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1480 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1481 if (argc > ARGS_ONE) {
1482 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1483 return CreateJsUndefined(env);
1484 }
1485
1486 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1487 std::shared_ptr<JsProcessInfo> processInfo = std::make_shared<JsProcessInfo>();
1488 auto execute = [obj = this, data = processInfo, value = errorVal] () {
1489 if (obj->ability_ == nullptr) {
1490 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1491 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1492 return;
1493 }
1494 auto getInfo = obj->ability_->GetProcessInfo();
1495 if (getInfo != nullptr && data != nullptr) {
1496 data->processName = getInfo->GetProcessName();
1497 data->pid = getInfo->GetPid();
1498 } else {
1499 TAG_LOGE(AAFwkTag::JSNAPI, "GetProcessInfo return nullptr");
1500 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1501 }
1502 };
1503 auto complete = [obj = this, info = processInfo, value = errorVal]
1504 (napi_env env, NapiAsyncTask &task, int32_t status) {
1505 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
1506 auto ecode = info == nullptr ? (NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1507 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1508 return;
1509 }
1510 task.Resolve(env, obj->CreateProcessInfo(env, info));
1511 };
1512
1513 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1514 napi_value result = nullptr;
1515 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetProcessInfo",
1516 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1517
1518 return result;
1519 }
1520
OnGetElementName(napi_env env,napi_callback_info info)1521 napi_value NapiJsContext::OnGetElementName(napi_env env, napi_callback_info info)
1522 {
1523 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1524 size_t argc = ARGS_MAX_COUNT;
1525 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1526 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1527 if (argc > ARGS_ONE) {
1528 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1529 return CreateJsUndefined(env);
1530 }
1531
1532 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1533 std::shared_ptr<JsElementName> elementName = std::make_shared<JsElementName>();
1534 auto execute = [obj = this, data = elementName, value = errorVal] () {
1535 if (obj->ability_ == nullptr) {
1536 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1537 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1538 return;
1539 }
1540 auto elementName = obj->ability_->GetElementName();
1541 if (elementName != nullptr && data != nullptr) {
1542 data->deviceId = elementName->GetDeviceID();
1543 data->bundleName = elementName->GetBundleName();
1544 data->abilityName = elementName->GetAbilityName();
1545 data->uri = obj->ability_->GetWant()->GetUriString();
1546 data->shortName = "";
1547 } else {
1548 TAG_LOGE(AAFwkTag::JSNAPI, "GetElementName return nullptr");
1549 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1550 }
1551 };
1552 auto complete = [obj = this, ename = elementName, value = errorVal]
1553 (napi_env env, NapiAsyncTask &task, int32_t status) {
1554 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || ename == nullptr) {
1555 auto ecode = ename == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1556 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1557 return;
1558 }
1559 task.Resolve(env, obj->CreateElementName(env, ename));
1560 };
1561
1562 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1563 napi_value result = nullptr;
1564 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetElementName",
1565 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1566
1567 return result;
1568 }
1569
OnGetProcessName(napi_env env,napi_callback_info info)1570 napi_value NapiJsContext::OnGetProcessName(napi_env env, napi_callback_info info)
1571 {
1572 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1573 size_t argc = ARGS_MAX_COUNT;
1574 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1575 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1576 if (argc > ARGS_ONE) {
1577 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1578 return CreateJsUndefined(env);
1579 }
1580
1581 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1582 std::shared_ptr<JsProcessName> processName = std::make_shared<JsProcessName>();
1583 auto execute = [obj = this, name = processName, value = errorVal] () {
1584 if (obj->ability_ == nullptr) {
1585 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1586 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1587 return;
1588 }
1589 if (name == nullptr) {
1590 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1591 TAG_LOGE(AAFwkTag::JSNAPI, "null name");
1592 return;
1593 }
1594 name->name = obj->ability_->GetProcessName();
1595 };
1596 auto complete = [obj = this, name = processName, value = errorVal]
1597 (napi_env env, NapiAsyncTask &task, int32_t status) {
1598 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
1599 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1600 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1601 TAG_LOGD(AAFwkTag::JSNAPI, "task execute error, name is nullptr or NAPI_ERR_ABILITY_CALL_INVALID");
1602 return;
1603 }
1604 task.Resolve(env, CreateJsValue(env, name->name));
1605 };
1606
1607 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1608 napi_value result = nullptr;
1609 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetProcessName",
1610 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1611
1612 return result;
1613 }
1614
OnGetCallingBundle(napi_env env,napi_callback_info info)1615 napi_value NapiJsContext::OnGetCallingBundle(napi_env env, napi_callback_info info)
1616 {
1617 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1618 size_t argc = ARGS_MAX_COUNT;
1619 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1620 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1621 if (argc > ARGS_ONE) {
1622 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1623 return CreateJsUndefined(env);
1624 }
1625
1626 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1627 std::shared_ptr<JsCallingBundleName> callingBundleName = std::make_shared<JsCallingBundleName>();
1628 auto execute = [obj = this, name = callingBundleName, value = errorVal] () {
1629 if (obj->ability_ == nullptr) {
1630 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1631 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1632 return;
1633 }
1634 if (name == nullptr) {
1635 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1636 TAG_LOGE(AAFwkTag::JSNAPI, "null name");
1637 return;
1638 }
1639 name->name = obj->ability_->GetCallingBundle();
1640 };
1641 auto complete = [obj = this, name = callingBundleName, value = errorVal]
1642 (napi_env env, NapiAsyncTask &task, int32_t status) {
1643 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || name == nullptr) {
1644 auto ecode = name == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1645 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1646 return;
1647 }
1648 task.Resolve(env, CreateJsValue(env, name->name));
1649 };
1650
1651 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1652 napi_value result = nullptr;
1653 NapiAsyncTask::ScheduleHighQos("NapiJsContext::OnGetCallingBundle",
1654 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1655
1656 return result;
1657 }
1658
OnGetOrCreateLocalDir(napi_env env,napi_callback_info info)1659 napi_value NapiJsContext::OnGetOrCreateLocalDir(napi_env env, napi_callback_info info)
1660 {
1661 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1662 size_t argc = ARGS_MAX_COUNT;
1663 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1664 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1665 if (argc > ARGS_ONE) {
1666 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1667 return CreateJsUndefined(env);
1668 }
1669
1670 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1671 std::shared_ptr<JsOrCreateLocalDir> createDir = std::make_shared<JsOrCreateLocalDir>();
1672 auto execute = [obj = this, dir = createDir, value = errorVal] () {
1673 if (obj->ability_ == nullptr) {
1674 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
1675 TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1676 return;
1677 }
1678 auto context = obj->ability_->GetAbilityContext();
1679 if (context == nullptr || dir == nullptr) {
1680 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
1681 TAG_LOGE(AAFwkTag::JSNAPI, "null context or dir");
1682 return;
1683 }
1684 dir->name = context->GetBaseDir();
1685 if (!OHOS::FileExists(dir->name)) {
1686 TAG_LOGI(AAFwkTag::JSNAPI, "create dir");
1687 OHOS::ForceCreateDirectory(dir->name);
1688 OHOS::ChangeModeDirectory(dir->name, MODE);
1689 }
1690 };
1691 auto complete = [obj = this, dir = createDir, value = errorVal]
1692 (napi_env env, NapiAsyncTask &task, int32_t status) {
1693 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || dir == nullptr) {
1694 TAG_LOGD(AAFwkTag::JSNAPI, "errorVal is error or JsCacheDir is nullptr");
1695 auto ecode = dir == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
1696 task.Reject(env, CreateJsError(env, ecode, obj->ConvertErrorCode(ecode)));
1697 return;
1698 }
1699 task.Resolve(env, CreateJsValue(env, dir->name));
1700 };
1701 auto callback = argc == ARGS_ZERO ? nullptr : argv[PARAM0];
1702 napi_value result = nullptr;
1703 NapiAsyncTask::Schedule("NapiJsContext::OnGetOrCreateLocalDir",
1704 env, CreateAsyncTaskWithLastParam(env, callback, std::move(execute), std::move(complete), &result));
1705
1706 return result;
1707 }
1708
OnSetShowOnLockScreen(napi_env env,napi_callback_info info)1709 napi_value NapiJsContext::OnSetShowOnLockScreen(napi_env env, napi_callback_info info)
1710 {
1711 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1712 size_t argc = ARGS_MAX_COUNT;
1713 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1714 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1715 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
1716 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1717 return CreateJsUndefined(env);
1718 }
1719
1720 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
1721 bool isShow = false;
1722 if (!ConvertFromJsValue(env, argv[PARAM0], isShow)) {
1723 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
1724 return CreateJsUndefined(env);
1725 }
1726 auto complete = [obj = this, isShow, value = errorVal]
1727 (napi_env env, NapiAsyncTask &task, int32_t status) {
1728 if (obj->ability_ == nullptr) {
1729 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
1730 return;
1731 }
1732 #ifdef SUPPORT_SCREEN
1733 obj->ability_->SetShowOnLockScreen(isShow);
1734 #endif
1735 task.Resolve(env, CreateJsUndefined(env));
1736 };
1737
1738 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
1739 napi_value result = nullptr;
1740 NapiAsyncTask::Schedule("NapiJsContext::OnSetShowOnLockScreen",
1741 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
1742
1743 return result;
1744 }
1745
OnSetWakeUpScreen(napi_env env,napi_callback_info info)1746 napi_value NapiJsContext::OnSetWakeUpScreen(napi_env env, napi_callback_info info)
1747 {
1748 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1749 size_t argc = ARGS_MAX_COUNT;
1750 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1751 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1752 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
1753 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1754 return CreateJsUndefined(env);
1755 }
1756
1757 bool wakeUp = false;
1758 if (!ConvertFromJsValue(env, argv[PARAM0], wakeUp)) {
1759 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
1760 return CreateJsUndefined(env);
1761 }
1762 auto complete = [obj = this, wakeUp]
1763 (napi_env env, NapiAsyncTask &task, int32_t status) {
1764 if (obj->ability_ == nullptr) {
1765 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
1766 return;
1767 }
1768 #ifdef SUPPORT_SCREEN
1769 obj->ability_->SetWakeUpScreen(wakeUp);
1770 #endif
1771 task.Resolve(env, CreateJsUndefined(env));
1772 };
1773
1774 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
1775 napi_value result = nullptr;
1776 NapiAsyncTask::Schedule("NapiJsContext::OnSetWakeUpScreen",
1777 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
1778
1779 return result;
1780 }
1781
OnSetDisplayOrientation(napi_env env,napi_callback_info info)1782 napi_value NapiJsContext::OnSetDisplayOrientation(napi_env env, napi_callback_info info)
1783 {
1784 TAG_LOGD(AAFwkTag::JSNAPI, "called");
1785 size_t argc = ARGS_MAX_COUNT;
1786 napi_value argv[ARGS_MAX_COUNT] = {nullptr};
1787 napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
1788 if (argc == ARGS_ZERO || argc > ARGS_TWO) {
1789 TAG_LOGE(AAFwkTag::JSNAPI, "input params count error, argc=%{public}zu", argc);
1790 return CreateJsUndefined(env);
1791 }
1792
1793 int32_t orientation = 0;
1794 if (!ConvertFromJsValue(env, argv[PARAM0], orientation)) {
1795 TAG_LOGE(AAFwkTag::JSNAPI, "input params int error");
1796 return CreateJsUndefined(env);
1797 }
1798
1799 int32_t maxRange = 3;
1800 if (orientation < 0 || orientation > maxRange) {
1801 TAG_LOGE(AAFwkTag::JSNAPI, "wrong parameter orientation : %{public}d", orientation);
1802 return CreateJsNull(env);
1803 }
1804 auto complete = [obj = this, orientationData = orientation]
1805 (napi_env env, NapiAsyncTask &task, int32_t status) {
1806 if (obj->ability_ == nullptr) {
1807 task.Reject(env, CreateJsError(env, static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), "get ability error"));
1808 return;
1809 }
1810 #ifdef SUPPORT_SCREEN
1811 obj->ability_->SetDisplayOrientation(orientationData);
1812 #endif
1813 task.Resolve(env, CreateJsUndefined(env));
1814 };
1815
1816 auto callback = argc == ARGS_ONE ? nullptr : argv[PARAM1];
1817 napi_value result = nullptr;
1818 NapiAsyncTask::ScheduleHighQos("NapiJsContext::SetDisplayOrientation",
1819 env, CreateAsyncTaskWithLastParam(env, callback, nullptr, std::move(complete), &result));
1820
1821 return result;
1822 }
1823 } // namespace AppExecFwk
1824 } // namespace OHOS
1825