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_wrap_utils.h"
17 
18 #include "hilog_tag_wrapper.h"
19 
20 namespace OHOS {
21 namespace AppExecFwk {
22 const std::int32_t STR_MAX_SIZE = 128;
23 const int32_t ERR_ABILITY_START_SUCCESS = 0;
24 const int32_t ERR_ABILITY_QUERY_FAILED = 1;
25 const int32_t ERR_NETWORK_UNAVAILABLE = 2;
26 const int32_t ERR_SYSTEM_ERROR = 3;
27 const int32_t ERR_LOADING_ERROR = 4;
28 const int32_t ERR_CONCURRENT_TASKS_WAITING_FOR_RETRY = 5;
29 const int32_t ERR_FREE_INSTALL_NOT_SUPPORTED = 6;
30 const int32_t ERR_SERVICE_ERROR = 7;
31 const int32_t ERR_PERMISSION_VERIFY_FAILED = 8;
32 const int32_t ERR_PARAMETER_INVALID = 9;
33 const int32_t ERR_REMOTE_INCOMPATIBLE = 10;
34 const int32_t ERR_DEVICE_OFFLINE = 11;
35 const int32_t ERR_FREE_INSTALL_TIMEOUT = 12;
36 const int32_t ERR_NOT_TOP_ABILITY = 13;
37 const int32_t ERR_TARGET_BUNDLE_NOT_EXIST = 14;
38 const int32_t ERR_CONTINUE_FREE_INSTALL_FAILED = 15;
39 const int32_t ERR_PARAM_INVALID = 202;
40 const std::map<int32_t, int32_t> START_ABILITY_ERROR_CODE_MAP = {
41     { NAPI_ERR_NO_ERROR, ERR_ABILITY_START_SUCCESS },
42     { NAPI_ERR_NO_PERMISSION, ERR_PERMISSION_VERIFY_FAILED },
43     { NAPI_ERR_ACE_ABILITY, ERR_ABILITY_QUERY_FAILED },
44     { NAPI_ERR_PARAM_INVALID, ERR_PARAM_INVALID },
45     { NAPI_ERR_ABILITY_TYPE_INVALID, ERR_ABILITY_QUERY_FAILED },
46     { NAPI_ERR_ABILITY_CALL_INVALID, ERR_ABILITY_QUERY_FAILED },
47     { ERR_OK, ERR_ABILITY_START_SUCCESS },
48     { RESOLVE_ABILITY_ERR, ERR_ABILITY_QUERY_FAILED },
49     { CHECK_PERMISSION_FAILED, ERR_PERMISSION_VERIFY_FAILED },
50     { RESOLVE_CALL_NO_PERMISSIONS, ERR_PERMISSION_VERIFY_FAILED },
51     { FA_FREE_INSTALL_QUERY_ERROR, ERR_ABILITY_QUERY_FAILED },
52     { HAG_QUERY_TIMEOUT, ERR_ABILITY_QUERY_FAILED },
53     { FA_NETWORK_UNAVAILABLE, ERR_NETWORK_UNAVAILABLE },
54     { FA_FREE_INSTALL_SERVICE_ERROR, ERR_SYSTEM_ERROR },
55     { FA_CRASH, ERR_SYSTEM_ERROR },
56     { FA_TIMEOUT, ERR_SYSTEM_ERROR },
57     { UNKNOWN_EXCEPTION, ERR_SYSTEM_ERROR },
58     { NOT_SUPPORT_PA_ON_SAME_DEVICE, ERR_SYSTEM_ERROR },
59     { FA_INTERNET_ERROR, ERR_SYSTEM_ERROR },
60     { JUMP_TO_THE_APPLICATION_MARKET_UPGRADE, ERR_SYSTEM_ERROR },
61     { USER_GIVES_UP, ERR_LOADING_ERROR },
62     { INSTALLATION_ERROR_IN_FREE_INSTALL, ERR_LOADING_ERROR },
63     { HAP_PACKAGE_DOWNLOAD_TIMED_OUT, ERR_LOADING_ERROR },
64     { CONCURRENT_TASKS_WAITING_FOR_RETRY, ERR_CONCURRENT_TASKS_WAITING_FOR_RETRY },
65     { FA_PACKAGE_DOES_NOT_SUPPORT_FREE_INSTALL, ERR_FREE_INSTALL_NOT_SUPPORTED },
66     { NOT_ALLOWED_TO_PULL_THIS_FA, ERR_SERVICE_ERROR },
67     { NOT_SUPPORT_CROSS_DEVICE_FREE_INSTALL_PA, ERR_SERVICE_ERROR },
68     { DMS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
69     { DMS_COMPONENT_ACCESS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
70     { DMS_ACCOUNT_ACCESS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
71     { INVALID_PARAMETERS_ERR, ERR_PARAMETER_INVALID },
72     { INVALID_REMOTE_PARAMETERS_ERR, ERR_PARAMETER_INVALID },
73     { REMOTE_DEVICE_NOT_COMPATIBLE, ERR_REMOTE_INCOMPATIBLE },
74     { DEVICE_OFFLINE_ERR, ERR_DEVICE_OFFLINE },
75     { FREE_INSTALL_TIMEOUT, ERR_FREE_INSTALL_TIMEOUT },
76     { NOT_TOP_ABILITY, ERR_NOT_TOP_ABILITY },
77     { TARGET_BUNDLE_NOT_EXIST, ERR_TARGET_BUNDLE_NOT_EXIST },
78     { CONTINUE_FREE_INSTALL_FAILED, ERR_CONTINUE_FREE_INSTALL_FAILED }
79 };
80 
CheckAbilityType(AbilityType typeInAbility,AbilityType typeWant)81 bool CheckAbilityType(AbilityType typeInAbility, AbilityType typeWant)
82 {
83     switch (typeWant) {
84         case AbilityType::PAGE:
85             if (typeInAbility == AbilityType::PAGE || typeInAbility == AbilityType::DATA) {
86                 return true;
87             }
88             return false;
89         default:
90             return typeInAbility != AbilityType::PAGE;
91     }
92     return false;
93 }
94 
CheckAbilityType(const CBBase * cbBase)95 bool CheckAbilityType(const CBBase *cbBase)
96 {
97     if (cbBase == nullptr) {
98         TAG_LOGE(AAFwkTag::JSNAPI, "null cbBase");
99         return false;
100     }
101 
102     if (cbBase->ability == nullptr) {
103         TAG_LOGE(AAFwkTag::JSNAPI, "null cbBase->ability");
104         return false;
105     }
106 
107     const std::shared_ptr<AbilityInfo> info = cbBase->ability->GetAbilityInfo();
108     if (info == nullptr) {
109         TAG_LOGE(AAFwkTag::JSNAPI, "null info");
110         return false;
111     }
112     return CheckAbilityType((AbilityType)info->type, cbBase->abilityType);
113 }
114 
CheckAbilityType(const AsyncJSCallbackInfo * asyncCallbackInfo)115 bool CheckAbilityType(const AsyncJSCallbackInfo *asyncCallbackInfo)
116 {
117     TAG_LOGI(AAFwkTag::JSNAPI, "start");
118     if (asyncCallbackInfo == nullptr) {
119         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
120         return false;
121     }
122 
123     if (asyncCallbackInfo->ability == nullptr) {
124         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
125         return false;
126     }
127 
128     const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
129     if (info == nullptr) {
130         TAG_LOGE(AAFwkTag::JSNAPI, "null info");
131         return false;
132     }
133 
134     return CheckAbilityType((AbilityType)info->type, asyncCallbackInfo->abilityType);
135 }
136 
CheckAbilityType(const AsyncCallbackInfo * asyncCallbackInfo)137 bool CheckAbilityType(const AsyncCallbackInfo *asyncCallbackInfo)
138 {
139     TAG_LOGI(AAFwkTag::JSNAPI, "called");
140     if (asyncCallbackInfo == nullptr) {
141         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
142         return false;
143     }
144 
145     if (asyncCallbackInfo->ability == nullptr) {
146         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
147         return false;
148     }
149 
150     const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
151     if (info == nullptr) {
152         TAG_LOGE(AAFwkTag::JSNAPI, "null info");
153         return false;
154     }
155 
156     return CheckAbilityType((AbilityType)info->type, asyncCallbackInfo->abilityType);
157 }
158 
GetContinueAbilityOptionsInfoCommon(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)159 napi_value GetContinueAbilityOptionsInfoCommon(
160     const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
161 {
162     TAG_LOGI(AAFwkTag::JSNAPI, "called");
163     napi_value result = nullptr;
164 
165     // reversible?: boolean
166     if (GetContinueAbilityOptionsReversible(env, value, info) == nullptr) {
167         return nullptr;
168     }
169 
170     // deviceId?: string
171     if (GetContinueAbilityOptionsDeviceID(env, value, info) == nullptr) {
172         return nullptr;
173     }
174 
175     napi_get_null(env, &result);
176 
177     return result;
178 }
179 
GetContinueAbilityOptionsReversible(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)180 napi_value GetContinueAbilityOptionsReversible(
181     const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
182 {
183     TAG_LOGI(AAFwkTag::JSNAPI, "called");
184     napi_valuetype valuetype = napi_undefined;
185     napi_value result = nullptr;
186     bool hasProperty = false;
187     bool reversible = false;
188 
189     NAPI_CALL(env, napi_has_named_property(env, value, "reversible", &hasProperty));
190     if (hasProperty) {
191         napi_get_named_property(env, value, "reversible", &result);
192         NAPI_CALL(env, napi_typeof(env, result, &valuetype));
193         if (valuetype != napi_boolean) {
194             TAG_LOGE(AAFwkTag::JSNAPI, "bool expected");
195             return nullptr;
196         }
197         napi_get_value_bool(env, result, &reversible);
198         info.reversible = reversible;
199     }
200 
201     return result;
202 }
203 
GetContinueAbilityOptionsDeviceID(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)204 napi_value GetContinueAbilityOptionsDeviceID(
205     const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
206 {
207     TAG_LOGI(AAFwkTag::JSNAPI, "called");
208     napi_valuetype valuetype = napi_undefined;
209     napi_value result = nullptr;
210     bool hasProperty = false;
211     char str[STR_MAX_SIZE] = {0};
212     size_t strLen = 0;
213 
214     NAPI_CALL(env, napi_has_named_property(env, value, "deviceId", &hasProperty));
215     if (hasProperty) {
216         napi_get_named_property(env, value, "deviceId", &result);
217         NAPI_CALL(env, napi_typeof(env, result, &valuetype));
218         if (valuetype != napi_string) {
219             TAG_LOGE(AAFwkTag::JSNAPI, "string expected");
220             return nullptr;
221         }
222         NAPI_CALL(env, napi_get_value_string_utf8(env, result, str, STR_MAX_SIZE - 1, &strLen));
223         info.deviceId = str;
224     }
225 
226     return result;
227 }
228 
WrapAppInfo(napi_env env,const ApplicationInfo & appInfo)229 napi_value WrapAppInfo(napi_env env, const ApplicationInfo &appInfo)
230 {
231     TAG_LOGI(AAFwkTag::JSNAPI, "called");
232     napi_value result = nullptr;
233     napi_value proValue = nullptr;
234     NAPI_CALL(env, napi_create_object(env, &result));
235     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
236     NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
237 
238     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
239     NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
240 
241     NAPI_CALL(env, napi_create_int32(env, appInfo.descriptionId, &proValue));
242     NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
243 
244     NAPI_CALL(env, napi_get_boolean(env, appInfo.isSystemApp, &proValue));
245     NAPI_CALL(env, napi_set_named_property(env, result, "systemApp", proValue));
246     NAPI_CALL(env, napi_get_boolean(env, appInfo.enabled, &proValue));
247     NAPI_CALL(env, napi_set_named_property(env, result, "enabled", proValue));
248     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
249     NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
250     NAPI_CALL(env, napi_create_string_utf8(env, std::to_string(appInfo.labelId).c_str(), NAPI_AUTO_LENGTH, &proValue));
251     NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
252     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
253     NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
254     NAPI_CALL(env, napi_create_string_utf8(env, std::to_string(appInfo.iconId).c_str(), NAPI_AUTO_LENGTH, &proValue));
255     NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
256     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &proValue));
257     NAPI_CALL(env, napi_set_named_property(env, result, "process", proValue));
258     NAPI_CALL(env, napi_create_int32(env, appInfo.supportedModes, &proValue));
259     NAPI_CALL(env, napi_set_named_property(env, result, "supportedModes", proValue));
260 
261     (void)WrapProperties(env, appInfo.moduleSourceDirs, "moduleSourceDirs", result);
262     (void)WrapProperties(env, appInfo.permissions, "permissions", result);
263     (void)WrapModuleInfos(env, appInfo, result);
264     NAPI_CALL(env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &proValue));
265     NAPI_CALL(env, napi_set_named_property(env, result, "entryDir", proValue));
266 
267     return result;
268 }
269 
GetStartAbilityErrorCode(ErrCode innerErrorCode)270 int32_t GetStartAbilityErrorCode(ErrCode innerErrorCode)
271 {
272     auto iter = START_ABILITY_ERROR_CODE_MAP.find(innerErrorCode);
273     if (iter != START_ABILITY_ERROR_CODE_MAP.end()) {
274         return iter->second;
275     }
276     return ERR_ABILITY_QUERY_FAILED;
277 }
278 
279 /**
280  * @brief GetFilesDir asynchronous processing function.
281  *
282  * @param env The environment that the Node-API call is invoked under.
283  * @param data Point to asynchronous processing of data.
284  */
GetFilesDirExecuteCallback(napi_env,void * data)285 void GetFilesDirExecuteCallback(napi_env, void *data)
286 {
287     TAG_LOGI(AAFwkTag::JSNAPI, "start");
288     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
289     if (asyncCallbackInfo == nullptr) {
290         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
291         return;
292     }
293 
294     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
295     asyncCallbackInfo->native_data.data_type = NVT_NONE;
296     if (asyncCallbackInfo->ability == nullptr) {
297         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
298         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
299         return;
300     }
301 
302     if (!CheckAbilityType(asyncCallbackInfo)) {
303         TAG_LOGE(AAFwkTag::JSNAPI, "error ability type");
304         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
305         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
306         return;
307     }
308 
309     asyncCallbackInfo->native_data.data_type = NVT_STRING;
310     std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
311     if (abilityContext == nullptr) {
312         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityContext");
313         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
314         return;
315     }
316     asyncCallbackInfo->native_data.str_value = abilityContext->GetFilesDir();
317     TAG_LOGI(AAFwkTag::JSNAPI, "end filesDir=%{public}s",
318              asyncCallbackInfo->native_data.str_value.c_str());
319 }
320 
IsUpdatingConfigurationsExecuteCallback(napi_env,void * data)321 void IsUpdatingConfigurationsExecuteCallback(napi_env, void *data)
322 {
323     TAG_LOGI(AAFwkTag::JSNAPI, "begin");
324     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
325     if (asyncCallbackInfo == nullptr) {
326         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
327         return;
328     }
329 
330     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
331     asyncCallbackInfo->native_data.data_type = NVT_NONE;
332     if (asyncCallbackInfo->ability == nullptr) {
333         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
334         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
335         return;
336     }
337 
338     if (!CheckAbilityType(asyncCallbackInfo)) {
339         TAG_LOGE(AAFwkTag::JSNAPI, "fail ability type");
340         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
341         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
342         return;
343     }
344 
345     asyncCallbackInfo->native_data.data_type = NVT_BOOL;
346     asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->IsUpdatingConfigurations();
347 }
348 
349 /**
350  * @brief PrintDrawnCompleted asynchronous processing function.
351  *
352  * @param env The environment that the Node-API call is invoked under.
353  * @param data Point to asynchronous processing of data.
354  */
PrintDrawnCompletedExecuteCallback(napi_env,void * data)355 void PrintDrawnCompletedExecuteCallback(napi_env, void *data)
356 {
357     TAG_LOGI(AAFwkTag::JSNAPI, "called");
358     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
359     if (asyncCallbackInfo == nullptr) {
360         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
361         return;
362     }
363 
364     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
365     asyncCallbackInfo->native_data.data_type = NVT_NONE;
366     if (asyncCallbackInfo->ability == nullptr) {
367         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
368         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
369         return;
370     }
371 
372     if (!CheckAbilityType(asyncCallbackInfo)) {
373         TAG_LOGE(AAFwkTag::JSNAPI, "fail ability type");
374         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
375         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
376         return;
377     }
378 
379     asyncCallbackInfo->native_data.data_type = NVT_NONE;
380     asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->PrintDrawnCompleted();
381 }
382 
383 
GetOrCreateDistributedDirExecuteCallback(napi_env,void * data)384 void GetOrCreateDistributedDirExecuteCallback(napi_env, void *data)
385 {
386     TAG_LOGI(AAFwkTag::JSNAPI, "called");
387     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
388     if (asyncCallbackInfo == nullptr) {
389         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
390         return;
391     }
392 
393     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
394     asyncCallbackInfo->native_data.data_type = NVT_NONE;
395     if (asyncCallbackInfo->ability == nullptr) {
396         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
397         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
398         return;
399     }
400 
401     if (!CheckAbilityType(asyncCallbackInfo)) {
402         TAG_LOGE(AAFwkTag::JSNAPI, "wrong type of ability");
403         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
404         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
405         return;
406     }
407 
408     asyncCallbackInfo->native_data.data_type = NVT_STRING;
409     std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
410     if (abilityContext == nullptr) {
411         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityContext");
412         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
413         return;
414     }
415     asyncCallbackInfo->native_data.str_value = abilityContext->GetDistributedFilesDir();
416     TAG_LOGI(AAFwkTag::JSNAPI, "end filesDir=%{public}s",
417              asyncCallbackInfo->native_data.str_value.c_str());
418 }
419 
420 /**
421  * @brief GetCacheDir asynchronous processing function.
422  *
423  * @param env The environment that the Node-API call is invoked under.
424  * @param data Point to asynchronous processing of data.
425  */
GetCacheDirExecuteCallback(napi_env,void * data)426 void GetCacheDirExecuteCallback(napi_env, void *data)
427 {
428     TAG_LOGI(AAFwkTag::JSNAPI, "called");
429     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
430     if (asyncCallbackInfo == nullptr) {
431         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
432         return;
433     }
434 
435     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
436     asyncCallbackInfo->native_data.data_type = NVT_NONE;
437     if (asyncCallbackInfo->ability == nullptr) {
438         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
439         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
440         return;
441     }
442 
443     if (!CheckAbilityType(asyncCallbackInfo)) {
444         TAG_LOGE(AAFwkTag::JSNAPI, "error type of ability");
445         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
446         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
447         return;
448     }
449 
450     asyncCallbackInfo->native_data.data_type = NVT_STRING;
451     std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
452     if (abilityContext == nullptr) {
453         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityContext");
454         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
455         return;
456     }
457     asyncCallbackInfo->native_data.str_value = abilityContext->GetCacheDir();
458     TAG_LOGI(AAFwkTag::JSNAPI, "end CacheDir=%{public}s",
459              asyncCallbackInfo->native_data.str_value.c_str());
460 }
461 
462 /**
463  * @brief GetExternalCacheDir asynchronous processing function.
464  *
465  * @param env The environment that the Node-API call is invoked under.
466  * @param data Point to asynchronous processing of data.
467  */
GetExternalCacheDirExecuteCallback(napi_env,void * data)468 void GetExternalCacheDirExecuteCallback(napi_env, void *data)
469 {
470     TAG_LOGI(AAFwkTag::JSNAPI, "called");
471     AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
472     if (asyncCallbackInfo == nullptr) {
473         TAG_LOGE(AAFwkTag::JSNAPI, "null asyncCallbackInfo");
474         return;
475     }
476 
477     asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
478     asyncCallbackInfo->native_data.data_type = NVT_NONE;
479     if (asyncCallbackInfo->ability == nullptr) {
480         TAG_LOGE(AAFwkTag::JSNAPI, "null ability");
481         asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
482         return;
483     }
484 
485     if (!CheckAbilityType(asyncCallbackInfo)) {
486         TAG_LOGE(AAFwkTag::JSNAPI, "wrong ability type");
487         asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
488         asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
489         return;
490     }
491 
492     asyncCallbackInfo->native_data.data_type = NVT_STRING;
493     asyncCallbackInfo->native_data.str_value = asyncCallbackInfo->ability->GetExternalCacheDir();
494     TAG_LOGI(AAFwkTag::JSNAPI, "end ExternalCacheDir=%{private}s",
495              asyncCallbackInfo->native_data.str_value.c_str());
496 }
497 
498 /**
499  * @brief Create asynchronous data.
500  *
501  * @param env The environment that the Node-API call is invoked under.
502  *
503  * @return Return a pointer to AppTypeCB on success, nullptr on failure.
504  */
CreateAppTypeCBInfo(napi_env env)505 AppTypeCB *CreateAppTypeCBInfo(napi_env env)
506 {
507     TAG_LOGI(AAFwkTag::JSNAPI, "called");
508     napi_value global = nullptr;
509     NAPI_CALL(env, napi_get_global(env, &global));
510 
511     napi_value abilityObj = nullptr;
512     NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
513 
514     Ability *ability = nullptr;
515     NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
516 
517     AppTypeCB *appTypeCB = new (std::nothrow) AppTypeCB;
518     if (appTypeCB == nullptr) {
519         TAG_LOGE(AAFwkTag::JSNAPI, "null appTypeCB");
520         return nullptr;
521     }
522     appTypeCB->cbBase.cbInfo.env = env;
523     appTypeCB->cbBase.asyncWork = nullptr;
524     appTypeCB->cbBase.deferred = nullptr;
525     appTypeCB->cbBase.ability = ability;
526 
527     return appTypeCB;
528 }
529 
530 /**
531  * @brief Create asynchronous data.
532  *
533  * @param env The environment that the Node-API call is invoked under.
534  *
535  * @return Return a pointer to AbilityInfoCB on success, nullptr on failure.
536  */
CreateAbilityInfoCBInfo(napi_env env)537 AbilityInfoCB *CreateAbilityInfoCBInfo(napi_env env)
538 {
539     TAG_LOGI(AAFwkTag::JSNAPI, "called");
540     napi_value global = nullptr;
541     NAPI_CALL(env, napi_get_global(env, &global));
542 
543     napi_value abilityObj = nullptr;
544     NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
545 
546     Ability *ability = nullptr;
547     NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
548 
549     AbilityInfoCB *abilityInfoCB = new (std::nothrow) AbilityInfoCB;
550     if (abilityInfoCB == nullptr) {
551         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityInfoCB");
552         return nullptr;
553     }
554     abilityInfoCB->cbBase.cbInfo.env = env;
555     abilityInfoCB->cbBase.asyncWork = nullptr;
556     abilityInfoCB->cbBase.deferred = nullptr;
557     abilityInfoCB->cbBase.ability = ability;
558 
559     return abilityInfoCB;
560 }
561 
BuildJsAbilityInfoNamedPropertyFirst(napi_env env,const AbilityInfo & abilityInfo,napi_value & result,napi_value & proValue)562 napi_value BuildJsAbilityInfoNamedPropertyFirst(napi_env env, const AbilityInfo &abilityInfo, napi_value &result,
563     napi_value &proValue)
564 {
565     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
566     NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", proValue));
567 
568     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
569     NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
570 
571     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
572     NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
573 
574     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
575     NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
576 
577     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
578     NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
579 
580     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
581     NAPI_CALL(env, napi_set_named_property(env, result, "moduleName", proValue));
582 
583     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.process.c_str(), NAPI_AUTO_LENGTH, &proValue));
584     NAPI_CALL(env, napi_set_named_property(env, result, "process", proValue));
585 
586     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.type), &proValue));
587     NAPI_CALL(env, napi_set_named_property(env, result, "type", proValue));
588 
589     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.orientation), &proValue));
590     NAPI_CALL(env, napi_set_named_property(env, result, "orientation", proValue));
591 
592     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.launchMode), &proValue));
593     NAPI_CALL(env, napi_set_named_property(env, result, "launchMode", proValue));
594 
595     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.uri.c_str(), NAPI_AUTO_LENGTH, &proValue));
596     NAPI_CALL(env, napi_set_named_property(env, result, "uri", proValue));
597 
598     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &proValue));
599     NAPI_CALL(env, napi_set_named_property(env, result, "readPermission", proValue));
600 
601     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &proValue));
602     NAPI_CALL(env, napi_set_named_property(env, result, "writePermission", proValue));
603 
604     NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.targetAbility.c_str(), NAPI_AUTO_LENGTH, &proValue));
605     NAPI_CALL(env, napi_set_named_property(env, result, "targetAbility", proValue));
606 
607     NAPI_CALL(env, napi_create_int32(env, abilityInfo.labelId, &proValue));
608     NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
609 
610     NAPI_CALL(env, napi_create_int32(env, abilityInfo.descriptionId, &proValue));
611     NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
612 
613     NAPI_CALL(env, napi_create_int32(env, abilityInfo.iconId, &proValue));
614     NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
615 
616     NAPI_CALL(env, napi_create_int32(env, abilityInfo.formEntity, &proValue));
617     NAPI_CALL(env, napi_set_named_property(env, result, "formEntity", proValue));
618 
619     NAPI_CALL(env, napi_create_int32(env, abilityInfo.minFormHeight, &proValue));
620     NAPI_CALL(env, napi_set_named_property(env, result, "minFormHeight", proValue));
621 
622     NAPI_CALL(env, napi_create_int32(env, abilityInfo.defaultFormHeight, &proValue));
623     NAPI_CALL(env, napi_set_named_property(env, result, "defaultFormHeight", proValue));
624 
625     NAPI_CALL(env, napi_create_int32(env, abilityInfo.minFormWidth, &proValue));
626     NAPI_CALL(env, napi_set_named_property(env, result, "minFormWidth", proValue));
627 
628     NAPI_CALL(env, napi_create_int32(env, abilityInfo.defaultFormWidth, &proValue));
629     NAPI_CALL(env, napi_set_named_property(env, result, "defaultFormWidth", proValue));
630 
631     NAPI_CALL(env, napi_create_int32(env, abilityInfo.backgroundModes, &proValue));
632     NAPI_CALL(env, napi_set_named_property(env, result, "backgroundModes", proValue));
633 
634     return result;
635 }
636 
BuildJsAbilityInfoNamedPropertySecond(napi_env env,const AbilityInfo & abilityInfo,napi_value & result,napi_value & proValue)637 napi_value BuildJsAbilityInfoNamedPropertySecond(napi_env env, const AbilityInfo &abilityInfo, napi_value &result,
638     napi_value &proValue)
639 {
640     NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.subType), &proValue));
641     NAPI_CALL(env, napi_set_named_property(env, result, "subType", proValue));
642 
643     NAPI_CALL(env, napi_get_boolean(env, abilityInfo.visible, &proValue));
644     NAPI_CALL(env, napi_set_named_property(env, result, "isVisible", proValue));
645 
646     NAPI_CALL(env, napi_get_boolean(env, abilityInfo.formEnabled, &proValue));
647     NAPI_CALL(env, napi_set_named_property(env, result, "formEnabled", proValue));
648     return result;
649 }
650 
WrapAbilityInfo(napi_env env,const AbilityInfo & abilityInfo)651 napi_value WrapAbilityInfo(napi_env env, const AbilityInfo &abilityInfo)
652 {
653     TAG_LOGI(AAFwkTag::JSNAPI, "called");
654     napi_value result = nullptr;
655     napi_value proValue = nullptr;
656     NAPI_CALL(env, napi_create_object(env, &result));
657     (void)BuildJsAbilityInfoNamedPropertyFirst(env, abilityInfo, result, proValue);
658     (void)BuildJsAbilityInfoNamedPropertySecond(env, abilityInfo, result, proValue);
659     (void)WrapProperties(env, abilityInfo.permissions, "permissions", result);
660     (void)WrapProperties(env, abilityInfo.deviceCapabilities, "deviceCapabilities", result);
661     (void)WrapProperties(env, abilityInfo.deviceTypes, "deviceTypes", result);
662 
663     napi_value applicationInfo = nullptr;
664     applicationInfo = WrapAppInfo(env, abilityInfo.applicationInfo);
665     NAPI_CALL(env, napi_set_named_property(env, result, "applicationInfo", applicationInfo));
666 
667     return result;
668 }
669 
WrapProperties(napi_env env,const std::vector<std::string> properties,const std::string & proName,napi_value & result)670 napi_value WrapProperties(napi_env env, const std::vector<std::string> properties, const std::string &proName,
671     napi_value &result)
672 {
673     napi_value jsArrayProperties = nullptr;
674     NAPI_CALL(env, napi_create_array(env, &jsArrayProperties));
675     napi_value proValue = nullptr;
676     for (size_t i = 0; i < properties.size(); i++) {
677         NAPI_CALL(
678             env, napi_create_string_utf8(env, properties.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
679         NAPI_CALL(env, napi_set_element(env, jsArrayProperties, i, proValue));
680     }
681     NAPI_CALL(env, napi_set_named_property(env, result, proName.c_str(), jsArrayProperties));
682     return result;
683 }
684 
WrapModuleInfos(napi_env env,const ApplicationInfo & appInfo,napi_value & result)685 napi_value WrapModuleInfos(napi_env env, const ApplicationInfo &appInfo, napi_value &result)
686 {
687     napi_value jsArrayModuleInfo = nullptr;
688     napi_value jsModuleInfoObject = nullptr;
689     napi_value proValue = nullptr;
690     NAPI_CALL(env, napi_create_array(env, &jsArrayModuleInfo));
691     for (size_t i = 0; i < appInfo.moduleInfos.size(); i++) {
692         NAPI_CALL(env, napi_create_object(env, &jsModuleInfoObject));
693         proValue = nullptr;
694         NAPI_CALL(env,
695             napi_create_string_utf8(env, appInfo.moduleInfos.at(i).moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
696         NAPI_CALL(env, napi_set_named_property(env, jsModuleInfoObject, "moduleName", proValue));
697 
698         NAPI_CALL(env,
699             napi_create_string_utf8(
700                 env, appInfo.moduleInfos.at(i).moduleSourceDir.c_str(), NAPI_AUTO_LENGTH, &proValue));
701         NAPI_CALL(env, napi_set_named_property(env, jsModuleInfoObject, "moduleSourceDir", proValue));
702         NAPI_CALL(env, napi_set_element(env, jsArrayModuleInfo, i, jsModuleInfoObject));
703     }
704     NAPI_CALL(env, napi_set_named_property(env, result, "moduleInfos", jsArrayModuleInfo));
705     return nullptr;
706 }
707 
ConvertAbilityInfo(napi_env env,const AbilityInfo & abilityInfo)708 napi_value ConvertAbilityInfo(napi_env env, const AbilityInfo &abilityInfo)
709 {
710     return WrapAbilityInfo(env, abilityInfo);
711 }
712 
713 /**
714  * @brief Create asynchronous data.
715  *
716  * @param env The environment that the Node-API call is invoked under.
717  *
718  * @return Return a pointer to HapModuleInfoCB on success, nullptr on failure.
719  */
CreateHapModuleInfoCBInfo(napi_env env)720 HapModuleInfoCB *CreateHapModuleInfoCBInfo(napi_env env)
721 {
722     TAG_LOGI(AAFwkTag::JSNAPI, "called");
723     napi_value global = nullptr;
724     NAPI_CALL(env, napi_get_global(env, &global));
725 
726     napi_value abilityObj = nullptr;
727     NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
728 
729     Ability *ability = nullptr;
730     NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
731 
732     HapModuleInfoCB *hapModuleInfoCB = new (std::nothrow) HapModuleInfoCB;
733     if (hapModuleInfoCB == nullptr) {
734         TAG_LOGE(AAFwkTag::JSNAPI, "null hapModuleInfoCB");
735         return nullptr;
736     }
737     hapModuleInfoCB->cbBase.cbInfo.env = env;
738     hapModuleInfoCB->cbBase.asyncWork = nullptr;
739     hapModuleInfoCB->cbBase.deferred = nullptr;
740     hapModuleInfoCB->cbBase.ability = ability;
741 
742     return hapModuleInfoCB;
743 }
744 
BuildJsHapModuleInfoNamedProperty(napi_env env,const HapModuleInfoCB & cb,napi_value & result,napi_value & proValue)745 napi_value BuildJsHapModuleInfoNamedProperty(napi_env env, const HapModuleInfoCB &cb, napi_value &result,
746     napi_value &proValue)
747 {
748     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
749     NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
750 
751     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
752     NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
753 
754     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
755     NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
756 
757     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
758     NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
759 
760     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.backgroundImg.c_str(), NAPI_AUTO_LENGTH, &proValue));
761     NAPI_CALL(env, napi_set_named_property(env, result, "backgroundImg", proValue));
762 
763     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
764     NAPI_CALL(env, napi_set_named_property(env, result, "moduleName", proValue));
765 
766     NAPI_CALL(env, napi_create_int32(env, cb.hapModuleInfo.supportedModes, &proValue));
767     NAPI_CALL(env, napi_set_named_property(env, result, "supportedModes", proValue));
768 
769     NAPI_CALL(env, napi_create_int32(env, cb.hapModuleInfo.descriptionId, &proValue));
770     NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
771 
772     NAPI_CALL(env, napi_create_int32(env, cb.hapModuleInfo.labelId, &proValue));
773     NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
774 
775     NAPI_CALL(env, napi_create_int32(env, cb.hapModuleInfo.iconId, &proValue));
776     NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
777 
778     NAPI_CALL(env, napi_create_string_utf8(env, cb.hapModuleInfo.mainAbility.c_str(), NAPI_AUTO_LENGTH, &proValue));
779     NAPI_CALL(env, napi_set_named_property(env, result, "mainAbilityName", proValue));
780 
781     NAPI_CALL(env, napi_get_boolean(env, cb.hapModuleInfo.installationFree, &proValue));
782     NAPI_CALL(env, napi_set_named_property(env, result, "installationFree", proValue));
783     return result;
784 }
785 
WrapHapModuleInfo(napi_env env,const HapModuleInfoCB & cb)786 napi_value WrapHapModuleInfo(napi_env env, const HapModuleInfoCB &cb)
787 {
788     TAG_LOGI(AAFwkTag::JSNAPI, "called");
789     napi_value result = nullptr;
790     napi_value proValue = nullptr;
791     NAPI_CALL(env, napi_create_object(env, &result));
792     napi_value ret = BuildJsHapModuleInfoNamedProperty(env, cb, result, proValue);
793     if (ret == nullptr) {
794         return ret;
795     }
796 
797     napi_value jsArrayreqCapabilities = nullptr;
798     NAPI_CALL(env, napi_create_array(env, &jsArrayreqCapabilities));
799     for (size_t i = 0; i < cb.hapModuleInfo.reqCapabilities.size(); i++) {
800         proValue = nullptr;
801         NAPI_CALL(env,
802             napi_create_string_utf8(env, cb.hapModuleInfo.reqCapabilities.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
803         NAPI_CALL(env, napi_set_element(env, jsArrayreqCapabilities, i, proValue));
804     }
805     NAPI_CALL(env, napi_set_named_property(env, result, "reqCapabilities", jsArrayreqCapabilities));
806 
807     napi_value jsArraydeviceTypes = nullptr;
808     NAPI_CALL(env, napi_create_array(env, &jsArraydeviceTypes));
809     for (size_t i = 0; i < cb.hapModuleInfo.deviceTypes.size(); i++) {
810         proValue = nullptr;
811         NAPI_CALL(env,
812             napi_create_string_utf8(env, cb.hapModuleInfo.deviceTypes.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
813         NAPI_CALL(env, napi_set_element(env, jsArraydeviceTypes, i, proValue));
814     }
815     NAPI_CALL(env, napi_set_named_property(env, result, "deviceTypes", jsArraydeviceTypes));
816 
817     napi_value abilityInfos = nullptr;
818     NAPI_CALL(env, napi_create_array(env, &abilityInfos));
819     for (size_t i = 0; i < cb.hapModuleInfo.abilityInfos.size(); i++) {
820         napi_value abilityInfo = nullptr;
821         abilityInfo = WrapAbilityInfo(env, cb.hapModuleInfo.abilityInfos.at(i));
822         NAPI_CALL(env, napi_set_element(env, abilityInfos, i, abilityInfo));
823     }
824     NAPI_CALL(env, napi_set_named_property(env, result, "abilityInfo", abilityInfos));
825 
826     return result;
827 }
828 
829 /**
830  * @brief Create asynchronous data.
831  *
832  * @param env The environment that the Node-API call is invoked under.
833  *
834  * @return Return a pointer to AppVersionInfoCB on success, nullptr on failure.
835  */
CreateAppVersionInfoCBInfo(napi_env env)836 AppVersionInfoCB *CreateAppVersionInfoCBInfo(napi_env env)
837 {
838     TAG_LOGI(AAFwkTag::JSNAPI, "called");
839     napi_value global = nullptr;
840     NAPI_CALL(env, napi_get_global(env, &global));
841 
842     napi_value abilityObj = nullptr;
843     NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
844 
845     Ability *ability = nullptr;
846     NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
847 
848     AppVersionInfoCB *appVersionInfoCB = new (std::nothrow) AppVersionInfoCB;
849     if (appVersionInfoCB == nullptr) {
850         TAG_LOGE(AAFwkTag::JSNAPI, "null appVersionInfoCB");
851         return nullptr;
852     }
853     appVersionInfoCB->cbBase.cbInfo.env = env;
854     appVersionInfoCB->cbBase.asyncWork = nullptr;
855     appVersionInfoCB->cbBase.deferred = nullptr;
856     appVersionInfoCB->cbBase.ability = ability;
857 
858     return appVersionInfoCB;
859 }
860 
SaveAppVersionInfo(AppVersionInfo & appVersionInfo,const std::string appName,const std::string versionName,const int32_t versionCode)861 void SaveAppVersionInfo(AppVersionInfo &appVersionInfo, const std::string appName, const std::string versionName,
862     const int32_t versionCode)
863 {
864     TAG_LOGI(AAFwkTag::JSNAPI, "called");
865     appVersionInfo.appName = appName;
866     appVersionInfo.versionName = versionName;
867     appVersionInfo.versionCode = versionCode;
868 }
869 
WrapAppVersionInfo(napi_env env,const AppVersionInfoCB & appVersionInfoCB)870 napi_value WrapAppVersionInfo(napi_env env, const AppVersionInfoCB &appVersionInfoCB)
871 {
872     TAG_LOGI(AAFwkTag::JSNAPI, "called");
873     napi_value result = nullptr;
874     napi_value proValue = nullptr;
875     NAPI_CALL(env, napi_create_object(env, &result));
876     NAPI_CALL(env,
877         napi_create_string_utf8(env, appVersionInfoCB.appVersionInfo.appName.c_str(), NAPI_AUTO_LENGTH, &proValue));
878     NAPI_CALL(env, napi_set_named_property(env, result, "appName", proValue));
879 
880     NAPI_CALL(env,
881         napi_create_string_utf8(env, appVersionInfoCB.appVersionInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &proValue));
882     NAPI_CALL(env, napi_set_named_property(env, result, "versionName", proValue));
883 
884     NAPI_CALL(env, napi_create_int32(env, appVersionInfoCB.appVersionInfo.versionCode, &proValue));
885     NAPI_CALL(env, napi_set_named_property(env, result, "versionCode", proValue));
886 
887     return result;
888 }
889 
890 /**
891  * @brief Create asynchronous data.
892  *
893  * @param env The environment that the Node-API call is invoked under.
894  *
895  * @return Return a pointer to AbilityNameCB on success, nullptr on failure.
896  */
CreateAbilityNameCBInfo(napi_env env)897 AbilityNameCB *CreateAbilityNameCBInfo(napi_env env)
898 {
899     TAG_LOGI(AAFwkTag::JSNAPI, "called");
900     napi_value global = nullptr;
901     NAPI_CALL(env, napi_get_global(env, &global));
902 
903     napi_value abilityObj = nullptr;
904     NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
905 
906     Ability *ability = nullptr;
907     NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
908 
909     AbilityNameCB *abilityNameCB = new (std::nothrow) AbilityNameCB;
910     if (abilityNameCB == nullptr) {
911         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityNameCB");
912         return nullptr;
913     }
914     abilityNameCB->cbBase.cbInfo.env = env;
915     abilityNameCB->cbBase.asyncWork = nullptr;
916     abilityNameCB->cbBase.deferred = nullptr;
917     abilityNameCB->cbBase.ability = ability;
918 
919     return abilityNameCB;
920 }
921 
WrapAbilityName(napi_env env,const AbilityNameCB * abilityNameCB)922 napi_value WrapAbilityName(napi_env env, const AbilityNameCB *abilityNameCB)
923 {
924     TAG_LOGI(AAFwkTag::JSNAPI, "called");
925     if (abilityNameCB == nullptr) {
926         TAG_LOGE(AAFwkTag::JSNAPI, "null abilityNameCB");
927         return nullptr;
928     }
929     napi_value result = nullptr;
930     NAPI_CALL(env, napi_create_string_utf8(env, abilityNameCB->name.c_str(), NAPI_AUTO_LENGTH, &result));
931 
932     return result;
933 }
934 
UnwrapAbilityStartSettingForNumber(napi_env env,const std::string key,napi_value param,AAFwk::AbilityStartSetting & setting)935 void UnwrapAbilityStartSettingForNumber(
936     napi_env env, const std::string key, napi_value param, AAFwk::AbilityStartSetting &setting)
937 {
938     int32_t natValue32 = 0;
939     double natValueDouble = 0.0;
940     bool isReadValue32 = false;
941     bool isReadDouble = false;
942     if (napi_get_value_int32(env, param, &natValue32) == napi_ok) {
943         TAG_LOGI(AAFwkTag::JSNAPI, "Property value=%{private}d.", natValue32);
944         isReadValue32 = true;
945     }
946 
947     if (napi_get_value_double(env, param, &natValueDouble) == napi_ok) {
948         TAG_LOGI(AAFwkTag::JSNAPI, "Property value=%{private}lf", natValueDouble);
949         isReadDouble = true;
950     }
951 
952     if (isReadValue32 && isReadDouble) {
953         if (abs(natValueDouble - natValue32 * 1.0) > 0.0) {
954             setting.AddProperty(key, std::to_string(natValueDouble));
955         } else {
956             setting.AddProperty(key, std::to_string(natValue32));
957         }
958     } else if (isReadValue32) {
959         setting.AddProperty(key, std::to_string(natValue32));
960     } else if (isReadDouble) {
961         setting.AddProperty(key, std::to_string(natValueDouble));
962     }
963 }
964 
UnwrapAbilityStartSetting(napi_env env,napi_value param,AAFwk::AbilityStartSetting & setting)965 bool UnwrapAbilityStartSetting(napi_env env, napi_value param, AAFwk::AbilityStartSetting &setting)
966 {
967     TAG_LOGI(AAFwkTag::JSNAPI, "called");
968 
969     if (!IsTypeForNapiValue(env, param, napi_object)) {
970         return false;
971     }
972 
973     napi_valuetype jsValueType = napi_undefined;
974     napi_value jsProNameList = nullptr;
975     uint32_t jsProCount = 0;
976 
977     NAPI_CALL_BASE(env, napi_get_property_names(env, param, &jsProNameList), false);
978     NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
979     TAG_LOGI(AAFwkTag::JSNAPI, "Property size: %{public}d", jsProCount);
980 
981     napi_value jsProName = nullptr;
982     napi_value jsProValue = nullptr;
983     for (uint32_t index = 0; index < jsProCount; index++) {
984         NAPI_CALL_BASE(env, napi_get_element(env, jsProNameList, index, &jsProName), false);
985 
986         std::string strProName = UnwrapStringFromJS(env, jsProName);
987         TAG_LOGI(AAFwkTag::JSNAPI, "Property name=%{public}s", strProName.c_str());
988         NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsProValue), false);
989         NAPI_CALL_BASE(env, napi_typeof(env, jsProValue, &jsValueType), false);
990 
991         switch (jsValueType) {
992             case napi_string: {
993                 std::string natValue = UnwrapStringFromJS(env, jsProValue);
994                 TAG_LOGI(AAFwkTag::JSNAPI, "Property value=%{private}s",
995                          natValue.c_str());
996                 setting.AddProperty(strProName, natValue);
997                 break;
998             }
999             case napi_boolean: {
1000                 bool natValue = false;
1001                 NAPI_CALL_BASE(env, napi_get_value_bool(env, jsProValue, &natValue), false);
1002                 TAG_LOGI(AAFwkTag::JSNAPI, "Property value=%{public}s",
1003                          natValue ? "true" : "false");
1004                 setting.AddProperty(strProName, std::to_string(natValue));
1005                 break;
1006             }
1007             case napi_number:
1008                 UnwrapAbilityStartSettingForNumber(env, strProName, jsProValue, setting);
1009                 break;
1010             default:
1011                 break;
1012         }
1013     }
1014 
1015     return true;
1016 }
1017 
UnwrapParamStopAbilityWrap(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)1018 bool UnwrapParamStopAbilityWrap(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
1019 {
1020     TAG_LOGI(AAFwkTag::JSNAPI, "called argc=%{public}zu", argc);
1021     const size_t argcMax = 2;
1022     if (argc > argcMax || argc < argcMax - 1) {
1023         TAG_LOGE(AAFwkTag::JSNAPI, "invalid argc");
1024         return false;
1025     }
1026 
1027     if (argc == argcMax) {
1028         if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
1029             TAG_LOGI(AAFwkTag::JSNAPI, "argv[PARAM1] invalid");
1030             return false;
1031         }
1032     }
1033 
1034     return UnwrapWant(env, argv[PARAM0], asyncCallbackInfo->param.want);
1035 }
1036 
UnwrapParamForWantAgent(napi_env & env,napi_value & args,AbilityRuntime::WantAgent::WantAgent * & wantAgent)1037 napi_value UnwrapParamForWantAgent(napi_env &env, napi_value &args, AbilityRuntime::WantAgent::WantAgent *&wantAgent)
1038 {
1039     napi_valuetype valuetype = napi_undefined;
1040     NAPI_CALL(env, napi_typeof(env, args, &valuetype));
1041     NAPI_ASSERT(env, valuetype == napi_object, "Wrong argument type. Object expected.");
1042     napi_value wantAgentParam = nullptr;
1043     napi_value result = nullptr;
1044 
1045     bool hasProperty = false;
1046     NAPI_CALL(env, napi_has_named_property(env, args, "wantAgent", &hasProperty));
1047     if (hasProperty) {
1048         napi_get_named_property(env, args, "wantAgent", &wantAgentParam);
1049         NAPI_CALL(env, napi_typeof(env, wantAgentParam, &valuetype));
1050         NAPI_ASSERT(env, valuetype == napi_object, "Wrong argument type. Object expected.");
1051         napi_unwrap(env, wantAgentParam, reinterpret_cast<void **>(&wantAgent));
1052     }
1053 
1054     napi_get_null(env, &result);
1055     return result;
1056 }
1057 }  // namespace AppExecFwk
1058 }  // namespace OHOS