1 /*
2  * Copyright (c) 2021 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.h"
17 
18 #include <chrono>
19 #include <dlfcn.h>
20 #include <memory>
21 #include <uv.h>
22 
23 #include "ability_util.h"
24 #include "hilog_tag_wrapper.h"
25 #include "js_napi_common_ability.h"
26 #include "js_runtime_utils.h"
27 #include "napi_common_ability_execute_utils.h"
28 #include "napi_common_ability_wrap_utils.h"
29 #include "napi_common_util.h"
30 #include "napi_context.h"
31 #include "napi_base_context.h"
32 #include "napi_remote_object.h"
33 #include "securec.h"
34 
35 using namespace OHOS::AbilityRuntime;
36 
37 namespace OHOS {
38 namespace AppExecFwk {
39 napi_ref thread_local g_contextObject = nullptr;
40 napi_ref thread_local g_dataAbilityHelper = nullptr;
41 bool thread_local g_dataAbilityHelperStatus = false;
42 
43 using NAPICreateJsRemoteObject = napi_value (*)(napi_env env, const sptr<IRemoteObject> target);
44 
SetGlobalClassContext(napi_env env,napi_value constructor)45 napi_status SetGlobalClassContext(napi_env env, napi_value constructor)
46 {
47     return napi_create_reference(env, constructor, 1, &g_contextObject);
48 }
49 
GetGlobalClassContext(napi_env env)50 napi_value GetGlobalClassContext(napi_env env)
51 {
52     napi_value constructor;
53     NAPI_CALL(env, napi_get_reference_value(env, g_contextObject, &constructor));
54     return constructor;
55 }
56 
SaveGlobalDataAbilityHelper(napi_env env,napi_value constructor)57 napi_status SaveGlobalDataAbilityHelper(napi_env env, napi_value constructor)
58 {
59     return napi_create_reference(env, constructor, 1, &g_dataAbilityHelper);
60 }
61 
GetGlobalDataAbilityHelper(napi_env env)62 napi_value GetGlobalDataAbilityHelper(napi_env env)
63 {
64     napi_value constructor;
65     NAPI_CALL(env, napi_get_reference_value(env, g_dataAbilityHelper, &constructor));
66     return constructor;
67 }
68 
GetDataAbilityHelperStatus()69 bool& GetDataAbilityHelperStatus()
70 {
71     return g_dataAbilityHelperStatus;
72 }
73 
NAPI_GetFilesDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)74 napi_value NAPI_GetFilesDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
75 {
76     TAG_LOGI(AAFwkTag::JSNAPI, "start");
77     size_t argc = ARGS_MAX_COUNT;
78     napi_value args[ARGS_MAX_COUNT] = {nullptr};
79     napi_value jsthis = nullptr;
80     void *data = nullptr;
81 
82     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
83 
84     if (argc > ARGS_ONE) {
85         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
86         return nullptr;
87     }
88 
89     if (argc == ARGS_ONE) {
90         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
91             TAG_LOGE(AAFwkTag::JSNAPI, "invalid args[PARAM0]");
92             return nullptr;
93         }
94     }
95 
96     AsyncParamEx asyncParamEx;
97     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
98         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
99         asyncParamEx.resource = "NAPI_GetFilesDirCallback";
100         asyncParamEx.execute = GetFilesDirExecuteCallback;
101         asyncParamEx.complete = CompleteAsyncCallbackWork;
102 
103         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
104     } else {
105         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
106         asyncParamEx.resource = "NAPI_GetFilesDirPromise";
107         asyncParamEx.execute = GetFilesDirExecuteCallback;
108         asyncParamEx.complete = CompletePromiseCallbackWork;
109 
110         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
111     }
112 }
113 
NAPI_GetFilesDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)114 napi_value NAPI_GetFilesDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
115 {
116     TAG_LOGI(AAFwkTag::JSNAPI, "called");
117     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
118     if (asyncCallbackInfo == nullptr) {
119         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
120         return WrapVoidToJS(env);
121     }
122 
123     asyncCallbackInfo->abilityType = abilityType;
124     napi_value ret = NAPI_GetFilesDirWrap(env, info, asyncCallbackInfo);
125     if (ret == nullptr) {
126         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
127         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
128         ret = WrapVoidToJS(env);
129     }
130 
131     return ret;
132 }
133 
134 /**
135  * @brief GetFilesDir processing function.
136  *
137  * @param env The environment that the Node-API call is invoked under.
138  * @param asyncCallbackInfo Process data asynchronously.
139  *
140  * @return Return JS data successfully, otherwise return nullptr.
141  */
NAPI_GetOrCreateDistributedDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)142 napi_value NAPI_GetOrCreateDistributedDirWrap(
143     napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
144 {
145     TAG_LOGI(AAFwkTag::JSNAPI, "start");
146     size_t argc = ARGS_MAX_COUNT;
147     napi_value args[ARGS_MAX_COUNT] = {nullptr};
148     napi_value jsthis = nullptr;
149     void *data = nullptr;
150 
151     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
152 
153     if (argc > ARGS_ONE) {
154         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
155         return nullptr;
156     }
157 
158     if (argc == ARGS_ONE) {
159         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
160             TAG_LOGE(AAFwkTag::JSNAPI, "invalid args[PARAM0]");
161             return nullptr;
162         }
163     }
164 
165     AsyncParamEx asyncParamEx;
166     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
167         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
168         asyncParamEx.resource = "NAPI_GetFilesDirCallback";
169         asyncParamEx.execute = GetOrCreateDistributedDirExecuteCallback;
170         asyncParamEx.complete = CompleteAsyncCallbackWork;
171 
172         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
173     } else {
174         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
175         asyncParamEx.resource = "NAPI_GetFilesDirPromise";
176         asyncParamEx.execute = GetOrCreateDistributedDirExecuteCallback;
177         asyncParamEx.complete = CompletePromiseCallbackWork;
178 
179         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
180     }
181 }
182 
NAPI_GetOrCreateDistributedDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)183 napi_value NAPI_GetOrCreateDistributedDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
184 {
185     TAG_LOGI(AAFwkTag::JSNAPI, "called");
186     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
187     if (asyncCallbackInfo == nullptr) {
188         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallback");
189         return WrapVoidToJS(env);
190     }
191 
192     asyncCallbackInfo->abilityType = abilityType;
193     napi_value ret = NAPI_GetOrCreateDistributedDirWrap(env, info, asyncCallbackInfo);
194     if (ret == nullptr) {
195         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
196         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
197         ret = WrapVoidToJS(env);
198     }
199 
200     return ret;
201 }
202 
203 /**
204  * @brief NAPI_GetCacheDirWrap processing function.
205  *
206  * @param env The environment that the Node-API call is invoked under.
207  * @param asyncCallbackInfo Process data asynchronously.
208  *
209  * @return Return JS data successfully, otherwise return nullptr.
210  */
NAPI_GetCacheDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)211 napi_value NAPI_GetCacheDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
212 {
213     TAG_LOGI(AAFwkTag::JSNAPI, "begin");
214     size_t argc = ARGS_MAX_COUNT;
215     napi_value args[ARGS_MAX_COUNT] = {nullptr};
216     napi_value jsthis = nullptr;
217     void *data = nullptr;
218 
219     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
220 
221     if (argc > ARGS_ONE) {
222         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
223         return nullptr;
224     }
225 
226     if (argc == ARGS_ONE) {
227         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
228             TAG_LOGE(AAFwkTag::JSNAPI, "invalid args[PARAM0]");
229             return nullptr;
230         }
231     }
232 
233     AsyncParamEx asyncParamEx;
234     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
235         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
236         asyncParamEx.resource = "NAPI_GetCacheDirCallback";
237         asyncParamEx.execute = GetCacheDirExecuteCallback;
238         asyncParamEx.complete = CompleteAsyncCallbackWork;
239 
240         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
241     } else {
242         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
243         asyncParamEx.resource = "NAPI_GetCacheDirPromise";
244         asyncParamEx.execute = GetCacheDirExecuteCallback;
245         asyncParamEx.complete = CompletePromiseCallbackWork;
246 
247         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
248     }
249 }
250 
NAPI_GetCacheDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)251 napi_value NAPI_GetCacheDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
252 {
253     TAG_LOGI(AAFwkTag::JSNAPI, "called");
254     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
255     if (asyncCallbackInfo == nullptr) {
256         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
257         return WrapVoidToJS(env);
258     }
259 
260     asyncCallbackInfo->abilityType = abilityType;
261     napi_value ret = NAPI_GetCacheDirWrap(env, info, asyncCallbackInfo);
262     if (ret == nullptr) {
263         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
264         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
265         ret = WrapVoidToJS(env);
266     }
267 
268     return ret;
269 }
270 
271 /**
272  * @brief NAPI_GetExternalCacheDirWrap processing function.
273  *
274  * @param env The environment that the Node-API call is invoked under.
275  * @param asyncCallbackInfo Process data asynchronously.
276  *
277  * @return Return JS data successfully, otherwise return nullptr.
278  */
NAPI_GetExternalCacheDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)279 napi_value NAPI_GetExternalCacheDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
280 {
281     TAG_LOGI(AAFwkTag::JSNAPI, "begin");
282     size_t argc = ARGS_MAX_COUNT;
283     napi_value args[ARGS_MAX_COUNT] = {nullptr};
284     napi_value jsthis = nullptr;
285     void *data = nullptr;
286 
287     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
288 
289     if (argc > ARGS_ONE) {
290         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
291         return nullptr;
292     }
293 
294     if (argc == ARGS_ONE) {
295         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
296             TAG_LOGE(AAFwkTag::JSNAPI, "args[PARAM0] invalid");
297             return nullptr;
298         }
299     }
300 
301     AsyncParamEx asyncParamEx;
302     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
303         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
304         asyncParamEx.resource = "NAPI_GetExternalCacheDirCallback";
305         asyncParamEx.execute = GetExternalCacheDirExecuteCallback;
306         asyncParamEx.complete = CompleteAsyncCallbackWork;
307 
308         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
309     } else {
310         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
311         asyncParamEx.resource = "NAPI_GetExternalCacheDirPromise";
312         asyncParamEx.execute = GetExternalCacheDirExecuteCallback;
313         asyncParamEx.complete = CompletePromiseCallbackWork;
314 
315         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
316     }
317 }
318 
NAPI_GetExternalCacheDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)319 napi_value NAPI_GetExternalCacheDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
320 {
321     TAG_LOGI(AAFwkTag::JSNAPI, "called");
322     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
323     if (asyncCallbackInfo == nullptr) {
324         TAG_LOGI(AAFwkTag::JSNAPI, "create callbackInfo failed");
325         return WrapVoidToJS(env);
326     }
327 
328     asyncCallbackInfo->abilityType = abilityType;
329     napi_value ret = NAPI_GetExternalCacheDirWrap(env, info, asyncCallbackInfo);
330     if (ret == nullptr) {
331         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
332         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
333         ret = WrapVoidToJS(env);
334     }
335 
336     return ret;
337 }
338 
NAPI_IsUpdatingConfigurationsWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)339 napi_value NAPI_IsUpdatingConfigurationsWrap(
340     napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
341 {
342     TAG_LOGI(AAFwkTag::JSNAPI, "called");
343     size_t argc = ARGS_MAX_COUNT;
344     napi_value args[ARGS_MAX_COUNT] = {nullptr};
345     napi_value jsthis = nullptr;
346     void *data = nullptr;
347 
348     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
349 
350     if (argc > ARGS_ONE) {
351         TAG_LOGI(AAFwkTag::JSNAPI, "invalid argc");
352         return nullptr;
353     }
354 
355     if (argc == ARGS_ONE) {
356         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
357             TAG_LOGI(AAFwkTag::JSNAPI, "args[PARAM0] invalid");
358             return nullptr;
359         }
360     }
361 
362     AsyncParamEx asyncParamEx;
363     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
364         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
365         asyncParamEx.resource = "NAPI_IsUpdatingConfigurationsCallback";
366         asyncParamEx.execute = IsUpdatingConfigurationsExecuteCallback;
367         asyncParamEx.complete = CompleteAsyncCallbackWork;
368 
369         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
370     } else {
371         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
372         asyncParamEx.resource = "NAPI_IsUpdatingConfigurationsPromise";
373         asyncParamEx.execute = IsUpdatingConfigurationsExecuteCallback;
374         asyncParamEx.complete = CompletePromiseCallbackWork;
375 
376         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
377     }
378 }
379 
NAPI_PrintDrawnCompletedWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)380 napi_value NAPI_PrintDrawnCompletedWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
381 {
382     TAG_LOGI(AAFwkTag::JSNAPI, "begin");
383     size_t argc = ARGS_MAX_COUNT;
384     napi_value args[ARGS_MAX_COUNT] = {nullptr};
385     napi_value jsthis = nullptr;
386     void *data = nullptr;
387 
388     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
389 
390     if (argc > ARGS_ONE) {
391         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
392         return nullptr;
393     }
394 
395     if (argc == ARGS_ONE) {
396         if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
397             TAG_LOGI(AAFwkTag::JSNAPI, "args[PARAM0] invalid");
398             return nullptr;
399         }
400     }
401 
402     AsyncParamEx asyncParamEx;
403     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
404         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
405         asyncParamEx.resource = "NAPI_PrintDrawnCompletedCallback";
406         asyncParamEx.execute = PrintDrawnCompletedExecuteCallback;
407         asyncParamEx.complete = CompleteAsyncVoidCallbackWork;
408 
409         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
410     } else {
411         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
412         asyncParamEx.resource = "NAPI_PrintDrawnCompletedPromise";
413         asyncParamEx.execute = PrintDrawnCompletedExecuteCallback;
414         asyncParamEx.complete = CompletePromiseVoidCallbackWork;
415 
416         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
417     }
418 }
419 
NAPI_IsUpdatingConfigurationsCommon(napi_env env,napi_callback_info info,AbilityType abilityType)420 napi_value NAPI_IsUpdatingConfigurationsCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
421 {
422     TAG_LOGI(AAFwkTag::JSNAPI, "called");
423     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
424     if (asyncCallbackInfo == nullptr) {
425         TAG_LOGE(AAFwkTag::JSNAPI, "create callbackInfo failed");
426         return WrapVoidToJS(env);
427     }
428 
429     asyncCallbackInfo->abilityType = abilityType;
430     napi_value ret = NAPI_IsUpdatingConfigurationsWrap(env, info, asyncCallbackInfo);
431     if (ret == nullptr) {
432         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
433         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
434         ret = WrapVoidToJS(env);
435     }
436 
437     return ret;
438 }
439 
NAPI_PrintDrawnCompletedCommon(napi_env env,napi_callback_info info,AbilityType abilityType)440 napi_value NAPI_PrintDrawnCompletedCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
441 {
442     TAG_LOGI(AAFwkTag::JSNAPI, "called");
443     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
444     if (asyncCallbackInfo == nullptr) {
445         TAG_LOGI(AAFwkTag::JSNAPI, "create callbackInfo failed");
446         return WrapVoidToJS(env);
447     }
448 
449     asyncCallbackInfo->abilityType = abilityType;
450     napi_value ret = NAPI_PrintDrawnCompletedWrap(env, info, asyncCallbackInfo);
451     if (ret == nullptr) {
452         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
453         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
454         ret = WrapVoidToJS(env);
455     }
456 
457     return ret;
458 }
459 
460 /**
461  * @brief Obtains the type of this application.
462  *
463  * @param env The environment that the Node-API call is invoked under.
464  * @param info The callback info passed into the callback function.
465  *
466  * @return The return value from NAPI C++ to JS for the module.
467  */
NAPI_GetAppTypeCommon(napi_env env,napi_callback_info info,AbilityType abilityType)468 napi_value NAPI_GetAppTypeCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
469 {
470     TAG_LOGI(AAFwkTag::JSNAPI, "called");
471     AppTypeCB *appTypeCB = CreateAppTypeCBInfo(env);
472     if (appTypeCB == nullptr) {
473         return WrapVoidToJS(env);
474     }
475 
476     appTypeCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
477     appTypeCB->cbBase.abilityType = abilityType;
478     napi_value ret = GetAppTypeWrap(env, info, appTypeCB);
479     if (ret == nullptr) {
480         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
481         if (appTypeCB != nullptr) {
482             delete appTypeCB;
483             appTypeCB = nullptr;
484         }
485         ret = WrapVoidToJS(env);
486     }
487 
488     return ret;
489 }
490 
491 #ifdef SUPPORT_GRAPHICS
GetDisplayOrientationWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)492 napi_value GetDisplayOrientationWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
493 {
494     TAG_LOGD(AAFwkTag::JSNAPI, "called");
495     size_t argc = ARGS_MAX_COUNT;
496     napi_value args[ARGS_MAX_COUNT] = {nullptr};
497     napi_value jsthis = nullptr;
498     void *data = nullptr;
499 
500     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
501 
502     if (!UnwrapParamGetDisplayOrientationWrap(env, argc, args, asyncCallbackInfo)) {
503         TAG_LOGI(AAFwkTag::JSNAPI, "unwrapParamGetDisplayOrientationWrap fail");
504         return nullptr;
505     }
506 
507     AsyncParamEx asyncParamEx;
508     if (asyncCallbackInfo->cbInfo.callback != nullptr) {
509         TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
510         asyncParamEx.resource = "NAPI_GetDisplayOrientationWrapCallback";
511         asyncParamEx.execute = GetDisplayOrientationExecuteCallback;
512         asyncParamEx.complete = CompleteAsyncCallbackWork;
513 
514         return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
515     } else {
516         TAG_LOGI(AAFwkTag::JSNAPI, "promise");
517         asyncParamEx.resource = "NAPI_GetDisplayOrientationWrapPromise";
518         asyncParamEx.execute = GetDisplayOrientationExecuteCallback;
519         asyncParamEx.complete = CompletePromiseCallbackWork;
520 
521         return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
522     }
523 }
524 
GetDisplayOrientationExecuteCallback(napi_env env,void * data)525 void GetDisplayOrientationExecuteCallback(napi_env env, void *data)
526 {
527     TAG_LOGI(AAFwkTag::JSNAPI, "called");
528     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
529     if (asyncCallbackInfo == nullptr) {
530         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
531         return;
532     }
533 
534     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
535     asyncCallbackInfo->native_data.data_type = NVT_NONE;
536 
537     if (asyncCallbackInfo->ability == nullptr) {
538         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
539         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
540         return;
541     }
542 
543     if (!CheckAbilityType(asyncCallbackInfo)) {
544         TAG_LOGE(AAFwkTag::JSNAPI, "invalid type");
545         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
546         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
547         return;
548     }
549 
550     asyncCallbackInfo->native_data.data_type = NVT_INT32;
551     asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->GetDisplayOrientation();
552 }
553 
UnwrapParamGetDisplayOrientationWrap(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)554 bool UnwrapParamGetDisplayOrientationWrap(napi_env env, size_t argc, napi_value *argv,
555     AsyncJSCallbackInfo *asyncCallbackInfo)
556 {
557     TAG_LOGI(AAFwkTag::JSNAPI, "argc=%{public}zu", argc);
558     const size_t argcMax = 1;
559     if (argc > argcMax || argc < argcMax - 1) {
560         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
561         return false;
562     }
563 
564     if (argc == argcMax) {
565         if (!CreateAsyncCallback(env, argv[PARAM0], asyncCallbackInfo)) {
566             TAG_LOGI(AAFwkTag::JSNAPI, "args[PARAM0] invalid");
567             return false;
568         }
569     }
570 
571     return true;
572 }
573 
NAPI_GetDisplayOrientationCommon(napi_env env,napi_callback_info info,AbilityType abilityType)574 napi_value NAPI_GetDisplayOrientationCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
575 {
576     TAG_LOGD(AAFwkTag::JSNAPI, "called");
577     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
578     if (asyncCallbackInfo == nullptr) {
579         TAG_LOGE(AAFwkTag::JSNAPI, "create callbackInfo failed");
580         return WrapVoidToJS(env);
581     }
582 
583     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
584     asyncCallbackInfo->abilityType = abilityType;
585     napi_value ret = GetDisplayOrientationWrap(env, info, asyncCallbackInfo);
586     if (ret == nullptr) {
587         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
588         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
589         ret = WrapVoidToJS(env);
590     }
591     TAG_LOGD(AAFwkTag::JSNAPI, "end");
592     return ret;
593 }
594 #endif
595 
596 /**
597  * @brief Obtains information about the current ability.
598  *
599  * @param env The environment that the Node-API call is invoked under.
600  * @param info The callback info passed into the callback function.
601  *
602  * @return The return value from NAPI C++ to JS for the module.
603  */
NAPI_GetAbilityInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)604 napi_value NAPI_GetAbilityInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
605 {
606     TAG_LOGI(AAFwkTag::JSNAPI, "called");
607     AbilityInfoCB *abilityInfoCB = CreateAbilityInfoCBInfo(env);
608     if (abilityInfoCB == nullptr) {
609         return WrapVoidToJS(env);
610     }
611 
612     abilityInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
613     abilityInfoCB->cbBase.abilityType = abilityType;
614     napi_value ret = GetAbilityInfoWrap(env, info, abilityInfoCB);
615     if (ret == nullptr) {
616         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
617         if (abilityInfoCB != nullptr) {
618             delete abilityInfoCB;
619             abilityInfoCB = nullptr;
620         }
621         ret = WrapVoidToJS(env);
622     }
623 
624     return ret;
625 }
626 
627 /**
628  * @brief Obtains the HapModuleInfo object of the application.
629  *
630  * @param env The environment that the Node-API call is invoked under.
631  * @param info The callback info passed into the callback function.
632  *
633  * @return The return value from NAPI C++ to JS for the module.
634  */
NAPI_GetHapModuleInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)635 napi_value NAPI_GetHapModuleInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
636 {
637     TAG_LOGI(AAFwkTag::JSNAPI, "called");
638     HapModuleInfoCB *hapModuleInfoCB = CreateHapModuleInfoCBInfo(env);
639     if (hapModuleInfoCB == nullptr) {
640         return WrapVoidToJS(env);
641     }
642 
643     hapModuleInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
644     hapModuleInfoCB->cbBase.abilityType = abilityType;
645     napi_value ret = GetHapModuleInfoWrap(env, info, hapModuleInfoCB);
646     if (ret == nullptr) {
647         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
648         if (hapModuleInfoCB != nullptr) {
649             delete hapModuleInfoCB;
650             hapModuleInfoCB = nullptr;
651         }
652         ret = WrapVoidToJS(env);
653     }
654 
655     return ret;
656 }
657 
658 /**
659  * @brief Obtains the AppVersionInfo object of the application.
660  *
661  * @param env The environment that the Node-API call is invoked under.
662  * @param info The callback info passed into the callback function.
663  *
664  * @return The return value from NAPI C++ to JS for the module.
665  */
NAPI_GetAppVersionInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)666 napi_value NAPI_GetAppVersionInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
667 {
668     TAG_LOGI(AAFwkTag::JSNAPI, "called");
669     AppVersionInfoCB *appVersionInfoCB = CreateAppVersionInfoCBInfo(env);
670     if (appVersionInfoCB == nullptr) {
671         return WrapVoidToJS(env);
672     }
673 
674     appVersionInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
675     appVersionInfoCB->cbBase.abilityType = abilityType;
676     napi_value ret = GetAppVersionInfoWrap(env, info, appVersionInfoCB);
677     if (ret == nullptr) {
678         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
679         if (appVersionInfoCB != nullptr) {
680             delete appVersionInfoCB;
681             appVersionInfoCB = nullptr;
682         }
683         ret = WrapVoidToJS(env);
684     }
685 
686     return ret;
687 }
688 
689 /**
690  * @brief Create asynchronous data.
691  *
692  * @param env The environment that the Node-API call is invoked under.
693  *
694  * @return Return a pointer to AsyncCallbackInfo on success, nullptr on failure
695  */
CreateAsyncCallbackInfo(napi_env env)696 AsyncCallbackInfo *CreateAsyncCallbackInfo(napi_env env)
697 {
698     TAG_LOGI(AAFwkTag::JSNAPI, "called");
699     if (env == nullptr) {
700         TAG_LOGI(AAFwkTag::JSNAPI, "null env");
701         return nullptr;
702     }
703 
704     napi_status ret;
705     napi_value global = nullptr;
706     const napi_extended_error_info *errorInfo = nullptr;
707     ret = napi_get_global(env, &global);
708     if (ret != napi_ok) {
709         napi_get_last_error_info(env, &errorInfo);
710         TAG_LOGE(AAFwkTag::JSNAPI, "get_global=%{public}d err:%{public}s", ret,
711                  errorInfo->error_message);
712     }
713 
714     napi_value abilityObj = nullptr;
715     ret = napi_get_named_property(env, global, "ability", &abilityObj);
716     if (ret != napi_ok) {
717         napi_get_last_error_info(env, &errorInfo);
718         TAG_LOGE(AAFwkTag::JSNAPI, "get_named_property=%{public}d err:%{public}s", ret,
719                  errorInfo->error_message);
720     }
721 
722     Ability *ability = nullptr;
723     ret = napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability));
724     if (ret != napi_ok) {
725         napi_get_last_error_info(env, &errorInfo);
726         TAG_LOGE(AAFwkTag::JSNAPI, "get_value_external=%{public}d err:%{public}s", ret,
727                  errorInfo->error_message);
728     }
729 
730     AsyncCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo;
731     if (asyncCallbackInfo == nullptr) {
732         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
733         return nullptr;
734     }
735     asyncCallbackInfo->cbInfo.env = env;
736     asyncCallbackInfo->asyncWork = nullptr;
737     asyncCallbackInfo->deferred = nullptr;
738     asyncCallbackInfo->ability = ability;
739     asyncCallbackInfo->native_result = false;
740     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
741     asyncCallbackInfo->abilityType = AbilityType::UNKNOWN;
742 
743     return asyncCallbackInfo;
744 }
745 
GetContextAsyncExecuteCB(napi_env,void * data)746 void GetContextAsyncExecuteCB(napi_env, void *data)
747 {
748     TAG_LOGI(AAFwkTag::JSNAPI, "execute");
749     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
750     if (asyncCallbackInfo == nullptr) {
751         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
752         return;
753     }
754     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
755     if (asyncCallbackInfo->ability == nullptr) {
756         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
757         asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
758         return;
759     }
760 
761     if (!CheckAbilityType(asyncCallbackInfo)) {
762         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
763         asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
764         return;
765     }
766     TAG_LOGI(AAFwkTag::JSNAPI, "execute end");
767 }
768 
GetContextAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)769 napi_value GetContextAsync(
770     napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
771 {
772     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback");
773     if (args == nullptr || asyncCallbackInfo == nullptr) {
774         TAG_LOGE(AAFwkTag::JSNAPI, "null params");
775         return nullptr;
776     }
777     napi_value resourceName = nullptr;
778     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
779 
780     napi_valuetype valuetype = napi_undefined;
781     napi_typeof(env, args[argCallback], &valuetype);
782     if (valuetype == napi_function) {
783         TAG_LOGD(AAFwkTag::JSNAPI, "napi_create_reference");
784         napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
785     }
786     napi_create_async_work(env, nullptr, resourceName, GetContextAsyncExecuteCB,
787         [](napi_env env, napi_status, void *data) {
788             TAG_LOGI(AAFwkTag::JSNAPI, "complete");
789             AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
790             napi_value callback = nullptr;
791             napi_value undefined = nullptr;
792             napi_value result[ARGS_TWO] = {nullptr};
793             napi_value callResult = nullptr;
794             napi_get_undefined(env, &undefined);
795             result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
796             if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
797                 napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result[PARAM1]);
798             } else {
799                 result[PARAM1] = WrapUndefinedToJS(env);
800             }
801             napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
802             napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
803 
804             if (asyncCallbackInfo->cbInfo.callback != nullptr) {
805                 TAG_LOGD(AAFwkTag::JSNAPI, "Delete GetContextAsync callback reference");
806                 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
807             }
808             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
809             delete asyncCallbackInfo;
810             asyncCallbackInfo = nullptr;
811             TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
812         }, static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
813     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
814     napi_value result = nullptr;
815     napi_get_null(env, &result);
816     TAG_LOGI(AAFwkTag::JSNAPI, "asyncCallback end");
817     return result;
818 }
819 
GetContextPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)820 napi_value GetContextPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
821 {
822     TAG_LOGI(AAFwkTag::JSNAPI, "promise");
823     if (asyncCallbackInfo == nullptr) {
824         TAG_LOGE(AAFwkTag::JSNAPI, "null param");
825         return nullptr;
826     }
827     napi_value resourceName = nullptr;
828     napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
829     napi_deferred deferred;
830     napi_value promise = nullptr;
831     napi_create_promise(env, &deferred, &promise);
832     asyncCallbackInfo->deferred = deferred;
833 
834     napi_create_async_work(
835         env,
836         nullptr,
837         resourceName,
838         GetContextAsyncExecuteCB,
839         [](napi_env env, napi_status, void *data) {
840             TAG_LOGI(AAFwkTag::JSNAPI, "complete");
841             AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
842             napi_value result = nullptr;
843             if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
844                 napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result);
845                 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
846             } else {
847                 result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
848                 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
849             }
850 
851             napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
852             delete asyncCallbackInfo;
853             asyncCallbackInfo = nullptr;
854             TAG_LOGI(AAFwkTag::JSNAPI, "complete end");
855         },
856         static_cast<void *>(asyncCallbackInfo),
857         &asyncCallbackInfo->asyncWork);
858     napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
859     TAG_LOGI(AAFwkTag::JSNAPI, "promise end");
860     return promise;
861 }
862 
863 /**
864  * @brief GetContext processing function.
865  *
866  * @param env The environment that the Node-API call is invoked under.
867  * @param asyncCallbackInfo Process data asynchronously.
868  *
869  * @return Return JS data successfully, otherwise return nullptr.
870  */
GetContextWrap(napi_env env,napi_callback_info,AsyncCallbackInfo * asyncCallbackInfo)871 napi_value GetContextWrap(napi_env env, napi_callback_info, AsyncCallbackInfo *asyncCallbackInfo)
872 {
873     TAG_LOGI(AAFwkTag::JSNAPI, "called");
874     if (asyncCallbackInfo == nullptr) {
875         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
876         return nullptr;
877     }
878 
879     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
880     if (!CheckAbilityType(asyncCallbackInfo)) {
881         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
882         asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
883         return nullptr;
884     }
885 
886     napi_value result = nullptr;
887     napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result);
888 
889     return result;
890 }
891 
892 /**
893  * @brief Get context.
894  *
895  * @param env The environment that the Node-API call is invoked under.
896  * @param info The callback info passed into the callback function.
897  *
898  * @return The return value from NAPI C++ to JS for the module.
899  */
NAPI_GetContextCommon(napi_env env,napi_callback_info info,AbilityType abilityType)900 napi_value NAPI_GetContextCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
901 {
902     TAG_LOGI(AAFwkTag::JSNAPI, "called");
903     AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
904     if (asyncCallbackInfo == nullptr) {
905         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
906         return WrapVoidToJS(env);
907     }
908 
909     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
910     asyncCallbackInfo->abilityType = abilityType;
911     napi_value ret = GetContextWrap(env, info, asyncCallbackInfo);
912 
913     delete asyncCallbackInfo;
914     asyncCallbackInfo = nullptr;
915 
916     if (ret == nullptr) {
917         ret = WrapVoidToJS(env);
918         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
919     }
920     return ret;
921 }
922 
923 /**
924  * @brief Get want.
925  *
926  * @param env The environment that the Node-API call is invoked under.
927  * @param info The callback info passed into the callback function.
928  *
929  * @return The return value from NAPI C++ to JS for the module.
930  */
NAPI_GetWantCommon(napi_env env,napi_callback_info info,AbilityType abilityType)931 napi_value NAPI_GetWantCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
932 {
933     AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
934     if (asyncCallbackInfo == nullptr) {
935         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
936         return WrapVoidToJS(env);
937     }
938 
939     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
940     asyncCallbackInfo->abilityType = abilityType;
941     napi_value ret = GetWantWrap(env, info, asyncCallbackInfo);
942     if (ret == nullptr) {
943         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
944         if (asyncCallbackInfo != nullptr) {
945             delete asyncCallbackInfo;
946             asyncCallbackInfo = nullptr;
947         }
948         ret = WrapVoidToJS(env);
949     }
950     return ret;
951 }
952 
953 /**
954  * @brief Obtains the class name in this ability name, without the prefixed bundle name.
955  *
956  * @param env The environment that the Node-API call is invoked under.
957  * @param info The callback info passed into the callback function.
958  *
959  * @return The return value from NAPI C++ to JS for the module.
960  */
NAPI_GetAbilityNameCommon(napi_env env,napi_callback_info info,AbilityType abilityType)961 napi_value NAPI_GetAbilityNameCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
962 {
963     TAG_LOGI(AAFwkTag::JSNAPI, "called");
964     AbilityNameCB *abilityNameCB = CreateAbilityNameCBInfo(env);
965     if (abilityNameCB == nullptr) {
966         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityNameCB");
967         return WrapVoidToJS(env);
968     }
969 
970     abilityNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
971     abilityNameCB->cbBase.abilityType = abilityType;
972     napi_value ret = GetAbilityNameWrap(env, info, abilityNameCB);
973     if (ret == nullptr) {
974         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
975         if (abilityNameCB != nullptr) {
976             delete abilityNameCB;
977             abilityNameCB = nullptr;
978         }
979         ret = WrapVoidToJS(env);
980     }
981 
982     return ret;
983 }
984 
985 /**
986  * @brief stopAbility.
987  *
988  * @param env The environment that the Node-API call is invoked under.
989  * @param info The callback info passed into the callback function.
990  *
991  * @return The return value from NAPI C++ to JS for the module.
992  */
NAPI_StopAbilityCommon(napi_env env,napi_callback_info info,AbilityType abilityType)993 napi_value NAPI_StopAbilityCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
994 {
995     TAG_LOGI(AAFwkTag::JSNAPI, "called");
996     AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
997     if (asyncCallbackInfo == nullptr) {
998         TAG_LOGE(AAFwkTag::JSNAPI, "create callbackInfo failed");
999         return WrapVoidToJS(env);
1000     }
1001 
1002     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1003     asyncCallbackInfo->abilityType = abilityType;
1004     napi_value ret = StopAbilityWrap(env, info, asyncCallbackInfo);
1005     if (ret == nullptr) {
1006         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
1007         FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
1008         ret = WrapVoidToJS(env);
1009     }
1010 
1011     return ret;
1012 }
1013 
1014 /**
1015  * @brief AcquireDataAbilityHelper.
1016  *
1017  * @param env The environment that the Node-API call is invoked under.
1018  * @param info The callback info passed into the callback function.
1019  *
1020  * @return The return value from NAPI C++ to JS for the module.
1021  */
NAPI_AcquireDataAbilityHelperCommon(napi_env env,napi_callback_info info,AbilityType abilityType)1022 napi_value NAPI_AcquireDataAbilityHelperCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
1023 {
1024     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1025     DataAbilityHelperCB *dataAbilityHelperCB = new DataAbilityHelperCB;
1026     dataAbilityHelperCB->cbBase.cbInfo.env = env;
1027     dataAbilityHelperCB->cbBase.ability = nullptr; // temporary value assignment
1028     dataAbilityHelperCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1029     dataAbilityHelperCB->cbBase.abilityType = abilityType;
1030     napi_value ret = AcquireDataAbilityHelperWrap(env, info, dataAbilityHelperCB);
1031     if (ret == nullptr) {
1032         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
1033         if (dataAbilityHelperCB != nullptr) {
1034             delete dataAbilityHelperCB;
1035             dataAbilityHelperCB = nullptr;
1036         }
1037         ret = WrapVoidToJS(env);
1038     }
1039 
1040     return ret;
1041 }
1042 
1043 /**
1044  * @brief acquireDataAbilityHelper processing function.
1045  *
1046  * @param env The environment that the Node-API call is invoked under.
1047  * @param dataAbilityHelperCB Process data asynchronously.
1048  *
1049  * @return Return JS data successfully, otherwise return nullptr.
1050  */
AcquireDataAbilityHelperWrap(napi_env env,napi_callback_info info,DataAbilityHelperCB * dataAbilityHelperCB)1051 napi_value AcquireDataAbilityHelperWrap(napi_env env, napi_callback_info info, DataAbilityHelperCB *dataAbilityHelperCB)
1052 {
1053     if (dataAbilityHelperCB == nullptr) {
1054         TAG_LOGE(AAFwkTag::JSNAPI, "null dataAbilityHelperCB");
1055         return nullptr;
1056     }
1057 
1058     size_t requireArgc = ARGS_TWO;
1059     size_t argc = ARGS_TWO;
1060     napi_value args[ARGS_TWO] = {nullptr};
1061     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1062     if (argc > requireArgc) {
1063         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1064         return nullptr;
1065     }
1066 
1067     size_t uriIndex = PARAM0;
1068     bool stageMode = false;
1069     napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[0], stageMode);
1070     if (status == napi_ok) {
1071         uriIndex = PARAM1;
1072         TAG_LOGI(AAFwkTag::JSNAPI, "argv[0] is a context, Stage Model: %{public}d", stageMode);
1073     }
1074 
1075     if (!stageMode) {
1076         auto ability = OHOS::AbilityRuntime::GetCurrentAbility(env);
1077         if (ability == nullptr) {
1078             TAG_LOGE(AAFwkTag::JSNAPI, "Failed to get native context instance");
1079             return nullptr;
1080         }
1081         dataAbilityHelperCB->cbBase.ability = ability;
1082 
1083         if (!CheckAbilityType(&dataAbilityHelperCB->cbBase)) {
1084             dataAbilityHelperCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
1085             TAG_LOGE(AAFwkTag::JSNAPI, "ability type invalid");
1086             return nullptr;
1087         }
1088     }
1089     napi_valuetype valuetype = napi_undefined;
1090     NAPI_CALL(env, napi_typeof(env, args[uriIndex], &valuetype));
1091     if (valuetype != napi_string) {
1092         TAG_LOGE(AAFwkTag::JSNAPI, "Wrong argument type");
1093         return nullptr;
1094     }
1095     napi_value result = nullptr;
1096     NAPI_CALL(env, napi_new_instance(env, GetGlobalDataAbilityHelper(env), uriIndex + 1, &args[PARAM0], &result));
1097 
1098     if (!IsTypeForNapiValue(env, result, napi_object)) {
1099         TAG_LOGE(AAFwkTag::JSNAPI, "result not object");
1100         return nullptr;
1101     }
1102 
1103     if (IsTypeForNapiValue(env, result, napi_null)) {
1104         TAG_LOGE(AAFwkTag::JSNAPI, "result null");
1105         return nullptr;
1106     }
1107 
1108     if (IsTypeForNapiValue(env, result, napi_undefined)) {
1109         TAG_LOGE(AAFwkTag::JSNAPI, "result undefined");
1110         return nullptr;
1111     }
1112 
1113     if (!GetDataAbilityHelperStatus()) {
1114         TAG_LOGE(AAFwkTag::JSNAPI, "GetDataAbilityHelperStatus false");
1115         return nullptr;
1116     }
1117 
1118     delete dataAbilityHelperCB;
1119     dataAbilityHelperCB = nullptr;
1120     return result;
1121 }
1122 
NAPI_StartBackgroundRunningCommon(napi_env env,napi_callback_info info)1123 napi_value NAPI_StartBackgroundRunningCommon(napi_env env, napi_callback_info info)
1124 {
1125     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1126     AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
1127     if (asyncCallbackInfo == nullptr) {
1128         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1129         return WrapVoidToJS(env);
1130     }
1131 
1132     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
1133     napi_value ret = StartBackgroundRunningWrap(env, info, asyncCallbackInfo);
1134     if (ret == nullptr) {
1135         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
1136         if (asyncCallbackInfo != nullptr) {
1137             delete asyncCallbackInfo;
1138             asyncCallbackInfo = nullptr;
1139         }
1140         ret = WrapVoidToJS(env);
1141     }
1142     TAG_LOGI(AAFwkTag::JSNAPI, "finish");
1143     return ret;
1144 }
1145 
NAPI_CancelBackgroundRunningCommon(napi_env env,napi_callback_info info)1146 napi_value NAPI_CancelBackgroundRunningCommon(napi_env env, napi_callback_info info)
1147 {
1148     TAG_LOGI(AAFwkTag::JSNAPI, "called");
1149     AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
1150     if (asyncCallbackInfo == nullptr) {
1151         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
1152         return WrapVoidToJS(env);
1153     }
1154 
1155     asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
1156     napi_value ret = CancelBackgroundRunningWrap(env, info, asyncCallbackInfo);
1157     if (ret == nullptr) {
1158         TAG_LOGE(AAFwkTag::JSNAPI, "null ret");
1159         if (asyncCallbackInfo != nullptr) {
1160             delete asyncCallbackInfo;
1161             asyncCallbackInfo = nullptr;
1162         }
1163         ret = WrapVoidToJS(env);
1164     }
1165 
1166     return ret;
1167 }
1168 }  // namespace AppExecFwk
1169 }  // namespace OHOS
1170