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_form_host.h"
17
18 #include <cinttypes>
19 #include <regex>
20 #include <uv.h>
21 #include <vector>
22
23 #include "form_info.h"
24 #include "form_callback_interface.h"
25 #include "form_host_client.h"
26 #include "hilog_wrapper.h"
27 #include "napi_form_util.h"
28 #include "napi/native_api.h"
29 #include "napi/native_node_api.h"
30 #include "napi_common_util.h"
31 #include "napi_common_want.h"
32 #include "runtime.h"
33
34 using namespace OHOS;
35 using namespace OHOS::AAFwk;
36 using namespace OHOS::AppExecFwk;
37
38 namespace {
39 constexpr size_t ARGS_SIZE_ZERO = 0;
40 constexpr size_t ARGS_SIZE_ONE = 1;
41 constexpr size_t ARGS_SIZE_TWO = 2;
42 constexpr size_t ARGS_SIZE_THREE = 3;
43 constexpr int REF_COUNT = 1;
44 constexpr int CALLBACK_FLG = 1;
45 constexpr int PROMISE_FLG = 2;
46 OHOS::AppExecFwk::Ability* g_ability = nullptr;
47 }
48
49 /**
50 * @brief GetGlobalAbility
51 *
52 * @param[in] env The environment that the Node-API call is invoked under
53 *
54 * @return OHOS::AppExecFwk::Ability*
55 */
GetGlobalAbility(napi_env env)56 static OHOS::AppExecFwk::Ability* GetGlobalAbility(napi_env env)
57 {
58 // get global value
59 napi_value global = nullptr;
60 napi_get_global(env, &global);
61
62 // get ability
63 napi_value abilityObj = nullptr;
64 napi_get_named_property(env, global, "ability", &abilityObj);
65
66 // get ability pointer
67 OHOS::AppExecFwk::Ability* ability = nullptr;
68 napi_get_value_external(env, abilityObj, (void**)&ability);
69 HILOG_INFO("%{public}s, ability = [%{public}p]", __func__, ability);
70 if (ability == nullptr) {
71 if (g_ability == nullptr) {
72 std::unique_ptr<AbilityRuntime::Runtime> runtime;
73 g_ability = OHOS::AppExecFwk::Ability::Create(runtime);
74 }
75 ability = g_ability;
76 HILOG_INFO("%{public}s, Use Local tmp Ability for Stage Module", __func__);
77 }
78 return ability;
79 }
80
81 /**
82 * @brief Get a C++ string value from Node-API
83 *
84 * @param[in] env The environment that the Node-API call is invoked under
85 * @param[in] value This is an opaque pointer that is used to represent a JavaScript value
86 *
87 * @return Return a C++ string
88 */
GetStringFromNAPI(napi_env env,napi_value value)89 static std::string GetStringFromNAPI(napi_env env, napi_value value)
90 {
91 std::string result;
92 size_t size = 0;
93
94 if (napi_get_value_string_utf8(env, value, nullptr, 0, &size) != napi_ok) {
95 HILOG_ERROR("%{public}s, can not get string size", __func__);
96 return "";
97 }
98 result.reserve(size + 1);
99 result.resize(size);
100 if (napi_get_value_string_utf8(env, value, result.data(), (size + 1), &size) != napi_ok) {
101 HILOG_ERROR("%{public}s, can not get string value", __func__);
102 return "";
103 }
104 return result;
105 }
106
GetFormIds(napi_env env,napi_value value,ErrCode & errCode,std::vector<int64_t> & formIds)107 static napi_value GetFormIds(napi_env env, napi_value value, ErrCode &errCode, std::vector<int64_t> &formIds)
108 {
109 errCode = ERR_INVALID_VALUE;
110
111 bool isArray;
112 NAPI_CALL(env, napi_is_array(env, value, &isArray));
113 if (!isArray) {
114 errCode = ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR;
115 return nullptr;
116 }
117
118 uint32_t arrayLength = 0;
119 NAPI_CALL(env, napi_get_array_length(env, value, &arrayLength));
120
121 for (size_t i = 0; i < arrayLength; i++) {
122 napi_value napiFormId;
123 napi_get_element(env, value, i, &napiFormId);
124
125 // Check the value type of the arguments
126 napi_valuetype valueType = napi_undefined;
127 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
128 if (valueType != napi_string) {
129 errCode = ERR_APPEXECFWK_FORM_INVALID_FORM_ID;
130 return nullptr;
131 }
132
133 std::string strFormId = GetStringFromNAPI(env, napiFormId);
134 int64_t formIdValue;
135 if (!ConvertStringToInt64(strFormId, formIdValue)) {
136 errCode = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR;
137 return nullptr;
138 }
139
140 formIds.push_back(formIdValue);
141 }
142
143 errCode = ERR_OK;
144 return nullptr;
145 }
146
147 /**
148 * @brief Parse form info into Node-API
149 *
150 * @param[in] env The environment that the Node-API call is invoked under
151 * @param[in] formInfo it is used for return forminfo to JavaScript
152 * @param[out] result This is an opaque pointer that is used to represent a JavaScript value
153 *
154 * @return void
155 */
ParseFormInfoIntoNapi(napi_env env,const FormInfo & formInfo,napi_value & result)156 static void ParseFormInfoIntoNapi(napi_env env, const FormInfo &formInfo, napi_value &result)
157 {
158 // bundleName
159 napi_value bundleName;
160 napi_create_string_utf8(env, formInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName);
161 HILOG_DEBUG("%{public}s, bundleName=%{public}s.", __func__, formInfo.bundleName.c_str());
162 napi_set_named_property(env, result, "bundleName", bundleName);
163
164 // moduleName
165 napi_value moduleName;
166 napi_create_string_utf8(env, formInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName);
167 HILOG_DEBUG("%{public}s, moduleName=%{public}s.", __func__, formInfo.moduleName.c_str());
168 napi_set_named_property(env, result, "moduleName", moduleName);
169
170 // abilityName
171 napi_value abilityName;
172 napi_create_string_utf8(env, formInfo.abilityName.c_str(), NAPI_AUTO_LENGTH, &abilityName);
173 HILOG_DEBUG("%{public}s, abilityName=%{public}s.", __func__, formInfo.abilityName.c_str());
174 napi_set_named_property(env, result, "abilityName", abilityName);
175
176 // name
177 napi_value name;
178 napi_create_string_utf8(env, formInfo.name.c_str(), NAPI_AUTO_LENGTH, &name);
179 HILOG_DEBUG("%{public}s, name=%{public}s.", __func__, formInfo.name.c_str());
180 napi_set_named_property(env, result, "name", name);
181
182 // description
183 napi_value description;
184 napi_create_string_utf8(env, formInfo.description.c_str(), NAPI_AUTO_LENGTH, &description);
185 HILOG_DEBUG("%{public}s, description=%{public}s.", __func__, formInfo.description.c_str());
186 napi_set_named_property(env, result, "description", description);
187
188 // descriptionId
189 napi_value descriptionId;
190 napi_create_int32(env, formInfo.descriptionId, &descriptionId);
191 HILOG_DEBUG("%{public}s, descriptionId=%{public}d.", __func__, formInfo.descriptionId);
192 napi_set_named_property(env, result, "descriptionId", descriptionId);
193
194 // type
195 napi_value type;
196 FormType formType = formInfo.type;
197 napi_create_int32(env, (int32_t)formType, &type);
198 HILOG_DEBUG("%{public}s, formInfo_type=%{public}d.", __func__, (int32_t)formType);
199 napi_set_named_property(env, result, "type", type);
200
201 // jsComponentName
202 napi_value jsComponentName;
203 napi_create_string_utf8(env, formInfo.jsComponentName.c_str(), NAPI_AUTO_LENGTH, &jsComponentName);
204 HILOG_DEBUG("%{public}s, jsComponentName=%{public}s.", __func__, formInfo.jsComponentName.c_str());
205 napi_set_named_property(env, result, "jsComponentName", jsComponentName);
206
207 // colorMode
208 napi_value colorMode;
209 FormsColorMode formsColorMode = formInfo.colorMode;
210 napi_create_int32(env, (int32_t)formsColorMode, &colorMode);
211 HILOG_DEBUG("%{public}s, formInfo_type=%{public}d.", __func__, (int32_t)formsColorMode);
212 napi_set_named_property(env, result, "colorMode", colorMode);
213
214 // defaultFlag
215 napi_value defaultFlag;
216 napi_create_int32(env, (int32_t)formInfo.defaultFlag, &defaultFlag);
217 HILOG_DEBUG("%{public}s, defaultFlag=%{public}d.", __func__, formInfo.defaultFlag);
218 napi_set_named_property(env, result, "isDefault", defaultFlag);
219
220 // updateEnabled
221 napi_value updateEnabled;
222 napi_create_int32(env, (int32_t)formInfo.updateEnabled, &updateEnabled);
223 HILOG_DEBUG("%{public}s, updateEnabled=%{public}d.", __func__, formInfo.updateEnabled);
224 napi_set_named_property(env, result, "updateEnabled", updateEnabled);
225
226 // formVisibleNotify
227 napi_value formVisibleNotify;
228 napi_create_int32(env, (int32_t)formInfo.formVisibleNotify, &formVisibleNotify);
229 HILOG_DEBUG("%{public}s, formVisibleNotify=%{public}d.", __func__, formInfo.formVisibleNotify);
230 napi_set_named_property(env, result, "formVisibleNotify", formVisibleNotify);
231
232 // formConfigAbility
233 napi_value formConfigAbility;
234 napi_create_string_utf8(env, formInfo.formConfigAbility.c_str(), NAPI_AUTO_LENGTH, &formConfigAbility);
235 HILOG_DEBUG("%{public}s, formConfigAbility=%{public}s.", __func__, formInfo.formConfigAbility.c_str());
236 napi_set_named_property(env, result, "formConfigAbility", formConfigAbility);
237
238 // updateDuration
239 napi_value updateDuration;
240 napi_create_int32(env, formInfo.updateDuration, &updateDuration);
241 HILOG_DEBUG("%{public}s, updateDuration=%{public}d.", __func__, formInfo.updateDuration);
242 napi_set_named_property(env, result, "updateDuration", updateDuration);
243
244 // scheduledUpdateTime
245 napi_value scheduledUpdateTime;
246 napi_create_string_utf8(env, formInfo.scheduledUpdateTime.c_str(), NAPI_AUTO_LENGTH, &scheduledUpdateTime);
247 HILOG_DEBUG("%{public}s, scheduledUpdateTime=%{public}s.", __func__, formInfo.scheduledUpdateTime.c_str());
248 napi_set_named_property(env, result, "scheduledUpdateTime", scheduledUpdateTime);
249
250 // defaultDimension
251 napi_value defaultDimension;
252 napi_create_int32(env, formInfo.defaultDimension, &defaultDimension);
253 HILOG_DEBUG("%{public}s, defaultDimension=%{public}d.", __func__, formInfo.defaultDimension);
254 napi_set_named_property(env, result, "defaultDimension", defaultDimension);
255
256 // supportDimensions
257 napi_value supportDimensions;
258 napi_create_array(env, &supportDimensions);
259 int iDimensionsCount = 0;
260 for (auto dimension : formInfo.supportDimensions) {
261 HILOG_DEBUG("%{public}s, dimension=%{public}d.", __func__, dimension);
262 napi_value dimensionInfo;
263 napi_create_int32(env, (int32_t)dimension, &dimensionInfo);
264 napi_set_element(env, supportDimensions, iDimensionsCount, dimensionInfo);
265 ++iDimensionsCount;
266 }
267 HILOG_DEBUG("%{public}s, supportDimensions size=%{public}zu.", __func__, formInfo.supportDimensions.size());
268 napi_set_named_property(env, result, "supportDimensions", supportDimensions);
269
270 // metaData
271 napi_value metaData;
272 napi_create_object(env, &metaData);
273
274 // metaData: customizeDatas
275 napi_value customizeDatas;
276 napi_create_array(env, &customizeDatas);
277 int iCustomizeDatasCount = 0;
278 for (auto customizeData : formInfo.customizeDatas) {
279 napi_value customizeDataOnject = nullptr;
280 napi_create_object(env, &customizeDataOnject);
281
282 // customizeData : name
283 napi_value customizeDataName;
284 napi_create_string_utf8(env, customizeData.name.c_str(), NAPI_AUTO_LENGTH, &customizeDataName);
285 HILOG_DEBUG("%{public}s, customizeData.name=%{public}s.", __func__, customizeData.name.c_str());
286 napi_set_named_property(env, customizeDataOnject, "name", customizeDataName);
287
288 // customizeData : value
289 napi_value customizeDataValue;
290 napi_create_string_utf8(env, customizeData.value.c_str(), NAPI_AUTO_LENGTH, &customizeDataValue);
291 HILOG_DEBUG("%{public}s, customizeData.value=%{public}s.", __func__, customizeData.value.c_str());
292 napi_set_named_property(env, customizeDataOnject, "value", customizeDataValue);
293
294 napi_set_element(env, customizeDatas, iCustomizeDatasCount, customizeDataOnject);
295 ++iDimensionsCount;
296 }
297 HILOG_DEBUG("%{public}s, customizeDatas size=%{public}zu.", __func__, formInfo.customizeDatas.size());
298 napi_set_named_property(env, metaData, "customizeData", customizeDatas);
299 napi_set_named_property(env, result, "metaData", metaData);
300
301 return;
302 }
303
InitErrMsg(napi_env env,int32_t code,int32_t type,napi_value callbackValue)304 static AsyncErrMsgCallbackInfo *InitErrMsg(napi_env env, int32_t code, int32_t type, napi_value callbackValue)
305 {
306 auto *asyncErrorInfo = new AsyncErrMsgCallbackInfo {
307 .env = env,
308 .asyncWork = nullptr,
309 .deferred = nullptr,
310 .callback = nullptr,
311 .callbackValue = callbackValue,
312 .code = code,
313 .type = type
314 };
315 return asyncErrorInfo;
316 }
317
318 /**
319 * @brief Call native kit function: DeleteForm
320 *
321 * @param[in] env The environment that the Node-API call is invoked under
322 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
323 *
324 * @return void
325 */
InnerDelForm(napi_env env,AsyncDelFormCallbackInfo * const asyncCallbackInfo)326 static void InnerDelForm(napi_env env, AsyncDelFormCallbackInfo* const asyncCallbackInfo)
327 {
328 HILOG_DEBUG("%{public}s called.", __func__);
329 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
330 ErrCode ret = ability->DeleteForm(asyncCallbackInfo->formId);
331 asyncCallbackInfo->result = ret;
332 HILOG_DEBUG("%{public}s, end", __func__);
333 }
334
335 /**
336 * @brief The implementation of Node-API interface: deleteForm
337 *
338 * @param[in] env The environment that the Node-API call is invoked under
339 * @param[out] info An opaque datatype that is passed to a callback function
340 *
341 * @return This is an opaque pointer that is used to represent a JavaScript value
342 */
NAPI_DeleteForm(napi_env env,napi_callback_info info)343 napi_value NAPI_DeleteForm(napi_env env, napi_callback_info info)
344 {
345 HILOG_INFO("%{public}s called.", __func__);
346
347 // Check the number of the arguments
348 size_t argc = ARGS_SIZE_TWO;
349 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
350 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
351 if (argc > ARGS_SIZE_TWO) {
352 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
353 return nullptr;
354 }
355 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
356
357 // Check the value type of the arguments
358 napi_valuetype valueType;
359 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
360 if (valueType != napi_string) {
361 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
362 AsyncErrMsgCallbackInfo {
363 .env = env,
364 .asyncWork = nullptr,
365 .deferred = nullptr,
366 .callback = nullptr,
367 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
368 .type = 0,
369 .callbackValue = argv[1]
370 };
371
372 if (argc == ARGS_SIZE_TWO) {
373 asyncErrorInfo->type = CALLBACK_FLG;
374 } else {
375 asyncErrorInfo->type = PROMISE_FLG;
376 }
377 return RetErrMsg(asyncErrorInfo);
378 }
379
380 std::string strFormId = GetStringFromNAPI(env, argv[0]);
381 int64_t formId;
382 HILOG_ERROR("%{public}s, form id ", strFormId.c_str());
383 if (!ConvertStringToInt64(strFormId, formId)) {
384 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
385 AsyncErrMsgCallbackInfo {
386 .env = env,
387 .asyncWork = nullptr,
388 .deferred = nullptr,
389 .callback = nullptr,
390 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
391 .type = 0,
392 .callbackValue = argv[1]
393 };
394
395 if (argc == ARGS_SIZE_TWO) {
396 asyncErrorInfo->type = CALLBACK_FLG;
397 } else {
398 asyncErrorInfo->type = PROMISE_FLG;
399 }
400 return RetErrMsg(asyncErrorInfo);
401 }
402
403 AsyncDelFormCallbackInfo *asyncCallbackInfo = new
404 AsyncDelFormCallbackInfo {
405 .env = env,
406 .ability = GetGlobalAbility(env),
407 .asyncWork = nullptr,
408 .deferred = nullptr,
409 .callback = nullptr,
410 .formId = 0,
411 .result = 0,
412 };
413 asyncCallbackInfo->formId = formId;
414
415 if (argc == ARGS_SIZE_TWO) {
416 HILOG_INFO("%{public}s, asyncCallback.", __func__);
417
418 // Check the value type of the arguments
419 valueType = napi_undefined;
420 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
421 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of deleteForm is incorrect, "
422 "expected type is function.");
423
424 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
425
426 napi_value resourceName;
427 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
428 napi_create_async_work(
429 env,
430 nullptr,
431 resourceName,
432 [](napi_env env, void *data) {
433 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
434 AsyncDelFormCallbackInfo *asyncCallbackInfo = (AsyncDelFormCallbackInfo *)data;
435 InnerDelForm(env, asyncCallbackInfo);
436 },
437 [](napi_env env, napi_status status, void *data) {
438 AsyncDelFormCallbackInfo *asyncCallbackInfo = (AsyncDelFormCallbackInfo *)data;
439 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
440
441 if (asyncCallbackInfo->callback != nullptr) {
442 napi_value result[ARGS_SIZE_TWO] = {0};
443 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
444 napi_value callback;
445 napi_value undefined;
446 napi_get_undefined(env, &undefined);
447 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
448 napi_value callResult;
449 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
450 napi_delete_reference(env, asyncCallbackInfo->callback);
451 }
452 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
453 delete asyncCallbackInfo;
454 },
455 (void *)asyncCallbackInfo,
456 &asyncCallbackInfo->asyncWork);
457 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
458 return NapiGetResut(env, 1);
459 } else {
460 HILOG_INFO("%{public}s, promise.", __func__);
461 napi_deferred deferred;
462 napi_value promise;
463 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
464 asyncCallbackInfo->deferred = deferred;
465
466 napi_value resourceName;
467 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
468 napi_create_async_work(
469 env,
470 nullptr,
471 resourceName,
472 [](napi_env env, void *data) {
473 HILOG_INFO("%{public}s, promise running", __func__);
474 AsyncDelFormCallbackInfo *asyncCallbackInfo = (AsyncDelFormCallbackInfo *)data;
475 InnerDelForm(env, asyncCallbackInfo);
476 },
477 [](napi_env env, napi_status status, void *data) {
478 HILOG_INFO("%{public}s, promise complete", __func__);
479 AsyncDelFormCallbackInfo *asyncCallbackInfo = (AsyncDelFormCallbackInfo *)data;
480
481 napi_value result;
482 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
483 if (asyncCallbackInfo->result == ERR_OK) {
484 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
485 } else {
486 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
487 }
488 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
489 delete asyncCallbackInfo;
490 },
491 (void *)asyncCallbackInfo,
492 &asyncCallbackInfo->asyncWork);
493 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
494 return promise;
495 }
496 }
497
498 /**
499 * @brief Call native kit function: ReleaseForm
500 *
501 * @param[in] env The environment that the Node-API call is invoked under
502 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
503 *
504 * @return void
505 */
InnerReleaseForm(napi_env env,AsyncReleaseFormCallbackInfo * const asyncCallbackInfo)506 static void InnerReleaseForm(napi_env env, AsyncReleaseFormCallbackInfo* const asyncCallbackInfo)
507 {
508 HILOG_DEBUG("%{public}s called.", __func__);
509 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
510 ErrCode ret = ability->ReleaseForm(asyncCallbackInfo->formId, asyncCallbackInfo->isReleaseCache);
511 asyncCallbackInfo->result = ret;
512 HILOG_DEBUG("%{public}s end", __func__);
513 }
514
515 // NAPI_ReleaseForm InnerReleaseForm callback execute
__anon17f5ec840602(napi_env env, void *data) 516 napi_async_execute_callback NAPI_ReleaseFormAsyncExecute = [](napi_env env, void *data) {
517 HILOG_INFO("NAPI_ReleaseForm InnerReleaseForm execute callback");
518 AsyncReleaseFormCallbackInfo *asyncCallbackInfo =
519 (AsyncReleaseFormCallbackInfo *)data;
520 InnerReleaseForm(env, asyncCallbackInfo);
521 };
522
523 // NAPI_ReleaseForm callback complete
__anon17f5ec840702(napi_env env, napi_status status, void *data) 524 napi_async_complete_callback NAPI_ReleaseFormAsyncComplete = [](napi_env env, napi_status status, void *data) {
525 HILOG_INFO("NAPI_ReleaseForm compeleted callback");
526 AsyncReleaseFormCallbackInfo *asyncCallbackInfo =
527 (AsyncReleaseFormCallbackInfo *)data;
528
529 if (asyncCallbackInfo->callback != nullptr) {
530 napi_value result[ARGS_SIZE_TWO] = {0};
531 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
532 napi_value callback;
533 napi_value undefined;
534 napi_get_undefined(env, &undefined);
535 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
536 napi_value callResult;
537 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
538 napi_delete_reference(env, asyncCallbackInfo->callback);
539 }
540 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
541 delete asyncCallbackInfo;
542 };
543
544 // NAPI_ReleaseForm promise Complete
__anon17f5ec840802(napi_env env, napi_status status, void *data) 545 napi_async_complete_callback NAPI_ReleaseFormPromiseComplete = [](napi_env env, napi_status status, void *data) {
546 HILOG_INFO("%{public}s, promise complete", __func__);
547 AsyncReleaseFormCallbackInfo *asyncCallbackInfo = (AsyncReleaseFormCallbackInfo *)data;
548
549 napi_value result;
550 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
551 if (asyncCallbackInfo->result == ERR_OK) {
552 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
553 } else {
554 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
555 }
556 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
557 delete asyncCallbackInfo;
558 };
559
560 // ReleaseForm callback
ReleaseFormCallback(napi_env env,AsyncReleaseFormCallbackInfo * asyncCallbackInfo)561 napi_value ReleaseFormCallback(napi_env env, AsyncReleaseFormCallbackInfo *asyncCallbackInfo)
562 {
563 HILOG_INFO("%{public}s, asyncCallback.", __func__);
564
565 napi_value resourceName;
566 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
567 napi_create_async_work(
568 env,
569 nullptr,
570 resourceName,
571 NAPI_ReleaseFormAsyncExecute,
572 NAPI_ReleaseFormAsyncComplete,
573 (void *)asyncCallbackInfo,
574 &asyncCallbackInfo->asyncWork);
575 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
576 return NapiGetResut(env, 1);
577 }
578
579 // ReleaseForm promise
ReleaseFormPromise(napi_env env,AsyncReleaseFormCallbackInfo * asyncCallbackInfo)580 napi_value ReleaseFormPromise(napi_env env, AsyncReleaseFormCallbackInfo *asyncCallbackInfo)
581 {
582 HILOG_INFO("%{public}s, promise.", __func__);
583 napi_deferred deferred;
584 napi_value promise;
585 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
586 asyncCallbackInfo->deferred = deferred;
587
588 napi_value resourceName;
589 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
590 napi_create_async_work(
591 env,
592 nullptr,
593 resourceName,
594 NAPI_ReleaseFormAsyncExecute,
595 NAPI_ReleaseFormPromiseComplete,
596 (void *)asyncCallbackInfo,
597 &asyncCallbackInfo->asyncWork);
598 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
599 return promise;
600 }
601
602 /**
603 * @brief The implementation of Node-API interface: releaseForm
604 *
605 * @param[in] env The environment that the Node-API call is invoked under
606 * @param[out] info An opaque datatype that is passed to a callback function
607 *
608 * @return This is an opaque pointer that is used to represent a JavaScript value
609 */
NAPI_ReleaseForm(napi_env env,napi_callback_info info)610 napi_value NAPI_ReleaseForm(napi_env env, napi_callback_info info)
611 {
612 HILOG_INFO("%{public}s called.", __func__);
613
614 // Check the number of the arguments
615 size_t argc = ARGS_SIZE_THREE;
616 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
617 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
618 if (argc < ARGS_SIZE_ONE || argc > ARGS_SIZE_THREE) {
619 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
620 return nullptr;
621 }
622 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
623
624 // Check the value type of the arguments
625 napi_valuetype valueType;
626 if (argc == ARGS_SIZE_THREE) {
627 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ONE], &valueType));
628 if (valueType != napi_boolean) {
629 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
630 AsyncErrMsgCallbackInfo {
631 .env = env,
632 .asyncWork = nullptr,
633 .deferred = nullptr,
634 .callback = nullptr,
635 .code = ERR_APPEXECFWK_FORM_RELEASE_FLG_ERR,
636 .type = CALLBACK_FLG,
637 .callbackValue = argv[ARGS_SIZE_TWO]
638 };
639 return RetErrMsg(asyncErrorInfo);
640 }
641 } else if (argc == ARGS_SIZE_TWO) {
642 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ONE], &valueType));
643 if (valueType != napi_function && valueType != napi_boolean) {
644 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
645 AsyncErrMsgCallbackInfo {
646 .env = env,
647 .asyncWork = nullptr,
648 .deferred = nullptr,
649 .callback = nullptr,
650 .code = ERR_APPEXECFWK_FORM_RELEASE_FLG_ERR,
651 .type = PROMISE_FLG,
652 .callbackValue = argv[ARGS_SIZE_ONE]
653 };
654 return RetErrMsg(asyncErrorInfo);
655 }
656 }
657
658 valueType = napi_undefined;
659 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ZERO], &valueType));
660 if (valueType != napi_string) {
661 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
662 AsyncErrMsgCallbackInfo {
663 .env = env,
664 .asyncWork = nullptr,
665 .deferred = nullptr,
666 .callback = nullptr,
667 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
668 .type = 0,
669 .callbackValue = argv[ARGS_SIZE_TWO]
670 };
671
672 if (argc == ARGS_SIZE_ONE) {
673 asyncErrorInfo->type = PROMISE_FLG;
674 } else if (argc == ARGS_SIZE_THREE) {
675 asyncErrorInfo->type = CALLBACK_FLG;
676 asyncErrorInfo->callbackValue = argv[ARGS_SIZE_TWO];
677 } else {
678 valueType = napi_undefined;
679 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
680 if (valueType == napi_function) {
681 asyncErrorInfo->type = CALLBACK_FLG;
682 asyncErrorInfo->callbackValue = argv[1];
683 } else if (valueType == napi_boolean) {
684 asyncErrorInfo->type = PROMISE_FLG;
685 } else {
686 NAPI_ASSERT(env, valueType == napi_function || valueType == napi_boolean,
687 "The arguments[2] type of releaseForm is incorrect,expected type is function or boolean.");
688 }
689 }
690 return RetErrMsg(asyncErrorInfo);
691 }
692
693 std::string strFormId = GetStringFromNAPI(env, argv[ARGS_SIZE_ZERO]);
694 int64_t formId;
695 if (!ConvertStringToInt64(strFormId, formId)) {
696 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
697 AsyncErrMsgCallbackInfo {
698 .env = env,
699 .asyncWork = nullptr,
700 .deferred = nullptr,
701 .callback = nullptr,
702 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
703 .type = 0,
704 .callbackValue = argv[ARGS_SIZE_TWO]
705 };
706
707 if (argc == ARGS_SIZE_ONE) {
708 asyncErrorInfo->type = PROMISE_FLG;
709 } else if (argc == ARGS_SIZE_THREE) {
710 asyncErrorInfo->type = CALLBACK_FLG;
711 asyncErrorInfo->callbackValue = argv[ARGS_SIZE_TWO];
712 } else {
713 valueType = napi_undefined;
714 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
715 if (valueType == napi_function) {
716 asyncErrorInfo->type = CALLBACK_FLG;
717 asyncErrorInfo->callbackValue = argv[1];
718 } else if (valueType == napi_boolean) {
719 asyncErrorInfo->type = PROMISE_FLG;
720 } else {
721 NAPI_ASSERT(env, valueType == napi_function || valueType == napi_boolean,
722 "The arguments[2] type of releaseForm is incorrect,expected type is function or boolean.");
723 }
724 }
725 return RetErrMsg(asyncErrorInfo);
726 }
727
728 AsyncReleaseFormCallbackInfo *asyncCallbackInfo = new
729 AsyncReleaseFormCallbackInfo {
730 .env = env,
731 .ability = GetGlobalAbility(env),
732 .asyncWork = nullptr,
733 .deferred = nullptr,
734 .callback = nullptr,
735 .formId = formId,
736 .isReleaseCache = false,
737 .result = 0,
738 };
739
740 if (argc == ARGS_SIZE_ONE) { // release promise, one argv
741 return ReleaseFormPromise(env, asyncCallbackInfo);
742 } else if (argc == ARGS_SIZE_THREE) { // release callback, three argv
743 HILOG_INFO("%{public}s, asyncCallback.", __func__);
744 valueType = napi_undefined;
745 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
746 NAPI_ASSERT(env, valueType == napi_boolean, "The arguments[1] type of releaseForm is incorrect, "
747 "expected type is boolean.");
748
749 napi_get_value_bool(env, argv[1], &asyncCallbackInfo->isReleaseCache);
750
751 // Check the value type of the arguments
752 valueType = napi_undefined;
753 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valueType));
754 NAPI_ASSERT(env, valueType == napi_function, "The arguments[2] type of releaseForm is incorrect, "
755 "expected type is function.");
756 napi_create_reference(env, argv[ARGS_SIZE_TWO], REF_COUNT, &asyncCallbackInfo->callback);
757 ReleaseFormCallback(env, asyncCallbackInfo);
758 } else {
759 valueType = napi_undefined;
760 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
761 if (valueType == napi_function) { // release callback, two argv
762 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
763 ReleaseFormCallback(env, asyncCallbackInfo);
764 } else if (valueType == napi_boolean) { // release promise, two argv
765 napi_get_value_bool(env, argv[1], &asyncCallbackInfo->isReleaseCache);
766 return ReleaseFormPromise(env, asyncCallbackInfo);
767 } else {
768 NAPI_ASSERT(env, valueType == napi_function || valueType == napi_boolean,
769 "The arguments[2] type of releaseForm is incorrect,expected type is function or boolean.");
770 }
771 }
772 return NapiGetResut(env, 1);
773 }
774
775 /**
776 * @brief Call native kit function: RequestForm
777 *
778 * @param[in] env The environment that the Node-API call is invoked under
779 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
780 *
781 * @return void
782 */
InnerRequestForm(napi_env env,AsyncRequestFormCallbackInfo * const asyncCallbackInfo)783 static void InnerRequestForm(napi_env env, AsyncRequestFormCallbackInfo* const asyncCallbackInfo)
784 {
785 HILOG_DEBUG("%{public}s called.", __func__);
786 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
787 asyncCallbackInfo->result = ability->RequestForm(asyncCallbackInfo->formId);
788 HILOG_DEBUG("%{public}s, end", __func__);
789 }
790
791 /**
792 * @brief The implementation of Node-API interface: requestForm
793 *
794 * @param[in] env The environment that the Node-API call is invoked under
795 * @param[out] info An opaque datatype that is passed to a callback function
796 *
797 * @return This is an opaque pointer that is used to represent a JavaScript value
798 */
NAPI_RequestForm(napi_env env,napi_callback_info info)799 napi_value NAPI_RequestForm(napi_env env, napi_callback_info info)
800 {
801 HILOG_INFO("%{public}s called.", __func__);
802
803 // Check the number of the arguments
804 size_t argc = ARGS_SIZE_TWO;
805 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
806 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
807 if (argc > ARGS_SIZE_TWO) {
808 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
809 return nullptr;
810 }
811 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
812
813 // Check the value type of the arguments
814 napi_valuetype valueType;
815 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
816 if (valueType != napi_string) {
817 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
818 AsyncErrMsgCallbackInfo {
819 .env = env,
820 .asyncWork = nullptr,
821 .deferred = nullptr,
822 .callback = nullptr,
823 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
824 .type = 0,
825 .callbackValue = argv[1]
826 };
827
828 if (argc == ARGS_SIZE_TWO) {
829 asyncErrorInfo->type = CALLBACK_FLG;
830 } else {
831 asyncErrorInfo->type = PROMISE_FLG;
832 }
833 return RetErrMsg(asyncErrorInfo);
834 }
835
836 std::string strFormId = GetStringFromNAPI(env, argv[0]);
837 int64_t formId;
838 if (!ConvertStringToInt64(strFormId, formId)) {
839 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
840 AsyncErrMsgCallbackInfo {
841 .env = env,
842 .asyncWork = nullptr,
843 .deferred = nullptr,
844 .callback = nullptr,
845 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
846 .type = 0,
847 .callbackValue = argv[1]
848 };
849
850 if (argc == ARGS_SIZE_TWO) {
851 asyncErrorInfo->type = CALLBACK_FLG;
852 } else {
853 asyncErrorInfo->type = PROMISE_FLG;
854 }
855 return RetErrMsg(asyncErrorInfo);
856 }
857
858 AsyncRequestFormCallbackInfo *asyncCallbackInfo = new
859 AsyncRequestFormCallbackInfo {
860 .env = env,
861 .ability = GetGlobalAbility(env),
862 .asyncWork = nullptr,
863 .deferred = nullptr,
864 .callback = nullptr,
865 .formId = formId,
866 .result = 0,
867 };
868
869 if (argc == ARGS_SIZE_TWO) {
870 HILOG_INFO("%{public}s, asyncCallback.", __func__);
871
872 // Check the value type of the arguments
873 valueType = napi_undefined;
874 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
875 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of requestForm is incorrect, "
876 "expected type is function.");
877
878 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
879
880 napi_value resourceName;
881 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
882 napi_create_async_work(
883 env,
884 nullptr,
885 resourceName,
886 [](napi_env env, void *data) {
887 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
888 AsyncRequestFormCallbackInfo *asyncCallbackInfo = (AsyncRequestFormCallbackInfo *)data;
889 InnerRequestForm(env, asyncCallbackInfo);
890 },
891 [](napi_env env, napi_status status, void *data) {
892 AsyncRequestFormCallbackInfo *asyncCallbackInfo = (AsyncRequestFormCallbackInfo *)data;
893 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
894
895 if (asyncCallbackInfo->callback != nullptr) {
896 napi_value result[ARGS_SIZE_TWO] = {0};
897 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
898 napi_value callback;
899 napi_value undefined;
900 napi_get_undefined(env, &undefined);
901 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
902 napi_value callResult;
903 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
904 napi_delete_reference(env, asyncCallbackInfo->callback);
905 }
906 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
907 delete asyncCallbackInfo;
908 },
909 (void *)asyncCallbackInfo,
910 &asyncCallbackInfo->asyncWork);
911 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
912 return NapiGetResut(env, 1);
913 } else {
914 HILOG_INFO("%{public}s, promise.", __func__);
915 napi_deferred deferred;
916 napi_value promise;
917 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
918 asyncCallbackInfo->deferred = deferred;
919
920 napi_value resourceName;
921 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
922 napi_create_async_work(
923 env,
924 nullptr,
925 resourceName,
926 [](napi_env env, void *data) {
927 HILOG_INFO("%{public}s, promise running", __func__);
928 AsyncRequestFormCallbackInfo *asyncCallbackInfo = (AsyncRequestFormCallbackInfo *)data;
929 InnerRequestForm(env, asyncCallbackInfo);
930 },
931 [](napi_env env, napi_status status, void *data) {
932 HILOG_INFO("%{public}s, promise complete", __func__);
933 AsyncRequestFormCallbackInfo *asyncCallbackInfo = (AsyncRequestFormCallbackInfo *)data;
934
935 napi_value result;
936 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
937 if (asyncCallbackInfo->result == ERR_OK) {
938 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
939 } else {
940 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
941 }
942 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
943 delete asyncCallbackInfo;
944 },
945 (void *)asyncCallbackInfo,
946 &asyncCallbackInfo->asyncWork);
947 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
948 return promise;
949 }
950 }
951
952 /**
953 * @brief Call native kit function: CastTempForm
954 *
955 * @param[in] env The environment that the Node-API call is invoked under
956 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
957 *
958 * @return void
959 */
InnerCastTempForm(napi_env env,AsyncCastTempFormCallbackInfo * const asyncCallbackInfo)960 static void InnerCastTempForm(napi_env env, AsyncCastTempFormCallbackInfo* const asyncCallbackInfo)
961 {
962 HILOG_DEBUG("%{public}s called.", __func__);
963 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
964 asyncCallbackInfo->result = ability->CastTempForm(asyncCallbackInfo->formId);
965 HILOG_DEBUG("%{public}s, end", __func__);
966 }
967
968 /**
969 * @brief The implementation of Node-API interface: castTempForm
970 *
971 * @param[in] env The environment that the Node-API call is invoked under
972 * @param[out] info An opaque datatype that is passed to a callback function
973 *
974 * @return This is an opaque pointer that is used to represent a JavaScript value
975 */
NAPI_CastTempForm(napi_env env,napi_callback_info info)976 napi_value NAPI_CastTempForm(napi_env env, napi_callback_info info)
977 {
978 HILOG_INFO("%{public}s called.", __func__);
979
980 // Check the number of the arguments
981 size_t argc = ARGS_SIZE_TWO;
982 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
983 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
984 if (argc > ARGS_SIZE_TWO) {
985 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
986 return nullptr;
987 }
988 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
989
990 // Check the value type of the arguments
991 napi_valuetype valueType;
992 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
993 if (valueType != napi_string) {
994 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
995 AsyncErrMsgCallbackInfo {
996 .env = env,
997 .asyncWork = nullptr,
998 .deferred = nullptr,
999 .callback = nullptr,
1000 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
1001 .type = 0,
1002 .callbackValue = argv[1]
1003 };
1004
1005 if (argc == ARGS_SIZE_TWO) {
1006 asyncErrorInfo->type = CALLBACK_FLG;
1007 } else {
1008 asyncErrorInfo->type = PROMISE_FLG;
1009 }
1010 return RetErrMsg(asyncErrorInfo);
1011 }
1012
1013 std::string strFormId = GetStringFromNAPI(env, argv[0]);
1014 int64_t formId;
1015 if (!ConvertStringToInt64(strFormId, formId)) {
1016 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1017 AsyncErrMsgCallbackInfo {
1018 .env = env,
1019 .asyncWork = nullptr,
1020 .deferred = nullptr,
1021 .callback = nullptr,
1022 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
1023 .type = 0,
1024 .callbackValue = argv[1]
1025 };
1026
1027 if (argc == ARGS_SIZE_TWO) {
1028 asyncErrorInfo->type = CALLBACK_FLG;
1029 } else {
1030 asyncErrorInfo->type = PROMISE_FLG;
1031 }
1032 return RetErrMsg(asyncErrorInfo);
1033 }
1034
1035 AsyncCastTempFormCallbackInfo *asyncCallbackInfo = new
1036 AsyncCastTempFormCallbackInfo {
1037 .env = env,
1038 .ability = GetGlobalAbility(env),
1039 .asyncWork = nullptr,
1040 .deferred = nullptr,
1041 .callback = nullptr,
1042 .formId = formId,
1043 .result = 0,
1044 };
1045
1046 if (argc == ARGS_SIZE_TWO) {
1047 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1048
1049 // Check the value type of the arguments
1050 valueType = napi_undefined;
1051 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
1052 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of castTempForm is incorrect, "
1053 "expected type is function.");
1054
1055 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
1056
1057 napi_value resourceName;
1058 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1059 napi_create_async_work(
1060 env,
1061 nullptr,
1062 resourceName,
1063 [](napi_env env, void *data) {
1064 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
1065 AsyncCastTempFormCallbackInfo *asyncCallbackInfo = (AsyncCastTempFormCallbackInfo *)data;
1066 InnerCastTempForm(env, asyncCallbackInfo);
1067 },
1068 [](napi_env env, napi_status status, void *data) {
1069 AsyncCastTempFormCallbackInfo *asyncCallbackInfo = (AsyncCastTempFormCallbackInfo *)data;
1070 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
1071
1072 if (asyncCallbackInfo->callback != nullptr) {
1073 napi_value result[ARGS_SIZE_TWO] = {0};
1074 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
1075 napi_value callback;
1076 napi_value undefined;
1077 napi_get_undefined(env, &undefined);
1078 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1079 napi_value callResult;
1080 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
1081 napi_delete_reference(env, asyncCallbackInfo->callback);
1082 }
1083 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1084 delete asyncCallbackInfo;
1085 },
1086 (void *)asyncCallbackInfo,
1087 &asyncCallbackInfo->asyncWork);
1088 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1089 return NapiGetResut(env, 1);
1090 } else {
1091 HILOG_INFO("%{public}s, promise.", __func__);
1092 napi_deferred deferred;
1093 napi_value promise;
1094 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1095 asyncCallbackInfo->deferred = deferred;
1096
1097 napi_value resourceName;
1098 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1099 napi_create_async_work(
1100 env,
1101 nullptr,
1102 resourceName,
1103 [](napi_env env, void *data) {
1104 HILOG_INFO("%{public}s, promise running", __func__);
1105 AsyncCastTempFormCallbackInfo *asyncCallbackInfo = (AsyncCastTempFormCallbackInfo *)data;
1106 InnerCastTempForm(env, asyncCallbackInfo);
1107 },
1108 [](napi_env env, napi_status status, void *data) {
1109 HILOG_INFO("%{public}s, promise complete", __func__);
1110 AsyncCastTempFormCallbackInfo *asyncCallbackInfo = (AsyncCastTempFormCallbackInfo *)data;
1111
1112 napi_value result;
1113 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
1114 if (asyncCallbackInfo->result == ERR_OK) {
1115 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1116 } else {
1117 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1118 }
1119 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1120 delete asyncCallbackInfo;
1121 },
1122 (void *)asyncCallbackInfo,
1123 &asyncCallbackInfo->asyncWork);
1124 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1125 return promise;
1126 }
1127 }
1128
1129 /**
1130 * @brief Call native kit function: NotifyVisibleForms
1131 *
1132 * @param[in] env The environment that the Node-API call is invoked under
1133 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
1134 *
1135 * @return void
1136 */
InnerNotifyVisibleForms(napi_env env,AsyncNotifyVisibleFormsCallbackInfo * const asyncCallbackInfo)1137 static void InnerNotifyVisibleForms(napi_env env, AsyncNotifyVisibleFormsCallbackInfo* const asyncCallbackInfo)
1138 {
1139 HILOG_DEBUG("%{public}s called.", __func__);
1140 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
1141 asyncCallbackInfo->result = ability->NotifyVisibleForms(asyncCallbackInfo->formIds);
1142 HILOG_DEBUG("%{public}s, end", __func__);
1143 }
1144
1145 /**
1146 * @brief The implementation of Node-API interface: notifyVisibleForms
1147 *
1148 * @param[in] env The environment that the Node-API call is invoked under
1149 * @param[out] info An opaque datatype that is passed to a callback function
1150 *
1151 * @return This is an opaque pointer that is used to represent a JavaScript value
1152 */
NAPI_NotifyVisibleForms(napi_env env,napi_callback_info info)1153 napi_value NAPI_NotifyVisibleForms(napi_env env, napi_callback_info info)
1154 {
1155 HILOG_INFO("%{public}s called.", __func__);
1156
1157 // Check the number of the arguments
1158 size_t argc = ARGS_SIZE_TWO;
1159 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1160 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
1161 if (argc > ARGS_SIZE_TWO) {
1162 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
1163 return nullptr;
1164 }
1165 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
1166
1167 bool isArray;
1168 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
1169 if (!isArray) {
1170 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1171 AsyncErrMsgCallbackInfo {
1172 .env = env,
1173 .asyncWork = nullptr,
1174 .deferred = nullptr,
1175 .callback = nullptr,
1176 .code = ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR,
1177 .type = 0,
1178 .callbackValue = argv[1]
1179 };
1180 if (argc == ARGS_SIZE_TWO) {
1181 asyncErrorInfo->type = CALLBACK_FLG;
1182 } else {
1183 asyncErrorInfo->type = PROMISE_FLG;
1184 }
1185 return RetErrMsg(asyncErrorInfo);
1186 }
1187
1188 uint32_t arrayLength = 0;
1189 NAPI_CALL(env, napi_get_array_length(env, argv[0], &arrayLength));
1190 if (arrayLength == 0) {
1191 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1192 AsyncErrMsgCallbackInfo {
1193 .env = env,
1194 .asyncWork = nullptr,
1195 .deferred = nullptr,
1196 .callback = nullptr,
1197 .code = ERR_APPEXECFWK_FORM_FORM_ID_ARRAY_ERR,
1198 .type = 0,
1199 .callbackValue = argv[1]
1200 };
1201
1202 if (argc == ARGS_SIZE_TWO) {
1203 asyncErrorInfo->type = CALLBACK_FLG;
1204 } else {
1205 asyncErrorInfo->type = PROMISE_FLG;
1206 }
1207 return RetErrMsg(asyncErrorInfo);
1208 }
1209
1210 std::vector<int64_t> formIds;
1211 formIds.clear();
1212 napi_valuetype valueType;
1213 for (size_t i = 0; i < arrayLength; i++) {
1214 napi_value napiFormId;
1215 napi_get_element(env, argv[0], i, &napiFormId);
1216
1217 // Check the value type of the arguments
1218 valueType = napi_undefined;
1219 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
1220 if (valueType != napi_string) {
1221 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1222 AsyncErrMsgCallbackInfo {
1223 .env = env,
1224 .asyncWork = nullptr,
1225 .deferred = nullptr,
1226 .callback = nullptr,
1227 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
1228 .type = 0,
1229 .callbackValue = argv[1]
1230 };
1231
1232 if (argc == ARGS_SIZE_TWO) {
1233 asyncErrorInfo->type = CALLBACK_FLG;
1234 } else {
1235 asyncErrorInfo->type = PROMISE_FLG;
1236 }
1237 return RetErrMsg(asyncErrorInfo);
1238 }
1239
1240 std::string strFormId = GetStringFromNAPI(env, napiFormId);
1241 int64_t formIdValue;
1242 if (!ConvertStringToInt64(strFormId, formIdValue)) {
1243 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1244 AsyncErrMsgCallbackInfo {
1245 .env = env,
1246 .asyncWork = nullptr,
1247 .deferred = nullptr,
1248 .callback = nullptr,
1249 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
1250 .type = 0,
1251 .callbackValue = argv[1]
1252 };
1253
1254 if (argc == ARGS_SIZE_TWO) {
1255 asyncErrorInfo->type = CALLBACK_FLG;
1256 } else {
1257 asyncErrorInfo->type = PROMISE_FLG;
1258 }
1259 return RetErrMsg(asyncErrorInfo);
1260 }
1261
1262 formIds.push_back(formIdValue);
1263 }
1264
1265 AsyncNotifyVisibleFormsCallbackInfo *asyncCallbackInfo = new
1266 AsyncNotifyVisibleFormsCallbackInfo {
1267 .env = env,
1268 .ability = GetGlobalAbility(env),
1269 .asyncWork = nullptr,
1270 .deferred = nullptr,
1271 .callback = nullptr,
1272 .formIds = formIds,
1273 .result = 1,
1274 };
1275
1276 if (argc == ARGS_SIZE_TWO) {
1277 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1278
1279 // Check the value type of the arguments
1280 valueType = napi_undefined;
1281 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
1282 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of notifyVisibleForms is incorrect,"
1283 "expected type is function.");
1284
1285 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
1286
1287 napi_value resourceName;
1288 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1289 napi_create_async_work(
1290 env,
1291 nullptr,
1292 resourceName,
1293 [](napi_env env, void *data) {
1294 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
1295
1296 AsyncNotifyVisibleFormsCallbackInfo *asyncCallbackInfo =
1297 (AsyncNotifyVisibleFormsCallbackInfo *)data;
1298
1299 InnerNotifyVisibleForms(env, asyncCallbackInfo);
1300 },
1301 [](napi_env env, napi_status status, void *data) {
1302 AsyncNotifyVisibleFormsCallbackInfo *asyncCallbackInfo =
1303 (AsyncNotifyVisibleFormsCallbackInfo *)data;
1304
1305 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
1306
1307 if (asyncCallbackInfo->callback != nullptr) {
1308 napi_value result[ARGS_SIZE_TWO] = {0};
1309 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
1310 napi_value callback;
1311 napi_value undefined;
1312 napi_get_undefined(env, &undefined);
1313 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1314 napi_value callResult;
1315 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
1316 napi_delete_reference(env, asyncCallbackInfo->callback);
1317 }
1318 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1319 delete asyncCallbackInfo;
1320 },
1321 (void *)asyncCallbackInfo,
1322 &asyncCallbackInfo->asyncWork);
1323 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1324 return NapiGetResut(env, 1);
1325 } else {
1326 HILOG_INFO("%{public}s, promise.", __func__);
1327 napi_deferred deferred;
1328 napi_value promise;
1329 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1330 asyncCallbackInfo->deferred = deferred;
1331
1332 napi_value resourceName;
1333 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1334 napi_create_async_work(
1335 env,
1336 nullptr,
1337 resourceName,
1338 [](napi_env env, void *data) {
1339 HILOG_INFO("%{public}s, promise running", __func__);
1340
1341 AsyncNotifyVisibleFormsCallbackInfo *asyncCallbackInfo =
1342 (AsyncNotifyVisibleFormsCallbackInfo *)data;
1343
1344 InnerNotifyVisibleForms(env, asyncCallbackInfo);
1345 },
1346 [](napi_env env, napi_status status, void *data) {
1347 HILOG_INFO("%{public}s, promise complete", __func__);
1348
1349 AsyncNotifyVisibleFormsCallbackInfo *asyncCallbackInfo =
1350 (AsyncNotifyVisibleFormsCallbackInfo *)data;
1351
1352 napi_value result;
1353 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
1354 if (asyncCallbackInfo->result == ERR_OK) {
1355 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1356 } else {
1357 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1358 }
1359 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1360 delete asyncCallbackInfo;
1361 },
1362 (void *)asyncCallbackInfo,
1363 &asyncCallbackInfo->asyncWork);
1364 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1365 return promise;
1366 }
1367 }
1368
1369 /**
1370 * @brief Call native kit function: NotifyInvisibleForms
1371 *
1372 * @param[in] env The environment that the Node-API call is invoked under
1373 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
1374 *
1375 * @return void
1376 */
InnerNotifyInvisibleForms(napi_env env,AsyncNotifyInvisibleFormsCallbackInfo * const asyncCallbackInfo)1377 static void InnerNotifyInvisibleForms(napi_env env, AsyncNotifyInvisibleFormsCallbackInfo* const asyncCallbackInfo)
1378 {
1379 HILOG_DEBUG("%{public}s called.", __func__);
1380 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
1381 asyncCallbackInfo->result = ability->NotifyInvisibleForms(asyncCallbackInfo->formIds);
1382 HILOG_DEBUG("%{public}s, end", __func__);
1383 }
1384
1385 /**
1386 * @brief The implementation of Node-API interface: notifyInvisibleForms
1387 *
1388 * @param[in] env The environment that the Node-API call is invoked under
1389 * @param[out] info An opaque datatype that is passed to a callback function
1390 *
1391 * @return This is an opaque pointer that is used to represent a JavaScript value
1392 */
NAPI_NotifyInvisibleForms(napi_env env,napi_callback_info info)1393 napi_value NAPI_NotifyInvisibleForms(napi_env env, napi_callback_info info)
1394 {
1395 HILOG_INFO("%{public}s called.", __func__);
1396
1397 // Check the number of the arguments
1398 size_t argc = ARGS_SIZE_TWO;
1399 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1400 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
1401 if (argc > ARGS_SIZE_TWO) {
1402 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
1403 return nullptr;
1404 }
1405 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
1406
1407 bool isArray;
1408 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
1409 if (!isArray) {
1410 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1411 AsyncErrMsgCallbackInfo {
1412 .env = env,
1413 .asyncWork = nullptr,
1414 .deferred = nullptr,
1415 .callback = nullptr,
1416 .code = ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR,
1417 .type = 0,
1418 .callbackValue = argv[1]
1419 };
1420 if (argc == ARGS_SIZE_TWO) {
1421 asyncErrorInfo->type = CALLBACK_FLG;
1422 } else {
1423 asyncErrorInfo->type = PROMISE_FLG;
1424 }
1425 return RetErrMsg(asyncErrorInfo);
1426 }
1427
1428 uint32_t arrayLength = 0;
1429 NAPI_CALL(env, napi_get_array_length(env, argv[0], &arrayLength));
1430 if (arrayLength == 0) {
1431 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1432 AsyncErrMsgCallbackInfo {
1433 .env = env,
1434 .asyncWork = nullptr,
1435 .deferred = nullptr,
1436 .callback = nullptr,
1437 .code = ERR_APPEXECFWK_FORM_FORM_ID_ARRAY_ERR,
1438 .type = 0,
1439 .callbackValue = argv[1]
1440 };
1441
1442 if (argc == ARGS_SIZE_TWO) {
1443 asyncErrorInfo->type = CALLBACK_FLG;
1444 } else {
1445 asyncErrorInfo->type = PROMISE_FLG;
1446 }
1447 return RetErrMsg(asyncErrorInfo);
1448 }
1449
1450 std::vector<int64_t> formIds;
1451 formIds.clear();
1452 napi_valuetype valueType;
1453 for (size_t i = 0; i < arrayLength; i++) {
1454 napi_value napiFormId;
1455 napi_get_element(env, argv[0], i, &napiFormId);
1456
1457 // Check the value type of the arguments
1458 valueType = napi_undefined;
1459 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
1460 if (valueType != napi_string) {
1461 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1462 AsyncErrMsgCallbackInfo {
1463 .env = env,
1464 .asyncWork = nullptr,
1465 .deferred = nullptr,
1466 .callback = nullptr,
1467 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
1468 .type = 0,
1469 .callbackValue = argv[1]
1470 };
1471
1472 if (argc == ARGS_SIZE_TWO) {
1473 asyncErrorInfo->type = CALLBACK_FLG;
1474 } else {
1475 asyncErrorInfo->type = PROMISE_FLG;
1476 }
1477 return RetErrMsg(asyncErrorInfo);
1478 }
1479
1480 std::string strFormId = GetStringFromNAPI(env, napiFormId);
1481 int64_t formIdValue;
1482 if (!ConvertStringToInt64(strFormId, formIdValue)) {
1483 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1484 AsyncErrMsgCallbackInfo {
1485 .env = env,
1486 .asyncWork = nullptr,
1487 .deferred = nullptr,
1488 .callback = nullptr,
1489 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
1490 .type = 0,
1491 .callbackValue = argv[1]
1492 };
1493
1494 if (argc == ARGS_SIZE_TWO) {
1495 asyncErrorInfo->type = CALLBACK_FLG;
1496 } else {
1497 asyncErrorInfo->type = PROMISE_FLG;
1498 }
1499 return RetErrMsg(asyncErrorInfo);
1500 }
1501
1502 formIds.push_back(formIdValue);
1503 }
1504
1505 AsyncNotifyInvisibleFormsCallbackInfo *asyncCallbackInfo = new
1506 AsyncNotifyInvisibleFormsCallbackInfo {
1507 .env = env,
1508 .ability = GetGlobalAbility(env),
1509 .asyncWork = nullptr,
1510 .deferred = nullptr,
1511 .callback = nullptr,
1512 .formIds = formIds,
1513 .result = 1,
1514 };
1515
1516 if (argc == ARGS_SIZE_TWO) {
1517 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1518
1519 // Check the value type of the arguments
1520 valueType = napi_undefined;
1521 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
1522 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of notifyInvisibleForms is incorrect,"
1523 "expected type is function.");
1524
1525 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
1526
1527 napi_value resourceName;
1528 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1529 napi_create_async_work(
1530 env,
1531 nullptr,
1532 resourceName,
1533 [](napi_env env, void *data) {
1534 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
1535
1536 AsyncNotifyInvisibleFormsCallbackInfo *asyncCallbackInfo =
1537 (AsyncNotifyInvisibleFormsCallbackInfo *)data;
1538
1539 InnerNotifyInvisibleForms(env, asyncCallbackInfo);
1540 },
1541 [](napi_env env, napi_status status, void *data) {
1542 AsyncNotifyInvisibleFormsCallbackInfo *asyncCallbackInfo =
1543 (AsyncNotifyInvisibleFormsCallbackInfo *)data;
1544
1545 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
1546
1547 if (asyncCallbackInfo->callback != nullptr) {
1548 napi_value result[ARGS_SIZE_TWO] = {0};
1549 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
1550 napi_value callback;
1551 napi_value undefined;
1552 napi_get_undefined(env, &undefined);
1553 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1554 napi_value callResult;
1555 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
1556 napi_delete_reference(env, asyncCallbackInfo->callback);
1557 }
1558 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1559 delete asyncCallbackInfo;
1560 },
1561 (void *)asyncCallbackInfo,
1562 &asyncCallbackInfo->asyncWork);
1563 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1564 return NapiGetResut(env, 1);
1565 } else {
1566 HILOG_INFO("%{public}s, promise.", __func__);
1567 napi_deferred deferred;
1568 napi_value promise;
1569 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1570 asyncCallbackInfo->deferred = deferred;
1571
1572 napi_value resourceName;
1573 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1574 napi_create_async_work(
1575 env,
1576 nullptr,
1577 resourceName,
1578 [](napi_env env, void *data) {
1579 HILOG_INFO("%{public}s, promise running", __func__);
1580
1581 AsyncNotifyInvisibleFormsCallbackInfo *asyncCallbackInfo =
1582 (AsyncNotifyInvisibleFormsCallbackInfo *)data;
1583
1584 InnerNotifyInvisibleForms(env, asyncCallbackInfo);
1585 },
1586 [](napi_env env, napi_status status, void *data) {
1587 HILOG_INFO("%{public}s, promise complete", __func__);
1588
1589 AsyncNotifyInvisibleFormsCallbackInfo *asyncCallbackInfo =
1590 (AsyncNotifyInvisibleFormsCallbackInfo *)data;
1591
1592 napi_value result;
1593 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
1594 if (asyncCallbackInfo->result == ERR_OK) {
1595 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1596 } else {
1597 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1598 }
1599 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1600 delete asyncCallbackInfo;
1601 },
1602 (void *)asyncCallbackInfo,
1603 &asyncCallbackInfo->asyncWork);
1604 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1605 return promise;
1606 }
1607 }
1608
1609 /**
1610 * @brief Call native kit function: EnableUpdateForm
1611 *
1612 * @param[in] env The environment that the Node-API call is invoked under
1613 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
1614 *
1615 * @return void
1616 */
InnerEnableFormsUpdate(napi_env env,AsyncEnableUpdateFormCallbackInfo * const asyncCallbackInfo)1617 static void InnerEnableFormsUpdate(napi_env env, AsyncEnableUpdateFormCallbackInfo* const asyncCallbackInfo)
1618 {
1619 HILOG_DEBUG("%{public}s called.", __func__);
1620 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
1621 asyncCallbackInfo->result = ability->EnableUpdateForm(asyncCallbackInfo->formIds);
1622 HILOG_DEBUG("%{public}s, end", __func__);
1623 }
1624
1625 /**
1626 * @brief The implementation of Node-API interface: enableFormsUpdate
1627 *
1628 * @param[in] env The environment that the Node-API call is invoked under
1629 * @param[out] info An opaque datatype that is passed to a callback function
1630 *
1631 * @return This is an opaque pointer that is used to represent a JavaScript value
1632 */
NAPI_EnableFormsUpdate(napi_env env,napi_callback_info info)1633 napi_value NAPI_EnableFormsUpdate(napi_env env, napi_callback_info info)
1634 {
1635 HILOG_INFO("%{public}s called.", __func__);
1636
1637 // Check the number of the arguments
1638 size_t argc = ARGS_SIZE_TWO;
1639 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1640 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
1641 if (argc > ARGS_SIZE_TWO) {
1642 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
1643 return nullptr;
1644 }
1645 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
1646
1647 bool isArray;
1648 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
1649 if (!isArray) {
1650 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1651 AsyncErrMsgCallbackInfo {
1652 .env = env,
1653 .asyncWork = nullptr,
1654 .deferred = nullptr,
1655 .callback = nullptr,
1656 .code = ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR,
1657 .type = 0,
1658 .callbackValue = argv[1]
1659 };
1660 if (argc == ARGS_SIZE_TWO) {
1661 asyncErrorInfo->type = CALLBACK_FLG;
1662 } else {
1663 asyncErrorInfo->type = PROMISE_FLG;
1664 }
1665 return RetErrMsg(asyncErrorInfo);
1666 }
1667
1668 uint32_t arrayLength = 0;
1669 NAPI_CALL(env, napi_get_array_length(env, argv[0], &arrayLength));
1670 if (arrayLength == 0) {
1671 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1672 AsyncErrMsgCallbackInfo {
1673 .env = env,
1674 .asyncWork = nullptr,
1675 .deferred = nullptr,
1676 .callback = nullptr,
1677 .code = ERR_APPEXECFWK_FORM_FORM_ID_ARRAY_ERR,
1678 .type = 0,
1679 .callbackValue = argv[1]
1680 };
1681
1682 if (argc == ARGS_SIZE_TWO) {
1683 asyncErrorInfo->type = CALLBACK_FLG;
1684 } else {
1685 asyncErrorInfo->type = PROMISE_FLG;
1686 }
1687 return RetErrMsg(asyncErrorInfo);
1688 }
1689
1690 std::vector<int64_t> formIds;
1691 formIds.clear();
1692 napi_valuetype valueType;
1693 for (size_t i = 0; i < arrayLength; i++) {
1694 napi_value napiFormId;
1695 napi_get_element(env, argv[0], i, &napiFormId);
1696
1697 // Check the value type of the arguments
1698 valueType = napi_undefined;
1699 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
1700 if (valueType != napi_string) {
1701 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1702 AsyncErrMsgCallbackInfo {
1703 .env = env,
1704 .asyncWork = nullptr,
1705 .deferred = nullptr,
1706 .callback = nullptr,
1707 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
1708 .type = 0,
1709 .callbackValue = argv[1]
1710 };
1711
1712 if (argc == ARGS_SIZE_TWO) {
1713 asyncErrorInfo->type = CALLBACK_FLG;
1714 } else {
1715 asyncErrorInfo->type = PROMISE_FLG;
1716 }
1717 return RetErrMsg(asyncErrorInfo);
1718 }
1719
1720 std::string strFormId = GetStringFromNAPI(env, napiFormId);
1721 int64_t formIdValue;
1722 if (!ConvertStringToInt64(strFormId, formIdValue)) {
1723 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1724 AsyncErrMsgCallbackInfo {
1725 .env = env,
1726 .asyncWork = nullptr,
1727 .deferred = nullptr,
1728 .callback = nullptr,
1729 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
1730 .type = 0,
1731 .callbackValue = argv[1]
1732 };
1733
1734 if (argc == ARGS_SIZE_TWO) {
1735 asyncErrorInfo->type = CALLBACK_FLG;
1736 } else {
1737 asyncErrorInfo->type = PROMISE_FLG;
1738 }
1739 return RetErrMsg(asyncErrorInfo);
1740 }
1741
1742 formIds.push_back(formIdValue);
1743 }
1744
1745 AsyncEnableUpdateFormCallbackInfo *asyncCallbackInfo = new
1746 AsyncEnableUpdateFormCallbackInfo {
1747 .env = env,
1748 .ability = GetGlobalAbility(env),
1749 .asyncWork = nullptr,
1750 .deferred = nullptr,
1751 .callback = nullptr,
1752 .formIds = formIds,
1753 .result = 0,
1754 };
1755
1756 if (argc == ARGS_SIZE_TWO) {
1757 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1758
1759 // Check the value type of the arguments
1760 valueType = napi_undefined;
1761 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
1762 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of enableFormsUpdate "
1763 "is incorrect, expected type is function.");
1764
1765 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
1766
1767 napi_value resourceName;
1768 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1769 napi_create_async_work(
1770 env,
1771 nullptr,
1772 resourceName,
1773 [](napi_env env, void *data) {
1774 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
1775
1776 AsyncEnableUpdateFormCallbackInfo *asyncCallbackInfo =
1777 (AsyncEnableUpdateFormCallbackInfo *)data;
1778
1779 InnerEnableFormsUpdate(env, asyncCallbackInfo);
1780 },
1781 [](napi_env env, napi_status status, void *data) {
1782 AsyncEnableUpdateFormCallbackInfo *asyncCallbackInfo =
1783 (AsyncEnableUpdateFormCallbackInfo *)data;
1784
1785 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
1786
1787 if (asyncCallbackInfo->callback != nullptr) {
1788 napi_value result[ARGS_SIZE_TWO] = {0};
1789 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
1790 napi_value callback;
1791 napi_value undefined;
1792 napi_get_undefined(env, &undefined);
1793 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
1794 napi_value callResult;
1795 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
1796 napi_delete_reference(env, asyncCallbackInfo->callback);
1797 }
1798 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1799 delete asyncCallbackInfo;
1800 },
1801 (void *)asyncCallbackInfo,
1802 &asyncCallbackInfo->asyncWork);
1803 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1804 return NapiGetResut(env, 1);
1805 } else {
1806 HILOG_INFO("%{public}s, promise.", __func__);
1807 napi_deferred deferred;
1808 napi_value promise;
1809 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1810 asyncCallbackInfo->deferred = deferred;
1811
1812 napi_value resourceName;
1813 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1814 napi_create_async_work(
1815 env,
1816 nullptr,
1817 resourceName,
1818 [](napi_env env, void *data) {
1819 HILOG_INFO("%{public}s, promise running", __func__);
1820 AsyncEnableUpdateFormCallbackInfo *asyncCallbackInfo =
1821 (AsyncEnableUpdateFormCallbackInfo *)data;
1822
1823 InnerEnableFormsUpdate(env, asyncCallbackInfo);
1824 },
1825 [](napi_env env, napi_status status, void *data) {
1826 HILOG_INFO("%{public}s, promise complete", __func__);
1827
1828 AsyncEnableUpdateFormCallbackInfo *asyncCallbackInfo =
1829 (AsyncEnableUpdateFormCallbackInfo *)data;
1830
1831 napi_value result;
1832 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
1833 if (asyncCallbackInfo->result == ERR_OK) {
1834 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1835 } else {
1836 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
1837 }
1838 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1839 delete asyncCallbackInfo;
1840 },
1841 (void *)asyncCallbackInfo,
1842 &asyncCallbackInfo->asyncWork);
1843 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1844 return promise;
1845 }
1846 }
1847
1848 /**
1849 * @brief Call native kit function: DisableUpdateForm
1850 *
1851 * @param[in] env The environment that the Node-API call is invoked under
1852 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
1853 *
1854 * @return void
1855 */
InnerDisableFormsUpdate(napi_env env,AsyncDisableUpdateFormCallbackInfo * const asyncCallbackInfo)1856 static void InnerDisableFormsUpdate(napi_env env, AsyncDisableUpdateFormCallbackInfo* const asyncCallbackInfo)
1857 {
1858 HILOG_DEBUG("%{public}s called.", __func__);
1859 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
1860 asyncCallbackInfo->result = ability->DisableUpdateForm(asyncCallbackInfo->formIds);
1861 HILOG_DEBUG("%{public}s, end", __func__);
1862 }
1863
1864 /**
1865 * @brief The implementation of Node-API interface: disableFormsUpdate
1866 *
1867 * @param[in] env The environment that the Node-API call is invoked under
1868 * @param[out] info An opaque datatype that is passed to a callback function
1869 *
1870 * @return This is an opaque pointer that is used to represent a JavaScript value
1871 */
NAPI_DisableFormsUpdate(napi_env env,napi_callback_info info)1872 napi_value NAPI_DisableFormsUpdate(napi_env env, napi_callback_info info)
1873 {
1874 HILOG_INFO("%{public}s called.", __func__);
1875
1876 // Check the number of the arguments
1877 size_t argc = ARGS_SIZE_TWO;
1878 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1879 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
1880 if (argc > ARGS_SIZE_TWO) {
1881 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
1882 return nullptr;
1883 }
1884 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
1885
1886 bool isArray;
1887 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
1888 if (!isArray) {
1889 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1890 AsyncErrMsgCallbackInfo {
1891 .env = env,
1892 .asyncWork = nullptr,
1893 .deferred = nullptr,
1894 .callback = nullptr,
1895 .code = ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR,
1896 .type = 0,
1897 .callbackValue = argv[1]
1898 };
1899 if (argc == ARGS_SIZE_TWO) {
1900 asyncErrorInfo->type = CALLBACK_FLG;
1901 } else {
1902 asyncErrorInfo->type = PROMISE_FLG;
1903 }
1904 return RetErrMsg(asyncErrorInfo);
1905 }
1906
1907 uint32_t arrayLength = 0;
1908 NAPI_CALL(env, napi_get_array_length(env, argv[0], &arrayLength));
1909 if (arrayLength == 0) {
1910 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1911 AsyncErrMsgCallbackInfo {
1912 .env = env,
1913 .asyncWork = nullptr,
1914 .deferred = nullptr,
1915 .callback = nullptr,
1916 .code = ERR_APPEXECFWK_FORM_FORM_ID_ARRAY_ERR,
1917 .type = 0,
1918 .callbackValue = argv[1]
1919 };
1920 if (argc == ARGS_SIZE_TWO) {
1921 asyncErrorInfo->type = CALLBACK_FLG;
1922 } else {
1923 asyncErrorInfo->type = PROMISE_FLG;
1924 }
1925 return RetErrMsg(asyncErrorInfo);
1926 }
1927
1928 std::vector<int64_t> formIds;
1929 formIds.clear();
1930 napi_valuetype valueType;
1931 for (size_t i = 0; i < arrayLength; i++) {
1932 napi_value napiFormId;
1933 napi_get_element(env, argv[0], i, &napiFormId);
1934
1935 // Check the value type of the arguments
1936 valueType = napi_undefined;
1937 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
1938 if (valueType != napi_string) {
1939 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1940 AsyncErrMsgCallbackInfo {
1941 .env = env,
1942 .asyncWork = nullptr,
1943 .deferred = nullptr,
1944 .callback = nullptr,
1945 .code = ERR_APPEXECFWK_FORM_INVALID_FORM_ID,
1946 .type = 0,
1947 .callbackValue = argv[1]
1948 };
1949
1950 if (argc == ARGS_SIZE_TWO) {
1951 asyncErrorInfo->type = CALLBACK_FLG;
1952 } else {
1953 asyncErrorInfo->type = PROMISE_FLG;
1954 }
1955 return RetErrMsg(asyncErrorInfo);
1956 }
1957
1958 std::string strFormId = GetStringFromNAPI(env, napiFormId);
1959 int64_t formIdValue;
1960 if (!ConvertStringToInt64(strFormId, formIdValue)) {
1961 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
1962 AsyncErrMsgCallbackInfo {
1963 .env = env,
1964 .asyncWork = nullptr,
1965 .deferred = nullptr,
1966 .callback = nullptr,
1967 .code = ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR,
1968 .type = 0,
1969 .callbackValue = argv[1]
1970 };
1971
1972 if (argc == ARGS_SIZE_TWO) {
1973 asyncErrorInfo->type = CALLBACK_FLG;
1974 } else {
1975 asyncErrorInfo->type = PROMISE_FLG;
1976 }
1977 return RetErrMsg(asyncErrorInfo);
1978 }
1979
1980 formIds.push_back(formIdValue);
1981 }
1982
1983 AsyncDisableUpdateFormCallbackInfo *asyncCallbackInfo = new
1984 AsyncDisableUpdateFormCallbackInfo {
1985 .env = env,
1986 .ability = GetGlobalAbility(env),
1987 .asyncWork = nullptr,
1988 .deferred = nullptr,
1989 .callback = nullptr,
1990 .formIds = formIds,
1991 .result = 0,
1992 };
1993
1994 if (argc == ARGS_SIZE_TWO) {
1995 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1996
1997 // Check the value type of the arguments
1998 valueType = napi_undefined;
1999 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2000 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of disableFormsUpdate "
2001 "is incorrect, expected type is function.");
2002
2003 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
2004
2005 napi_value resourceName;
2006 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2007 napi_create_async_work(
2008 env,
2009 nullptr,
2010 resourceName,
2011 [](napi_env env, void *data) {
2012 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2013
2014 AsyncDisableUpdateFormCallbackInfo *asyncCallbackInfo =
2015 (AsyncDisableUpdateFormCallbackInfo *)data;
2016
2017 InnerDisableFormsUpdate(env, asyncCallbackInfo);
2018 },
2019 [](napi_env env, napi_status status, void *data) {
2020 AsyncDisableUpdateFormCallbackInfo *asyncCallbackInfo =
2021 (AsyncDisableUpdateFormCallbackInfo *)data;
2022
2023 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2024
2025 if (asyncCallbackInfo->callback != nullptr) {
2026 napi_value result[ARGS_SIZE_TWO] = {0};
2027 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, result);
2028 napi_value callback;
2029 napi_value undefined;
2030 napi_get_undefined(env, &undefined);
2031 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2032 napi_value callResult;
2033 napi_call_function(env, undefined, callback, ARGS_SIZE_TWO, result, &callResult);
2034 napi_delete_reference(env, asyncCallbackInfo->callback);
2035 }
2036 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2037 delete asyncCallbackInfo;
2038 },
2039 (void *)asyncCallbackInfo,
2040 &asyncCallbackInfo->asyncWork);
2041 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2042 return NapiGetResut(env, 1);
2043 } else {
2044 HILOG_INFO("%{public}s, promise.", __func__);
2045 napi_deferred deferred;
2046 napi_value promise;
2047 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2048 asyncCallbackInfo->deferred = deferred;
2049
2050 napi_value resourceName;
2051 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2052 napi_create_async_work(
2053 env,
2054 nullptr,
2055 resourceName,
2056 [](napi_env env, void *data) {
2057 HILOG_INFO("%{public}s, promise running", __func__);
2058
2059 AsyncDisableUpdateFormCallbackInfo *asyncCallbackInfo =
2060 (AsyncDisableUpdateFormCallbackInfo *)data;
2061
2062 InnerDisableFormsUpdate(env, asyncCallbackInfo);
2063 },
2064 [](napi_env env, napi_status status, void *data) {
2065 HILOG_INFO("%{public}s, promise complete", __func__);
2066
2067 AsyncDisableUpdateFormCallbackInfo *asyncCallbackInfo =
2068 (AsyncDisableUpdateFormCallbackInfo *)data;
2069
2070 napi_value result;
2071 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
2072 if (asyncCallbackInfo->result == ERR_OK) {
2073 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2074 } else {
2075 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2076 }
2077 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2078 delete asyncCallbackInfo;
2079 },
2080 (void *)asyncCallbackInfo,
2081 &asyncCallbackInfo->asyncWork);
2082 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
2083 return promise;
2084 }
2085 }
2086
2087 /**
2088 * @brief Call native kit function: CheckFMSReady
2089 *
2090 * @param[in] env The environment that the Node-API call is invoked under
2091 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
2092 *
2093 * @return void
2094 */
InnerCheckFMSReady(napi_env env,AsyncCheckFMSReadyCallbackInfo * const asyncCallbackInfo)2095 static void InnerCheckFMSReady(napi_env env, AsyncCheckFMSReadyCallbackInfo* const asyncCallbackInfo)
2096 {
2097 HILOG_DEBUG("%{public}s called.", __func__);
2098 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
2099 if (ability->CheckFMSReady()) {
2100 asyncCallbackInfo->isFMSReady = 0;
2101 } else {
2102 asyncCallbackInfo->isFMSReady = 1;
2103 }
2104 HILOG_DEBUG("%{public}s, end", __func__);
2105 }
2106
2107 /**
2108 * @brief The implementation of Node-API interface: checkFMSReady
2109 *
2110 * @param[in] env The environment that the Node-API call is invoked under
2111 * @param[out] info An opaque datatype that is passed to a callback function
2112 *
2113 * @return This is an opaque pointer that is used to represent a JavaScript value
2114 */
NAPI_CheckFMSReady(napi_env env,napi_callback_info info)2115 napi_value NAPI_CheckFMSReady(napi_env env, napi_callback_info info)
2116 {
2117 HILOG_INFO("%{public}s called.", __func__);
2118
2119 // Check the number of the arguments
2120 size_t argc = ARGS_SIZE_ONE;
2121 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
2122 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2123 if (argc > ARGS_SIZE_ONE) {
2124 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2125 return nullptr;
2126 }
2127 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
2128
2129 AsyncCheckFMSReadyCallbackInfo *asyncCallbackInfo = new
2130 AsyncCheckFMSReadyCallbackInfo {
2131 .env = env,
2132 .ability = GetGlobalAbility(env),
2133 .asyncWork = nullptr,
2134 .deferred = nullptr,
2135 .callback = nullptr,
2136 .isFMSReady = false,
2137 };
2138
2139 if (argc == ARGS_SIZE_ONE) {
2140 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2141
2142 // Check the value type of the arguments
2143 napi_valuetype valueType;
2144 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
2145 NAPI_ASSERT(env, valueType == napi_function, "The arguments[0] type of checkFMSReady is incorrect, "
2146 "expected type is function.");
2147
2148 napi_create_reference(env, argv[0], REF_COUNT, &asyncCallbackInfo->callback);
2149 napi_value resourceName;
2150 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2151 napi_create_async_work(
2152 env,
2153 nullptr,
2154 resourceName,
2155 [](napi_env env, void *data) {
2156 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2157
2158 AsyncCheckFMSReadyCallbackInfo *asyncCallbackInfo =
2159 (AsyncCheckFMSReadyCallbackInfo *)data;
2160
2161 InnerCheckFMSReady(env, asyncCallbackInfo);
2162 },
2163 [](napi_env env, napi_status status, void *data) {
2164 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2165
2166 AsyncCheckFMSReadyCallbackInfo *asyncCallbackInfo =
2167 (AsyncCheckFMSReadyCallbackInfo *)data;
2168
2169 if (asyncCallbackInfo->callback != nullptr) {
2170 napi_value isFMSReadyResult;
2171 napi_create_int32(env, asyncCallbackInfo->isFMSReady, &isFMSReadyResult);
2172 napi_value callbackValues[ARGS_SIZE_TWO] = {0};
2173 InnerCreateCallbackRetMsg(env, 0, callbackValues);
2174 callbackValues[1] = isFMSReadyResult;
2175 napi_value callback;
2176 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2177 napi_value callResult;
2178 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
2179 napi_delete_reference(env, asyncCallbackInfo->callback);
2180 }
2181 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2182 delete asyncCallbackInfo;
2183 },
2184 (void *)asyncCallbackInfo,
2185 &asyncCallbackInfo->asyncWork);
2186 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2187 return NapiGetResut(env, 1);
2188 } else {
2189 HILOG_INFO("%{public}s, promise.", __func__);
2190 napi_deferred deferred;
2191 napi_value promise;
2192 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2193 asyncCallbackInfo->deferred = deferred;
2194
2195 napi_value resourceName;
2196 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2197 napi_create_async_work(
2198 env,
2199 nullptr,
2200 resourceName,
2201 [](napi_env env, void *data) {
2202 HILOG_INFO("%{public}s, promise running", __func__);
2203
2204 AsyncCheckFMSReadyCallbackInfo *asyncCallbackInfo =
2205 (AsyncCheckFMSReadyCallbackInfo *)data;
2206
2207 InnerCheckFMSReady(env, asyncCallbackInfo);
2208 },
2209 [](napi_env env, napi_status status, void *data) {
2210 HILOG_INFO("%{public}s, promise complete", __func__);
2211
2212 AsyncCheckFMSReadyCallbackInfo *asyncCallbackInfo =
2213 (AsyncCheckFMSReadyCallbackInfo *)data;
2214
2215 napi_value result;
2216 napi_create_int32(env, asyncCallbackInfo->isFMSReady, &result);
2217 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2218 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2219 delete asyncCallbackInfo;
2220 },
2221 (void *)asyncCallbackInfo,
2222 &asyncCallbackInfo->asyncWork);
2223 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
2224 return promise;
2225 }
2226 }
2227
InnerDeleteInvalidForms(napi_env env,AsyncDeleteInvalidFormsCallbackInfo * const asyncCallbackInfo)2228 static void InnerDeleteInvalidForms(napi_env env, AsyncDeleteInvalidFormsCallbackInfo *const asyncCallbackInfo)
2229 {
2230 HILOG_DEBUG("%{public}s called.", __func__);
2231 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
2232 ErrCode ret = ability->DeleteInvalidForms(asyncCallbackInfo->formIds, asyncCallbackInfo->numFormsDeleted);
2233 asyncCallbackInfo->result = ret;
2234 if (ret != ERR_OK) {
2235 asyncCallbackInfo->numFormsDeleted = 0;
2236 }
2237 HILOG_DEBUG("%{public}s, end", __func__);
2238 }
2239
DeleteInvalidFormsCallback(napi_env env,AsyncDeleteInvalidFormsCallbackInfo * const asyncCallbackInfo)2240 napi_value DeleteInvalidFormsCallback(napi_env env, AsyncDeleteInvalidFormsCallbackInfo *const asyncCallbackInfo)
2241 {
2242 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2243 napi_value resourceName;
2244 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2245 napi_create_async_work(
2246 env,
2247 nullptr,
2248 resourceName,
2249 [](napi_env env, void *data) {
2250 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2251 auto *asyncCallbackInfo = (AsyncDeleteInvalidFormsCallbackInfo *) data;
2252 InnerDeleteInvalidForms(env, asyncCallbackInfo);
2253 },
2254 [](napi_env env, napi_status status, void *data) {
2255 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2256 auto *asyncCallbackInfo = (AsyncDeleteInvalidFormsCallbackInfo *) data;
2257
2258 if (asyncCallbackInfo->callback != nullptr) {
2259 napi_value callback;
2260 napi_value callbackValues[ARGS_SIZE_TWO] = {nullptr, nullptr};
2261 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, &callbackValues[0]);
2262 if (asyncCallbackInfo->result == ERR_OK) {
2263 napi_create_int32(env, asyncCallbackInfo->numFormsDeleted, &callbackValues[1]);
2264 }
2265
2266 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2267 napi_value callResult;
2268 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
2269 napi_delete_reference(env, asyncCallbackInfo->callback);
2270 }
2271 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2272 delete asyncCallbackInfo;
2273 },
2274 (void *) asyncCallbackInfo,
2275 &asyncCallbackInfo->asyncWork);
2276 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2277 return NapiGetResut(env, 1);
2278 }
2279
DeleteInvalidFormsPromise(napi_env env,AsyncDeleteInvalidFormsCallbackInfo * const asyncCallbackInfo)2280 napi_value DeleteInvalidFormsPromise(napi_env env, AsyncDeleteInvalidFormsCallbackInfo *const asyncCallbackInfo)
2281 {
2282 HILOG_INFO("%{public}s, promise.", __func__);
2283 napi_deferred deferred;
2284 napi_value promise;
2285 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2286 asyncCallbackInfo->deferred = deferred;
2287
2288 napi_value resourceName;
2289 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2290 napi_create_async_work(
2291 env,
2292 nullptr,
2293 resourceName,
2294 [](napi_env env, void *data) {
2295 HILOG_INFO("%{public}s, promise runnning", __func__);
2296 auto *asyncCallbackInfo = (AsyncDeleteInvalidFormsCallbackInfo *) data;
2297 InnerDeleteInvalidForms(env, asyncCallbackInfo);
2298 },
2299 [](napi_env env, napi_status status, void *data) {
2300 HILOG_INFO("%{public}s, promise complete", __func__);
2301 auto *asyncCallbackInfo = (AsyncDeleteInvalidFormsCallbackInfo *) data;
2302 if (asyncCallbackInfo->result != ERR_OK) {
2303 napi_value result;
2304 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
2305 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2306 } else {
2307 napi_value result;
2308 napi_create_int32(env, asyncCallbackInfo->numFormsDeleted, &result);
2309 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2310 }
2311 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2312 delete asyncCallbackInfo;
2313 },
2314 (void *) asyncCallbackInfo,
2315 &asyncCallbackInfo->asyncWork);
2316 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
2317 return promise;
2318 }
2319
2320 /**
2321 * @brief The implementation of Node-API interface: deleteInvalidForms
2322 *
2323 * @param[in] env The environment that the Node-API call is invoked under
2324 * @param[out] info An opaque datatype that is passed to a callback function
2325 *
2326 * @return This is an opaque pointer that is used to represent a JavaScript value
2327 */
NAPI_DeleteInvalidForms(napi_env env,napi_callback_info info)2328 napi_value NAPI_DeleteInvalidForms(napi_env env, napi_callback_info info)
2329 {
2330 HILOG_INFO("%{public}s called.", __func__);
2331
2332 // Check the number of the arguments
2333 size_t argc = ARGS_SIZE_TWO;
2334 napi_value argv[ARGS_SIZE_TWO] = {nullptr, nullptr};
2335 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2336 if (argc > ARGS_SIZE_TWO) {
2337 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2338 return nullptr;
2339 }
2340
2341 int32_t callbackType = (argc == ARGS_SIZE_TWO) ? CALLBACK_FLG : PROMISE_FLG;
2342 bool isArray;
2343 NAPI_CALL(env, napi_is_array(env, argv[0], &isArray));
2344 if (!isArray) {
2345 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_FORM_ARRAY_ERR, callbackType, argv[1]));
2346 }
2347
2348 uint32_t arrayLength = 0;
2349 NAPI_CALL(env, napi_get_array_length(env, argv[0], &arrayLength));
2350
2351 std::vector<int64_t> formIds;
2352 formIds.clear();
2353 for (size_t i = 0; i < arrayLength; i++) {
2354 napi_value napiFormId;
2355 napi_get_element(env, argv[0], i, &napiFormId);
2356
2357 // Check the value type of the arguments
2358 napi_valuetype valueType = napi_undefined;
2359 NAPI_CALL(env, napi_typeof(env, napiFormId, &valueType));
2360 if (valueType != napi_string) {
2361 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_INVALID_FORM_ID, callbackType, argv[1]));
2362 }
2363
2364 std::string strFormId = GetStringFromNAPI(env, napiFormId);
2365 int64_t formIdValue;
2366 if (!ConvertStringToInt64(strFormId, formIdValue)) {
2367 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_FORM_ID_NUM_ERR, callbackType, argv[1]));
2368 }
2369
2370 formIds.push_back(formIdValue);
2371 }
2372
2373 auto *asyncCallbackInfo = new AsyncDeleteInvalidFormsCallbackInfo {
2374 .env = env,
2375 .ability = GetGlobalAbility(env),
2376 .formIds = formIds,
2377 };
2378
2379 if (argc == ARGS_SIZE_TWO) {
2380 // Check the value type of the arguments
2381 napi_valuetype valueType = napi_undefined;
2382 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2383 NAPI_ASSERT(env, valueType == napi_function, "The type of args[1] is incorrect, expected type is function.");
2384 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
2385 return DeleteInvalidFormsCallback(env, asyncCallbackInfo);
2386 } else {
2387 return DeleteInvalidFormsPromise(env, asyncCallbackInfo);
2388 }
2389 }
2390
ParseFormStateInfo(napi_env env,FormStateInfo & stateInfo)2391 napi_value ParseFormStateInfo(napi_env env, FormStateInfo &stateInfo)
2392 {
2393 napi_value formStateInfoObject = nullptr;
2394 napi_create_object(env, &formStateInfoObject);
2395 napi_value jsValue = WrapWant(env, stateInfo.want);
2396 SetPropertyValueByPropertyName(env, formStateInfoObject, "want", jsValue);
2397 napi_value formState = nullptr;
2398 napi_create_int32(env, (int32_t) stateInfo.state, &formState);
2399 SetPropertyValueByPropertyName(env, formStateInfoObject, "formState", formState);
2400
2401 return formStateInfoObject;
2402 }
2403
AcquireFormStateCallbackComplete(napi_env env,AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2404 void AcquireFormStateCallbackComplete(napi_env env, AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2405 {
2406 HILOG_INFO("%{public}s, onAcquireFormState back", __func__);
2407 if (asyncCallbackInfo->callback != nullptr) {
2408 napi_value callback;
2409 napi_value callbackValues[ARGS_SIZE_TWO] = {nullptr, nullptr};
2410 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, &callbackValues[0]);
2411 if (asyncCallbackInfo->result == ERR_OK) {
2412 callbackValues[1] = ParseFormStateInfo(env, asyncCallbackInfo->stateInfo);
2413 }
2414
2415 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2416 napi_value callResult;
2417 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
2418 napi_delete_reference(env, asyncCallbackInfo->callback);
2419 }
2420 HILOG_INFO("%{public}s, onAcquireFormState back done", __func__);
2421 }
2422
AcquireFormStatePromiseComplete(napi_env env,AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2423 void AcquireFormStatePromiseComplete(napi_env env, AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2424 {
2425 HILOG_INFO("%{public}s, onAcquireFormState back", __func__);
2426 if (asyncCallbackInfo->result != ERR_OK) {
2427 napi_value result;
2428 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
2429 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2430 } else {
2431 napi_value result = ParseFormStateInfo(env, asyncCallbackInfo->stateInfo);
2432 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2433 }
2434 HILOG_INFO("%{public}s, onAcquireFormState back done", __func__);
2435 }
2436
2437 namespace {
2438 class FormStateCallbackClient : public FormStateCallbackInterface {
2439 public:
FormStateCallbackClient(AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2440 explicit FormStateCallbackClient(AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2441 {
2442 asyncCallbackInfo_ = asyncCallbackInfo;
2443 }
2444
~FormStateCallbackClient()2445 virtual ~FormStateCallbackClient()
2446 {
2447 if (asyncCallbackInfo_ != nullptr) {
2448 delete asyncCallbackInfo_;
2449 asyncCallbackInfo_ = nullptr;
2450 }
2451 }
2452
ProcessAcquireState(FormState state)2453 void ProcessAcquireState(FormState state) override
2454 {
2455 if (asyncCallbackInfo_ == nullptr) {
2456 return;
2457 }
2458 asyncCallbackInfo_->stateInfo.state = state;
2459 if (asyncCallbackInfo_->callbackType == CALLBACK_FLG) {
2460 AcquireFormStateCallbackComplete(asyncCallbackInfo_->env, asyncCallbackInfo_);
2461 } else {
2462 AcquireFormStatePromiseComplete(asyncCallbackInfo_->env, asyncCallbackInfo_);
2463 }
2464 delete asyncCallbackInfo_;
2465 asyncCallbackInfo_ = nullptr;
2466 }
2467
2468 private:
2469 AsyncAcquireFormStateCallbackInfo *asyncCallbackInfo_ = nullptr;
2470 };
2471
2472 class FormUninstallCallbackClient {
2473 public:
FormUninstallCallbackClient(napi_env env,napi_ref callbackRef)2474 explicit FormUninstallCallbackClient(napi_env env, napi_ref callbackRef)
2475 {
2476 env_ = env;
2477 callbackRef_ = callbackRef;
2478 }
2479
~FormUninstallCallbackClient()2480 virtual ~FormUninstallCallbackClient()
2481 {
2482 napi_delete_reference(env_, callbackRef_);
2483 }
2484
ProcessFormUninstall(const int64_t formId)2485 void ProcessFormUninstall(const int64_t formId)
2486 {
2487 std::string formIdString = std::to_string(formId);
2488 napi_value callbackValues;
2489 napi_create_string_utf8(env_, formIdString.c_str(), NAPI_AUTO_LENGTH, &callbackValues);
2490 napi_value callResult;
2491 napi_value myCallback = nullptr;
2492 napi_get_reference_value(env_, callbackRef_, &myCallback);
2493 if (myCallback != nullptr) {
2494 napi_call_function(env_, nullptr, myCallback, ARGS_SIZE_ONE, &callbackValues, &callResult);
2495 }
2496 }
2497
IsStrictEqual(napi_value callback)2498 bool IsStrictEqual(napi_value callback)
2499 {
2500 bool isEqual = false;
2501 napi_value myCallback = nullptr;
2502 napi_get_reference_value(env_, callbackRef_, &myCallback);
2503 napi_strict_equals(env_, myCallback, callback, &isEqual);
2504 HILOG_INFO("isStrictEqual: %{public}d", isEqual);
2505 return isEqual;
2506 }
2507
2508 private:
2509 napi_ref callbackRef_ {};
2510 napi_env env_;
2511 };
2512
2513 std::map<napi_ref, std::shared_ptr<FormUninstallCallbackClient>> g_formUninstallCallbackMap {};
2514 std::mutex formUninstallCallbackMapMutex_;
2515
FormUninstallCallback(const std::vector<int64_t> & formIds)2516 void FormUninstallCallback(const std::vector<int64_t> &formIds)
2517 {
2518 std::lock_guard<std::mutex> lock(formUninstallCallbackMapMutex_);
2519 for (auto &iter : g_formUninstallCallbackMap) {
2520 for (int64_t formId : formIds) {
2521 iter.second->ProcessFormUninstall(formId);
2522 }
2523 }
2524 }
2525
AddFormUninstallCallback(napi_env env,napi_value callback)2526 bool AddFormUninstallCallback(napi_env env, napi_value callback)
2527 {
2528 std::lock_guard<std::mutex> lock(formUninstallCallbackMapMutex_);
2529 for (auto &iter : g_formUninstallCallbackMap) {
2530 if (iter.second->IsStrictEqual(callback)) {
2531 HILOG_ERROR("found equal callback");
2532 return false;
2533 }
2534 }
2535
2536 napi_ref callbackRef;
2537 napi_create_reference(env, callback, REF_COUNT, &callbackRef);
2538 std::shared_ptr<FormUninstallCallbackClient> callbackClient = std::make_shared<FormUninstallCallbackClient>(env,
2539 callbackRef);
2540
2541 auto ret = g_formUninstallCallbackMap.emplace(callbackRef, callbackClient);
2542 if (!ret.second) {
2543 HILOG_ERROR("failed to emplace callback");
2544 return false;
2545 }
2546 return true;
2547 }
2548
DelFormUninstallCallback(napi_value callback)2549 bool DelFormUninstallCallback(napi_value callback)
2550 {
2551 int32_t count = 0;
2552 std::lock_guard<std::mutex> lock(formUninstallCallbackMapMutex_);
2553 for (auto iter = g_formUninstallCallbackMap.begin(); iter != g_formUninstallCallbackMap.end();) {
2554 if (iter->second->IsStrictEqual(callback)) {
2555 HILOG_INFO("found equal callback");
2556 iter = g_formUninstallCallbackMap.erase(iter);
2557 count++;
2558 } else {
2559 iter++;
2560 }
2561 }
2562 HILOG_INFO("%{public}d form uninstall callback deleted.", count);
2563 return true;
2564 }
2565
ClearFormUninstallCallback()2566 bool ClearFormUninstallCallback()
2567 {
2568 std::lock_guard<std::mutex> lock(formUninstallCallbackMapMutex_);
2569 g_formUninstallCallbackMap.clear();
2570 return true;
2571 }
2572 }
2573
InnerAcquireFormState(napi_env env,AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2574 static void InnerAcquireFormState(napi_env env, AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2575 {
2576 HILOG_DEBUG("%{public}s called.", __func__);
2577 std::shared_ptr<FormStateCallbackInterface> formStateCallback = std::make_shared<FormStateCallbackClient>(
2578 asyncCallbackInfo);
2579 FormHostClient::GetInstance()->AddFormState(formStateCallback, asyncCallbackInfo->want);
2580 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
2581
2582 ErrCode ret = ability->AcquireFormState(asyncCallbackInfo->want, asyncCallbackInfo->stateInfo);
2583 asyncCallbackInfo->result = ret;
2584 HILOG_DEBUG("%{public}s, end", __func__);
2585 }
2586
AcquireFormStateCallback(napi_env env,AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2587 napi_value AcquireFormStateCallback(napi_env env, AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2588 {
2589 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2590 napi_value resourceName;
2591 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2592 napi_create_async_work(
2593 env,
2594 nullptr,
2595 resourceName,
2596 [](napi_env env, void *data) {
2597 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2598 auto *asyncCallbackInfo = (AsyncAcquireFormStateCallbackInfo *) data;
2599 InnerAcquireFormState(env, asyncCallbackInfo);
2600 },
2601 [](napi_env env, napi_status status, void *data) {
2602 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2603 auto *asyncCallbackInfo = (AsyncAcquireFormStateCallbackInfo *) data;
2604 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2605 if (asyncCallbackInfo->result != ERR_OK) {
2606 FormHostClient::GetInstance()->OnAcquireState(FormState::UNKNOWN, asyncCallbackInfo->want);
2607 }
2608 },
2609 (void *) asyncCallbackInfo,
2610 &asyncCallbackInfo->asyncWork);
2611 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2612 return NapiGetResut(env, 1);
2613 }
2614
AcquireFormStatePromise(napi_env env,AsyncAcquireFormStateCallbackInfo * const asyncCallbackInfo)2615 napi_value AcquireFormStatePromise(napi_env env, AsyncAcquireFormStateCallbackInfo *const asyncCallbackInfo)
2616 {
2617 HILOG_INFO("%{public}s, promise.", __func__);
2618 napi_deferred deferred;
2619 napi_value promise;
2620 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2621 asyncCallbackInfo->deferred = deferred;
2622
2623 napi_value resourceName;
2624 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2625 napi_create_async_work(
2626 env,
2627 nullptr,
2628 resourceName,
2629 [](napi_env env, void *data) {
2630 HILOG_INFO("%{public}s, promise runnning", __func__);
2631 auto *asyncCallbackInfo = (AsyncAcquireFormStateCallbackInfo *) data;
2632 InnerAcquireFormState(env, asyncCallbackInfo);
2633 },
2634 [](napi_env env, napi_status status, void *data) {
2635 HILOG_INFO("%{public}s, promise complete", __func__);
2636 auto *asyncCallbackInfo = (AsyncAcquireFormStateCallbackInfo *) data;
2637 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2638 if (asyncCallbackInfo->result != ERR_OK) {
2639 FormHostClient::GetInstance()->OnAcquireState(FormState::UNKNOWN, asyncCallbackInfo->want);
2640 }
2641 },
2642 (void *) asyncCallbackInfo,
2643 &asyncCallbackInfo->asyncWork);
2644 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
2645 return promise;
2646 }
2647
2648 /**
2649 * @brief The implementation of Node-API interface: acquireFormState
2650 *
2651 * @param[in] env The environment that the Node-API call is invoked under
2652 * @param[out] info An opaque datatype that is passed to a callback function
2653 *
2654 * @return This is an opaque pointer that is used to represent a JavaScript value
2655 */
NAPI_AcquireFormState(napi_env env,napi_callback_info info)2656 napi_value NAPI_AcquireFormState(napi_env env, napi_callback_info info)
2657 {
2658 HILOG_INFO("%{public}s called.", __func__);
2659
2660 // Check the number of the arguments
2661 size_t argc = ARGS_SIZE_TWO;
2662 napi_value argv[ARGS_SIZE_TWO] = {nullptr, nullptr};
2663 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2664 if (argc > ARGS_SIZE_TWO) {
2665 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2666 return nullptr;
2667 }
2668 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
2669
2670 int32_t callbackType = (argc == ARGS_SIZE_TWO) ? CALLBACK_FLG : PROMISE_FLG;
2671 napi_valuetype valueType = napi_undefined;
2672 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
2673 if (valueType != napi_object) {
2674 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_INVALID_PARAM, callbackType, argv[1]));
2675 }
2676
2677 auto *asyncCallbackInfo = new AsyncAcquireFormStateCallbackInfo {
2678 .env = env,
2679 .ability = GetGlobalAbility(env),
2680 .asyncWork = nullptr,
2681 .deferred = nullptr,
2682 .callback = nullptr,
2683 .want = {},
2684 .stateInfo = {},
2685 .callbackType = callbackType,
2686 .result = ERR_OK,
2687 };
2688
2689 bool parseResult = UnwrapWant(env, argv[0], asyncCallbackInfo->want);
2690 if (!parseResult) {
2691 HILOG_ERROR("%{public}s, failed to parse want.", __func__);
2692 delete asyncCallbackInfo;
2693 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_INVALID_PARAM, callbackType, argv[1]));
2694 }
2695
2696 if (argc == ARGS_SIZE_TWO) {
2697 // Check the value type of the arguments
2698 valueType = napi_undefined;
2699 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2700 NAPI_ASSERT(env, valueType == napi_function,
2701 "The arguments[1] type of acquireFormState is incorrect, expected type is function.");
2702 napi_create_reference(env, argv[1], REF_COUNT, &asyncCallbackInfo->callback);
2703 return AcquireFormStateCallback(env, asyncCallbackInfo);
2704 } else {
2705 return AcquireFormStatePromise(env, asyncCallbackInfo);
2706 }
2707 }
2708
2709 /**
2710 * @brief The implementation of Node-API interface: on
2711 *
2712 * @param[in] env The environment that the Node-API call is invoked under
2713 * @param[out] info An opaque datatype that is passed to a callback function
2714 *
2715 * @return This is an opaque pointer that is used to represent a JavaScript value
2716 */
NAPI_RegisterFormUninstallObserver(napi_env env,napi_callback_info info)2717 napi_value NAPI_RegisterFormUninstallObserver(napi_env env, napi_callback_info info)
2718 {
2719 HILOG_INFO("%{public}s called.", __func__);
2720
2721 // Check the number of the arguments
2722 size_t argc = ARGS_SIZE_TWO;
2723 napi_value argv[ARGS_SIZE_TWO] = {nullptr, nullptr};
2724 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2725 if (argc != ARGS_SIZE_TWO) {
2726 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2727 return nullptr;
2728 }
2729 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
2730
2731 napi_valuetype valueType = napi_undefined;
2732 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
2733 if (valueType != napi_string) {
2734 HILOG_ERROR("The type of args[0] is incorrect, expected type is string.");
2735 return nullptr;
2736 }
2737 std::string type;
2738 if (!UnwrapStringFromJS2(env, argv[0], type)) {
2739 HILOG_ERROR("failed to get args[0].");
2740 return nullptr;
2741 }
2742
2743 if (type != "formUninstall") {
2744 HILOG_ERROR("args[0] should be formUninstall.");
2745 return nullptr;
2746 }
2747
2748 valueType = napi_undefined;
2749 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2750 if (valueType != napi_function) {
2751 HILOG_ERROR("The type of args[1] is incorrect, expected type is function.");
2752 return nullptr;
2753 }
2754
2755 FormHostClient::GetInstance()->RegisterUninstallCallback(FormUninstallCallback);
2756 AddFormUninstallCallback(env, argv[1]);
2757 return nullptr;
2758 }
2759
2760 /**
2761 * @brief The implementation of Node-API interface: off
2762 *
2763 * @param[in] env The environment that the Node-API call is invoked under
2764 * @param[out] info An opaque datatype that is passed to a callback function
2765 *
2766 * @return This is an opaque pointer that is used to represent a JavaScript value
2767 */
NAPI_UnregisterFormUninstallObserver(napi_env env,napi_callback_info info)2768 napi_value NAPI_UnregisterFormUninstallObserver(napi_env env, napi_callback_info info)
2769 {
2770 HILOG_INFO("%{public}s called.", __func__);
2771
2772 // Check the number of the arguments
2773 size_t argc = ARGS_SIZE_TWO;
2774 napi_value argv[ARGS_SIZE_TWO] = {nullptr, nullptr};
2775 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2776 if (argc > ARGS_SIZE_TWO) {
2777 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2778 return nullptr;
2779 }
2780 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
2781
2782 napi_valuetype valueType = napi_undefined;
2783 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
2784 if (valueType != napi_string) {
2785 HILOG_ERROR("The type of args[0] is incorrect, expected type is string.");
2786 return nullptr;
2787 }
2788 std::string type;
2789 if (!UnwrapStringFromJS2(env, argv[0], type)) {
2790 HILOG_ERROR("failed to get args[0].");
2791 return nullptr;
2792 }
2793
2794 if (type != "formUninstall") {
2795 HILOG_ERROR("args[0] should be formUninstall.");
2796 return nullptr;
2797 }
2798
2799 if (argc == ARGS_SIZE_TWO) {
2800 valueType = napi_undefined;
2801 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2802 if (valueType != napi_function) {
2803 HILOG_ERROR("The type of args[1] is incorrect, expected type is function.");
2804 return nullptr;
2805 }
2806 DelFormUninstallCallback(argv[1]);
2807 return nullptr;
2808 } else {
2809 ClearFormUninstallCallback();
2810 return nullptr;
2811 }
2812 }
2813
InnerNotifyFormsVisible(napi_env env,AsyncNotifyFormsVisibleCallbackInfo * const asyncCallbackInfo)2814 static void InnerNotifyFormsVisible(napi_env env, AsyncNotifyFormsVisibleCallbackInfo *const asyncCallbackInfo)
2815 {
2816 HILOG_DEBUG("%{public}s called.", __func__);
2817 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
2818 ErrCode ret = ability->NotifyFormsVisible(asyncCallbackInfo->formIds, asyncCallbackInfo->isVisible);
2819 asyncCallbackInfo->result = ret;
2820 HILOG_DEBUG("%{public}s, end", __func__);
2821 }
2822
NotifyFormsVisibleCallback(napi_env env,AsyncNotifyFormsVisibleCallbackInfo * const asyncCallbackInfo)2823 napi_value NotifyFormsVisibleCallback(napi_env env, AsyncNotifyFormsVisibleCallbackInfo *const asyncCallbackInfo)
2824 {
2825 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2826 napi_value resourceName;
2827 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2828 napi_create_async_work(
2829 env,
2830 nullptr,
2831 resourceName,
2832 [](napi_env env, void *data) {
2833 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2834 auto *asyncCallbackInfo = (AsyncNotifyFormsVisibleCallbackInfo *) data;
2835 InnerNotifyFormsVisible(env, asyncCallbackInfo);
2836 },
2837 [](napi_env env, napi_status status, void *data) {
2838 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2839 auto *asyncCallbackInfo = (AsyncNotifyFormsVisibleCallbackInfo *) data;
2840
2841 if (asyncCallbackInfo->callback != nullptr) {
2842 napi_value callback;
2843 napi_value callbackValues[ARGS_SIZE_TWO] = {nullptr, nullptr};
2844 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, callbackValues);
2845
2846 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2847 napi_value callResult;
2848 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
2849 napi_delete_reference(env, asyncCallbackInfo->callback);
2850 }
2851 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2852 delete asyncCallbackInfo;
2853 },
2854 (void *) asyncCallbackInfo,
2855 &asyncCallbackInfo->asyncWork);
2856 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2857 return NapiGetResut(env, 1);
2858 }
2859
NotifyFormsVisiblePromise(napi_env env,AsyncNotifyFormsVisibleCallbackInfo * const asyncCallbackInfo)2860 napi_value NotifyFormsVisiblePromise(napi_env env, AsyncNotifyFormsVisibleCallbackInfo *const asyncCallbackInfo)
2861 {
2862 HILOG_INFO("%{public}s, promise.", __func__);
2863 napi_deferred deferred;
2864 napi_value promise;
2865 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2866 asyncCallbackInfo->deferred = deferred;
2867
2868 napi_value resourceName;
2869 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2870 napi_create_async_work(
2871 env,
2872 nullptr,
2873 resourceName,
2874 [](napi_env env, void *data) {
2875 HILOG_INFO("%{public}s, promise runnning", __func__);
2876 auto *asyncCallbackInfo = (AsyncNotifyFormsVisibleCallbackInfo *) data;
2877 InnerNotifyFormsVisible(env, asyncCallbackInfo);
2878 },
2879 [](napi_env env, napi_status status, void *data) {
2880 HILOG_INFO("%{public}s, promise complete", __func__);
2881 auto *asyncCallbackInfo = (AsyncNotifyFormsVisibleCallbackInfo *) data;
2882 napi_value result;
2883 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
2884 if (asyncCallbackInfo->result == ERR_OK) {
2885 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2886 } else {
2887 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
2888 }
2889 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2890 delete asyncCallbackInfo;
2891 },
2892 (void *) asyncCallbackInfo,
2893 &asyncCallbackInfo->asyncWork);
2894 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
2895 return promise;
2896 }
2897
2898 /**
2899 * @brief The implementation of Node-API interface: notifyFormsVisible
2900 *
2901 * @param[in] env The environment that the Node-API call is invoked under
2902 * @param[out] info An opaque datatype that is passed to a callback function
2903 *
2904 * @return This is an opaque pointer that is used to represent a JavaScript value
2905 */
NAPI_NotifyFormsVisible(napi_env env,napi_callback_info info)2906 napi_value NAPI_NotifyFormsVisible(napi_env env, napi_callback_info info)
2907 {
2908 HILOG_INFO("%{public}s called.", __func__);
2909
2910 // Check the number of the arguments
2911 size_t argc = ARGS_SIZE_THREE;
2912 napi_value argv[ARGS_SIZE_THREE] = {nullptr, nullptr, nullptr};
2913 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
2914 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
2915 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
2916 return nullptr;
2917 }
2918
2919 int32_t callbackType = (argc == ARGS_SIZE_THREE) ? CALLBACK_FLG : PROMISE_FLG;
2920
2921 ErrCode errCode;
2922 std::vector<int64_t> formIds {};
2923 GetFormIds(env, argv[0], errCode, formIds);
2924 if (errCode != ERR_OK) {
2925 return RetErrMsg(InitErrMsg(env, errCode, callbackType, argv[ARGS_SIZE_TWO]));
2926 }
2927
2928 napi_valuetype valueType = napi_undefined;
2929 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
2930 if (valueType != napi_boolean) {
2931 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_INVALID_PARAM, callbackType, argv[ARGS_SIZE_TWO]));
2932 }
2933
2934 auto *asyncCallbackInfo = new AsyncNotifyFormsVisibleCallbackInfo {
2935 .env = env,
2936 .ability = GetGlobalAbility(env),
2937 .asyncWork = nullptr,
2938 .deferred = nullptr,
2939 .callback = nullptr,
2940 .formIds = formIds,
2941 .isVisible = false,
2942 };
2943 napi_get_value_bool(env, argv[1], &asyncCallbackInfo->isVisible);
2944
2945 if (argc == ARGS_SIZE_THREE) {
2946 // Check the value type of the arguments
2947 valueType = napi_undefined;
2948 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valueType));
2949 NAPI_ASSERT(env, valueType == napi_function, "The type of arg 2 is incorrect, expected type is function.");
2950 napi_create_reference(env, argv[ARGS_SIZE_TWO], REF_COUNT, &asyncCallbackInfo->callback);
2951 return NotifyFormsVisibleCallback(env, asyncCallbackInfo);
2952 } else {
2953 return NotifyFormsVisiblePromise(env, asyncCallbackInfo);
2954 }
2955 }
2956
InnerNotifyFormsEnableUpdate(napi_env env,AsyncNotifyFormsEnableUpdateCallbackInfo * const asyncCallbackInfo)2957 static void InnerNotifyFormsEnableUpdate(napi_env env,
2958 AsyncNotifyFormsEnableUpdateCallbackInfo *const asyncCallbackInfo)
2959 {
2960 HILOG_DEBUG("%{public}s called.", __func__);
2961 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
2962 ErrCode ret = ability->NotifyFormsEnableUpdate(asyncCallbackInfo->formIds, asyncCallbackInfo->isEnableUpdate);
2963 asyncCallbackInfo->result = ret;
2964 HILOG_DEBUG("%{public}s, end", __func__);
2965 }
2966
NotifyFormsEnableUpdateCallback(napi_env env,AsyncNotifyFormsEnableUpdateCallbackInfo * const asyncCallbackInfo)2967 napi_value NotifyFormsEnableUpdateCallback(napi_env env,
2968 AsyncNotifyFormsEnableUpdateCallbackInfo *const asyncCallbackInfo)
2969 {
2970 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2971 napi_value resourceName;
2972 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2973 napi_create_async_work(
2974 env,
2975 nullptr,
2976 resourceName,
2977 [](napi_env env, void *data) {
2978 HILOG_INFO("%{public}s, napi_create_async_work running", __func__);
2979 auto *asyncCallbackInfo = (AsyncNotifyFormsEnableUpdateCallbackInfo *) data;
2980 InnerNotifyFormsEnableUpdate(env, asyncCallbackInfo);
2981 },
2982 [](napi_env env, napi_status status, void *data) {
2983 HILOG_INFO("%{public}s, napi_create_async_work complete", __func__);
2984 auto *asyncCallbackInfo = (AsyncNotifyFormsEnableUpdateCallbackInfo *) data;
2985
2986 if (asyncCallbackInfo->callback != nullptr) {
2987 napi_value callback;
2988 napi_value callbackValues[ARGS_SIZE_TWO] = {nullptr, nullptr};
2989 InnerCreateCallbackRetMsg(env, asyncCallbackInfo->result, callbackValues);
2990
2991 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
2992 napi_value callResult;
2993 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
2994 napi_delete_reference(env, asyncCallbackInfo->callback);
2995 }
2996 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2997 delete asyncCallbackInfo;
2998 },
2999 (void *) asyncCallbackInfo,
3000 &asyncCallbackInfo->asyncWork);
3001 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3002 return NapiGetResut(env, 1);
3003 }
3004
NotifyFormsEnableUpdatePromise(napi_env env,AsyncNotifyFormsEnableUpdateCallbackInfo * const asyncCallbackInfo)3005 napi_value NotifyFormsEnableUpdatePromise(napi_env env,
3006 AsyncNotifyFormsEnableUpdateCallbackInfo *const asyncCallbackInfo)
3007 {
3008 HILOG_INFO("%{public}s, promise.", __func__);
3009 napi_deferred deferred;
3010 napi_value promise;
3011 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
3012 asyncCallbackInfo->deferred = deferred;
3013
3014 napi_value resourceName;
3015 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3016 napi_create_async_work(
3017 env,
3018 nullptr,
3019 resourceName,
3020 [](napi_env env, void *data) {
3021 HILOG_INFO("%{public}s, promise runnning", __func__);
3022 auto *asyncCallbackInfo = (AsyncNotifyFormsEnableUpdateCallbackInfo *) data;
3023 InnerNotifyFormsEnableUpdate(env, asyncCallbackInfo);
3024 },
3025 [](napi_env env, napi_status status, void *data) {
3026 HILOG_INFO("%{public}s, promise complete", __func__);
3027 auto *asyncCallbackInfo = (AsyncNotifyFormsEnableUpdateCallbackInfo *) data;
3028 napi_value result;
3029 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &result);
3030 if (asyncCallbackInfo->result == ERR_OK) {
3031 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
3032 } else {
3033 napi_reject_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
3034 }
3035 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
3036 delete asyncCallbackInfo;
3037 },
3038 (void *) asyncCallbackInfo,
3039 &asyncCallbackInfo->asyncWork);
3040 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
3041 return promise;
3042 }
3043
3044 /**
3045 * @brief The implementation of Node-API interface: notifyFormsEnableUpdate
3046 *
3047 * @param[in] env The environment that the Node-API call is invoked under
3048 * @param[out] info An opaque datatype that is passed to a callback function
3049 *
3050 * @return This is an opaque pointer that is used to represent a JavaScript value
3051 */
NAPI_NotifyFormsEnableUpdate(napi_env env,napi_callback_info info)3052 napi_value NAPI_NotifyFormsEnableUpdate(napi_env env, napi_callback_info info)
3053 {
3054 HILOG_INFO("%{public}s called.", __func__);
3055
3056 // Check the number of the arguments
3057 size_t argc = ARGS_SIZE_THREE;
3058 napi_value argv[ARGS_SIZE_THREE] = {nullptr, nullptr, nullptr};
3059 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
3060 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
3061 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
3062 return nullptr;
3063 }
3064
3065 int32_t callbackType = (argc == ARGS_SIZE_THREE) ? CALLBACK_FLG : PROMISE_FLG;
3066
3067 ErrCode errCode;
3068 std::vector<int64_t> formIds {};
3069 GetFormIds(env, argv[0], errCode, formIds);
3070 if (errCode != ERR_OK) {
3071 return RetErrMsg(InitErrMsg(env, errCode, callbackType, argv[ARGS_SIZE_TWO]));
3072 }
3073
3074 napi_valuetype valueType = napi_undefined;
3075 NAPI_CALL(env, napi_typeof(env, argv[1], &valueType));
3076 if (valueType != napi_boolean) {
3077 return RetErrMsg(InitErrMsg(env, ERR_APPEXECFWK_FORM_INVALID_PARAM, callbackType, argv[ARGS_SIZE_TWO]));
3078 }
3079
3080 auto *asyncCallbackInfo = new AsyncNotifyFormsEnableUpdateCallbackInfo {
3081 .env = env,
3082 .ability = GetGlobalAbility(env),
3083 .asyncWork = nullptr,
3084 .deferred = nullptr,
3085 .callback = nullptr,
3086 .formIds = formIds,
3087 .isEnableUpdate = false,
3088 };
3089 napi_get_value_bool(env, argv[1], &asyncCallbackInfo->isEnableUpdate);
3090
3091 if (argc == ARGS_SIZE_THREE) {
3092 // Check the value type of the arguments
3093 valueType = napi_undefined;
3094 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valueType));
3095 NAPI_ASSERT(env, valueType == napi_function, "The type of arg 2 is incorrect, expected type is function.");
3096 napi_create_reference(env, argv[ARGS_SIZE_TWO], REF_COUNT, &asyncCallbackInfo->callback);
3097 return NotifyFormsEnableUpdateCallback(env, asyncCallbackInfo);
3098 } else {
3099 return NotifyFormsEnableUpdatePromise(env, asyncCallbackInfo);
3100 }
3101 }
3102
3103 /**
3104 * @brief Call native kit function: GetAllFormsInfo
3105 *
3106 * @param[in] env The environment that the Node-API call is invoked under
3107 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
3108 *
3109 * @return void
3110 */
InnerGetAllFormsInfo(napi_env env,AsyncGetFormsInfoCallbackInfo * const asyncCallbackInfo)3111 static void InnerGetAllFormsInfo(napi_env env, AsyncGetFormsInfoCallbackInfo* const asyncCallbackInfo)
3112 {
3113 HILOG_DEBUG("%{public}s called.", __func__);
3114 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
3115 asyncCallbackInfo->result = ability->GetAllFormsInfo(asyncCallbackInfo->formInfos);
3116 HILOG_DEBUG("%{public}s, end", __func__);
3117 }
3118
3119 // NAPI_GetAllFormsInfo callback execute
__anon17f5ec843602(napi_env env, void *data) 3120 napi_async_execute_callback NAPI_GetAllFormsInfoAsyncExecute = [](napi_env env, void *data) {
3121 HILOG_INFO("NAPI_GetAllFormsInfo execute callback");
3122 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo = (AsyncGetFormsInfoCallbackInfo *)data;
3123 InnerGetAllFormsInfo(env, asyncCallbackInfo);
3124 };
3125
3126 // NAPI_GetFormsInfo callback complete
__anon17f5ec843702(napi_env env, napi_status status, void *data) 3127 napi_async_complete_callback NAPI_GetFormsInfoAsyncComplete = [](napi_env env, napi_status status, void *data) {
3128 HILOG_INFO("NAPI_GetFormsInfo compeleted callback");
3129 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo = (AsyncGetFormsInfoCallbackInfo *)data;
3130 napi_value arrayFormInfos;
3131 napi_create_array(env, &arrayFormInfos);
3132 if (asyncCallbackInfo->result == ERR_OK) {
3133 int iFormInfoCount = 0;
3134 for (auto formInfo : asyncCallbackInfo->formInfos) {
3135 napi_value formInfoObject = nullptr;
3136 napi_create_object(env, &formInfoObject);
3137 ParseFormInfoIntoNapi(env, formInfo, formInfoObject);
3138 napi_set_element(env, arrayFormInfos, iFormInfoCount, formInfoObject);
3139 ++iFormInfoCount;
3140 }
3141 }
3142 if (asyncCallbackInfo->callback != nullptr) {
3143 napi_value callbackValues[ARGS_SIZE_TWO] = {0};
3144 napi_value callback;
3145 ErrCode errCode = asyncCallbackInfo->result;
3146 InnerCreateCallbackRetMsg(env, errCode, callbackValues);
3147 if (errCode == ERR_OK) {
3148 callbackValues[1] = arrayFormInfos;
3149 }
3150 napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
3151 napi_value callResult;
3152 napi_call_function(env, nullptr, callback, ARGS_SIZE_TWO, callbackValues, &callResult);
3153 napi_delete_reference(env, asyncCallbackInfo->callback);
3154 }
3155 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
3156 delete asyncCallbackInfo;
3157 };
3158
3159 // NAPI_GetFormsInfo promise Complete
__anon17f5ec843802(napi_env env, napi_status status, void *data) 3160 napi_async_complete_callback NAPI_GetFormsInfoPromiseComplete = [](napi_env env, napi_status status, void *data) {
3161 HILOG_INFO("%{public}s, promise complete", __func__);
3162 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo = (AsyncGetFormsInfoCallbackInfo *)data;
3163 if (asyncCallbackInfo->result == ERR_OK) {
3164 napi_value arrayFormInfos;
3165 napi_create_array(env, &arrayFormInfos);
3166 int iFormInfoCount = 0;
3167 for (auto formInfo : asyncCallbackInfo->formInfos) {
3168 napi_value formInfoObject = nullptr;
3169 napi_create_object(env, &formInfoObject);
3170 ParseFormInfoIntoNapi(env, formInfo, formInfoObject);
3171 napi_set_element(env, arrayFormInfos, iFormInfoCount, formInfoObject);
3172 ++iFormInfoCount;
3173 }
3174 napi_resolve_deferred(
3175 asyncCallbackInfo->env,
3176 asyncCallbackInfo->deferred,
3177 arrayFormInfos);
3178 } else {
3179 napi_value getFormsInfoResult;
3180 InnerCreatePromiseRetMsg(env, asyncCallbackInfo->result, &getFormsInfoResult);
3181
3182 napi_reject_deferred(
3183 asyncCallbackInfo->env,
3184 asyncCallbackInfo->deferred,
3185 getFormsInfoResult);
3186 }
3187
3188 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
3189 delete asyncCallbackInfo;
3190 };
3191
3192 /**
3193 * @brief The implementation of Node-API interface: getAllFormsInfo
3194 *
3195 * @param[in] env The environment that the Node-API call is invoked under
3196 * @param[out] info An opaque datatype that is passed to a callback function
3197 *
3198 * @return This is an opaque pointer that is used to represent a JavaScript value
3199 */
NAPI_GetAllFormsInfo(napi_env env,napi_callback_info info)3200 napi_value NAPI_GetAllFormsInfo(napi_env env, napi_callback_info info)
3201 {
3202 HILOG_INFO("%{public}s called.", __func__);
3203
3204 // Check the number of the arguments
3205 size_t argc = ARGS_SIZE_ONE;
3206 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
3207 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
3208 if (argc > ARGS_SIZE_ONE) {
3209 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
3210 return nullptr;
3211 }
3212 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
3213
3214 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo = new
3215 AsyncGetFormsInfoCallbackInfo {
3216 .env = env,
3217 .ability = GetGlobalAbility(env),
3218 .asyncWork = nullptr,
3219 .deferred = nullptr,
3220 .callback = nullptr,
3221 .formInfos = std::vector<OHOS::AppExecFwk::FormInfo>(),
3222 .bundleName = "",
3223 .moduleName = "",
3224 .result = 0,
3225 };
3226
3227 if (argc == ARGS_SIZE_ONE) {
3228 HILOG_INFO("%{public}s, asyncCallback.", __func__);
3229
3230 // Check the value type of the arguments
3231 napi_valuetype valueType;
3232 NAPI_CALL(env, napi_typeof(env, argv[0], &valueType));
3233 NAPI_ASSERT(env, valueType == napi_function, "The arguments[0] type of getAllFormsInfo is incorrect, "
3234 "expected type is function.");
3235
3236 napi_create_reference(env, argv[0], REF_COUNT, &asyncCallbackInfo->callback);
3237 napi_value resourceName;
3238 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3239 napi_create_async_work(
3240 env,
3241 nullptr,
3242 resourceName,
3243 NAPI_GetAllFormsInfoAsyncExecute,
3244 NAPI_GetFormsInfoAsyncComplete,
3245 (void *)asyncCallbackInfo,
3246 &asyncCallbackInfo->asyncWork);
3247 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3248 return NapiGetResut(env, 1);
3249 } else {
3250 HILOG_INFO("%{public}s, promise.", __func__);
3251 napi_deferred deferred;
3252 napi_value promise;
3253 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
3254 asyncCallbackInfo->deferred = deferred;
3255
3256 napi_value resourceName;
3257 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3258 napi_create_async_work(
3259 env,
3260 nullptr,
3261 resourceName,
3262 NAPI_GetAllFormsInfoAsyncExecute,
3263 NAPI_GetFormsInfoPromiseComplete,
3264 (void *)asyncCallbackInfo,
3265 &asyncCallbackInfo->asyncWork);
3266 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
3267 return promise;
3268 }
3269 }
3270
3271 /**
3272 * @brief Call native kit function: GetFormsInfoByApp
3273 *
3274 * @param[in] env The environment that the Node-API call is invoked under
3275 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
3276 *
3277 * @return void
3278 */
InnerGetFormsInfoByApp(napi_env env,AsyncGetFormsInfoCallbackInfo * const asyncCallbackInfo)3279 static void InnerGetFormsInfoByApp(napi_env env, AsyncGetFormsInfoCallbackInfo* const asyncCallbackInfo)
3280 {
3281 HILOG_DEBUG("%{public}s called.", __func__);
3282 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
3283 asyncCallbackInfo->result = ability->GetFormsInfoByApp(
3284 asyncCallbackInfo->bundleName,
3285 asyncCallbackInfo->formInfos);
3286 HILOG_DEBUG("%{public}s, end", __func__);
3287 }
3288
3289 /**
3290 * @brief Call native kit function: GetFormsInfoByModule
3291 *
3292 * @param[in] env The environment that the Node-API call is invoked under
3293 * @param[out] asyncCallbackInfo Reference, callback info via Node-API
3294 *
3295 * @return void
3296 */
InnerGetFormsInfoByModule(napi_env env,AsyncGetFormsInfoCallbackInfo * const asyncCallbackInfo)3297 static void InnerGetFormsInfoByModule(napi_env env, AsyncGetFormsInfoCallbackInfo* const asyncCallbackInfo)
3298 {
3299 HILOG_DEBUG("%{public}s called.", __func__);
3300 OHOS::AppExecFwk::Ability *ability = asyncCallbackInfo->ability;
3301 asyncCallbackInfo->result = ability->GetFormsInfoByModule(
3302 asyncCallbackInfo->bundleName,
3303 asyncCallbackInfo->moduleName,
3304 asyncCallbackInfo->formInfos);
3305 HILOG_DEBUG("%{public}s, end", __func__);
3306 }
3307
3308 // NAPI_GetFormsInfo byModule callback execute
__anon17f5ec843902(napi_env env, void *data) 3309 auto NAPI_GetFormsInfoByModuleAsyncExecute = [](napi_env env, void *data) {
3310 HILOG_INFO("NAPI_GetFormsInfo byModule execute callback");
3311 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo =
3312 (AsyncGetFormsInfoCallbackInfo *)data;
3313 InnerGetFormsInfoByModule(env, asyncCallbackInfo);
3314 };
3315
3316 // NAPI_GetFormsInfo byApp callback execute
__anon17f5ec843a02(napi_env env, void *data) 3317 auto NAPI_GetFormsInfoByAppAsyncExecute = [](napi_env env, void *data) {
3318 HILOG_INFO("NAPI_GetFormsInfo byApp execute callback");
3319 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo =
3320 (AsyncGetFormsInfoCallbackInfo *)data;
3321 InnerGetFormsInfoByApp(env, asyncCallbackInfo);
3322 };
3323
3324 // GetFormsInfo callback
GetFormsInfoCallback(napi_env env,AsyncGetFormsInfoCallbackInfo * asyncCallbackInfo,bool isByApp)3325 napi_value GetFormsInfoCallback(napi_env env, AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo, bool isByApp)
3326 {
3327 HILOG_INFO("%{public}s, callback.", __func__);
3328 napi_value resourceName;
3329 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3330 napi_create_async_work(
3331 env,
3332 nullptr,
3333 resourceName,
3334 isByApp ? NAPI_GetFormsInfoByAppAsyncExecute :
3335 NAPI_GetFormsInfoByModuleAsyncExecute,
3336 NAPI_GetFormsInfoAsyncComplete,
3337 (void *)asyncCallbackInfo,
3338 &asyncCallbackInfo->asyncWork);
3339 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3340 return NapiGetResut(env, 1);
3341 }
3342
3343 // GetFormsInfo promise
GetFormsInfoPromise(napi_env env,AsyncGetFormsInfoCallbackInfo * asyncCallbackInfo,bool isByApp)3344 napi_value GetFormsInfoPromise(napi_env env, AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo, bool isByApp)
3345 {
3346 HILOG_INFO("%{public}s, promise.", __func__);
3347 napi_deferred deferred;
3348 napi_value promise;
3349 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
3350 asyncCallbackInfo->deferred = deferred;
3351 napi_value resourceName;
3352 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3353 napi_create_async_work(
3354 env,
3355 nullptr,
3356 resourceName,
3357 isByApp ? NAPI_GetFormsInfoByAppAsyncExecute : NAPI_GetFormsInfoByModuleAsyncExecute,
3358 NAPI_GetFormsInfoPromiseComplete,
3359 (void *)asyncCallbackInfo,
3360 &asyncCallbackInfo->asyncWork);
3361 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
3362 return promise;
3363 }
3364
3365 // GetFormsInfo THREE ARGV
GetFormsInfoThreeArgv(napi_env env,napi_value * argv,AsyncGetFormsInfoCallbackInfo * const asyncCallbackInfo)3366 napi_value GetFormsInfoThreeArgv(napi_env env, napi_value *argv, AsyncGetFormsInfoCallbackInfo* const asyncCallbackInfo)
3367 {
3368 HILOG_INFO("%{public}s.", __func__);
3369
3370 // Check the value type of the arguments
3371 napi_valuetype valueType;
3372 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ONE], &valueType));
3373 std::string moduleNameInfo = GetStringFromNAPI(env, argv[ARGS_SIZE_ONE]);
3374 HILOG_INFO("%{public}s, moduleNameInfo=%{public}s.", __func__, moduleNameInfo.c_str());
3375 asyncCallbackInfo->moduleName = moduleNameInfo;
3376
3377 // Check the value type of the arguments
3378 valueType = napi_undefined;
3379 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valueType));
3380 NAPI_ASSERT(env, valueType == napi_function, "The arguments[2] type of getFormsInfo is incorrect, "
3381 "expected type is function.");
3382 napi_create_reference(env, argv[ARGS_SIZE_TWO], REF_COUNT, &asyncCallbackInfo->callback);
3383 return GetFormsInfoCallback(env, asyncCallbackInfo, false);
3384 }
3385
3386 // GetFormsInfo TWO ARGV
GetFormsInfoTwoArgv(napi_env env,napi_value * argv,AsyncGetFormsInfoCallbackInfo * const asyncCallbackInfo)3387 napi_value GetFormsInfoTwoArgv(napi_env env, napi_value *argv, AsyncGetFormsInfoCallbackInfo* const asyncCallbackInfo)
3388 {
3389 HILOG_INFO("%{public}s.", __func__);
3390
3391 // Check the value type of the arguments
3392 napi_valuetype valueType;
3393 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ONE], &valueType));
3394
3395 // GetFormsInfoByModule promise
3396 if (valueType == napi_string) {
3397 std::string moduleNameInfo = GetStringFromNAPI(env, argv[ARGS_SIZE_ONE]);
3398 HILOG_INFO("%{public}s, moduleNameInfo=%{public}s.", __func__, moduleNameInfo.c_str());
3399 asyncCallbackInfo->moduleName = moduleNameInfo;
3400 return GetFormsInfoPromise(env, asyncCallbackInfo, false);
3401 } else if (valueType == napi_function) { // GetFormsInfoByApp callback
3402 HILOG_INFO("%{public}s, asyncCallback.", __func__);
3403
3404 // Check the value type of the arguments
3405 valueType = napi_undefined;
3406 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ONE], &valueType));
3407 NAPI_ASSERT(env, valueType == napi_function, "The arguments[1] type of getFormsInfo is incorrect, "
3408 "expected type is function.");
3409 napi_create_reference(env, argv[ARGS_SIZE_ONE], REF_COUNT, &asyncCallbackInfo->callback);
3410 return GetFormsInfoCallback(env, asyncCallbackInfo, true);
3411 } else {
3412 AsyncErrMsgCallbackInfo *asyncErrorInfo = new
3413 AsyncErrMsgCallbackInfo {
3414 .env = env,
3415 .asyncWork = nullptr,
3416 .deferred = nullptr,
3417 .callback = nullptr,
3418 .code = ERR_APPEXECFWK_FORM_INVALID_MODULENAME,
3419 .type = PROMISE_FLG,
3420 .callbackValue = argv[1]
3421 };
3422 return RetErrMsg(asyncErrorInfo);
3423 }
3424 }
3425
3426 /**
3427 * @brief The implementation of Node-API interface: getFormsInfo
3428 *
3429 * @param[in] env The environment that the Node-API call is invoked under
3430 * @param[out] info An opaque datatype that is passed to a callback function
3431 *
3432 * @return This is an opaque pointer that is used to represent a JavaScript value
3433 */
NAPI_GetFormsInfo(napi_env env,napi_callback_info info)3434 napi_value NAPI_GetFormsInfo(napi_env env, napi_callback_info info)
3435 {
3436 HILOG_INFO("%{public}s called.", __func__);
3437
3438 // Check the number of the arguments
3439 size_t argc = ARGS_SIZE_THREE;
3440 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
3441 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
3442 if (argc > ARGS_SIZE_THREE) {
3443 HILOG_ERROR("%{public}s, wrong number of arguments.", __func__);
3444 return nullptr;
3445 }
3446 HILOG_INFO("%{public}s, argc = [%{public}zu]", __func__, argc);
3447
3448 // Check the value type of the arguments
3449 napi_valuetype valueType;
3450 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_ZERO], &valueType));
3451 std::string bundleNameInfo = GetStringFromNAPI(env, argv[ARGS_SIZE_ZERO]);
3452 HILOG_INFO("%{public}s, bundleName=%{public}s.", __func__, bundleNameInfo.c_str());
3453
3454 AsyncGetFormsInfoCallbackInfo *asyncCallbackInfo = new
3455 AsyncGetFormsInfoCallbackInfo {
3456 .env = env,
3457 .ability = GetGlobalAbility(env),
3458 .asyncWork = nullptr,
3459 .deferred = nullptr,
3460 .callback = nullptr,
3461 .formInfos = std::vector<OHOS::AppExecFwk::FormInfo>(),
3462 .bundleName = bundleNameInfo,
3463 .moduleName = "",
3464 .result = 0,
3465 };
3466
3467 if (argc == ARGS_SIZE_THREE) { // GetFormsInfoByModule callback
3468 HILOG_INFO("%{public}s, ARGS_SIZE_THREE.", __func__);
3469 return GetFormsInfoThreeArgv(env, argv, asyncCallbackInfo);
3470 } else if (argc == ARGS_SIZE_TWO) {
3471 HILOG_INFO("%{public}s, ARGS_SIZE_TWO.", __func__);
3472 return GetFormsInfoTwoArgv(env, argv, asyncCallbackInfo);
3473 } else if (argc == ARGS_SIZE_ONE) { // GetFormsInfoByApp promise
3474 return GetFormsInfoPromise(env, asyncCallbackInfo, true);
3475 }
3476 return NapiGetResut(env, 1);
3477 }
3478
3479