1 /*
2  * Copyright (c) 2024 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_common_ability_execute_utils.h"
17 
18 #include "hilog_tag_wrapper.h"
19 #include "napi_common_ability_wrap_utils.h"
20 
21 namespace OHOS {
22 namespace AppExecFwk {
23 /**
24  * @brief GetAppType asynchronous processing function.
25  *
26  * @param env The environment that the Node-API call is invoked under.
27  * @param data Point to asynchronous processing of data.
28  */
GetAppTypeExecuteCB(napi_env,void * data)29 void GetAppTypeExecuteCB(napi_env, void *data)
30 {
31     TAG_LOGI(AAFwkTag::JSNAPI, "called");
32     AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
33     if (appTypeCB == nullptr) {
34         TAG_LOGE(AAFwkTag::JSNAPI, "null appTypeCB");
35         return;
36     }
37 
38     appTypeCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
39     if (appTypeCB->cbBase.ability == nullptr) {
40         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
41         appTypeCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
42         return;
43     }
44 
45     if (!CheckAbilityType(&appTypeCB->cbBase)) {
46         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
47         appTypeCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
48         return;
49     }
50 
51     appTypeCB->name = appTypeCB->cbBase.ability->GetAppType();
52 }
53 
54 /**
55  * @brief The callback at the end of the asynchronous callback.
56  *
57  * @param env The environment that the Node-API call is invoked under.
58  * @param data Point to asynchronous processing of data.
59  */
GetAppTypeAsyncCompleteCB(napi_env env,napi_status,void * data)60 void GetAppTypeAsyncCompleteCB(napi_env env, napi_status, void *data)
61 {
62     TAG_LOGI(AAFwkTag::JSNAPI, "called");
63     AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
64     napi_value callback = nullptr;
65     napi_value undefined = nullptr;
66     napi_value result[ARGS_TWO] = {nullptr};
67     napi_value callResult = nullptr;
68     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
69 
70     result[PARAM0] = GetCallbackErrorValue(env, appTypeCB->cbBase.errCode);
71     if (appTypeCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
72         NAPI_CALL_RETURN_VOID(env,
73             napi_create_string_utf8(
74                 env, appTypeCB->cbBase.ability->GetAppType().c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]));
75     } else {
76         result[PARAM1] = WrapUndefinedToJS(env);
77     }
78     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appTypeCB->cbBase.cbInfo.callback, &callback));
79     NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
80 
81     if (appTypeCB->cbBase.cbInfo.callback != nullptr) {
82         NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appTypeCB->cbBase.cbInfo.callback));
83     }
84     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appTypeCB->cbBase.asyncWork));
85     delete appTypeCB;
86     appTypeCB = nullptr;
87     TAG_LOGD(AAFwkTag::JSNAPI, "end");
88 }
89 
90 /**
91  * @brief The callback at the end of the Promise callback.
92  *
93  * @param env The environment that the Node-API call is invoked under.
94  * @param data Point to asynchronous processing of data.
95  */
GetAppTypePromiseCompleteCB(napi_env env,napi_status,void * data)96 void GetAppTypePromiseCompleteCB(napi_env env, napi_status, void *data)
97 {
98     TAG_LOGI(AAFwkTag::JSNAPI, "called");
99     AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
100     napi_value result = nullptr;
101     if (appTypeCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
102         napi_create_string_utf8(env, appTypeCB->cbBase.ability->GetAppType().c_str(), NAPI_AUTO_LENGTH, &result);
103         napi_resolve_deferred(env, appTypeCB->cbBase.deferred, result);
104     } else {
105         result = GetCallbackErrorValue(env, appTypeCB->cbBase.errCode);
106         napi_reject_deferred(env, appTypeCB->cbBase.deferred, result);
107     }
108 
109     napi_delete_async_work(env, appTypeCB->cbBase.asyncWork);
110     delete appTypeCB;
111     appTypeCB = nullptr;
112     TAG_LOGD(AAFwkTag::JSNAPI, "end");
113 }
114 
115 /**
116  * @brief GetAppType Async.
117  *
118  * @param env The environment that the Node-API call is invoked under.
119  * @param args Indicates the arguments passed into the callback.
120  * @param argcPromise Asynchronous data processing.
121  * @param appTypeCB Process data asynchronously.
122  *
123  * @return Return JS data successfully, otherwise return nullptr.
124  */
GetAppTypeAsync(napi_env env,napi_value * args,const size_t argCallback,AppTypeCB * appTypeCB)125 napi_value GetAppTypeAsync(napi_env env, napi_value *args, const size_t argCallback, AppTypeCB *appTypeCB)
126 {
127     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
128     if (args == nullptr || appTypeCB == nullptr) {
129         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
130         return nullptr;
131     }
132     napi_value resourceName = nullptr;
133     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
134 
135     napi_valuetype valuetype = napi_undefined;
136     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
137     if (valuetype == napi_function) {
138         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appTypeCB->cbBase.cbInfo.callback));
139     }
140     NAPI_CALL(env,
141         napi_create_async_work(env,
142             nullptr,
143             resourceName,
144             GetAppTypeExecuteCB,
145             GetAppTypeAsyncCompleteCB,
146             static_cast<void *>(appTypeCB),
147             &appTypeCB->cbBase.asyncWork));
148     NAPI_CALL(env, napi_queue_async_work_with_qos(env, appTypeCB->cbBase.asyncWork, napi_qos_user_initiated));
149     napi_value result = nullptr;
150     NAPI_CALL(env, napi_get_null(env, &result));
151 
152     return result;
153 }
154 
155 /**
156  * @brief GetAppType Promise.
157  *
158  * @param env The environment that the Node-API call is invoked under.
159  * @param appTypeCB Process data asynchronously.
160  *
161  * @return Return JS data successfully, otherwise return nullptr.
162  */
GetAppTypePromise(napi_env env,AppTypeCB * appTypeCB)163 napi_value GetAppTypePromise(napi_env env, AppTypeCB *appTypeCB)
164 {
165     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
166     if (appTypeCB == nullptr) {
167         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
168         return nullptr;
169     }
170     napi_value resourceName = nullptr;
171     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
172     napi_deferred deferred;
173     napi_value promise = nullptr;
174     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
175     appTypeCB->cbBase.deferred = deferred;
176 
177     NAPI_CALL(env,
178         napi_create_async_work(env,
179             nullptr,
180             resourceName,
181             GetAppTypeExecuteCB,
182             GetAppTypePromiseCompleteCB,
183             static_cast<void *>(appTypeCB),
184             &appTypeCB->cbBase.asyncWork));
185     NAPI_CALL(env, napi_queue_async_work_with_qos(env, appTypeCB->cbBase.asyncWork, napi_qos_user_initiated));
186 
187     return promise;
188 }
189 
190 /**
191  * @brief GetAppType processing function.
192  *
193  * @param env The environment that the Node-API call is invoked under.
194  * @param appTypeCB Process data asynchronously.
195  *
196  * @return Return JS data successfully, otherwise return nullptr.
197  */
GetAppTypeWrap(napi_env env,napi_callback_info info,AppTypeCB * appTypeCB)198 napi_value GetAppTypeWrap(napi_env env, napi_callback_info info, AppTypeCB *appTypeCB)
199 {
200     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
201     if (appTypeCB == nullptr) {
202         TAG_LOGE(AAFwkTag::JSNAPI, "null appTypeCB");
203         return nullptr;
204     }
205 
206     size_t argcAsync = 1;
207     const size_t argcPromise = 0;
208     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
209     napi_value args[ARGS_MAX_COUNT] = {nullptr};
210     napi_value ret = nullptr;
211 
212     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
213     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
214         TAG_LOGE(AAFwkTag::JSNAPI, "Wrong arguments count");
215         return nullptr;
216     }
217 
218     if (argcAsync > argcPromise) {
219         ret = GetAppTypeAsync(env, args, 0, appTypeCB);
220     } else {
221         ret = GetAppTypePromise(env, appTypeCB);
222     }
223 
224     return ret;
225 }
226 
227 /**
228  * @brief GetAbilityInfo asynchronous processing function.
229  *
230  * @param env The environment that the Node-API call is invoked under.
231  * @param data Point to asynchronous processing of data.
232  */
GetAbilityInfoExecuteCB(napi_env,void * data)233 void GetAbilityInfoExecuteCB(napi_env, void *data)
234 {
235     TAG_LOGI(AAFwkTag::JSNAPI, "called");
236     AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
237     if (abilityInfoCB == nullptr) {
238         TAG_LOGE(AAFwkTag::JSNAPI, "nullabilityInfoCB");
239         return;
240     }
241 
242     abilityInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
243     if (abilityInfoCB->cbBase.ability == nullptr) {
244         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
245         abilityInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
246         return;
247     }
248 
249     if (!CheckAbilityType(&abilityInfoCB->cbBase)) {
250         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
251         abilityInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
252         return;
253     }
254 
255     std::shared_ptr<AbilityInfo> abilityInfoPtr = abilityInfoCB->cbBase.ability->GetAbilityInfo();
256     if (abilityInfoPtr != nullptr) {
257         abilityInfoCB->abilityInfo = *abilityInfoPtr;
258     } else {
259         abilityInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
260     }
261     TAG_LOGD(AAFwkTag::JSNAPI, "end");
262 }
263 
264 /**
265  * @brief The callback at the end of the asynchronous callback.
266  *
267  * @param env The environment that the Node-API call is invoked under.
268  * @param data Point to asynchronous processing of data.
269  */
GetAbilityInfoAsyncCompleteCB(napi_env env,napi_status,void * data)270 void GetAbilityInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
271 {
272     TAG_LOGI(AAFwkTag::JSNAPI, "called");
273     AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
274     napi_value callback = nullptr;
275     napi_value undefined = nullptr;
276     napi_value result[ARGS_TWO] = {nullptr};
277     napi_value callResult = nullptr;
278     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
279     result[PARAM0] = GetCallbackErrorValue(env, abilityInfoCB->cbBase.errCode);
280     if (abilityInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
281         result[PARAM1] = WrapAbilityInfo(env, abilityInfoCB->abilityInfo);
282     } else {
283         result[PARAM1] = WrapUndefinedToJS(env);
284     }
285     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, abilityInfoCB->cbBase.cbInfo.callback, &callback));
286     NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
287 
288     if (abilityInfoCB->cbBase.cbInfo.callback != nullptr) {
289         NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, abilityInfoCB->cbBase.cbInfo.callback));
290     }
291     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, abilityInfoCB->cbBase.asyncWork));
292     delete abilityInfoCB;
293     abilityInfoCB = nullptr;
294     TAG_LOGD(AAFwkTag::JSNAPI, "end");
295 }
296 
297 /**
298  * @brief The callback at the end of the Promise callback.
299  *
300  * @param env The environment that the Node-API call is invoked under.
301  * @param data Point to asynchronous processing of data.
302  */
GetAbilityInfoPromiseCompleteCB(napi_env env,napi_status,void * data)303 void GetAbilityInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
304 {
305     TAG_LOGI(AAFwkTag::JSNAPI, "called");
306     AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
307     napi_value result = nullptr;
308     if (abilityInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
309         result = WrapAbilityInfo(env, abilityInfoCB->abilityInfo);
310         napi_resolve_deferred(env, abilityInfoCB->cbBase.deferred, result);
311     } else {
312         result = GetCallbackErrorValue(env, abilityInfoCB->cbBase.errCode);
313         napi_reject_deferred(env, abilityInfoCB->cbBase.deferred, result);
314     }
315 
316     napi_delete_async_work(env, abilityInfoCB->cbBase.asyncWork);
317     delete abilityInfoCB;
318     abilityInfoCB = nullptr;
319     TAG_LOGD(AAFwkTag::JSNAPI, "end");
320 }
321 
322 /**
323  * @brief GetAbilityInfo Async.
324  *
325  * @param env The environment that the Node-API call is invoked under.
326  * @param args Indicates the arguments passed into the callback.
327  * @param argcPromise Asynchronous data processing.
328  * @param abilityInfoCB Process data asynchronously.
329  *
330  * @return Return JS data successfully, otherwise return nullptr.
331  */
GetAbilityInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AbilityInfoCB * abilityInfoCB)332 napi_value GetAbilityInfoAsync(napi_env env, napi_value *args, const size_t argCallback, AbilityInfoCB *abilityInfoCB)
333 {
334     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
335     if (args == nullptr || abilityInfoCB == nullptr) {
336         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
337         return nullptr;
338     }
339     napi_value resourceName = nullptr;
340     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
341 
342     napi_valuetype valuetype = napi_undefined;
343     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
344     if (valuetype == napi_function) {
345         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &abilityInfoCB->cbBase.cbInfo.callback));
346     }
347     NAPI_CALL(env,
348         napi_create_async_work(env,
349             nullptr,
350             resourceName,
351             GetAbilityInfoExecuteCB,
352             GetAbilityInfoAsyncCompleteCB,
353             static_cast<void *>(abilityInfoCB),
354             &abilityInfoCB->cbBase.asyncWork));
355     NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
356     napi_value result = nullptr;
357     NAPI_CALL(env, napi_get_null(env, &result));
358 
359     return result;
360 }
361 
362 /**
363  * @brief GetAbilityInfo Promise.
364  *
365  * @param env The environment that the Node-API call is invoked under.
366  * @param abilityInfoCB Process data asynchronously.
367  *
368  * @return Return JS data successfully, otherwise return nullptr.
369  */
GetAbilityInfoPromise(napi_env env,AbilityInfoCB * abilityInfoCB)370 napi_value GetAbilityInfoPromise(napi_env env, AbilityInfoCB *abilityInfoCB)
371 {
372     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
373     if (abilityInfoCB == nullptr) {
374         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
375         return nullptr;
376     }
377     napi_value resourceName = nullptr;
378     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
379     napi_deferred deferred;
380     napi_value promise = nullptr;
381     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
382     abilityInfoCB->cbBase.deferred = deferred;
383 
384     NAPI_CALL(env,
385         napi_create_async_work(env,
386             nullptr,
387             resourceName,
388             GetAbilityInfoExecuteCB,
389             GetAbilityInfoPromiseCompleteCB,
390             static_cast<void *>(abilityInfoCB),
391             &abilityInfoCB->cbBase.asyncWork));
392     NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
393 
394     return promise;
395 }
396 
397 /**
398  * @brief GetAbilityInfo processing function.
399  *
400  * @param env The environment that the Node-API call is invoked under.
401  * @param abilityInfoCB Process data asynchronously.
402  *
403  * @return Return JS data successfully, otherwise return nullptr.
404  */
GetAbilityInfoWrap(napi_env env,napi_callback_info info,AbilityInfoCB * abilityInfoCB)405 napi_value GetAbilityInfoWrap(napi_env env, napi_callback_info info, AbilityInfoCB *abilityInfoCB)
406 {
407     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
408     if (abilityInfoCB == nullptr) {
409         TAG_LOGE(AAFwkTag::JSNAPI, "nullabilityInfoCB");
410         return nullptr;
411     }
412 
413     size_t argcAsync = 1;
414     const size_t argcPromise = 0;
415     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
416     napi_value args[ARGS_MAX_COUNT] = {nullptr};
417     napi_value ret = nullptr;
418 
419     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
420     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
421         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
422         return nullptr;
423     }
424 
425     if (argcAsync > argcPromise) {
426         ret = GetAbilityInfoAsync(env, args, 0, abilityInfoCB);
427     } else {
428         ret = GetAbilityInfoPromise(env, abilityInfoCB);
429     }
430 
431     return ret;
432 }
433 
GetHapModuleInfoExecuteCB(napi_env,void * data)434 void GetHapModuleInfoExecuteCB(napi_env, void *data)
435 {
436     TAG_LOGI(AAFwkTag::JSNAPI, "called");
437     HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
438     if (hapModuleInfoCB == nullptr) {
439         TAG_LOGE(AAFwkTag::JSNAPI, "null hapModuleInfoCB");
440         return;
441     }
442 
443     hapModuleInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
444     if (hapModuleInfoCB->cbBase.ability == nullptr) {
445         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
446         hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
447         return;
448     }
449 
450     if (!CheckAbilityType(&hapModuleInfoCB->cbBase)) {
451         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
452         hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
453         return;
454     }
455 
456     std::shared_ptr<HapModuleInfo> hapModuleInfoPtr = hapModuleInfoCB->cbBase.ability->GetHapModuleInfo();
457     if (hapModuleInfoPtr != nullptr) {
458         hapModuleInfoCB->hapModuleInfo = *hapModuleInfoPtr;
459     } else {
460         hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
461     }
462     TAG_LOGD(AAFwkTag::JSNAPI, "end");
463 }
464 
GetHapModuleInfoAsyncCompleteCB(napi_env env,napi_status,void * data)465 void GetHapModuleInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
466 {
467     TAG_LOGI(AAFwkTag::JSNAPI, "called");
468     HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
469     napi_value callback = nullptr;
470     napi_value undefined = nullptr;
471     napi_value result[ARGS_TWO] = {nullptr};
472     napi_value callResult = nullptr;
473     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
474     result[PARAM0] = GetCallbackErrorValue(env, hapModuleInfoCB->cbBase.errCode);
475     if (hapModuleInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
476         result[PARAM1] = WrapHapModuleInfo(env, *hapModuleInfoCB);
477     } else {
478         result[PARAM1] = WrapUndefinedToJS(env);
479     }
480     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, hapModuleInfoCB->cbBase.cbInfo.callback, &callback));
481     NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
482 
483     if (hapModuleInfoCB->cbBase.cbInfo.callback != nullptr) {
484         NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, hapModuleInfoCB->cbBase.cbInfo.callback));
485     }
486     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, hapModuleInfoCB->cbBase.asyncWork));
487     delete hapModuleInfoCB;
488     hapModuleInfoCB = nullptr;
489     TAG_LOGD(AAFwkTag::JSNAPI, "end");
490 }
491 
GetHapModuleInfoPromiseCompleteCB(napi_env env,napi_status,void * data)492 void GetHapModuleInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
493 {
494     TAG_LOGI(AAFwkTag::JSNAPI, "called");
495     HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
496     napi_value result = nullptr;
497     if (hapModuleInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
498         result = WrapHapModuleInfo(env, *hapModuleInfoCB);
499         napi_resolve_deferred(env, hapModuleInfoCB->cbBase.deferred, result);
500     } else {
501         result = GetCallbackErrorValue(env, hapModuleInfoCB->cbBase.errCode);
502         napi_reject_deferred(env, hapModuleInfoCB->cbBase.deferred, result);
503     }
504 
505     napi_delete_async_work(env, hapModuleInfoCB->cbBase.asyncWork);
506     delete hapModuleInfoCB;
507     hapModuleInfoCB = nullptr;
508     TAG_LOGD(AAFwkTag::JSNAPI, "end");
509 }
510 
511 /**
512  * @brief GetHapModuleInfo Async.
513  *
514  * @param env The environment that the Node-API call is invoked under.
515  * @param args Indicates the arguments passed into the callback.
516  * @param argcPromise Asynchronous data processing.
517  * @param hapModuleInfoCB Process data asynchronously.
518  *
519  * @return Return JS data successfully, otherwise return nullptr.
520  */
GetHapModuleInfoAsync(napi_env env,napi_value * args,const size_t argCallback,HapModuleInfoCB * hapModuleInfoCB)521 napi_value GetHapModuleInfoAsync(
522     napi_env env, napi_value *args, const size_t argCallback, HapModuleInfoCB *hapModuleInfoCB)
523 {
524     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
525     if (args == nullptr || hapModuleInfoCB == nullptr) {
526         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
527         return nullptr;
528     }
529     napi_value resourceName = nullptr;
530     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
531 
532     napi_valuetype valuetype = napi_undefined;
533     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
534     if (valuetype == napi_function) {
535         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &hapModuleInfoCB->cbBase.cbInfo.callback));
536     }
537     NAPI_CALL(env,
538         napi_create_async_work(env,
539             nullptr,
540             resourceName,
541             GetHapModuleInfoExecuteCB,
542             GetHapModuleInfoAsyncCompleteCB,
543             static_cast<void *>(hapModuleInfoCB),
544             &hapModuleInfoCB->cbBase.asyncWork));
545     NAPI_CALL(env, napi_queue_async_work_with_qos(env, hapModuleInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
546     napi_value result = nullptr;
547     NAPI_CALL(env, napi_get_null(env, &result));
548 
549     return result;
550 }
551 
552 /**
553  * @brief GetHapModuleInfo Promise.
554  *
555  * @param env The environment that the Node-API call is invoked under.
556  * @param hapModuleInfoCB Process data asynchronously.
557  *
558  * @return Return JS data successfully, otherwise return nullptr.
559  */
GetHapModuleInfoPromise(napi_env env,HapModuleInfoCB * hapModuleInfoCB)560 napi_value GetHapModuleInfoPromise(napi_env env, HapModuleInfoCB *hapModuleInfoCB)
561 {
562     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
563     if (hapModuleInfoCB == nullptr) {
564         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
565         return nullptr;
566     }
567     napi_value resourceName = nullptr;
568     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
569     napi_deferred deferred;
570     napi_value promise = nullptr;
571     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
572     hapModuleInfoCB->cbBase.deferred = deferred;
573 
574     NAPI_CALL(env,
575         napi_create_async_work(env,
576             nullptr,
577             resourceName,
578             GetHapModuleInfoExecuteCB,
579             GetHapModuleInfoPromiseCompleteCB,
580             static_cast<void *>(hapModuleInfoCB),
581             &hapModuleInfoCB->cbBase.asyncWork));
582     NAPI_CALL(env, napi_queue_async_work_with_qos(env, hapModuleInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
583 
584     return promise;
585 }
586 
GetHapModuleInfoWrap(napi_env env,napi_callback_info info,HapModuleInfoCB * hapModuleInfoCB)587 napi_value GetHapModuleInfoWrap(napi_env env, napi_callback_info info, HapModuleInfoCB *hapModuleInfoCB)
588 {
589     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
590     if (hapModuleInfoCB == nullptr) {
591         TAG_LOGE(AAFwkTag::JSNAPI, "null hapModuleInfoCB");
592         return nullptr;
593     }
594 
595     size_t argcAsync = 1;
596     const size_t argcPromise = 0;
597     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
598     napi_value args[ARGS_MAX_COUNT] = {nullptr};
599     napi_value ret = nullptr;
600 
601     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
602     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
603         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
604         return nullptr;
605     }
606 
607     if (argcAsync > argcPromise) {
608         ret = GetHapModuleInfoAsync(env, args, 0, hapModuleInfoCB);
609     } else {
610         ret = GetHapModuleInfoPromise(env, hapModuleInfoCB);
611     }
612 
613     return ret;
614 }
615 
GetAppVersionInfoExecuteCB(napi_env,void * data)616 void GetAppVersionInfoExecuteCB(napi_env, void *data)
617 {
618     TAG_LOGI(AAFwkTag::JSNAPI, "called");
619     AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
620     if (appVersionInfoCB == nullptr) {
621         TAG_LOGE(AAFwkTag::JSNAPI, "null appVersionInfoCB");
622         return;
623     }
624 
625     appVersionInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
626     if (appVersionInfoCB->cbBase.ability == nullptr) {
627         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
628         appVersionInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
629         return;
630     }
631 
632     if (!CheckAbilityType(&appVersionInfoCB->cbBase)) {
633         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
634         appVersionInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
635         return;
636     }
637 
638     std::shared_ptr<ApplicationInfo> appInfoPtr = appVersionInfoCB->cbBase.ability->GetApplicationInfo();
639     if (appInfoPtr != nullptr) {
640         SaveAppVersionInfo(appVersionInfoCB->appVersionInfo, appInfoPtr->name, appInfoPtr->versionName,
641             appInfoPtr->versionCode);
642     } else {
643         appVersionInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
644     }
645     TAG_LOGD(AAFwkTag::JSNAPI, "end");
646 }
647 
GetAppVersionInfoAsyncCompleteCB(napi_env env,napi_status,void * data)648 void GetAppVersionInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
649 {
650     TAG_LOGI(AAFwkTag::JSNAPI, "called");
651     AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
652     napi_value callback = nullptr;
653     napi_value undefined = nullptr;
654     napi_value result[ARGS_TWO] = {nullptr};
655     napi_value callResult = nullptr;
656     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
657     result[PARAM0] = GetCallbackErrorValue(env, appVersionInfoCB->cbBase.errCode);
658     if (appVersionInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
659         result[PARAM1] = WrapAppVersionInfo(env, *appVersionInfoCB);
660     } else {
661         result[PARAM1] = WrapUndefinedToJS(env);
662     }
663     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appVersionInfoCB->cbBase.cbInfo.callback, &callback));
664     NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
665 
666     if (appVersionInfoCB->cbBase.cbInfo.callback != nullptr) {
667         NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appVersionInfoCB->cbBase.cbInfo.callback));
668     }
669     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appVersionInfoCB->cbBase.asyncWork));
670     delete appVersionInfoCB;
671     appVersionInfoCB = nullptr;
672     TAG_LOGD(AAFwkTag::JSNAPI, "end");
673 }
674 
GetAppVersionInfoPromiseCompleteCB(napi_env env,napi_status,void * data)675 void GetAppVersionInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
676 {
677     TAG_LOGI(AAFwkTag::JSNAPI, "called");
678     AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
679     napi_value result = nullptr;
680     if (appVersionInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
681         result = WrapAppVersionInfo(env, *appVersionInfoCB);
682         napi_resolve_deferred(env, appVersionInfoCB->cbBase.deferred, result);
683     } else {
684         result = GetCallbackErrorValue(env, appVersionInfoCB->cbBase.errCode);
685         napi_reject_deferred(env, appVersionInfoCB->cbBase.deferred, result);
686     }
687 
688     napi_delete_async_work(env, appVersionInfoCB->cbBase.asyncWork);
689     delete appVersionInfoCB;
690     appVersionInfoCB = nullptr;
691     TAG_LOGD(AAFwkTag::JSNAPI, "end");
692 }
693 
694 /**
695  * @brief GetAppVersionInfo Async.
696  *
697  * @param env The environment that the Node-API call is invoked under.
698  * @param args Indicates the arguments passed into the callback.
699  * @param argcPromise Asynchronous data processing.
700  * @param AppVersionInfoCB Process data asynchronously.
701  *
702  * @return Return JS data successfully, otherwise return nullptr.
703  */
GetAppVersionInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AppVersionInfoCB * appVersionInfoCB)704 napi_value GetAppVersionInfoAsync(
705     napi_env env, napi_value *args, const size_t argCallback, AppVersionInfoCB *appVersionInfoCB)
706 {
707     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
708     if (args == nullptr || appVersionInfoCB == nullptr) {
709         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
710         return nullptr;
711     }
712     napi_value resourceName = nullptr;
713     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
714 
715     napi_valuetype valuetype = napi_undefined;
716     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
717     if (valuetype == napi_function) {
718         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appVersionInfoCB->cbBase.cbInfo.callback));
719     }
720     NAPI_CALL(
721         env, napi_create_async_work(env, nullptr, resourceName, GetAppVersionInfoExecuteCB,
722                  GetAppVersionInfoAsyncCompleteCB, static_cast<void *>(appVersionInfoCB),
723                  &appVersionInfoCB->cbBase.asyncWork));
724     NAPI_CALL(env, napi_queue_async_work_with_qos(env, appVersionInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
725     napi_value result = nullptr;
726     NAPI_CALL(env, napi_get_null(env, &result));
727 
728     return result;
729 }
730 
731 /**
732  * @brief GetAppVersionInfo Promise.
733  *
734  * @param env The environment that the Node-API call is invoked under.
735  * @param AppVersionInfoCB Process data asynchronously.
736  *
737  * @return Return JS data successfully, otherwise return nullptr.
738  */
GetAppVersionInfoPromise(napi_env env,AppVersionInfoCB * appVersionInfoCB)739 napi_value GetAppVersionInfoPromise(napi_env env, AppVersionInfoCB *appVersionInfoCB)
740 {
741     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
742     if (appVersionInfoCB == nullptr) {
743         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
744         return nullptr;
745     }
746     napi_value resourceName = nullptr;
747     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
748     napi_deferred deferred;
749     napi_value promise = nullptr;
750     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
751     appVersionInfoCB->cbBase.deferred = deferred;
752 
753     NAPI_CALL(
754         env, napi_create_async_work(env, nullptr, resourceName, GetAppVersionInfoExecuteCB,
755                  GetAppVersionInfoPromiseCompleteCB, static_cast<void *>(appVersionInfoCB),
756                  &appVersionInfoCB->cbBase.asyncWork));
757     NAPI_CALL(env, napi_queue_async_work_with_qos(env, appVersionInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
758 
759     return promise;
760 }
761 
GetAppVersionInfoWrap(napi_env env,napi_callback_info info,AppVersionInfoCB * appVersionInfoCB)762 napi_value GetAppVersionInfoWrap(napi_env env, napi_callback_info info, AppVersionInfoCB *appVersionInfoCB)
763 {
764     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
765     if (appVersionInfoCB == nullptr) {
766         TAG_LOGE(AAFwkTag::JSNAPI, "null appVersionInfoCB");
767         return nullptr;
768     }
769 
770     size_t argcAsync = 1;
771     const size_t argcPromise = 0;
772     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
773     napi_value args[ARGS_MAX_COUNT] = {nullptr};
774     napi_value ret = nullptr;
775 
776     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
777     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
778         TAG_LOGE(AAFwkTag::JSNAPI, "fail argument count");
779         return nullptr;
780     }
781 
782     if (argcAsync > argcPromise) {
783         ret = GetAppVersionInfoAsync(env, args, 0, appVersionInfoCB);
784     } else {
785         ret = GetAppVersionInfoPromise(env, appVersionInfoCB);
786     }
787 
788     return ret;
789 }
790 
GetWantExecuteCB(napi_env,void * data)791 void GetWantExecuteCB(napi_env, void *data)
792 {
793     TAG_LOGI(AAFwkTag::JSNAPI, "called");
794     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
795     if (asyncCallbackInfo == nullptr) {
796         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
797         return;
798     }
799     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
800     if (asyncCallbackInfo->ability == nullptr) {
801         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
802         asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
803         return;
804     }
805 
806     if (!CheckAbilityType(asyncCallbackInfo)) {
807         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
808         asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
809         return;
810     }
811 
812     std::shared_ptr<AAFwk::Want> ptrWant = asyncCallbackInfo->ability->GetWant();
813     if (ptrWant != nullptr) {
814         asyncCallbackInfo->param.want = *ptrWant;
815     } else {
816         asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_CALL_INVALID;
817     }
818     TAG_LOGD(AAFwkTag::JSNAPI, "end");
819 }
820 
GetWantAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)821 napi_value GetWantAsync(napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
822 {
823     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
824     if (args == nullptr || asyncCallbackInfo == nullptr) {
825         TAG_LOGE(AAFwkTag::JSNAPI, "null params");
826         return nullptr;
827     }
828     napi_value resourceName = nullptr;
829     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
830 
831     napi_valuetype valuetype = napi_undefined;
832     napi_typeof(env, args[argCallback], &valuetype);
833     if (valuetype == napi_function) {
834         TAG_LOGD(AAFwkTag::JSNAPI, "napi_create_reference");
835         napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
836     }
837     napi_create_async_work(env, nullptr, resourceName, GetWantExecuteCB,
838         [](napi_env env, napi_status, void *data) {
839             TAG_LOGI(AAFwkTag::JSNAPI, "called");
840             AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
841             napi_value callback = nullptr;
842             napi_value undefined = nullptr;
843             napi_value result[ARGS_TWO] = {nullptr};
844             napi_value callResult = nullptr;
845             napi_get_undefined(env, &undefined);
846             result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
847             if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
848                 result[PARAM1] = WrapWant(env, asyncCallbackInfo->param.want);
849             } else {
850                 result[PARAM1] = WrapUndefinedToJS(env);
851             }
852             napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
853             napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
854 
855             if (asyncCallbackInfo->cbInfo.callback != nullptr) {
856                 TAG_LOGD(AAFwkTag::JSNAPI, "Delete GetWantAsync callback reference.");
857                 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
858             }
859             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
860             delete asyncCallbackInfo;
861             asyncCallbackInfo = nullptr;
862             TAG_LOGD(AAFwkTag::JSNAPI, "end");
863         },
864         static_cast<void *>(asyncCallbackInfo),
865         &asyncCallbackInfo->asyncWork);
866     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
867     napi_value result = nullptr;
868     napi_get_null(env, &result);
869 
870     return result;
871 }
872 
GetWantPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)873 napi_value GetWantPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
874 {
875     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
876     if (asyncCallbackInfo == nullptr) {
877         TAG_LOGE(AAFwkTag::JSNAPI, "null params");
878         return nullptr;
879     }
880     napi_value resourceName = nullptr;
881     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
882     napi_deferred deferred;
883     napi_value promise = nullptr;
884     napi_create_promise(env, &deferred, &promise);
885     asyncCallbackInfo->deferred = deferred;
886 
887     napi_create_async_work(
888         env,
889         nullptr,
890         resourceName,
891         GetWantExecuteCB,
892         [](napi_env env, napi_status, void *data) {
893             TAG_LOGI(AAFwkTag::JSNAPI, "called");
894             AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
895             napi_value result = nullptr;
896             if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
897                 result = WrapWant(env, asyncCallbackInfo->param.want);
898                 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
899             } else {
900                 result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
901                 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
902             }
903 
904             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
905             delete asyncCallbackInfo;
906             asyncCallbackInfo = nullptr;
907             TAG_LOGD(AAFwkTag::JSNAPI, "end");
908         },
909         static_cast<void *>(asyncCallbackInfo),
910         &asyncCallbackInfo->asyncWork);
911     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
912 
913     return promise;
914 }
915 
916 /**
917  * @brief GetWantWrap processing function.
918  *
919  * @param env The environment that the Node-API call is invoked under.
920  * @param asyncCallbackInfo Process data asynchronously.
921  *
922  * @return Return JS data successfully, otherwise return nullptr.
923  */
GetWantWrap(napi_env env,napi_callback_info info,AsyncCallbackInfo * asyncCallbackInfo)924 napi_value GetWantWrap(napi_env env, napi_callback_info info, AsyncCallbackInfo *asyncCallbackInfo)
925 {
926     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
927     if (asyncCallbackInfo == nullptr) {
928         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
929         return nullptr;
930     }
931 
932     size_t argcAsync = 1;
933     const size_t argcPromise = 0;
934     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
935     napi_value args[ARGS_MAX_COUNT] = {nullptr};
936     napi_value ret = nullptr;
937 
938     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
939     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
940         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
941         return nullptr;
942     }
943 
944     if (argcAsync > argcPromise) {
945         ret = GetWantAsync(env, args, 0, asyncCallbackInfo);
946     } else {
947         ret = GetWantPromise(env, asyncCallbackInfo);
948     }
949 
950     return ret;
951 }
952 
953 /**
954  * @brief GetAbilityName asynchronous processing function.
955  *
956  * @param env The environment that the Node-API call is invoked under.
957  * @param data Point to asynchronous processing of data.
958  */
GetAbilityNameExecuteCB(napi_env,void * data)959 void GetAbilityNameExecuteCB(napi_env, void *data)
960 {
961     TAG_LOGI(AAFwkTag::JSNAPI, "called");
962     AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
963     if (abilityNameCB == nullptr) {
964         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityNameCB");
965         return;
966     }
967     abilityNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
968     if (abilityNameCB->cbBase.ability == nullptr) {
969         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
970         abilityNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
971         return;
972     }
973 
974     if (!CheckAbilityType(&abilityNameCB->cbBase)) {
975         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
976         abilityNameCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
977         return;
978     }
979 
980     abilityNameCB->name = abilityNameCB->cbBase.ability->GetAbilityName();
981     TAG_LOGD(AAFwkTag::JSNAPI, "end");
982 }
983 
984 /**
985  * @brief The callback at the end of the asynchronous callback.
986  *
987  * @param env The environment that the Node-API call is invoked under.
988  * @param data Point to asynchronous processing of data.
989  */
GetAbilityNameAsyncCompleteCB(napi_env env,napi_status,void * data)990 void GetAbilityNameAsyncCompleteCB(napi_env env, napi_status, void *data)
991 {
992     TAG_LOGI(AAFwkTag::JSNAPI, "called");
993     AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
994     napi_value callback = nullptr;
995     napi_value undefined = nullptr;
996     napi_value result[ARGS_TWO] = {nullptr};
997     napi_value callResult = nullptr;
998     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
999     result[PARAM0] = GetCallbackErrorValue(env, abilityNameCB->cbBase.errCode);
1000     if (abilityNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1001         result[PARAM1] = WrapAbilityName(env, abilityNameCB);
1002     } else {
1003         result[PARAM1] = WrapUndefinedToJS(env);
1004     }
1005     NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, abilityNameCB->cbBase.cbInfo.callback, &callback));
1006     NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1007     if (abilityNameCB->cbBase.cbInfo.callback != nullptr) {
1008         NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, abilityNameCB->cbBase.cbInfo.callback));
1009     }
1010     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, abilityNameCB->cbBase.asyncWork));
1011     delete abilityNameCB;
1012     abilityNameCB = nullptr;
1013     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1014 }
1015 
1016 /**
1017  * @brief The callback at the end of the Promise callback.
1018  *
1019  * @param env The environment that the Node-API call is invoked under.
1020  * @param data Point to asynchronous processing of data.
1021  */
GetAbilityNamePromiseCompleteCB(napi_env env,napi_status,void * data)1022 void GetAbilityNamePromiseCompleteCB(napi_env env, napi_status, void *data)
1023 {
1024     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1025     AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
1026     napi_value result = nullptr;
1027     if (abilityNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1028         result = WrapAbilityName(env, abilityNameCB);
1029         napi_resolve_deferred(env, abilityNameCB->cbBase.deferred, result);
1030     } else {
1031         result = GetCallbackErrorValue(env, abilityNameCB->cbBase.errCode);
1032         napi_reject_deferred(env, abilityNameCB->cbBase.deferred, result);
1033     }
1034 
1035     napi_delete_async_work(env, abilityNameCB->cbBase.asyncWork);
1036     delete abilityNameCB;
1037     abilityNameCB = nullptr;
1038 }
1039 
1040 /**
1041  * @brief GetAbilityName Async.
1042  *
1043  * @param env The environment that the Node-API call is invoked under.
1044  * @param args Indicates the arguments passed into the callback.
1045  * @param argcPromise Asynchronous data processing.
1046  * @param abilityNameCB Process data asynchronously.
1047  *
1048  * @return Return JS data successfully, otherwise return nullptr.
1049  */
GetAbilityNameAsync(napi_env env,napi_value * args,const size_t argCallback,AbilityNameCB * abilityNameCB)1050 napi_value GetAbilityNameAsync(napi_env env, napi_value *args, const size_t argCallback, AbilityNameCB *abilityNameCB)
1051 {
1052     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1053     if (args == nullptr || abilityNameCB == nullptr) {
1054         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1055         return nullptr;
1056     }
1057     napi_value resourceName = nullptr;
1058     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1059 
1060     napi_valuetype valuetype = napi_undefined;
1061     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1062     if (valuetype == napi_function) {
1063         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &abilityNameCB->cbBase.cbInfo.callback));
1064     }
1065     NAPI_CALL(env,
1066         napi_create_async_work(env,
1067             nullptr,
1068             resourceName,
1069             GetAbilityNameExecuteCB,
1070             GetAbilityNameAsyncCompleteCB,
1071             static_cast<void *>(abilityNameCB),
1072             &abilityNameCB->cbBase.asyncWork));
1073     NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1074     napi_value result = nullptr;
1075     NAPI_CALL(env, napi_get_null(env, &result));
1076 
1077     return result;
1078 }
1079 
1080 /**
1081  * @brief GetAbilityName Promise.
1082  *
1083  * @param env The environment that the Node-API call is invoked under.
1084  * @param abilityNameCB Process data asynchronously.
1085  *
1086  * @return Return JS data successfully, otherwise return nullptr.
1087  */
GetAbilityNamePromise(napi_env env,AbilityNameCB * abilityNameCB)1088 napi_value GetAbilityNamePromise(napi_env env, AbilityNameCB *abilityNameCB)
1089 {
1090     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1091     if (abilityNameCB == nullptr) {
1092         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1093         return nullptr;
1094     }
1095     napi_value resourceName = nullptr;
1096     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1097     napi_deferred deferred;
1098     napi_value promise = nullptr;
1099     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1100     abilityNameCB->cbBase.deferred = deferred;
1101 
1102     NAPI_CALL(env,
1103         napi_create_async_work(env,
1104             nullptr,
1105             resourceName,
1106             GetAbilityNameExecuteCB,
1107             GetAbilityNamePromiseCompleteCB,
1108             static_cast<void *>(abilityNameCB),
1109             &abilityNameCB->cbBase.asyncWork));
1110     NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityNameCB->cbBase.asyncWork, napi_qos_user_initiated));
1111 
1112     return promise;
1113 }
1114 
1115 /**
1116  * @brief GetAbilityName processing function.
1117  *
1118  * @param env The environment that the Node-API call is invoked under.
1119  * @param abilityNameCB Process data asynchronously.
1120  *
1121  * @return Return JS data successfully, otherwise return nullptr.
1122  */
GetAbilityNameWrap(napi_env env,napi_callback_info info,AbilityNameCB * abilityNameCB)1123 napi_value GetAbilityNameWrap(napi_env env, napi_callback_info info, AbilityNameCB *abilityNameCB)
1124 {
1125     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1126     if (abilityNameCB == nullptr) {
1127         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityNameCB");
1128         return nullptr;
1129     }
1130 
1131     size_t argcAsync = 1;
1132     const size_t argcPromise = 0;
1133     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1134     napi_value args[ARGS_MAX_COUNT] = {nullptr};
1135     napi_value ret = nullptr;
1136 
1137     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1138     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1139         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1140         return nullptr;
1141     }
1142 
1143     if (argcAsync > argcPromise) {
1144         ret = GetAbilityNameAsync(env, args, 0, abilityNameCB);
1145     } else {
1146         ret = GetAbilityNamePromise(env, abilityNameCB);
1147     }
1148 
1149     return ret;
1150 }
1151 
StopAbilityExecuteCallback(napi_env,void * data)1152 void StopAbilityExecuteCallback(napi_env, void *data)
1153 {
1154     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1155     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
1156     if (asyncCallbackInfo == nullptr) {
1157         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1158         return;
1159     }
1160 
1161     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1162     asyncCallbackInfo->native_data.data_type = NVT_NONE;
1163 
1164     if (asyncCallbackInfo->ability == nullptr) {
1165         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1166         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
1167         return;
1168     }
1169 
1170     if (!CheckAbilityType(asyncCallbackInfo)) {
1171         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
1172         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
1173         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
1174         return;
1175     }
1176 
1177     asyncCallbackInfo->native_data.data_type = NVT_BOOL;
1178     asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->StopAbility(asyncCallbackInfo->param.want);
1179     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1180 }
1181 
StopAbilityWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)1182 napi_value StopAbilityWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
1183 {
1184     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1185     size_t argc = ARGS_MAX_COUNT;
1186     napi_value args[ARGS_MAX_COUNT] = {nullptr};
1187     napi_value jsthis = nullptr;
1188     void *data = nullptr;
1189 
1190     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1191 
1192     if (!UnwrapParamStopAbilityWrap(env, argc, args, asyncCallbackInfo)) {
1193         TAG_LOGI(AAFwkTag::JSNAPI, "Invoke UnwrapParamStopAbility fail");
1194         return nullptr;
1195     }
1196 
1197     AsyncParamEx asyncParamEx;
1198     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1199         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1200         asyncParamEx.resource = "NAPI_StopAbilityWrapCallback";
1201         asyncParamEx.execute = StopAbilityExecuteCallback;
1202         asyncParamEx.complete = CompleteAsyncCallbackWork;
1203 
1204         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1205     } else {
1206         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1207         asyncParamEx.resource = "NAPI_StopAbilityWrapPromise";
1208         asyncParamEx.execute = StopAbilityExecuteCallback;
1209         asyncParamEx.complete = CompletePromiseCallbackWork;
1210 
1211         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1212     }
1213 }
1214 
StartBackgroundRunningExecuteCB(napi_env env,void * data)1215 void StartBackgroundRunningExecuteCB(napi_env env, void *data)
1216 {
1217     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1218     AsyncCallbackInfo *asyncCallbackInfo = (AsyncCallbackInfo *)data;
1219     if (asyncCallbackInfo == nullptr) {
1220         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1221         return;
1222     }
1223     if (asyncCallbackInfo->errCode == NAPI_ERR_PARAM_INVALID) {
1224         TAG_LOGE(AAFwkTag::JSNAPI, "parse input param failed");
1225         return;
1226     }
1227     if (asyncCallbackInfo->ability == nullptr) {
1228         asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
1229         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1230         return;
1231     }
1232     const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
1233     if (info == nullptr) {
1234         TAG_LOGE(AAFwkTag::JSNAPI, "ability info is null");
1235         asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
1236         return;
1237     }
1238 
1239     AbilityRuntime::WantAgent::WantAgent wantAgentObj;
1240     if (!asyncCallbackInfo->wantAgent) {
1241         TAG_LOGW(AAFwkTag::JSNAPI, "input param without wantAgent");
1242         wantAgentObj = AbilityRuntime::WantAgent::WantAgent();
1243     } else {
1244         wantAgentObj = *asyncCallbackInfo->wantAgent;
1245     }
1246     asyncCallbackInfo->errCode = asyncCallbackInfo->ability->StartBackgroundRunning(wantAgentObj);
1247 
1248     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1249 }
1250 
BackgroundRunningCallbackCompletedCB(napi_env env,napi_status status,void * data)1251 void BackgroundRunningCallbackCompletedCB(napi_env env, napi_status status, void *data)
1252 {
1253     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1254     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
1255     napi_value callback = nullptr;
1256     napi_value undefined = nullptr;
1257     napi_value result[ARGS_TWO] = {nullptr};
1258     napi_value callResult = nullptr;
1259     napi_get_undefined(env, &undefined);
1260     if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
1261         result[0] = WrapUndefinedToJS(env);
1262         napi_create_int32(env, 0, &result[1]);
1263     } else {
1264         result[1] = WrapUndefinedToJS(env);
1265         result[0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
1266     }
1267 
1268     napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
1269     napi_call_function(env, undefined, callback, ARGS_TWO, result, &callResult);
1270 
1271     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1272         napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
1273     }
1274     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1275     delete asyncCallbackInfo;
1276     asyncCallbackInfo = nullptr;
1277     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1278 }
1279 
BackgroundRunningPromiseCompletedCB(napi_env env,napi_status status,void * data)1280 void BackgroundRunningPromiseCompletedCB(napi_env env, napi_status status, void *data)
1281 {
1282     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1283     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
1284     napi_value result = nullptr;
1285     if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
1286         napi_create_int32(env, 0, &result);
1287         napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
1288     } else {
1289         result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
1290         napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
1291     }
1292 
1293     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1294     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1295     delete asyncCallbackInfo;
1296 }
1297 
StartBackgroundRunningAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)1298 napi_value StartBackgroundRunningAsync(
1299     napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
1300 {
1301     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1302     if (args == nullptr || asyncCallbackInfo == nullptr) {
1303         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1304         return nullptr;
1305     }
1306     napi_value resourceName = nullptr;
1307     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1308 
1309     napi_valuetype valuetype = napi_undefined;
1310     NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1311     if (valuetype == napi_function) {
1312         NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback));
1313     }
1314 
1315     NAPI_CALL(env,
1316         napi_create_async_work(env,
1317             nullptr,
1318             resourceName,
1319             StartBackgroundRunningExecuteCB,
1320             BackgroundRunningCallbackCompletedCB,
1321             static_cast<void *>(asyncCallbackInfo),
1322             &asyncCallbackInfo->asyncWork));
1323     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_utility));
1324 
1325     return WrapVoidToJS(env);
1326 }
1327 
StartBackgroundRunningPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1328 napi_value StartBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
1329 {
1330     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1331     if (asyncCallbackInfo == nullptr) {
1332         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1333         return nullptr;
1334     }
1335     napi_value resourceName;
1336     NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1337     napi_deferred deferred;
1338     napi_value promise = nullptr;
1339     NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1340     asyncCallbackInfo->deferred = deferred;
1341 
1342     NAPI_CALL(env,
1343         napi_create_async_work(env,
1344             nullptr,
1345             resourceName,
1346             StartBackgroundRunningExecuteCB,
1347             BackgroundRunningPromiseCompletedCB,
1348             static_cast<void *>(asyncCallbackInfo),
1349             &asyncCallbackInfo->asyncWork));
1350     NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_utility));
1351     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1352     return promise;
1353 }
1354 
StartBackgroundRunningWrap(napi_env & env,napi_callback_info & info,AsyncCallbackInfo * asyncCallbackInfo)1355 napi_value StartBackgroundRunningWrap(napi_env &env, napi_callback_info &info, AsyncCallbackInfo *asyncCallbackInfo)
1356 {
1357     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1358     size_t paramNums = 3;
1359     const size_t minParamNums = 2;
1360     const size_t maxParamNums = 3;
1361     napi_value args[maxParamNums] = {nullptr};
1362     napi_value ret = nullptr;
1363 
1364     NAPI_CALL(env, napi_get_cb_info(env, info, &paramNums, args, NULL, NULL));
1365 
1366     if (paramNums < minParamNums || paramNums > maxParamNums) {
1367         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1368         return nullptr;
1369     }
1370 
1371     if (UnwrapParamForWantAgent(env, args[1], asyncCallbackInfo->wantAgent) == nullptr) {
1372         asyncCallbackInfo->errCode = NAPI_ERR_PARAM_INVALID;
1373     }
1374 
1375     if (paramNums == maxParamNums) {
1376         ret = StartBackgroundRunningAsync(env, args, maxParamNums - 1, asyncCallbackInfo);
1377     } else {
1378         ret = StartBackgroundRunningPromise(env, asyncCallbackInfo);
1379     }
1380 
1381     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1382     return ret;
1383 }
1384 
CancelBackgroundRunningExecuteCB(napi_env env,void * data)1385 void CancelBackgroundRunningExecuteCB(napi_env env, void *data)
1386 {
1387     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
1388     if (asyncCallbackInfo->ability != nullptr) {
1389         asyncCallbackInfo->errCode = asyncCallbackInfo->ability->StopBackgroundRunning();
1390     } else {
1391         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
1392     }
1393 }
1394 
CancelBackgroundRunningAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)1395 napi_value CancelBackgroundRunningAsync(
1396     napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
1397 {
1398     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
1399     if (args == nullptr || asyncCallbackInfo == nullptr) {
1400         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1401         return nullptr;
1402     }
1403     napi_value resourceName = nullptr;
1404     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1405 
1406     napi_valuetype valuetype = napi_undefined;
1407     napi_typeof(env, args[argCallback], &valuetype);
1408     if (valuetype == napi_function) {
1409         napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
1410     }
1411 
1412     napi_create_async_work(
1413         env,
1414         nullptr,
1415         resourceName,
1416         CancelBackgroundRunningExecuteCB,
1417         BackgroundRunningCallbackCompletedCB,
1418         static_cast<void *>(asyncCallbackInfo),
1419         &asyncCallbackInfo->asyncWork);
1420     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1421     napi_value result = nullptr;
1422     napi_get_null(env, &result);
1423 
1424     return result;
1425 }
1426 
CancelBackgroundRunningPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1427 napi_value CancelBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
1428 {
1429     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
1430     if (asyncCallbackInfo == nullptr) {
1431         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
1432         return nullptr;
1433     }
1434     napi_value resourceName = nullptr;
1435     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1436     napi_deferred deferred;
1437     napi_value promise = nullptr;
1438     napi_create_promise(env, &deferred, &promise);
1439 
1440     asyncCallbackInfo->deferred = deferred;
1441 
1442     napi_create_async_work(
1443         env,
1444         nullptr,
1445         resourceName,
1446         CancelBackgroundRunningExecuteCB,
1447         BackgroundRunningPromiseCompletedCB,
1448         static_cast<void *>(asyncCallbackInfo),
1449         &asyncCallbackInfo->asyncWork);
1450     napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
1451 
1452     return promise;
1453 }
1454 
CancelBackgroundRunningWrap(napi_env & env,napi_callback_info & info,AsyncCallbackInfo * asyncCallbackInfo)1455 napi_value CancelBackgroundRunningWrap(napi_env &env, napi_callback_info &info, AsyncCallbackInfo *asyncCallbackInfo)
1456 {
1457     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1458     size_t argcAsync = 1;
1459     const size_t argcPromise = 0;
1460     const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1461     napi_value args[ARGS_MAX_COUNT] = {nullptr};
1462     napi_value ret = nullptr;
1463 
1464     NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, NULL, NULL));
1465     if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1466         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1467         return nullptr;
1468     }
1469 
1470     if (argcAsync > argcPromise) {
1471         ret = CancelBackgroundRunningAsync(env, args, 0, asyncCallbackInfo);
1472     } else {
1473         ret = CancelBackgroundRunningPromise(env, asyncCallbackInfo);
1474     }
1475 
1476     TAG_LOGD(AAFwkTag::JSNAPI, "end");
1477     return ret;
1478 }
1479 }  // namespace AppExecFwk
1480 }  // namespace OHOS