1 /*
2 * Copyright (c) 2021-2025 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 #include "bundle_mgr.h"
16
17 #include <string>
18 #include <unordered_map>
19
20 #include "app_log_wrapper.h"
21 #include "appexecfwk_errors.h"
22 #include "bundle_constants.h"
23 #include "bundle_errors.h"
24 #include "bundle_mgr_client.h"
25 #include "bundle_mgr_interface.h"
26 #include "bundle_mgr_proxy.h"
27 #include "business_error.h"
28 #include "cleancache_callback.h"
29 #include "common_func.h"
30 #include "if_system_ability_manager.h"
31 #include "installer_callback.h"
32 #include "ipc_skeleton.h"
33 #include "iservice_registry.h"
34 #include "napi_arg.h"
35 #include "napi_constants.h"
36 #include "napi/native_api.h"
37 #include "napi/native_node_api.h"
38 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
39 #include "bundle_graphics_client.h"
40 #include "pixel_map_napi.h"
41 #endif
42 #include "securec.h"
43 #include "system_ability_definition.h"
44
45 namespace OHOS {
46 namespace AppExecFwk {
47 using namespace OHOS;
48 using namespace OHOS::AAFwk;
49 using namespace OHOS::AppExecFwk;
50 using namespace OHOS::AbilityRuntime;
51
52 namespace {
53 constexpr size_t NAPI_ERR_NO_ERROR = 0;
54 constexpr size_t ARGS_ASYNC_COUNT = 1;
55 constexpr size_t ARGS_MAX_COUNT = 10;
56 constexpr size_t CALLBACK_SIZE = 1;
57 constexpr int32_t PARAM0 = 0;
58 constexpr int32_t PARAM1 = 1;
59 constexpr int32_t PARAM2 = 2;
60 constexpr int32_t PARAM3 = 3;
61 constexpr int32_t NAPI_RETURN_FAILED = -1;
62 constexpr int32_t NAPI_RETURN_ZERO = 0;
63 constexpr int32_t NAPI_RETURN_TWO = 2;
64 constexpr int32_t NAPI_RETURN_THREE = 3;
65 constexpr int32_t CODE_SUCCESS = 0;
66 constexpr int32_t CODE_FAILED = -1;
67 constexpr int32_t OPERATION_FAILED = 1;
68 constexpr int32_t INVALID_PARAM = 2;
69 constexpr int32_t PARAM_TYPE_ERROR = 1;
70 constexpr int32_t UNDEFINED_ERROR = -1;
71 #ifndef BUNDLE_FRAMEWORK_GRAPHICS
72 constexpr int32_t UNSUPPORTED_FEATURE_ERRCODE = 801;
73 const char* UNSUPPORTED_FEATURE_MESSAGE = "unsupported BundleManagerService feature";
74 #endif
75 enum class InstallErrorCode : uint8_t {
76 SUCCESS = 0,
77 STATUS_INSTALL_FAILURE = 1,
78 STATUS_INSTALL_FAILURE_ABORTED = 2,
79 STATUS_INSTALL_FAILURE_INVALID = 3,
80 STATUS_INSTALL_FAILURE_CONFLICT = 4,
81 STATUS_INSTALL_FAILURE_STORAGE = 5,
82 STATUS_INSTALL_FAILURE_INCOMPATIBLE = 6,
83 STATUS_UNINSTALL_FAILURE = 7,
84 STATUS_UNINSTALL_FAILURE_BLOCKED = 8,
85 STATUS_UNINSTALL_FAILURE_ABORTED = 9,
86 STATUS_UNINSTALL_FAILURE_CONFLICT = 10,
87 STATUS_INSTALL_FAILURE_DOWNLOAD_TIMEOUT = 0x0B,
88 STATUS_INSTALL_FAILURE_DOWNLOAD_FAILED = 0x0C,
89 STATUS_RECOVER_FAILURE_INVALID = 0x0D,
90 STATUS_ABILITY_NOT_FOUND = 0x40,
91 STATUS_BMS_SERVICE_ERROR = 0x41,
92 STATUS_FAILED_NO_SPACE_LEFT = 0X42,
93 STATUS_GRANT_REQUEST_PERMISSIONS_FAILED = 0X43,
94 STATUS_INSTALL_PERMISSION_DENIED = 0X44,
95 STATUS_UNINSTALL_PERMISSION_DENIED = 0X45,
96 STATUS_USER_NOT_EXIST = 0X50,
97 STATUS_USER_FAILURE_INVALID = 0X51,
98 STATUS_USER_CREATE_FAILED = 0X52,
99 STATUS_USER_REMOVE_FAILED = 0X53,
100 };
101
102 const char* IS_SET_APPLICATION_ENABLED = "IsSetApplicationEnabled";
103 const char* IS_ABILITY_ENABLED = "IsAbilityEnabled";
104 const char* GET_LAUNCH_WANT_FOR_BUNDLE = "GetLaunchWantForBundle";
105 const char* GET_BUNDLE_ARCHIVE_INFO = "GetBundleArchiveInfo";
106 const char* GET_ABILITY_ICON = "GetAbilityIcon";
107 constexpr const char* NAPI_GET_APPLICATION_INFO = "GetApplicationInfo";
108 const char* GET_BUNDLE_INFO = "getBundleInfo";
109 const char* GET_ALL_BUNDLE_INFO = "GetAllBundleInfo";
110 const char* GET_PERMISSION_DEF = "GetPermissionDef";
111 const char* QUERY_ABILITY_BY_WANT = "queryAbilityByWant";
112 const char* TYPE_MISMATCH = "type misMatch";
113
114 const std::vector<int32_t> PACKINFO_FLAGS = {
115 BundlePackFlag::GET_PACK_INFO_ALL,
116 BundlePackFlag::GET_PACKAGES,
117 BundlePackFlag::GET_BUNDLE_SUMMARY,
118 BundlePackFlag::GET_MODULE_SUMMARY,
119 };
120
121 thread_local std::mutex g_permissionsCallbackMutex;
122 thread_local std::mutex g_anyPermissionsCallbackMutex;
123
124 struct PermissionsKey {
125 napi_ref callback = 0;
126 std::vector<int32_t> uids;
operator <OHOS::AppExecFwk::__anon65a7b6110111::PermissionsKey127 bool operator<(const PermissionsKey &other) const
128 {
129 return this->callback < other.callback;
130 }
131 };
132
133 static OHOS::sptr<OHOS::AppExecFwk::IBundleMgr> bundleMgr_ = nullptr;
134 static std::unordered_map<Query, napi_ref, QueryHash> cache;
135 static std::unordered_map<Query, napi_ref, QueryHash> abilityInfoCache;
136 static std::mutex abilityInfoCacheMutex_;
137 static std::mutex bundleMgrMutex_;
138 static sptr<BundleMgrDeathRecipient> bundleMgrDeathRecipient(new (std::nothrow) BundleMgrDeathRecipient());
139 } // namespace
140
OnRemoteDied(const wptr<IRemoteObject> & remote)141 void BundleMgrDeathRecipient::OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject>& remote)
142 {
143 APP_LOGD("BundleManagerService dead");
144 std::lock_guard<std::mutex> lock(bundleMgrMutex_);
145 bundleMgr_ = nullptr;
146 };
147
AsyncWorkData(napi_env napiEnv)148 AsyncWorkData::AsyncWorkData(napi_env napiEnv) : env(napiEnv) {}
149
~AsyncWorkData()150 AsyncWorkData::~AsyncWorkData()
151 {
152 if (callback) {
153 APP_LOGD("AsyncWorkData::~AsyncWorkData delete callback");
154 napi_delete_reference(env, callback);
155 callback = nullptr;
156 }
157 if (asyncWork) {
158 APP_LOGD("AsyncWorkData::~AsyncWorkData delete asyncWork");
159 napi_delete_async_work(env, asyncWork);
160 asyncWork = nullptr;
161 }
162 }
163 napi_ref thread_local g_classBundleInstaller;
164
GetBundleMgr()165 static OHOS::sptr<OHOS::AppExecFwk::IBundleMgr> GetBundleMgr()
166 {
167 if (bundleMgr_ == nullptr) {
168 std::lock_guard<std::mutex> lock(bundleMgrMutex_);
169 if (bundleMgr_ == nullptr) {
170 auto systemAbilityManager = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
171 if (systemAbilityManager == nullptr) {
172 APP_LOGE("GetBundleMgr GetSystemAbilityManager is null");
173 return nullptr;
174 }
175 auto bundleMgrSa = systemAbilityManager->GetSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
176 if (bundleMgrSa == nullptr) {
177 APP_LOGE("GetBundleMgr GetSystemAbility is null");
178 return nullptr;
179 }
180 auto bundleMgr = OHOS::iface_cast<IBundleMgr>(bundleMgrSa);
181 if (bundleMgr == nullptr) {
182 APP_LOGE("GetBundleMgr iface_cast get null");
183 }
184 bundleMgr_ = bundleMgr;
185 bundleMgr_->AsObject()->AddDeathRecipient(bundleMgrDeathRecipient);
186 }
187 }
188 return bundleMgr_;
189 }
190
HandleAbilityInfoCache(napi_env env,const Query & query,const AsyncAbilityInfoCallbackInfo * info,napi_value jsObject)191 static void HandleAbilityInfoCache(
192 napi_env env, const Query &query, const AsyncAbilityInfoCallbackInfo *info, napi_value jsObject)
193 {
194 if (info == nullptr) {
195 return;
196 }
197 ElementName element = info->want.GetElement();
198 if (element.GetBundleName().empty() || element.GetAbilityName().empty()) {
199 return;
200 }
201 uint32_t explicitQueryResultLen = 1;
202 if (info->abilityInfos.size() != explicitQueryResultLen ||
203 info->abilityInfos[0].uid != IPCSkeleton::GetCallingUid()) {
204 return;
205 }
206 napi_ref cacheAbilityInfo = nullptr;
207 NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, jsObject, NAPI_RETURN_ONE, &cacheAbilityInfo));
208 abilityInfoCache.clear();
209 abilityInfoCache[query] = cacheAbilityInfo;
210 }
211
CheckIsSystemApp()212 static bool CheckIsSystemApp()
213 {
214 auto iBundleMgr = GetBundleMgr();
215 if (iBundleMgr == nullptr) {
216 APP_LOGE("can not get iBundleMgr");
217 return false;
218 }
219
220 int32_t uid = IPCSkeleton::GetCallingUid();
221 return iBundleMgr->CheckIsSystemAppByUid(uid);
222 }
223
ConvertCustomizeData(napi_env env,napi_value objCustomizeData,const CustomizeData & customizeData)224 static void ConvertCustomizeData(napi_env env, napi_value objCustomizeData, const CustomizeData &customizeData)
225 {
226 napi_value nName;
227 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, customizeData.name.c_str(), NAPI_AUTO_LENGTH, &nName));
228 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objCustomizeData, "name", nName));
229 napi_value nValue;
230 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, customizeData.value.c_str(), NAPI_AUTO_LENGTH, &nValue));
231 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objCustomizeData, "value", nValue));
232 napi_value nExtra;
233 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, customizeData.extra.c_str(), NAPI_AUTO_LENGTH, &nExtra));
234 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objCustomizeData, "extra", nExtra));
235 }
236
ConvertInnerMetadata(napi_env env,napi_value value,const Metadata & metadata)237 static void ConvertInnerMetadata(napi_env env, napi_value value, const Metadata &metadata)
238 {
239 napi_value nName;
240 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.name.c_str(), NAPI_AUTO_LENGTH, &nName));
241 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "name", nName));
242 napi_value nValue;
243 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.value.c_str(), NAPI_AUTO_LENGTH, &nValue));
244 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "value", nValue));
245 napi_value nResource;
246 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.resource.c_str(), NAPI_AUTO_LENGTH, &nResource));
247 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "resource", nResource));
248 }
249
ConvertResource(napi_env env,napi_value objResource,const Resource & resource)250 static void ConvertResource(napi_env env, napi_value objResource, const Resource &resource)
251 {
252 napi_value nBundleName;
253 NAPI_CALL_RETURN_VOID(
254 env, napi_create_string_utf8(env, resource.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
255 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, "bundleName", nBundleName));
256
257 napi_value nModuleName;
258 NAPI_CALL_RETURN_VOID(
259 env, napi_create_string_utf8(env, resource.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
260 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, "moduleName", nModuleName));
261
262 napi_value nId;
263 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, resource.id, &nId));
264 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, "id", nId));
265 }
266
ConvertApplicationInfo(napi_env env,napi_value objAppInfo,const ApplicationInfo & appInfo)267 static void ConvertApplicationInfo(napi_env env, napi_value objAppInfo, const ApplicationInfo &appInfo)
268 {
269 napi_value nName;
270 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
271 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "name", nName));
272
273 napi_value nCodePath;
274 NAPI_CALL_RETURN_VOID(
275 env, napi_create_string_utf8(env, appInfo.codePath.c_str(), NAPI_AUTO_LENGTH, &nCodePath));
276 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "codePath", nCodePath));
277
278 napi_value nAccessTokenId;
279 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.accessTokenId, &nAccessTokenId));
280 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "accessTokenId", nAccessTokenId));
281
282 napi_value nDescription;
283 NAPI_CALL_RETURN_VOID(
284 env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
285 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "description", nDescription));
286
287 napi_value nDescriptionId;
288 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.descriptionId, &nDescriptionId));
289 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "descriptionId", nDescriptionId));
290
291 napi_value nIconPath;
292 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
293 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "icon", nIconPath));
294
295 napi_value nIconId;
296 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.iconId, &nIconId));
297 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconId", nIconId));
298
299 napi_value nLabel;
300 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
301 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "label", nLabel));
302
303 napi_value nLabelId;
304 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.labelId, &nLabelId));
305 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelId", nLabelId));
306
307 napi_value nIsSystemApp;
308 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.isSystemApp, &nIsSystemApp));
309 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "systemApp", nIsSystemApp));
310
311 napi_value nSupportedModes;
312 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.supportedModes, &nSupportedModes));
313 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "supportedModes", nSupportedModes));
314
315 napi_value nProcess;
316 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
317 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "process", nProcess));
318
319 napi_value nIconIndex;
320 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.iconId, &nIconIndex));
321 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconIndex", nIconIndex));
322
323 napi_value nLabelIndex;
324 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.labelId, &nLabelIndex));
325 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelIndex", nLabelIndex));
326
327 napi_value nEntryDir;
328 NAPI_CALL_RETURN_VOID(
329 env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &nEntryDir));
330 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "entryDir", nEntryDir));
331
332 napi_value nPermissions;
333 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nPermissions));
334 for (size_t idx = 0; idx < appInfo.permissions.size(); idx++) {
335 napi_value nPermission;
336 NAPI_CALL_RETURN_VOID(
337 env, napi_create_string_utf8(env, appInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
338 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
339 }
340 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "permissions", nPermissions));
341
342 napi_value nModuleSourceDirs;
343 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nModuleSourceDirs));
344 for (size_t idx = 0; idx < appInfo.moduleSourceDirs.size(); idx++) {
345 napi_value nModuleSourceDir;
346 NAPI_CALL_RETURN_VOID(env,
347 napi_create_string_utf8(env, appInfo.moduleSourceDirs[idx].c_str(), NAPI_AUTO_LENGTH, &nModuleSourceDir));
348 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nModuleSourceDirs, idx, nModuleSourceDir));
349 }
350 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "moduleSourceDirs", nModuleSourceDirs));
351
352 napi_value nModuleInfos;
353 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nModuleInfos));
354 for (size_t idx = 0; idx < appInfo.moduleInfos.size(); idx++) {
355 napi_value objModuleInfos;
356 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objModuleInfos));
357
358 napi_value nModuleName;
359 NAPI_CALL_RETURN_VOID(env,
360 napi_create_string_utf8(env, appInfo.moduleInfos[idx].moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
361 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objModuleInfos, "moduleName", nModuleName));
362
363 napi_value nModuleSourceDir;
364 NAPI_CALL_RETURN_VOID(env,
365 napi_create_string_utf8(
366 env, appInfo.moduleInfos[idx].moduleSourceDir.c_str(), NAPI_AUTO_LENGTH, &nModuleSourceDir));
367 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objModuleInfos, "moduleSourceDir", nModuleSourceDir));
368
369 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nModuleInfos, idx, objModuleInfos));
370 }
371 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "moduleInfos", nModuleInfos));
372
373 napi_value nMetaData;
374 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
375 for (const auto &item : appInfo.metaData) {
376 napi_value nCustomizeDataArray;
377 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nCustomizeDataArray));
378 for (size_t j = 0; j < item.second.size(); j++) {
379 napi_value nCustomizeData;
380 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nCustomizeData));
381 ConvertCustomizeData(env, nCustomizeData, item.second[j]);
382 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nCustomizeDataArray, j, nCustomizeData));
383 }
384 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMetaData, item.first.c_str(), nCustomizeDataArray));
385 }
386 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "metaData", nMetaData));
387
388 napi_value nMetadata;
389 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetadata));
390 for (const auto &item : appInfo.metadata) {
391 napi_value nInnerMetadata;
392 size_t len = item.second.size();
393 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, len, &nInnerMetadata));
394 for (size_t index = 0; index < len; ++index) {
395 napi_value nMeta;
396 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMeta));
397 ConvertInnerMetadata(env, nMeta, item.second[index]);
398 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nInnerMetadata, index, nMeta));
399 }
400 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMetadata, item.first.c_str(), nInnerMetadata));
401 }
402 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "metadata", nMetadata));
403
404 napi_value nEnabled;
405 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.enabled, &nEnabled));
406 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "enabled", nEnabled));
407
408 napi_value nUid;
409 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.uid, &nUid));
410 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "uid", nUid));
411
412 napi_value nEntityType;
413 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.entityType.c_str(), NAPI_AUTO_LENGTH,
414 &nEntityType));
415 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "entityType", nEntityType));
416
417 napi_value nRemovable;
418 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.removable, &nRemovable));
419 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "removable", nRemovable));
420
421 napi_value nFingerprint;
422 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.fingerprint.c_str(), NAPI_AUTO_LENGTH,
423 &nFingerprint));
424 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "fingerprint", nFingerprint));
425
426 napi_value nIconResource;
427 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nIconResource));
428 ConvertResource(env, nIconResource, appInfo.iconResource);
429 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconResource", nIconResource));
430
431 napi_value nLabelResource;
432 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nLabelResource));
433 ConvertResource(env, nLabelResource, appInfo.labelResource);
434 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelResource", nLabelResource));
435
436 napi_value nDescriptionResource;
437 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDescriptionResource));
438 ConvertResource(env, nDescriptionResource, appInfo.descriptionResource);
439 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "descriptionResource", nDescriptionResource));
440
441 napi_value nAppDistributionType;
442 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appDistributionType.c_str(), NAPI_AUTO_LENGTH,
443 &nAppDistributionType));
444 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appDistributionType", nAppDistributionType));
445
446 napi_value nAppProvisionType;
447 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appProvisionType.c_str(), NAPI_AUTO_LENGTH,
448 &nAppProvisionType));
449 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appProvisionType", nAppProvisionType));
450 }
451
ConvertMetaData(napi_env env,napi_value objMetaData,const MetaData & metaData)452 static void ConvertMetaData(napi_env env, napi_value objMetaData, const MetaData &metaData)
453 {
454 for (size_t idx = 0; idx < metaData.customizeData.size(); idx++) {
455 napi_value nCustomizeData;
456 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nCustomizeData));
457 ConvertCustomizeData(env, nCustomizeData, metaData.customizeData[idx]);
458 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, objMetaData, idx, nCustomizeData));
459 }
460 }
461
ConvertAbilityInfo(napi_env env,napi_value objAbilityInfo,const AbilityInfo & abilityInfo)462 static void ConvertAbilityInfo(napi_env env, napi_value objAbilityInfo, const AbilityInfo &abilityInfo)
463 {
464 napi_value nName;
465 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
466 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "name", nName));
467
468 napi_value nLabel;
469 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
470 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "label", nLabel));
471
472 napi_value nDescription;
473 NAPI_CALL_RETURN_VOID(
474 env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
475 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "description", nDescription));
476
477 napi_value nIconPath;
478 NAPI_CALL_RETURN_VOID(
479 env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
480 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "icon", nIconPath));
481
482 napi_value nVisible;
483 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.visible, &nVisible));
484 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "isVisible", nVisible));
485
486 napi_value nPermissions;
487 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nPermissions));
488 for (size_t idx = 0; idx < abilityInfo.permissions.size(); idx++) {
489 napi_value nPermission;
490 NAPI_CALL_RETURN_VOID(
491 env, napi_create_string_utf8(env, abilityInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
492 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
493 }
494 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "permissions", nPermissions));
495
496 napi_value nDeviceCapabilities;
497 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceCapabilities));
498 for (size_t idx = 0; idx < abilityInfo.deviceCapabilities.size(); idx++) {
499 napi_value nDeviceCapability;
500 NAPI_CALL_RETURN_VOID(env,
501 napi_create_string_utf8(
502 env, abilityInfo.deviceCapabilities[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceCapability));
503 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceCapabilities, idx, nDeviceCapability));
504 }
505 NAPI_CALL_RETURN_VOID(
506 env, napi_set_named_property(env, objAbilityInfo, "deviceCapabilities", nDeviceCapabilities));
507
508 napi_value nDeviceTypes;
509 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
510 for (size_t idx = 0; idx < abilityInfo.deviceTypes.size(); idx++) {
511 napi_value nDeviceType;
512 NAPI_CALL_RETURN_VOID(
513 env, napi_create_string_utf8(env, abilityInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
514 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
515 }
516 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "deviceTypes", nDeviceTypes));
517
518 napi_value nProcess;
519 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
520 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "process", nProcess));
521
522 napi_value nUri;
523 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.uri.c_str(), NAPI_AUTO_LENGTH, &nUri));
524 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "uri", nUri));
525
526 napi_value nBundleName;
527 NAPI_CALL_RETURN_VOID(
528 env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
529 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "bundleName", nBundleName));
530
531 napi_value nModuleName;
532 NAPI_CALL_RETURN_VOID(
533 env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
534 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "moduleName", nModuleName));
535
536 napi_value nAppInfo;
537 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nAppInfo));
538 ConvertApplicationInfo(env, nAppInfo, abilityInfo.applicationInfo);
539 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "applicationInfo", nAppInfo));
540
541 napi_value nType;
542 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.type), &nType));
543 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "type", nType));
544
545 napi_value nOrientation;
546 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.orientation), &nOrientation));
547 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "orientation", nOrientation));
548
549 napi_value nLaunchMode;
550 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.launchMode), &nLaunchMode));
551 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "launchMode", nLaunchMode));
552
553 napi_value nBackgroundModes;
554 if (!abilityInfo.isModuleJson) {
555 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.backgroundModes, &nBackgroundModes));
556 } else {
557 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 0, &nBackgroundModes));
558 }
559 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "backgroundModes", nBackgroundModes));
560
561 napi_value nDescriptionId;
562 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.descriptionId, &nDescriptionId));
563 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "descriptionId", nDescriptionId));
564
565 napi_value nFormEnabled;
566 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.formEnabled, &nFormEnabled));
567 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "formEnabled", nFormEnabled));
568
569 napi_value nIconId;
570 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.iconId, &nIconId));
571 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "iconId", nIconId));
572
573 napi_value nLabelId;
574 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.labelId, &nLabelId));
575 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "labelId", nLabelId));
576
577 napi_value nSubType;
578 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.subType), &nSubType));
579 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "subType", nSubType));
580
581 napi_value nReadPermission;
582 NAPI_CALL_RETURN_VOID(
583 env, napi_create_string_utf8(env, abilityInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &nReadPermission));
584 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "readPermission", nReadPermission));
585
586 napi_value nWritePermission;
587 NAPI_CALL_RETURN_VOID(
588 env, napi_create_string_utf8(env, abilityInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &nWritePermission));
589 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "writePermission", nWritePermission));
590
591 napi_value nTargetAbility;
592 NAPI_CALL_RETURN_VOID(env,
593 napi_create_string_utf8(env, abilityInfo.targetAbility.c_str(), NAPI_AUTO_LENGTH, &nTargetAbility));
594 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "targetAbility", nTargetAbility));
595
596 napi_value nMetaData;
597 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nMetaData));
598 ConvertMetaData(env, nMetaData, abilityInfo.metaData);
599 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "metaData", nMetaData));
600
601 napi_value nMetadata;
602 size_t size = abilityInfo.metadata.size();
603 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
604 for (size_t index = 0; index < size; ++index) {
605 napi_value innerMeta;
606 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &innerMeta));
607 ConvertInnerMetadata(env, innerMeta, abilityInfo.metadata[index]);
608 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, innerMeta));
609 }
610 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "metadata", nMetadata));
611
612 napi_value nEnabled;
613 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.enabled, &nEnabled));
614 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "enabled", nEnabled));
615
616 napi_value nMaxWindowRatio;
617 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.maxWindowRatio, &nMaxWindowRatio));
618 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "maxWindowRatio", nMaxWindowRatio));
619
620 napi_value mMinWindowRatio;
621 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.minWindowRatio, &mMinWindowRatio));
622 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "minWindowRatio", mMinWindowRatio));
623
624 napi_value nMaxWindowWidth;
625 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowWidth, &nMaxWindowWidth));
626 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "maxWindowWidth", nMaxWindowWidth));
627
628 napi_value nMinWindowWidth;
629 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowWidth, &nMinWindowWidth));
630 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "minWindowWidth", nMinWindowWidth));
631
632 napi_value nMaxWindowHeight;
633 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowHeight, &nMaxWindowHeight));
634 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "maxWindowHeight", nMaxWindowHeight));
635
636 napi_value nMinWindowHeight;
637 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowHeight, &nMinWindowHeight));
638 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "minWindowHeight", nMinWindowHeight));
639 }
640
ProcessAbilityInfos(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::AbilityInfo> & abilityInfos)641 static void ProcessAbilityInfos(
642 napi_env env, napi_value result, const std::vector<OHOS::AppExecFwk::AbilityInfo> &abilityInfos)
643 {
644 if (abilityInfos.size() > 0) {
645 APP_LOGI("-----abilityInfos is not null-----");
646 size_t index = 0;
647 for (const auto &item : abilityInfos) {
648 APP_LOGI("name: %{public}s ", item.name.c_str());
649 napi_value objAbilityInfo = nullptr;
650 napi_create_object(env, &objAbilityInfo);
651 ConvertAbilityInfo(env, objAbilityInfo, item);
652 napi_set_element(env, result, index, objAbilityInfo);
653 index++;
654 }
655 } else {
656 APP_LOGI("-----abilityInfos is null-----");
657 }
658 }
659
ConvertHapModuleInfo(napi_env env,napi_value objHapModuleInfo,const HapModuleInfo & hapModuleInfo)660 static void ConvertHapModuleInfo(napi_env env, napi_value objHapModuleInfo, const HapModuleInfo &hapModuleInfo)
661 {
662 napi_value nName;
663 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
664 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "name", nName));
665
666 napi_value nModuleName;
667 NAPI_CALL_RETURN_VOID(
668 env, napi_create_string_utf8(env, hapModuleInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
669 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "moduleName", nModuleName));
670
671 napi_value nDescription;
672 NAPI_CALL_RETURN_VOID(
673 env, napi_create_string_utf8(env, hapModuleInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
674 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "description", nDescription));
675
676 napi_value ndescriptionId;
677 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.descriptionId, &ndescriptionId));
678 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "descriptionId", ndescriptionId));
679
680 napi_value nIcon;
681 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIcon));
682 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "icon", nIcon));
683
684 napi_value nLabel;
685 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
686 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "label", nLabel));
687
688 napi_value nHashValue;
689 NAPI_CALL_RETURN_VOID(
690 env, napi_create_string_utf8(env, hapModuleInfo.hashValue.c_str(), NAPI_AUTO_LENGTH, &nHashValue));
691 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "hashValue", nHashValue));
692
693 napi_value nLabelId;
694 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.labelId, &nLabelId));
695 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "labelId", nLabelId));
696
697 napi_value nIconId;
698 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.iconId, &nIconId));
699 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "iconId", nIconId));
700
701 napi_value nBackgroundImg;
702 NAPI_CALL_RETURN_VOID(
703 env, napi_create_string_utf8(env, hapModuleInfo.backgroundImg.c_str(), NAPI_AUTO_LENGTH, &nBackgroundImg));
704 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "backgroundImg", nBackgroundImg));
705
706 napi_value nSupportedModes;
707 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, hapModuleInfo.supportedModes, &nSupportedModes));
708 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "supportedModes", nSupportedModes));
709
710 napi_value nReqCapabilities;
711 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqCapabilities));
712 for (size_t idx = 0; idx < hapModuleInfo.reqCapabilities.size(); idx++) {
713 napi_value nReqCapabilitie;
714 NAPI_CALL_RETURN_VOID(env,
715 napi_create_string_utf8(
716 env, hapModuleInfo.reqCapabilities[idx].c_str(), NAPI_AUTO_LENGTH, &nReqCapabilitie));
717 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqCapabilities, idx, nReqCapabilitie));
718 }
719 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "reqCapabilities", nReqCapabilities));
720
721 napi_value nDeviceTypes;
722 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
723 for (size_t idx = 0; idx < hapModuleInfo.deviceTypes.size(); idx++) {
724 napi_value nDeviceType;
725 NAPI_CALL_RETURN_VOID(
726 env, napi_create_string_utf8(env, hapModuleInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
727 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
728 }
729 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "deviceTypes", nDeviceTypes));
730
731 napi_value nAbilityInfos;
732 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilityInfos));
733 for (size_t idx = 0; idx < hapModuleInfo.abilityInfos.size(); idx++) {
734 napi_value objAbilityInfo;
735 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAbilityInfo));
736 ConvertAbilityInfo(env, objAbilityInfo, hapModuleInfo.abilityInfos[idx]);
737 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilityInfos, idx, objAbilityInfo));
738 }
739 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "abilityInfo", nAbilityInfos));
740
741 napi_value nMainAbilityName;
742 NAPI_CALL_RETURN_VOID(
743 env, napi_create_string_utf8(env, hapModuleInfo.mainAbility.c_str(), NAPI_AUTO_LENGTH, &nMainAbilityName));
744 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "mainAbilityName", nMainAbilityName));
745
746 napi_value nInstallationFree;
747 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, hapModuleInfo.installationFree, &nInstallationFree));
748 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "installationFree", nInstallationFree));
749
750 napi_value nMainElementName;
751 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.mainElementName.c_str(), NAPI_AUTO_LENGTH,
752 &nMainElementName));
753 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "mainElementName", nMainElementName));
754
755 napi_value nMetadata;
756 size_t size = hapModuleInfo.metadata.size();
757 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
758 for (size_t index = 0; index < size; ++index) {
759 napi_value innerMeta;
760 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &innerMeta));
761 ConvertInnerMetadata(env, innerMeta, hapModuleInfo.metadata[index]);
762 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, innerMeta));
763 }
764 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "metadata", nMetadata));
765 }
766
ConvertRequestPermissionUsedScene(napi_env env,napi_value result,const RequestPermissionUsedScene & requestPermissionUsedScene)767 static void ConvertRequestPermissionUsedScene(napi_env env, napi_value result,
768 const RequestPermissionUsedScene &requestPermissionUsedScene)
769 {
770 napi_value nAbilities;
771 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilities));
772 for (size_t idx = 0; idx < requestPermissionUsedScene.abilities.size(); idx++) {
773 napi_value objAbility;
774 NAPI_CALL_RETURN_VOID(env,
775 napi_create_string_utf8(env, requestPermissionUsedScene.abilities[idx].c_str(),
776 NAPI_AUTO_LENGTH, &objAbility));
777 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilities, idx, objAbility));
778 }
779 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "abilities", nAbilities));
780
781 napi_value nWhen;
782 NAPI_CALL_RETURN_VOID(env,
783 napi_create_string_utf8(env, requestPermissionUsedScene.when.c_str(), NAPI_AUTO_LENGTH, &nWhen));
784 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "when", nWhen));
785 }
786
ConvertRequestPermission(napi_env env,napi_value result,const RequestPermission & requestPermission)787 static void ConvertRequestPermission(napi_env env, napi_value result, const RequestPermission &requestPermission)
788 {
789 napi_value nPermissionName;
790 NAPI_CALL_RETURN_VOID(
791 env, napi_create_string_utf8(env, requestPermission.name.c_str(), NAPI_AUTO_LENGTH, &nPermissionName));
792 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "name", nPermissionName));
793
794 napi_value nReason;
795 NAPI_CALL_RETURN_VOID(
796 env, napi_create_string_utf8(env, requestPermission.reason.c_str(), NAPI_AUTO_LENGTH, &nReason));
797 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reason", nReason));
798
799 napi_value nReasonId;
800 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, requestPermission.reasonId, &nReasonId));
801 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reasonId", nReasonId));
802
803 napi_value nUsedScene;
804 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nUsedScene));
805 ConvertRequestPermissionUsedScene(env, nUsedScene, requestPermission.usedScene);
806 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "usedScene", nUsedScene));
807 }
808
ConvertBundleInfo(napi_env env,napi_value objBundleInfo,const BundleInfo & bundleInfo)809 static void ConvertBundleInfo(napi_env env, napi_value objBundleInfo, const BundleInfo &bundleInfo)
810 {
811 napi_value nName;
812 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
813 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "name", nName));
814
815 napi_value nVendor;
816 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.vendor.c_str(), NAPI_AUTO_LENGTH, &nVendor));
817 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "vendor", nVendor));
818
819 napi_value nVersionCode;
820 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, bundleInfo.versionCode, &nVersionCode));
821 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionCode", nVersionCode));
822
823 napi_value nVersionName;
824 NAPI_CALL_RETURN_VOID(
825 env, napi_create_string_utf8(env, bundleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
826 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionName", nVersionName));
827
828 napi_value nCpuAbi;
829 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.cpuAbi.c_str(), NAPI_AUTO_LENGTH, &nCpuAbi));
830 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "cpuAbi", nCpuAbi));
831
832 napi_value nAppId;
833 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.appId.c_str(), NAPI_AUTO_LENGTH, &nAppId));
834 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "appId", nAppId));
835
836 napi_value nEntryModuleName;
837 NAPI_CALL_RETURN_VOID(
838 env, napi_create_string_utf8(env, bundleInfo.entryModuleName.c_str(), NAPI_AUTO_LENGTH, &nEntryModuleName));
839 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "entryModuleName", nEntryModuleName));
840
841 napi_value nCompatibleVersion;
842 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.compatibleVersion, &nCompatibleVersion));
843 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "compatibleVersion", nCompatibleVersion));
844
845 napi_value nTargetVersion;
846 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.targetVersion, &nTargetVersion));
847 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "targetVersion", nTargetVersion));
848
849 napi_value nUid;
850 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.uid, &nUid));
851 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "uid", nUid));
852
853 napi_value nInstallTime;
854 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.installTime, &nInstallTime));
855 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "installTime", nInstallTime));
856
857 napi_value nUpdateTime;
858 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.updateTime, &nUpdateTime));
859 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "updateTime", nUpdateTime));
860
861 napi_value nAppInfo;
862 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nAppInfo));
863 ConvertApplicationInfo(env, nAppInfo, bundleInfo.applicationInfo);
864 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "appInfo", nAppInfo));
865
866 napi_value nAbilityInfos;
867 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilityInfos));
868 for (size_t idx = 0; idx < bundleInfo.abilityInfos.size(); idx++) {
869 napi_value objAbilityInfo;
870 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAbilityInfo));
871 ConvertAbilityInfo(env, objAbilityInfo, bundleInfo.abilityInfos[idx]);
872 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilityInfos, idx, objAbilityInfo));
873 }
874 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "abilityInfos", nAbilityInfos));
875
876 napi_value nHapModuleInfos;
877 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nHapModuleInfos));
878 for (size_t idx = 0; idx < bundleInfo.hapModuleInfos.size(); idx++) {
879 napi_value objHapModuleInfo;
880 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objHapModuleInfo));
881 ConvertHapModuleInfo(env, objHapModuleInfo, bundleInfo.hapModuleInfos[idx]);
882 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nHapModuleInfos, idx, objHapModuleInfo));
883 }
884 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "hapModuleInfos", nHapModuleInfos));
885
886 napi_value nReqPermissions;
887 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissions));
888 for (size_t idx = 0; idx < bundleInfo.reqPermissions.size(); idx++) {
889 napi_value nReqPermission;
890 NAPI_CALL_RETURN_VOID(env,
891 napi_create_string_utf8(env, bundleInfo.reqPermissions[idx].c_str(), NAPI_AUTO_LENGTH, &nReqPermission));
892 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissions, idx, nReqPermission));
893 }
894 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "reqPermissions", nReqPermissions));
895
896 napi_value nReqPermissionStates;
897 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionStates));
898 for (size_t idx = 0; idx < bundleInfo.reqPermissionStates.size(); idx++) {
899 napi_value nReqPermissionState;
900 NAPI_CALL_RETURN_VOID(env,
901 napi_create_int32(env, bundleInfo.reqPermissionStates[idx], &nReqPermissionState));
902 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionStates, idx, nReqPermissionState));
903 }
904 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "reqPermissionStates",
905 nReqPermissionStates));
906
907 napi_value nIsCompressNativeLibs;
908 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, bundleInfo.applicationInfo.isCompressNativeLibs,
909 &nIsCompressNativeLibs));
910 NAPI_CALL_RETURN_VOID(
911 env, napi_set_named_property(env, objBundleInfo, "isCompressNativeLibs", nIsCompressNativeLibs));
912
913 napi_value nIsSilentInstallation;
914 NAPI_CALL_RETURN_VOID(
915 env, napi_create_string_utf8(env, std::string().c_str(), NAPI_AUTO_LENGTH, &nIsSilentInstallation));
916 NAPI_CALL_RETURN_VOID(
917 env, napi_set_named_property(env, objBundleInfo, "isSilentInstallation", nIsSilentInstallation));
918
919 napi_value nType;
920 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, std::string().c_str(), NAPI_AUTO_LENGTH, &nType));
921 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "type", nType));
922
923 napi_value nReqPermissionDetails;
924 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionDetails));
925 for (size_t idx = 0; idx < bundleInfo.reqPermissionDetails.size(); idx++) {
926 napi_value objReqPermission;
927 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objReqPermission));
928 ConvertRequestPermission(env, objReqPermission, bundleInfo.reqPermissionDetails[idx]);
929 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionDetails, idx, objReqPermission));
930 }
931 NAPI_CALL_RETURN_VOID(
932 env, napi_set_named_property(env, objBundleInfo, "reqPermissionDetails", nReqPermissionDetails));
933
934 napi_value nMinCompatibleVersionCode;
935 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.minCompatibleVersionCode, &nMinCompatibleVersionCode));
936 NAPI_CALL_RETURN_VOID(
937 env, napi_set_named_property(env, objBundleInfo, "minCompatibleVersionCode", nMinCompatibleVersionCode));
938
939 napi_value nEntryInstallationFree;
940 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, bundleInfo.entryInstallationFree, &nEntryInstallationFree));
941 NAPI_CALL_RETURN_VOID(
942 env, napi_set_named_property(env, objBundleInfo, "entryInstallationFree", nEntryInstallationFree));
943 }
944
ConvertFormCustomizeData(napi_env env,napi_value objformInfo,const FormCustomizeData & customizeData)945 static void ConvertFormCustomizeData(napi_env env, napi_value objformInfo, const FormCustomizeData &customizeData)
946 {
947 napi_value nName;
948 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, customizeData.name.c_str(), NAPI_AUTO_LENGTH, &nName));
949 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "name", nName));
950 napi_value nValue;
951 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, customizeData.value.c_str(), NAPI_AUTO_LENGTH, &nValue));
952 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "value", nValue));
953 }
954
ConvertFormWindow(napi_env env,napi_value objWindowInfo,const FormWindow & formWindow)955 static void ConvertFormWindow(napi_env env, napi_value objWindowInfo, const FormWindow &formWindow)
956 {
957 napi_value nDesignWidth;
958 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, formWindow.designWidth, &nDesignWidth));
959 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWindowInfo, "designWidth", nDesignWidth));
960 napi_value nAutoDesignWidth;
961 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, formWindow.autoDesignWidth, &nAutoDesignWidth));
962 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWindowInfo, "autoDesignWidth", nAutoDesignWidth));
963 }
964
ConvertFormInfo(napi_env env,napi_value objformInfo,const FormInfo & formInfo)965 static void ConvertFormInfo(napi_env env, napi_value objformInfo, const FormInfo &formInfo)
966 {
967 napi_value nName;
968 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, formInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
969 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "name", nName));
970 APP_LOGI("ConvertFormInfo name=%{public}s", formInfo.name.c_str());
971
972 napi_value nDescription;
973 NAPI_CALL_RETURN_VOID(
974 env, napi_create_string_utf8(env, formInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
975 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "description", nDescription));
976
977 napi_value nDescriptionId;
978 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, formInfo.descriptionId, &nDescriptionId));
979 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "descriptionId", nDescriptionId));
980
981 napi_value nBundleName;
982 NAPI_CALL_RETURN_VOID(
983 env, napi_create_string_utf8(env, formInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
984 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "bundleName", nBundleName));
985
986 napi_value nModuleName;
987 NAPI_CALL_RETURN_VOID(
988 env, napi_create_string_utf8(env, formInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
989 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "moduleName", nModuleName));
990
991 napi_value nAbilityName;
992 NAPI_CALL_RETURN_VOID(
993 env, napi_create_string_utf8(env, formInfo.abilityName.c_str(), NAPI_AUTO_LENGTH, &nAbilityName));
994 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "abilityName", nAbilityName));
995
996 napi_value nRelatedBundleName;
997 NAPI_CALL_RETURN_VOID(
998 env, napi_create_string_utf8(env, formInfo.relatedBundleName.c_str(), NAPI_AUTO_LENGTH, &nRelatedBundleName));
999 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "relatedBundleName", nRelatedBundleName));
1000
1001 napi_value nDefaultFlag;
1002 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, formInfo.defaultFlag, &nDefaultFlag));
1003 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "defaultFlag", nDefaultFlag));
1004
1005 napi_value nFormVisibleNotify;
1006 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, formInfo.formVisibleNotify, &nFormVisibleNotify));
1007 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "formVisibleNotify", nFormVisibleNotify));
1008
1009 napi_value nFormConfigAbility;
1010 NAPI_CALL_RETURN_VOID(
1011 env, napi_create_string_utf8(env, formInfo.formConfigAbility.c_str(), NAPI_AUTO_LENGTH, &nFormConfigAbility));
1012 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "formConfigAbility", nFormConfigAbility));
1013
1014 napi_value nType;
1015 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(formInfo.type), &nType));
1016 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "type", nType));
1017
1018 napi_value nColorMode;
1019 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(formInfo.colorMode), &nColorMode));
1020 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "colorMode", nColorMode));
1021
1022 napi_value nSupportDimensions;
1023 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nSupportDimensions));
1024 for (size_t idx = 0; idx < formInfo.supportDimensions.size(); idx++) {
1025 napi_value nSupportDimension;
1026 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, formInfo.supportDimensions[idx], &nSupportDimension));
1027 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSupportDimensions, idx, nSupportDimension));
1028 }
1029 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "supportDimensions", nSupportDimensions));
1030
1031 napi_value nDefaultDimension;
1032 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, formInfo.defaultDimension, &nDefaultDimension));
1033 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "defaultDimension", nDefaultDimension));
1034
1035 napi_value nJsComponentName;
1036 NAPI_CALL_RETURN_VOID(
1037 env, napi_create_string_utf8(env, formInfo.jsComponentName.c_str(), NAPI_AUTO_LENGTH, &nJsComponentName));
1038 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "jsComponentName", nJsComponentName));
1039
1040 napi_value nUpdateDuration;
1041 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, formInfo.updateDuration, &nUpdateDuration));
1042 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "updateDuration", nUpdateDuration));
1043
1044 napi_value nCustomizeDatas;
1045 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nCustomizeDatas));
1046 for (size_t idx = 0; idx < formInfo.customizeDatas.size(); idx++) {
1047 napi_value nCustomizeData;
1048 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nCustomizeData));
1049 ConvertFormCustomizeData(env, nCustomizeData, formInfo.customizeDatas[idx]);
1050 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nCustomizeDatas, idx, nCustomizeData));
1051 }
1052 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "customizeDatas", nCustomizeDatas));
1053
1054 napi_value nSrc;
1055 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, formInfo.src.c_str(), NAPI_AUTO_LENGTH, &nSrc));
1056 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "src", nSrc));
1057 APP_LOGI("ConvertFormInfo src=%{public}s", formInfo.src.c_str());
1058
1059 napi_value nWindow;
1060 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nWindow));
1061 ConvertFormWindow(env, nWindow, formInfo.window);
1062 APP_LOGI("ConvertFormInfo window.designWidth=%{public}d", formInfo.window.designWidth);
1063 APP_LOGI("ConvertFormInfo window.autoDesignWidth=%{public}d", formInfo.window.autoDesignWidth);
1064 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objformInfo, "window", nWindow));
1065 }
1066
GetStringFromNAPI(napi_env env,napi_value value)1067 static std::string GetStringFromNAPI(napi_env env, napi_value value)
1068 {
1069 napi_valuetype valueType = napi_undefined;
1070 napi_typeof(env, value, &valueType);
1071 if (valueType != napi_string) {
1072 return "";
1073 }
1074 std::string result;
1075 size_t size = 0;
1076
1077 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
1078 return "";
1079 }
1080 result.reserve(size + NAPI_RETURN_ONE);
1081 result.resize(size);
1082 if (napi_get_value_string_utf8(env, value, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
1083 return "";
1084 }
1085 return result;
1086 }
1087
ParseInt(napi_env env,int & param,napi_value args)1088 static napi_value ParseInt(napi_env env, int ¶m, napi_value args)
1089 {
1090 napi_valuetype valuetype = napi_undefined;
1091 NAPI_CALL(env, napi_typeof(env, args, &valuetype));
1092 APP_LOGD("valuetype=%{public}d", valuetype);
1093 if (valuetype != napi_number) {
1094 APP_LOGE("Wrong argument type, int32 expected");
1095 return nullptr;
1096 }
1097 int32_t value = 0;
1098 napi_get_value_int32(env, args, &value);
1099 APP_LOGD("param=%{public}d", value);
1100 param = value;
1101 // create result code
1102 napi_value result = nullptr;
1103 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &result));
1104 return result;
1105 }
1106
GetCallbackErrorValue(napi_env env,int errCode)1107 static napi_value GetCallbackErrorValue(napi_env env, int errCode)
1108 {
1109 napi_value result = nullptr;
1110 napi_value eCode = nullptr;
1111 NAPI_CALL(env, napi_create_int32(env, errCode, &eCode));
1112 NAPI_CALL(env, napi_create_object(env, &result));
1113 NAPI_CALL(env, napi_set_named_property(env, result, "code", eCode));
1114 return result;
1115 }
1116
InnerGetApplicationInfos(napi_env env,int32_t flags,const int userId,std::vector<OHOS::AppExecFwk::ApplicationInfo> & appInfos)1117 static bool InnerGetApplicationInfos(napi_env env, int32_t flags, const int userId,
1118 std::vector<OHOS::AppExecFwk::ApplicationInfo> &appInfos)
1119 {
1120 auto iBundleMgr = GetBundleMgr();
1121 if (iBundleMgr == nullptr) {
1122 APP_LOGE("can not get iBundleMgr");
1123 return false;
1124 }
1125 return iBundleMgr->GetApplicationInfos(flags, userId, appInfos);
1126 }
1127
ProcessApplicationInfos(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::ApplicationInfo> & appInfos)1128 static void ProcessApplicationInfos(
1129 napi_env env, napi_value result, const std::vector<OHOS::AppExecFwk::ApplicationInfo> &appInfos)
1130 {
1131 if (!appInfos.empty()) {
1132 size_t index = 0;
1133 for (const auto &item : appInfos) {
1134 APP_LOGI("name: %{public}s, bundleName: %{public}s ", item.name.c_str(), item.bundleName.c_str());
1135 for (const auto &moduleInfo : item.moduleInfos) {
1136 APP_LOGI("moduleName: %{public}s, moduleSourceDir: %{public}s ",
1137 moduleInfo.moduleName.c_str(), moduleInfo.moduleSourceDir.c_str());
1138 }
1139 napi_value objAppInfo;
1140 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAppInfo));
1141 ConvertApplicationInfo(env, objAppInfo, item);
1142 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, objAppInfo));
1143 index++;
1144 }
1145 } else {
1146 APP_LOGI("-----appInfos is null-----");
1147 }
1148 }
1149 /**
1150 * Promise and async callback
1151 */
GetApplicationInfos(napi_env env,napi_callback_info info)1152 napi_value GetApplicationInfos(napi_env env, napi_callback_info info)
1153 {
1154 APP_LOGD("NAPI_GetApplicationInfos called");
1155 size_t argc = ARGS_SIZE_THREE;
1156 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
1157 napi_value thisArg = nullptr;
1158 void *data = nullptr;
1159 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1160 APP_LOGI("argc = [%{public}zu]", argc);
1161 AsyncApplicationInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncApplicationInfosCallbackInfo(env);
1162 if (asyncCallbackInfo == nullptr) {
1163 return nullptr;
1164 }
1165 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
1166 for (size_t i = 0; i < argc; ++i) {
1167 napi_valuetype valueType = napi_undefined;
1168 napi_typeof(env, argv[i], &valueType);
1169 if ((i == 0) && (valueType == napi_number)) {
1170 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
1171 if (argc == ARGS_SIZE_ONE) {
1172 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
1173 }
1174 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_number)) {
1175 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
1176 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_function)) {
1177 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
1178 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1179 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_function)) {
1180 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1181 break;
1182 } else {
1183 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1184 asyncCallbackInfo->message = TYPE_MISMATCH;
1185 }
1186 }
1187
1188 if (argc == 0) {
1189 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1190 asyncCallbackInfo->message = TYPE_MISMATCH;
1191 }
1192
1193 napi_value promise = nullptr;
1194 if (asyncCallbackInfo->callback == nullptr) {
1195 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
1196 } else {
1197 NAPI_CALL(env, napi_get_undefined(env, &promise));
1198 }
1199
1200 napi_value resource = nullptr;
1201 NAPI_CALL(env, napi_create_string_utf8(env, "GetApplicationInfo", NAPI_AUTO_LENGTH, &resource));
1202
1203 NAPI_CALL(env, napi_create_async_work(
1204 env, nullptr, resource,
1205 [](napi_env env, void* data) {
1206 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
1207 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
1208 if (!asyncCallbackInfo->err) {
1209 asyncCallbackInfo->ret = InnerGetApplicationInfos(asyncCallbackInfo->env,
1210 asyncCallbackInfo->flags,
1211 asyncCallbackInfo->userId,
1212 asyncCallbackInfo->appInfos);
1213 }
1214 },
1215 [](napi_env env, napi_status status, void* data) {
1216 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
1217 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
1218 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
1219 napi_value result[2] = { 0 };
1220 if (asyncCallbackInfo->err) {
1221 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
1222 &result[0]));
1223 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
1224 NAPI_AUTO_LENGTH, &result[1]));
1225 } else {
1226 if (asyncCallbackInfo->ret) {
1227 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
1228 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
1229 ProcessApplicationInfos(env, result[1], asyncCallbackInfo->appInfos);
1230 } else {
1231 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[0]));
1232 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
1233 }
1234 }
1235 if (asyncCallbackInfo->deferred) {
1236 if (asyncCallbackInfo->ret) {
1237 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
1238 } else {
1239 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
1240 }
1241 } else {
1242 napi_value callback = nullptr;
1243 napi_value placeHolder = nullptr;
1244 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
1245 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
1246 sizeof(result) / sizeof(result[0]), result, &placeHolder));
1247 }
1248 },
1249 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
1250 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1251 callbackPtr.release();
1252 return promise;
1253 }
1254
ParseStringArray(napi_env env,std::vector<std::string> & stringArray,napi_value args)1255 static napi_value ParseStringArray(napi_env env, std::vector<std::string> &stringArray, napi_value args)
1256 {
1257 APP_LOGD("begin to parse string array");
1258 bool isArray = false;
1259 NAPI_CALL(env, napi_is_array(env, args, &isArray));
1260 if (!isArray) {
1261 APP_LOGE("args not array");
1262 return nullptr;
1263 }
1264 uint32_t arrayLength = 0;
1265 NAPI_CALL(env, napi_get_array_length(env, args, &arrayLength));
1266 APP_LOGD("length=%{public}ud", arrayLength);
1267 for (uint32_t j = 0; j < arrayLength; j++) {
1268 napi_value value = nullptr;
1269 NAPI_CALL(env, napi_get_element(env, args, j, &value));
1270 napi_valuetype valueType = napi_undefined;
1271 NAPI_CALL(env, napi_typeof(env, value, &valueType));
1272 if (valueType != napi_string) {
1273 APP_LOGE("array inside not string type");
1274 stringArray.clear();
1275 return nullptr;
1276 }
1277 stringArray.push_back(GetStringFromNAPI(env, value));
1278 }
1279 // create result code
1280 napi_value result;
1281 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &result));
1282 return result;
1283 }
1284
1285 // QueryAbilityInfos(want)
InnerQueryAbilityInfos(napi_env env,const Want & want,int32_t flags,int32_t userId,std::vector<AbilityInfo> & abilityInfos)1286 static bool InnerQueryAbilityInfos(napi_env env, const Want &want,
1287 int32_t flags, int32_t userId, std::vector<AbilityInfo> &abilityInfos)
1288 {
1289 auto iBundleMgr = GetBundleMgr();
1290 if (iBundleMgr == nullptr) {
1291 APP_LOGE("can not get iBundleMgr");
1292 return false;
1293 }
1294 return iBundleMgr->QueryAbilityInfos(want, flags, userId, abilityInfos);
1295 }
1296
ParseBundleOptions(napi_env env,BundleOptions & bundleOptions,napi_value args)1297 static bool ParseBundleOptions(napi_env env, BundleOptions &bundleOptions, napi_value args)
1298 {
1299 APP_LOGD("begin to parse bundleOptions");
1300 napi_valuetype valueType;
1301 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
1302 if (valueType != napi_object) {
1303 APP_LOGE("args not object type");
1304 return false;
1305 }
1306
1307 napi_value prop = nullptr;
1308 napi_get_named_property(env, args, "userId", &prop);
1309 napi_typeof(env, prop, &valueType);
1310 if (valueType == napi_number) {
1311 napi_get_value_int32(env, prop, &bundleOptions.userId);
1312 }
1313 return true;
1314 }
1315
ParseWant(napi_env env,Want & want,napi_value args)1316 static bool ParseWant(napi_env env, Want &want, napi_value args)
1317 {
1318 APP_LOGD("begin to parse want");
1319 napi_valuetype valueType;
1320 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
1321 if (valueType != napi_object) {
1322 APP_LOGE("args not object type");
1323 return false;
1324 }
1325 int32_t wantFlags = 0;
1326 std::vector<std::string> wantEntities;
1327 std::string elementUri;
1328 std::string elementDeviceId;
1329 std::string elementBundleName;
1330 std::string elementModuleName;
1331 std::string elementAbilityName;
1332
1333 napi_value prop = nullptr;
1334 napi_get_named_property(env, args, "bundleName", &prop);
1335 std::string wantBundleName = GetStringFromNAPI(env, prop);
1336
1337 prop = nullptr;
1338 napi_get_named_property(env, args, "moduleName", &prop);
1339 std::string wantModuleName = GetStringFromNAPI(env, prop);
1340
1341 prop = nullptr;
1342 napi_get_named_property(env, args, "abilityName", &prop);
1343 std::string wantAbilityName = GetStringFromNAPI(env, prop);
1344
1345 prop = nullptr;
1346 napi_get_named_property(env, args, "deviceId", &prop);
1347 std::string wantDeviceId = GetStringFromNAPI(env, prop);
1348
1349 prop = nullptr;
1350 napi_get_named_property(env, args, "type", &prop);
1351 std::string wantType = GetStringFromNAPI(env, prop);
1352
1353 prop = nullptr;
1354 napi_get_named_property(env, args, "flags", &prop);
1355 napi_typeof(env, prop, &valueType);
1356 if (valueType == napi_number) {
1357 napi_get_value_int32(env, prop, &wantFlags);
1358 }
1359
1360 prop = nullptr;
1361 napi_get_named_property(env, args, "action", &prop);
1362 std::string wantAction = GetStringFromNAPI(env, prop);
1363
1364 prop = nullptr;
1365 napi_get_named_property(env, args, "uri", &prop);
1366 std::string wantUri = GetStringFromNAPI(env, prop);
1367
1368 prop = nullptr;
1369 napi_get_named_property(env, args, "entities", &prop);
1370 ParseStringArray(env, wantEntities, prop);
1371 for (size_t idx = 0; idx < wantEntities.size(); idx++) {
1372 APP_LOGD("entity:%{public}s", wantEntities[idx].c_str());
1373 want.AddEntity(wantEntities[idx]);
1374 }
1375
1376 napi_value elementProp = nullptr;
1377 napi_get_named_property(env, args, "elementName", &elementProp);
1378 napi_typeof(env, elementProp, &valueType);
1379 if (valueType == napi_object) {
1380 APP_LOGD("begin to parse want elementName");
1381 prop = nullptr;
1382 napi_get_named_property(env, elementProp, "deviceId", &prop);
1383 elementDeviceId = GetStringFromNAPI(env, prop);
1384
1385 prop = nullptr;
1386 napi_get_named_property(env, elementProp, "uri", &prop);
1387 elementUri = GetStringFromNAPI(env, prop);
1388
1389 prop = nullptr;
1390 napi_status status = napi_get_named_property(env, elementProp, "bundleName", &prop);
1391 napi_typeof(env, prop, &valueType);
1392 if ((status != napi_ok) || (valueType != napi_string)) {
1393 APP_LOGE("elementName bundleName incorrect");
1394 return false;
1395 }
1396 elementBundleName = GetStringFromNAPI(env, prop);
1397
1398 prop = nullptr;
1399 status = napi_get_named_property(env, elementProp, "abilityName", &prop);
1400 napi_typeof(env, prop, &valueType);
1401 if ((status != napi_ok) || (valueType != napi_string)) {
1402 APP_LOGE("elementName abilityName incorrect");
1403 return false;
1404 }
1405 elementAbilityName = GetStringFromNAPI(env, prop);
1406
1407 prop = nullptr;
1408 bool hasKey = false;
1409 napi_has_named_property(env, elementProp, "moduleName", &hasKey);
1410 if (hasKey) {
1411 status = napi_get_named_property(env, elementProp, "moduleName", &prop);
1412 napi_typeof(env, prop, &valueType);
1413 if ((status != napi_ok) || (valueType != napi_string)) {
1414 APP_LOGE("elementName moduleName incorrect");
1415 return false;
1416 }
1417 elementModuleName = GetStringFromNAPI(env, prop);
1418 }
1419 }
1420 if (elementBundleName.empty()) {
1421 elementBundleName = wantBundleName;
1422 }
1423 if (elementModuleName.empty()) {
1424 elementModuleName = wantModuleName;
1425 }
1426 if (elementAbilityName.empty()) {
1427 elementAbilityName = wantAbilityName;
1428 }
1429 if (elementDeviceId.empty()) {
1430 elementDeviceId = wantDeviceId;
1431 }
1432 if (elementUri.empty()) {
1433 elementUri = wantUri;
1434 }
1435 APP_LOGD("bundleName:%{public}s, moduleName: %{public}s, abilityName:%{public}s",
1436 elementBundleName.c_str(), elementModuleName.c_str(), elementAbilityName.c_str());
1437 APP_LOGD("action:%{public}s, uri:%{private}s, type:%{public}s, flags:%{public}d",
1438 wantAction.c_str(), elementUri.c_str(), wantType.c_str(), wantFlags);
1439 want.SetAction(wantAction);
1440 want.SetUri(elementUri);
1441 want.SetType(wantType);
1442 want.SetFlags(wantFlags);
1443 ElementName elementName(elementDeviceId, elementBundleName, elementAbilityName, elementModuleName);
1444 want.SetElement(elementName);
1445 return true;
1446 }
1447
1448 /**
1449 * Promise and async callback
1450 */
QueryAbilityInfos(napi_env env,napi_callback_info info)1451 napi_value QueryAbilityInfos(napi_env env, napi_callback_info info)
1452 {
1453 APP_LOGI("QueryAbilityInfos called");
1454 size_t argc = ARGS_SIZE_FOUR;
1455 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
1456 napi_value thisArg = nullptr;
1457 void *data = nullptr;
1458 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1459 APP_LOGI("argc = [%{public}zu]", argc);
1460 Want want;
1461 AsyncAbilityInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncAbilityInfoCallbackInfo(env);
1462 if (asyncCallbackInfo == nullptr) {
1463 return nullptr;
1464 }
1465 std::unique_ptr<AsyncAbilityInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
1466 asyncCallbackInfo->want = want;
1467 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
1468
1469 for (size_t i = 0; i < argc; ++i) {
1470 napi_valuetype valueType = napi_undefined;
1471 napi_typeof(env, argv[i], &valueType);
1472 if ((i == 0) && (valueType == napi_object)) {
1473 bool ret = ParseWant(env, asyncCallbackInfo->want, argv[i]);
1474 if (!ret) {
1475 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1476 }
1477 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_number)) {
1478 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
1479 } else if (i == ARGS_SIZE_TWO) {
1480 if (valueType == napi_number) {
1481 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
1482 } else if (valueType == napi_function) {
1483 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1484 break;
1485 } else {
1486 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1487 }
1488 } else if ((i == ARGS_SIZE_THREE) && (valueType == napi_function)) {
1489 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1490 } else {
1491 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1492 }
1493 }
1494 napi_value promise = nullptr;
1495 if (asyncCallbackInfo->callback == nullptr) {
1496 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
1497 } else {
1498 NAPI_CALL(env, napi_get_undefined(env, &promise));
1499 }
1500 napi_value resource = nullptr;
1501 NAPI_CALL(env, napi_create_string_utf8(env, "QueryAbilityInfos", NAPI_AUTO_LENGTH, &resource));
1502 NAPI_CALL(env, napi_create_async_work(
1503 env, nullptr, resource,
1504 [](napi_env env, void *data) {
1505 AsyncAbilityInfoCallbackInfo *asyncCallbackInfo =
1506 reinterpret_cast<AsyncAbilityInfoCallbackInfo *>(data);
1507 if (!asyncCallbackInfo->err) {
1508 {
1509 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
1510 auto item = abilityInfoCache.find(Query(asyncCallbackInfo->want.ToString(),
1511 QUERY_ABILITY_BY_WANT, asyncCallbackInfo->flags, asyncCallbackInfo->userId, env));
1512 if (item != abilityInfoCache.end()) {
1513 APP_LOGD("has cache,no need to query from host");
1514 asyncCallbackInfo->ret = true;
1515 return;
1516 }
1517 }
1518 asyncCallbackInfo->ret = InnerQueryAbilityInfos(env, asyncCallbackInfo->want, asyncCallbackInfo->flags,
1519 asyncCallbackInfo->userId, asyncCallbackInfo->abilityInfos);
1520 }
1521 },
1522 [](napi_env env, napi_status status, void *data) {
1523 AsyncAbilityInfoCallbackInfo *asyncCallbackInfo =
1524 reinterpret_cast<AsyncAbilityInfoCallbackInfo *>(data);
1525 std::unique_ptr<AsyncAbilityInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
1526 napi_value result[2] = { 0 };
1527 if (asyncCallbackInfo->err) {
1528 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
1529 &result[0]));
1530 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, "type mismatch",
1531 NAPI_AUTO_LENGTH, &result[1]));
1532 } else {
1533 if (asyncCallbackInfo->ret) {
1534 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
1535 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
1536 // get from cache first
1537 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
1538 Query query(asyncCallbackInfo->want.ToString(), QUERY_ABILITY_BY_WANT,
1539 asyncCallbackInfo->flags, asyncCallbackInfo->userId, env);
1540 auto item = abilityInfoCache.find(query);
1541 if (item != abilityInfoCache.end()) {
1542 APP_LOGD("get abilityInfo from cache");
1543 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, item->second, &result[1]));
1544 } else {
1545 ProcessAbilityInfos(env, result[1], asyncCallbackInfo->abilityInfos);
1546 HandleAbilityInfoCache(env, query, asyncCallbackInfo, result[1]);
1547 }
1548 } else {
1549 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 1, &result[0]));
1550 NAPI_CALL_RETURN_VOID(env,
1551 napi_create_string_utf8(env, "QueryAbilityInfos failed", NAPI_AUTO_LENGTH, &result[1]));
1552 }
1553 }
1554 if (asyncCallbackInfo->deferred) {
1555 if (asyncCallbackInfo->ret) {
1556 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
1557 } else {
1558 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
1559 }
1560 } else {
1561 napi_value callback = nullptr;
1562 napi_value placeHolder = nullptr;
1563 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
1564 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
1565 sizeof(result) / sizeof(result[0]), result, &placeHolder));
1566 }
1567 },
1568 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
1569 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
1570 callbackPtr.release();
1571 return promise;
1572 }
1573
ParseString(napi_env env,std::string & param,napi_value args)1574 static napi_value ParseString(napi_env env, std::string ¶m, napi_value args)
1575 {
1576 napi_valuetype valuetype;
1577 NAPI_CALL(env, napi_typeof(env, args, &valuetype));
1578 if (valuetype != napi_string) {
1579 APP_LOGE("Wrong argument type. String expected");
1580 return nullptr;
1581 }
1582 param = GetStringFromNAPI(env, args);
1583 APP_LOGD("param=%{public}s", param.c_str());
1584 // create result code
1585 napi_value result = nullptr;
1586 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &result));
1587 return result;
1588 }
1589
InnerGetBundleInfos(napi_env env,int32_t flags,int32_t userId,std::vector<OHOS::AppExecFwk::BundleInfo> & bundleInfos)1590 static bool InnerGetBundleInfos(
1591 napi_env env, int32_t flags, int32_t userId, std::vector<OHOS::AppExecFwk::BundleInfo> &bundleInfos)
1592 {
1593 auto iBundleMgr = GetBundleMgr();
1594 if (iBundleMgr == nullptr) {
1595 APP_LOGE("can not get iBundleMgr");
1596 return false;
1597 }
1598 return iBundleMgr->GetBundleInfos(flags, bundleInfos, userId);
1599 }
1600
ProcessBundleInfos(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::BundleInfo> & bundleInfos)1601 static void ProcessBundleInfos(
1602 napi_env env, napi_value result, const std::vector<OHOS::AppExecFwk::BundleInfo> &bundleInfos)
1603 {
1604 if (bundleInfos.size() > 0) {
1605 APP_LOGI("-----bundleInfos is not null-----");
1606 size_t index = 0;
1607 for (const auto &item : bundleInfos) {
1608 APP_LOGD("name is %{public}s and bundleName is %{public}s ",
1609 item.name.c_str(), item.applicationInfo.bundleName.c_str());
1610 for (const auto &moduleInfo : item.applicationInfo.moduleInfos) {
1611 APP_LOGD("moduleName: %{public}s, moduleSourceDir: %{public}s ",
1612 moduleInfo.moduleName.c_str(), moduleInfo.moduleSourceDir.c_str());
1613 }
1614 napi_value objBundleInfo = nullptr;
1615 napi_create_object(env, &objBundleInfo);
1616 ConvertBundleInfo(env, objBundleInfo, item);
1617 napi_set_element(env, result, index, objBundleInfo);
1618 index++;
1619 }
1620 } else {
1621 APP_LOGI("-----bundleInfos is null-----");
1622 }
1623 }
1624
GetBundleInfosExec(napi_env env,void * data)1625 void GetBundleInfosExec(napi_env env, void *data)
1626 {
1627 APP_LOGD("NAPI begin");
1628 AsyncBundleInfosCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfosCallbackInfo*>(data);
1629 if (asyncCallbackInfo == nullptr) {
1630 APP_LOGE("asyncCallbackInfo is nullptr");
1631 return;
1632 }
1633 if (asyncCallbackInfo->err == NO_ERROR) {
1634 asyncCallbackInfo->ret = InnerGetBundleInfos(
1635 env, asyncCallbackInfo->flags, asyncCallbackInfo->userId, asyncCallbackInfo->bundleInfos);
1636 }
1637 APP_LOGD("NAPI end");
1638 }
1639
GetBundleInfosComplete(napi_env env,napi_status status,void * data)1640 void GetBundleInfosComplete(napi_env env, napi_status status, void *data)
1641 {
1642 APP_LOGD("NAPI begin");
1643 AsyncBundleInfosCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfosCallbackInfo*>(data);
1644 if (asyncCallbackInfo == nullptr) {
1645 APP_LOGE("asyncCallbackInfo is nullptr");
1646 return;
1647 }
1648 std::unique_ptr<AsyncBundleInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
1649 napi_value result[ARGS_SIZE_TWO] = { 0 };
1650 if (asyncCallbackInfo->err != NO_ERROR) {
1651 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
1652 &result[0]));
1653 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
1654 NAPI_AUTO_LENGTH, &result[ARGS_POS_ONE]));
1655 } else {
1656 if (asyncCallbackInfo->ret) {
1657 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[ARGS_POS_ZERO]));
1658 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[ARGS_POS_ONE]));
1659 ProcessBundleInfos(env, result[ARGS_POS_ONE], asyncCallbackInfo->bundleInfos);
1660 } else {
1661 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[ARGS_POS_ZERO]));
1662 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[ARGS_POS_ONE]));
1663 }
1664 }
1665 if (asyncCallbackInfo->deferred) {
1666 if (asyncCallbackInfo->ret) {
1667 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ONE]));
1668 } else {
1669 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[ARGS_POS_ZERO]));
1670 }
1671 } else {
1672 napi_value callback = nullptr;
1673 napi_value placeHolder = nullptr;
1674 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
1675 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
1676 sizeof(result) / sizeof(result[ARGS_POS_ZERO]), result, &placeHolder));
1677 }
1678 APP_LOGD("NAPI end");
1679 }
1680
GetBundleInfos(napi_env env,napi_callback_info info)1681 napi_value GetBundleInfos(napi_env env, napi_callback_info info)
1682 {
1683 APP_LOGD("NAPI called");
1684 size_t argc = ARGS_SIZE_THREE;
1685 napi_value argv[ARGS_SIZE_THREE] = {0};
1686 napi_value thisArg = nullptr;
1687 void *data = nullptr;
1688 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
1689 APP_LOGD("argc = [%{public}zu]", argc);
1690 AsyncBundleInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncBundleInfosCallbackInfo(env);
1691 if (asyncCallbackInfo == nullptr) {
1692 APP_LOGE("asyncCallbackInfo is nullptr");
1693 return nullptr;
1694 }
1695 std::unique_ptr<AsyncBundleInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
1696 for (size_t i = 0; i < argc; ++i) {
1697 napi_valuetype valueType = napi_undefined;
1698 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
1699 if ((i == PARAM0) && (valueType == napi_number)) {
1700 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
1701 } else if ((i == PARAM1) && (valueType == napi_number)) {
1702 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
1703 } else if ((i == PARAM1) && (valueType == napi_function)) {
1704 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1705 break;
1706 } else if ((i == PARAM2) && (valueType == napi_function)) {
1707 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1708 break;
1709 } else {
1710 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1711 asyncCallbackInfo->message = TYPE_MISMATCH;
1712 }
1713 }
1714 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncBundleInfosCallbackInfo>(
1715 env, asyncCallbackInfo, GET_ALL_BUNDLE_INFO, GetBundleInfosExec, GetBundleInfosComplete);
1716 callbackPtr.release();
1717 APP_LOGD("NAPI done");
1718 return promise;
1719 }
1720
InnerGetPermissionDef(const std::string & permissionName,PermissionDef & permissionDef)1721 static bool InnerGetPermissionDef(const std::string &permissionName, PermissionDef &permissionDef)
1722 {
1723 auto iBundleMgr = GetBundleMgr();
1724 if (iBundleMgr == nullptr) {
1725 APP_LOGE("can not get iBundleMgr");
1726 return false;
1727 };
1728 ErrCode ret = iBundleMgr->GetPermissionDef(permissionName, permissionDef);
1729 if (ret != NO_ERROR) {
1730 APP_LOGE("permissionName is not find");
1731 return false;
1732 }
1733 return true;
1734 }
1735
GetPermissionDefExec(napi_env env,void * data)1736 void GetPermissionDefExec(napi_env env, void *data)
1737 {
1738 APP_LOGD("NAPI begin");
1739 AsyncPermissionDefCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncPermissionDefCallbackInfo *>(data);
1740 if (asyncCallbackInfo == nullptr) {
1741 APP_LOGE("asyncCallbackInfo is nullptr");
1742 return;
1743 }
1744 if (asyncCallbackInfo->err == NO_ERROR) {
1745 asyncCallbackInfo->ret =
1746 InnerGetPermissionDef(asyncCallbackInfo->permissionName, asyncCallbackInfo->permissionDef);
1747 }
1748 APP_LOGD("NAPI end");
1749 }
1750
GetPermissionDefComplete(napi_env env,napi_status status,void * data)1751 void GetPermissionDefComplete(napi_env env, napi_status status, void *data)
1752 {
1753 APP_LOGD("NAPI begin");
1754 AsyncPermissionDefCallbackInfo *asyncCallbackInfo =
1755 reinterpret_cast<AsyncPermissionDefCallbackInfo *>(data);
1756 if (asyncCallbackInfo == nullptr) {
1757 APP_LOGE("asyncCallbackInfo is nullptr");
1758 return;
1759 }
1760 std::unique_ptr<AsyncPermissionDefCallbackInfo> callbackPtr {asyncCallbackInfo};
1761 napi_value result[ARGS_SIZE_TWO] = {0};
1762 if (asyncCallbackInfo->err) {
1763 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
1764 &result[PARAM0]));
1765 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
1766 NAPI_AUTO_LENGTH, &result[PARAM1]));
1767 } else {
1768 if (asyncCallbackInfo->ret) {
1769 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, CODE_SUCCESS, &result[PARAM0]));
1770 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
1771 CommonFunc::ConvertPermissionDef(env, result[PARAM1], asyncCallbackInfo->permissionDef);
1772 } else {
1773 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, OPERATION_FAILED, &result[PARAM0]));
1774 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[PARAM1]));
1775 }
1776 }
1777 if (asyncCallbackInfo->deferred) {
1778 if (asyncCallbackInfo->ret) {
1779 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[PARAM1]));
1780 } else {
1781 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[PARAM0]));
1782 }
1783 } else {
1784 napi_value callback = nullptr;
1785 napi_value placeHolder = nullptr;
1786 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
1787 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
1788 sizeof(result) / sizeof(result[PARAM0]), result, &placeHolder));
1789 }
1790 APP_LOGD("NAPI end");
1791 }
1792
GetPermissionDef(napi_env env,napi_callback_info info)1793 napi_value GetPermissionDef(napi_env env, napi_callback_info info)
1794 {
1795 APP_LOGD("Napi called");
1796 size_t argc = ARGS_SIZE_TWO;
1797 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
1798 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
1799 APP_LOGD("argc = [%{public}zu]", argc);
1800 AsyncPermissionDefCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncPermissionDefCallbackInfo(env);
1801 if (asyncCallbackInfo == nullptr) {
1802 return nullptr;
1803 }
1804 std::unique_ptr<AsyncPermissionDefCallbackInfo> callbackPtr {asyncCallbackInfo};
1805 for (size_t i = 0; i < argc; ++i) {
1806 napi_valuetype valuetype = napi_undefined;
1807 NAPI_CALL(env, napi_typeof(env, argv[i], &valuetype));
1808 if ((i == PARAM0) && (valuetype == napi_string)) {
1809 ParseString(env, asyncCallbackInfo->permissionName, argv[i]);
1810 } else if ((i == PARAM1) && (valuetype == napi_function)) {
1811 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
1812 } else {
1813 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
1814 asyncCallbackInfo->message = TYPE_MISMATCH;
1815 }
1816 }
1817 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncPermissionDefCallbackInfo>(
1818 env, asyncCallbackInfo, GET_PERMISSION_DEF, GetPermissionDefExec, GetPermissionDefComplete);
1819 callbackPtr.release();
1820 APP_LOGD("Napi done");
1821 return promise;
1822 }
1823
VerifyCallingPermission(std::string permissionName)1824 static bool VerifyCallingPermission(std::string permissionName)
1825 {
1826 auto iBundleMgr = GetBundleMgr();
1827 if (iBundleMgr == nullptr) {
1828 APP_LOGE("can not get iBundleMgr");
1829 return false;
1830 }
1831 return iBundleMgr->VerifyCallingPermission(permissionName);
1832 }
1833
VerifySystemApi()1834 static bool VerifySystemApi()
1835 {
1836 auto iBundleMgr = GetBundleMgr();
1837 if (iBundleMgr == nullptr) {
1838 APP_LOGE("can not get iBundleMgr");
1839 return false;
1840 }
1841 return iBundleMgr->VerifySystemApi();
1842 }
1843
ParseHashParam(napi_env env,std::string & key,std::string & value,napi_value args)1844 static bool ParseHashParam(napi_env env, std::string &key, std::string &value, napi_value args)
1845 {
1846 napi_valuetype valueType;
1847 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
1848 if (valueType != napi_object) {
1849 APP_LOGE("args type incorrect");
1850 return false;
1851 }
1852 napi_value property = nullptr;
1853 bool hasKey = false;
1854 napi_has_named_property(env, args, "moduleName", &hasKey);
1855 if (!hasKey) {
1856 APP_LOGE("parse HashParam failed due to moduleName is not exist");
1857 return false;
1858 }
1859 napi_status status = napi_get_named_property(env, args, "moduleName", &property);
1860 if (status != napi_ok) {
1861 APP_LOGE("napi get named moduleName property error");
1862 return false;
1863 }
1864 ParseString(env, key, property);
1865 if (key.empty()) {
1866 APP_LOGE("param string moduleName is empty");
1867 return false;
1868 }
1869 APP_LOGD("ParseHashParam moduleName=%{public}s", key.c_str());
1870
1871 property = nullptr;
1872 hasKey = false;
1873 napi_has_named_property(env, args, "hashValue", &hasKey);
1874 if (!hasKey) {
1875 APP_LOGE("parse HashParam failed due to hashValue is not exist");
1876 return false;
1877 }
1878 status = napi_get_named_property(env, args, "hashValue", &property);
1879 if (status != napi_ok) {
1880 APP_LOGE("napi get named hashValue property error");
1881 return false;
1882 }
1883 ParseString(env, value, property);
1884 if (value.empty()) {
1885 APP_LOGE("param string hashValue is empty");
1886 return false;
1887 }
1888 APP_LOGD("ParseHashParam hashValue=%{public}s", value.c_str());
1889 return true;
1890 }
1891
ParseHashParams(napi_env env,napi_value args,std::map<std::string,std::string> & hashParams)1892 static bool ParseHashParams(napi_env env, napi_value args, std::map<std::string, std::string> &hashParams)
1893 {
1894 bool hasKey = false;
1895 napi_has_named_property(env, args, "hashParams", &hasKey);
1896 if (hasKey) {
1897 napi_value property = nullptr;
1898 napi_status status = napi_get_named_property(env, args, "hashParams", &property);
1899 if (status != napi_ok) {
1900 APP_LOGE("napi get named hashParams property error");
1901 return false;
1902 }
1903 bool isArray = false;
1904 uint32_t arrayLength = 0;
1905 napi_value valueAry = 0;
1906 napi_valuetype valueAryType = napi_undefined;
1907 NAPI_CALL_BASE(env, napi_is_array(env, property, &isArray), false);
1908 if (!isArray) {
1909 APP_LOGE("hashParams is not array");
1910 return false;
1911 }
1912
1913 NAPI_CALL_BASE(env, napi_get_array_length(env, property, &arrayLength), false);
1914 APP_LOGD("ParseHashParams property is array, length=%{public}ud", arrayLength);
1915 for (uint32_t j = 0; j < arrayLength; j++) {
1916 NAPI_CALL_BASE(env, napi_get_element(env, property, j, &valueAry), false);
1917 NAPI_CALL_BASE(env, napi_typeof(env, valueAry, &valueAryType), false);
1918 std::string key;
1919 std::string value;
1920 if (!ParseHashParam(env, key, value, valueAry)) {
1921 APP_LOGD("parse hash param failed");
1922 return false;
1923 }
1924 if (hashParams.find(key) != hashParams.end()) {
1925 APP_LOGD("moduleName(%{public}s) is duplicate", key.c_str());
1926 return false;
1927 }
1928 hashParams.emplace(key, value);
1929 }
1930 }
1931 return true;
1932 }
1933
ParseUserId(napi_env env,napi_value args,int32_t & userId)1934 static bool ParseUserId(napi_env env, napi_value args, int32_t &userId)
1935 {
1936 bool hasKey = false;
1937 napi_has_named_property(env, args, "userId", &hasKey);
1938 if (hasKey) {
1939 napi_value property = nullptr;
1940 napi_status status = napi_get_named_property(env, args, "userId", &property);
1941 if (status != napi_ok) {
1942 APP_LOGE("napi get named userId property error");
1943 return false;
1944 }
1945 napi_valuetype valueType;
1946 napi_typeof(env, property, &valueType);
1947 if (valueType != napi_number) {
1948 APP_LOGE("param(userId) type incorrect");
1949 return false;
1950 }
1951
1952 userId = Constants::UNSPECIFIED_USERID;
1953 NAPI_CALL_BASE(env, napi_get_value_int32(env, property, &userId), false);
1954 }
1955 return true;
1956 }
1957
ParseInstallFlag(napi_env env,napi_value args,InstallFlag & installFlag)1958 static bool ParseInstallFlag(napi_env env, napi_value args, InstallFlag &installFlag)
1959 {
1960 bool hasKey = false;
1961 napi_has_named_property(env, args, "installFlag", &hasKey);
1962 if (hasKey) {
1963 napi_value property = nullptr;
1964 napi_status status = napi_get_named_property(env, args, "installFlag", &property);
1965 if (status != napi_ok) {
1966 APP_LOGE("napi get named installFlag property error");
1967 return false;
1968 }
1969 napi_valuetype valueType;
1970 napi_typeof(env, property, &valueType);
1971 if (valueType != napi_number) {
1972 APP_LOGE("param(installFlag) type incorrect");
1973 return false;
1974 }
1975
1976 int32_t flag = 0;
1977 NAPI_CALL_BASE(env, napi_get_value_int32(env, property, &flag), false);
1978 installFlag = static_cast<OHOS::AppExecFwk::InstallFlag>(flag);
1979 }
1980 return true;
1981 }
1982
ParseIsKeepData(napi_env env,napi_value args,bool & isKeepData)1983 static bool ParseIsKeepData(napi_env env, napi_value args, bool &isKeepData)
1984 {
1985 bool hasKey = false;
1986 napi_has_named_property(env, args, "isKeepData", &hasKey);
1987 if (hasKey) {
1988 napi_value property = nullptr;
1989 napi_status status = napi_get_named_property(env, args, "isKeepData", &property);
1990 if (status != napi_ok) {
1991 APP_LOGE("napi get named isKeepData property error");
1992 return false;
1993 }
1994 napi_valuetype valueType;
1995 napi_typeof(env, property, &valueType);
1996 if (valueType != napi_boolean) {
1997 APP_LOGE("param(isKeepData) type incorrect");
1998 return false;
1999 }
2000
2001 NAPI_CALL_BASE(env, napi_get_value_bool(env, property, &isKeepData), false);
2002 }
2003 return true;
2004 }
2005
ParseCrowdtestDeadline(napi_env env,napi_value args,int64_t & crowdtestDeadline)2006 static bool ParseCrowdtestDeadline(napi_env env, napi_value args, int64_t &crowdtestDeadline)
2007 {
2008 bool hasKey = false;
2009 napi_has_named_property(env, args, "crowdtestDeadline", &hasKey);
2010 if (hasKey) {
2011 napi_value property = nullptr;
2012 napi_status status = napi_get_named_property(env, args, "crowdtestDeadline", &property);
2013 if (status != napi_ok) {
2014 APP_LOGE("napi get named crowdtestDeadline property error");
2015 return false;
2016 }
2017 napi_valuetype valueType;
2018 napi_typeof(env, property, &valueType);
2019 if (valueType != napi_number) {
2020 APP_LOGE("param(crowdtestDeadline) type incorrect");
2021 return false;
2022 }
2023 NAPI_CALL_BASE(env, napi_get_value_int64(env, property, &crowdtestDeadline), false);
2024 }
2025 return true;
2026 }
2027
ParseInstallParam(napi_env env,InstallParam & installParam,napi_value args)2028 static bool ParseInstallParam(napi_env env, InstallParam &installParam, napi_value args)
2029 {
2030 napi_valuetype valueType;
2031 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
2032 if (valueType != napi_object) {
2033 APP_LOGE("args type incorrect");
2034 return false;
2035 }
2036
2037 if (!ParseUserId(env, args, installParam.userId) || !ParseInstallFlag(env, args, installParam.installFlag) ||
2038 !ParseIsKeepData(env, args, installParam.isKeepData) || !ParseHashParams(env, args, installParam.hashParams) ||
2039 !ParseCrowdtestDeadline(env, args, installParam.crowdtestDeadline)) {
2040 APP_LOGE("ParseInstallParam failed");
2041 return false;
2042 }
2043 return true;
2044 }
2045
InnerGetAllFormsInfo(napi_env env,std::vector<OHOS::AppExecFwk::FormInfo> & formInfos)2046 static bool InnerGetAllFormsInfo(napi_env env, std::vector<OHOS::AppExecFwk::FormInfo> &formInfos)
2047 {
2048 auto iBundleMgr = GetBundleMgr();
2049 if (iBundleMgr == nullptr) {
2050 APP_LOGE("can not get iBundleMgr");
2051 return false;
2052 }
2053 return iBundleMgr->GetAllFormsInfo(formInfos);
2054 }
2055
ProcessFormsInfo(napi_env env,napi_value result,const std::vector<OHOS::AppExecFwk::FormInfo> & formInfos)2056 static void ProcessFormsInfo(napi_env env, napi_value result, const std::vector<OHOS::AppExecFwk::FormInfo> &formInfos)
2057 {
2058 if (formInfos.size() > 0) {
2059 APP_LOGI("-----formInfos is not null-----");
2060 size_t index = 0;
2061 for (const auto &item : formInfos) {
2062 APP_LOGI("name: %{public}s, bundleName: %{public}s ", item.name.c_str(), item.bundleName.c_str());
2063 napi_value objFormInfo;
2064 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objFormInfo));
2065 ConvertFormInfo(env, objFormInfo, item);
2066 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, objFormInfo));
2067 index++;
2068 }
2069 } else {
2070 APP_LOGI("-----formInfos is null-----");
2071 }
2072 }
2073 /**
2074 * Promise and async callback
2075 */
GetAllFormsInfo(napi_env env,napi_callback_info info)2076 napi_value GetAllFormsInfo(napi_env env, napi_callback_info info)
2077 {
2078 size_t argc = ARGS_SIZE_ONE;
2079 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
2080 napi_value thisArg;
2081 void *data = nullptr;
2082 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
2083 APP_LOGI("ARGCSIZE is =%{public}zu", argc);
2084
2085 AsyncFormInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncFormInfosCallbackInfo(env);
2086 if (asyncCallbackInfo == nullptr) {
2087 return nullptr;
2088 }
2089 std::unique_ptr<AsyncFormInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
2090 if (argc > (ARGS_SIZE_ONE - CALLBACK_SIZE)) {
2091 APP_LOGI("GetAllFormsInfo asyncCallback");
2092 napi_value resourceName;
2093 NAPI_CALL(env, napi_create_string_latin1(env, "GetAllFormsInfo", NAPI_AUTO_LENGTH, &resourceName));
2094 napi_valuetype valuetype = napi_undefined;
2095 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
2096 if (valuetype != napi_function) {
2097 APP_LOGE("Wrong argument type. Function expected");
2098 return nullptr;
2099 }
2100 NAPI_CALL(env, napi_create_reference(env, argv[PARAM0], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
2101
2102 NAPI_CALL(env, napi_create_async_work(
2103 env,
2104 nullptr,
2105 resourceName,
2106 [](napi_env env, void *data) {
2107 AsyncFormInfosCallbackInfo *asyncCallbackInfo =
2108 reinterpret_cast<AsyncFormInfosCallbackInfo *>(data);
2109 asyncCallbackInfo->ret = InnerGetAllFormsInfo(env, asyncCallbackInfo->formInfos);
2110 },
2111 [](napi_env env, napi_status status, void *data) {
2112 AsyncFormInfosCallbackInfo *asyncCallbackInfo =
2113 reinterpret_cast<AsyncFormInfosCallbackInfo *>(data);
2114 std::unique_ptr<AsyncFormInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
2115 napi_value result[ARGS_SIZE_TWO] = {0};
2116 napi_value callback = 0;
2117 napi_value undefined = 0;
2118 napi_value callResult = 0;
2119 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2120 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[PARAM1]));
2121 ProcessFormsInfo(env, result[PARAM1], asyncCallbackInfo->formInfos);
2122 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->ret ? CODE_SUCCESS : CODE_FAILED);
2123 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2124 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
2125 &result[PARAM0], &callResult));
2126 },
2127 reinterpret_cast<void*>(asyncCallbackInfo),
2128 &asyncCallbackInfo->asyncWork));
2129 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2130 callbackPtr.release();
2131 napi_value result;
2132 napi_create_int32(env, NAPI_RETURN_ONE, &result);
2133 return result;
2134 } else {
2135 APP_LOGI("GetFormInfos promise");
2136 napi_deferred deferred;
2137 napi_value promise;
2138 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2139 asyncCallbackInfo->deferred = deferred;
2140
2141 napi_value resourceName;
2142 NAPI_CALL(env, napi_create_string_latin1(env, "GetFormInfos", NAPI_AUTO_LENGTH, &resourceName));
2143 NAPI_CALL(env, napi_create_async_work(
2144 env,
2145 nullptr,
2146 resourceName,
2147 [](napi_env env, void *data) {
2148 AsyncFormInfosCallbackInfo *asyncCallbackInfo =
2149 reinterpret_cast<AsyncFormInfosCallbackInfo *>(data);
2150 InnerGetAllFormsInfo(env, asyncCallbackInfo->formInfos);
2151 },
2152 [](napi_env env, napi_status status, void *data) {
2153 APP_LOGI("=================load=================");
2154 AsyncFormInfosCallbackInfo *asyncCallbackInfo =
2155 reinterpret_cast<AsyncFormInfosCallbackInfo *>(data);
2156 std::unique_ptr<AsyncFormInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
2157 napi_value result;
2158 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result));
2159 ProcessFormsInfo(env, result, asyncCallbackInfo->formInfos);
2160 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
2161 result));
2162 },
2163 reinterpret_cast<void*>(asyncCallbackInfo),
2164 &asyncCallbackInfo->asyncWork));
2165 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2166 callbackPtr.release();
2167 return promise;
2168 }
2169 }
2170
InnerGetFormInfosByModule(napi_env env,const std::string & bundleName,const std::string & moduleName,std::vector<OHOS::AppExecFwk::FormInfo> & formInfos)2171 static bool InnerGetFormInfosByModule(napi_env env, const std::string &bundleName, const std::string &moduleName,
2172 std::vector<OHOS::AppExecFwk::FormInfo> &formInfos)
2173 {
2174 auto iBundleMgr = GetBundleMgr();
2175 if (iBundleMgr == nullptr) {
2176 APP_LOGE("can not get iBundleMgr");
2177 return false;
2178 }
2179 return iBundleMgr->GetFormsInfoByModule(bundleName, moduleName, formInfos);
2180 }
2181 /**
2182 * Promise and async callback
2183 */
GetFormsInfoByModule(napi_env env,napi_callback_info info)2184 napi_value GetFormsInfoByModule(napi_env env, napi_callback_info info)
2185 {
2186 size_t argc = ARGS_SIZE_THREE;
2187 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
2188 napi_value thisArg;
2189 void *data = nullptr;
2190 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
2191 APP_LOGI("ARGCSIZE is =%{public}zu", argc);
2192 std::string bundleName;
2193 std::string moduleName;
2194 ParseString(env, bundleName, argv[PARAM0]);
2195 ParseString(env, moduleName, argv[PARAM1]);
2196
2197 AsyncFormInfosByModuleCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncFormInfosByModuleCallbackInfo(env);
2198 if (asyncCallbackInfo == nullptr) {
2199 return nullptr;
2200 }
2201 std::unique_ptr<AsyncFormInfosByModuleCallbackInfo> callbackPtr {asyncCallbackInfo};
2202 asyncCallbackInfo->bundleName = bundleName;
2203 asyncCallbackInfo->moduleName = moduleName;
2204
2205 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
2206 APP_LOGI("GetFormsInfoByModule asyncCallback");
2207 napi_value resourceName;
2208 NAPI_CALL(env, napi_create_string_latin1(env, "GetFormsInfoByModule", NAPI_AUTO_LENGTH, &resourceName));
2209 napi_valuetype valuetype = napi_undefined;
2210 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
2211 if (valuetype != napi_function) {
2212 APP_LOGE("Wrong argument type. Function expected");
2213 return nullptr;
2214 }
2215 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
2216
2217 NAPI_CALL(env, napi_create_async_work(
2218 env,
2219 nullptr,
2220 resourceName,
2221 [](napi_env env, void *data) {
2222 AsyncFormInfosByModuleCallbackInfo *asyncCallbackInfo =
2223 reinterpret_cast<AsyncFormInfosByModuleCallbackInfo *>(data);
2224 asyncCallbackInfo->ret = InnerGetFormInfosByModule(
2225 env, asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName, asyncCallbackInfo->formInfos);
2226 },
2227 [](napi_env env, napi_status status, void *data) {
2228 AsyncFormInfosByModuleCallbackInfo *asyncCallbackInfo =
2229 reinterpret_cast<AsyncFormInfosByModuleCallbackInfo *>(data);
2230 std::unique_ptr<AsyncFormInfosByModuleCallbackInfo> callbackPtr {asyncCallbackInfo};
2231 napi_value result[ARGS_SIZE_TWO] = {0};
2232 napi_value callback = 0;
2233 napi_value undefined = 0;
2234 napi_value callResult = 0;
2235 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2236 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[PARAM1]));
2237 ProcessFormsInfo(env, result[PARAM1], asyncCallbackInfo->formInfos);
2238 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->ret ? CODE_SUCCESS : CODE_FAILED);
2239 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2240 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
2241 &result[PARAM0], &callResult));
2242 },
2243 reinterpret_cast<void*>(asyncCallbackInfo),
2244 &asyncCallbackInfo->asyncWork));
2245 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2246 callbackPtr.release();
2247 napi_value result;
2248 napi_create_int32(env, NAPI_RETURN_ONE, &result);
2249 return result;
2250 } else {
2251 APP_LOGI("GetFormsInfoByModule promise");
2252 napi_deferred deferred;
2253 napi_value promise;
2254 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2255 asyncCallbackInfo->deferred = deferred;
2256
2257 napi_value resourceName;
2258 NAPI_CALL(env, napi_create_string_latin1(env, "GetFormsInfoByModule", NAPI_AUTO_LENGTH, &resourceName));
2259 NAPI_CALL(env, napi_create_async_work(
2260 env,
2261 nullptr,
2262 resourceName,
2263 [](napi_env env, void *data) {
2264 AsyncFormInfosByModuleCallbackInfo *asyncCallbackInfo =
2265 reinterpret_cast<AsyncFormInfosByModuleCallbackInfo *>(data);
2266 InnerGetFormInfosByModule(
2267 env, asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName, asyncCallbackInfo->formInfos);
2268 },
2269 [](napi_env env, napi_status status, void *data) {
2270 APP_LOGI("=================load=================");
2271 AsyncFormInfosByModuleCallbackInfo *asyncCallbackInfo =
2272 reinterpret_cast<AsyncFormInfosByModuleCallbackInfo *>(data);
2273 std::unique_ptr<AsyncFormInfosByModuleCallbackInfo> callbackPtr {asyncCallbackInfo};
2274 napi_value result;
2275 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result));
2276 ProcessFormsInfo(env, result, asyncCallbackInfo->formInfos);
2277 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
2278 result));
2279 },
2280 reinterpret_cast<void*>(asyncCallbackInfo),
2281 &asyncCallbackInfo->asyncWork));
2282 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2283 callbackPtr.release();
2284 return promise;
2285 }
2286 }
2287
InnerGetFormInfosByApp(napi_env env,const std::string & bundleName,std::vector<OHOS::AppExecFwk::FormInfo> & formInfos)2288 static bool InnerGetFormInfosByApp(
2289 napi_env env, const std::string &bundleName, std::vector<OHOS::AppExecFwk::FormInfo> &formInfos)
2290 {
2291 auto iBundleMgr = GetBundleMgr();
2292 if (iBundleMgr == nullptr) {
2293 APP_LOGE("can not get iBundleMgr");
2294 return false;
2295 }
2296 return iBundleMgr->GetFormsInfoByApp(bundleName, formInfos);
2297 }
2298 /**
2299 * Promise and async callback
2300 */
GetFormsInfoByApp(napi_env env,napi_callback_info info)2301 napi_value GetFormsInfoByApp(napi_env env, napi_callback_info info)
2302 {
2303 size_t argc = ARGS_SIZE_TWO;
2304 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
2305 napi_value thisArg;
2306 void *data = nullptr;
2307 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
2308 APP_LOGI("ARGCSIZE is =%{public}zu", argc);
2309 std::string bundleName;
2310 ParseString(env, bundleName, argv[PARAM0]);
2311
2312 AsyncFormInfosByAppCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncFormInfosByAppCallbackInfo(env);
2313 if (asyncCallbackInfo == nullptr) {
2314 return nullptr;
2315 }
2316 std::unique_ptr<AsyncFormInfosByAppCallbackInfo> callbackPtr {asyncCallbackInfo};
2317 asyncCallbackInfo->bundleName = bundleName;
2318 if (argc > (ARGS_SIZE_TWO - CALLBACK_SIZE)) {
2319 APP_LOGI("GetFormsInfoByApp asyncCallback");
2320 napi_value resourceName;
2321 NAPI_CALL(env, napi_create_string_latin1(env, "GetFormsInfoByApp", NAPI_AUTO_LENGTH, &resourceName));
2322 napi_valuetype valuetype = napi_undefined;
2323 napi_typeof(env, argv[ARGS_SIZE_ONE], &valuetype);
2324 if (valuetype != napi_function) {
2325 APP_LOGE("Wrong argument type. Function expected");
2326 return nullptr;
2327 }
2328 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_ONE], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
2329
2330 NAPI_CALL(env, napi_create_async_work(
2331 env,
2332 nullptr,
2333 resourceName,
2334 [](napi_env env, void *data) {
2335 AsyncFormInfosByAppCallbackInfo *asyncCallbackInfo =
2336 reinterpret_cast<AsyncFormInfosByAppCallbackInfo *>(data);
2337 asyncCallbackInfo->ret =
2338 InnerGetFormInfosByApp(env, asyncCallbackInfo->bundleName, asyncCallbackInfo->formInfos);
2339 },
2340 [](napi_env env, napi_status status, void *data) {
2341 AsyncFormInfosByAppCallbackInfo *asyncCallbackInfo =
2342 reinterpret_cast<AsyncFormInfosByAppCallbackInfo *>(data);
2343 std::unique_ptr<AsyncFormInfosByAppCallbackInfo> callbackPtr {asyncCallbackInfo};
2344 napi_value result[ARGS_SIZE_TWO] = {0};
2345 napi_value callback = 0;
2346 napi_value undefined = 0;
2347 napi_value callResult = 0;
2348 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2349 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[PARAM1]));
2350 ProcessFormsInfo(env, result[PARAM1], asyncCallbackInfo->formInfos);
2351 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->ret ? CODE_SUCCESS : CODE_FAILED);
2352 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2353 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
2354 &result[PARAM0], &callResult));
2355 },
2356 reinterpret_cast<void*>(asyncCallbackInfo),
2357 &asyncCallbackInfo->asyncWork));
2358 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2359 callbackPtr.release();
2360 napi_value result;
2361 napi_create_int32(env, NAPI_RETURN_ONE, &result);
2362 return result;
2363 } else {
2364 APP_LOGI("GetFormsInfoByApp promise");
2365 napi_deferred deferred;
2366 napi_value promise;
2367 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2368 asyncCallbackInfo->deferred = deferred;
2369
2370 napi_value resourceName;
2371 NAPI_CALL(env, napi_create_string_latin1(env, "GetFormsInfoByApp", NAPI_AUTO_LENGTH, &resourceName));
2372 NAPI_CALL(env, napi_create_async_work(
2373 env,
2374 nullptr,
2375 resourceName,
2376 [](napi_env env, void *data) {
2377 AsyncFormInfosByAppCallbackInfo *asyncCallbackInfo =
2378 reinterpret_cast<AsyncFormInfosByAppCallbackInfo *>(data);
2379 InnerGetFormInfosByApp(env, asyncCallbackInfo->bundleName, asyncCallbackInfo->formInfos);
2380 },
2381 [](napi_env env, napi_status status, void *data) {
2382 APP_LOGI("=================load=================");
2383 AsyncFormInfosByAppCallbackInfo *asyncCallbackInfo =
2384 reinterpret_cast<AsyncFormInfosByAppCallbackInfo *>(data);
2385 std::unique_ptr<AsyncFormInfosByAppCallbackInfo> callbackPtr {asyncCallbackInfo};
2386 napi_value result;
2387 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result));
2388 ProcessFormsInfo(env, result, asyncCallbackInfo->formInfos);
2389 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
2390 result));
2391 },
2392 reinterpret_cast<void*>(asyncCallbackInfo),
2393 &asyncCallbackInfo->asyncWork));
2394 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2395 callbackPtr.release();
2396 return promise;
2397 }
2398 }
2399
InnerGetBundleGids(napi_env env,const std::string & bundleName,std::vector<int> & gids)2400 static bool InnerGetBundleGids(napi_env env, const std::string &bundleName, std::vector<int> &gids)
2401 {
2402 auto iBundleMgr = GetBundleMgr();
2403 if (iBundleMgr == nullptr) {
2404 APP_LOGE("can not get iBundleMgr");
2405 return false;
2406 };
2407 auto ret = iBundleMgr->GetBundleGids(bundleName, gids);
2408 return ret;
2409 }
2410
ProcessGids(napi_env env,napi_value result,const std::vector<int32_t> & gids)2411 static void ProcessGids(napi_env env, napi_value result, const std::vector<int32_t> &gids)
2412 {
2413 if (gids.size() > 0) {
2414 APP_LOGI("-----gids is not null-----");
2415 size_t index = 0;
2416 for (const auto &item : gids) {
2417 napi_value value;
2418 napi_create_int32(env, item, &value);
2419 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, value));
2420 index++;
2421 }
2422 APP_LOGI("-----gids is not null end-----");
2423 } else {
2424 APP_LOGI("-----ShortcutInfos is null-----");
2425 }
2426 }
2427
WrapVoidToJS(napi_env env)2428 napi_value WrapVoidToJS(napi_env env)
2429 {
2430 napi_value result = nullptr;
2431 NAPI_CALL(env, napi_get_null(env, &result));
2432 return result;
2433 }
2434
WrapUndefinedToJS(napi_env env)2435 napi_value WrapUndefinedToJS(napi_env env)
2436 {
2437 napi_value result = nullptr;
2438 NAPI_CALL(env, napi_get_undefined(env, &result));
2439 return result;
2440 }
2441
CreateAsyncGetBundleGidsCallbackInfo(napi_env env)2442 AsyncGetBundleGidsCallbackInfo *CreateAsyncGetBundleGidsCallbackInfo(napi_env env)
2443 {
2444 APP_LOGI("called");
2445 AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncGetBundleGidsCallbackInfo(env);
2446 if (asyncCallbackInfo == nullptr) {
2447 APP_LOGE("asyncCallbackInfo is nullptr");
2448 return nullptr;
2449 }
2450
2451 APP_LOGI("end");
2452 return asyncCallbackInfo;
2453 }
2454
GetBundleGidsExecute(napi_env env,void * data)2455 void GetBundleGidsExecute(napi_env env, void *data)
2456 {
2457 APP_LOGI("NAPI_GetBundleGids, worker pool thread execute");
2458 AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetBundleGidsCallbackInfo *>(data);
2459 if (asyncCallbackInfo == nullptr) {
2460 APP_LOGE("NAPI_GetBundleGids, asyncCallbackInfo == nullptr");
2461 return;
2462 }
2463
2464 bool ret = InnerGetBundleGids(env, asyncCallbackInfo->bundleName, asyncCallbackInfo->gids);
2465 if (!ret) {
2466 asyncCallbackInfo->err = NAPI_RETURN_FAILED;
2467 }
2468 }
2469
GetBundleGidsAsyncComplete(napi_env env,napi_status status,void * data)2470 void GetBundleGidsAsyncComplete(napi_env env, napi_status status, void *data)
2471 {
2472 APP_LOGI("NAPI_GetBundleGids, main event thread complete");
2473 AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetBundleGidsCallbackInfo *>(data);
2474 std::unique_ptr<AsyncGetBundleGidsCallbackInfo> callbackPtr {asyncCallbackInfo};
2475 napi_value callback = nullptr;
2476 napi_value undefined = nullptr;
2477 napi_value result[ARGS_SIZE_TWO] = {nullptr};
2478 napi_value callResult = nullptr;
2479 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2480 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->err);
2481
2482 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
2483 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[PARAM1]));
2484 ProcessGids(env, result[PARAM1], asyncCallbackInfo->gids);
2485 } else {
2486 result[PARAM1] = WrapUndefinedToJS(env);
2487 }
2488
2489 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2490 NAPI_CALL_RETURN_VOID(env,
2491 napi_call_function(env, undefined, callback, sizeof(result) / sizeof(result[PARAM0]), result, &callResult));
2492 APP_LOGI("main event thread complete end");
2493 }
2494
GetBundleGidsPromiseComplete(napi_env env,napi_status status,void * data)2495 void GetBundleGidsPromiseComplete(napi_env env, napi_status status, void *data)
2496 {
2497 APP_LOGI("main event thread complete begin");
2498 AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo = static_cast<AsyncGetBundleGidsCallbackInfo *>(data);
2499 std::unique_ptr<AsyncGetBundleGidsCallbackInfo> callbackPtr {asyncCallbackInfo};
2500 napi_value result = nullptr;
2501 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
2502 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result));
2503 ProcessGids(env, result, asyncCallbackInfo->gids);
2504 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result));
2505 } else {
2506 result = GetCallbackErrorValue(env, asyncCallbackInfo->err);
2507 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result));
2508 }
2509 APP_LOGI("main event thread complete end");
2510 }
2511
GetBundleGidsAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncGetBundleGidsCallbackInfo * asyncCallbackInfo)2512 napi_value GetBundleGidsAsync(
2513 napi_env env, napi_value *args, const size_t argCallback, AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo)
2514 {
2515 APP_LOGI("asyncCallback");
2516 if (args == nullptr || asyncCallbackInfo == nullptr) {
2517 APP_LOGE("param == nullptr");
2518 return nullptr;
2519 }
2520
2521 napi_value resourceName = nullptr;
2522 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2523
2524 napi_valuetype valuetype = napi_undefined;
2525 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
2526 if (valuetype == napi_function) {
2527 NAPI_CALL(env, napi_create_reference(env, args[argCallback], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
2528 } else {
2529 return nullptr;
2530 }
2531
2532 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetBundleGidsExecute, GetBundleGidsAsyncComplete,
2533 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
2534 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2535 napi_value result = nullptr;
2536 NAPI_CALL(env, napi_get_null(env, &result));
2537 APP_LOGI("asyncCallback end");
2538 return result;
2539 }
2540
GetBundleGidsPromise(napi_env env,AsyncGetBundleGidsCallbackInfo * asyncCallbackInfo)2541 napi_value GetBundleGidsPromise(napi_env env, AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo)
2542 {
2543 APP_LOGI("promise");
2544 if (asyncCallbackInfo == nullptr) {
2545 APP_LOGE("param == nullptr");
2546 return nullptr;
2547 }
2548 napi_value resourceName = nullptr;
2549 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2550 napi_deferred deferred;
2551 napi_value promise = nullptr;
2552 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2553 asyncCallbackInfo->deferred = deferred;
2554
2555 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName,
2556 GetBundleGidsExecute, GetBundleGidsPromiseComplete,
2557 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
2558 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2559 APP_LOGI("promise end");
2560 return promise;
2561 }
2562
GetBundleGidsWrap(napi_env env,napi_callback_info info,AsyncGetBundleGidsCallbackInfo * asyncCallbackInfo)2563 napi_value GetBundleGidsWrap(napi_env env, napi_callback_info info, AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo)
2564 {
2565 APP_LOGI("asyncCallback");
2566 if (asyncCallbackInfo == nullptr) {
2567 APP_LOGE("asyncCallbackInfo is nullptr");
2568 return nullptr;
2569 }
2570
2571 size_t argcAsync = ARGS_SIZE_TWO;
2572 const size_t argcPromise = ARGS_SIZE_ONE;
2573 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2574 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2575 napi_value ret = nullptr;
2576
2577 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2578 if (argcAsync > argCountWithAsync) {
2579 APP_LOGE("Wrong argument count");
2580 return nullptr;
2581 }
2582
2583 napi_valuetype valueType = napi_undefined;
2584 NAPI_CALL(env, napi_typeof(env, args[PARAM0], &valueType));
2585 if (valueType == napi_string) {
2586 ParseString(env, asyncCallbackInfo->bundleName, args[PARAM0]);
2587 } else {
2588 asyncCallbackInfo->err = INVALID_PARAM;
2589 }
2590
2591 if (argcAsync > argcPromise) {
2592 ret = GetBundleGidsAsync(env, args, argcAsync - 1, asyncCallbackInfo);
2593 } else {
2594 ret = GetBundleGidsPromise(env, asyncCallbackInfo);
2595 }
2596 APP_LOGI("asyncCallback end");
2597 return ret;
2598 }
2599
GetBundleGids(napi_env env,napi_callback_info info)2600 napi_value GetBundleGids(napi_env env, napi_callback_info info)
2601 {
2602 APP_LOGI("NAPI_GetBundleGids start");
2603 AsyncGetBundleGidsCallbackInfo *asyncCallbackInfo = CreateAsyncGetBundleGidsCallbackInfo(env);
2604 if (asyncCallbackInfo == nullptr) {
2605 return WrapVoidToJS(env);
2606 }
2607 std::unique_ptr<AsyncGetBundleGidsCallbackInfo> callbackPtr {asyncCallbackInfo};
2608 napi_value ret = GetBundleGidsWrap(env, info, asyncCallbackInfo);
2609 if (ret == nullptr) {
2610 APP_LOGE("ret == nullptr");
2611 ret = WrapVoidToJS(env);
2612 } else {
2613 callbackPtr.release();
2614 }
2615 APP_LOGI("end");
2616 return ret;
2617 }
2618
InnerSetApplicationEnabled(const std::string & bundleName,bool isEnable)2619 static bool InnerSetApplicationEnabled(const std::string &bundleName, bool isEnable)
2620 {
2621 auto iBundleMgr = GetBundleMgr();
2622 if (iBundleMgr == nullptr) {
2623 APP_LOGE("can not get iBundleMgr");
2624 return false;
2625 }
2626 ErrCode result = iBundleMgr->SetApplicationEnabled(bundleName, isEnable);
2627 if (result != ERR_OK) {
2628 APP_LOGE("InnerSetApplicationEnabled failed, bundleName is %{public}s, error is %{public}d",
2629 bundleName.c_str(), result);
2630 return false;
2631 }
2632 return true;
2633 }
2634
InnerSetAbilityEnabled(const OHOS::AppExecFwk::AbilityInfo & abilityInfo,bool isEnable)2635 static bool InnerSetAbilityEnabled(const OHOS::AppExecFwk::AbilityInfo &abilityInfo, bool isEnable)
2636 {
2637 auto iBundleMgr = GetBundleMgr();
2638 if (iBundleMgr == nullptr) {
2639 APP_LOGE("can not get iBundleMgr");
2640 return false;
2641 }
2642 ErrCode result = iBundleMgr->SetAbilityEnabled(abilityInfo, isEnable);
2643 if (result != ERR_OK) {
2644 APP_LOGE("InnerSetAbilityEnabled failed, error is %{public}d", result);
2645 return false;
2646 }
2647 return true;
2648 }
2649
InnerCleanBundleCacheCallback(const std::string & bundleName,const OHOS::sptr<CleanCacheCallback> cleanCacheCallback)2650 static bool InnerCleanBundleCacheCallback(
2651 const std::string& bundleName, const OHOS::sptr<CleanCacheCallback> cleanCacheCallback)
2652 {
2653 auto iBundleMgr = GetBundleMgr();
2654 if (iBundleMgr == nullptr) {
2655 APP_LOGE("can not get iBundleMgr");
2656 return false;
2657 }
2658 if (cleanCacheCallback == nullptr) {
2659 APP_LOGE("callback nullptr");
2660 return false;
2661 }
2662 int32_t userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
2663 ErrCode result = iBundleMgr->CleanBundleCacheFiles(bundleName, cleanCacheCallback, userId);
2664 if (result != ERR_OK) {
2665 APP_LOGE("CleanBundleDataFiles call error, bundleName is %{public}s, userId is %{public}d",
2666 bundleName.c_str(), userId);
2667 return false;
2668 }
2669
2670 return true;
2671 }
2672
ParseModuleName(napi_env env,napi_value param,std::string & moduleName)2673 bool ParseModuleName(napi_env env, napi_value param, std::string &moduleName)
2674 {
2675 bool hasKey = false;
2676 napi_has_named_property(env, param, "moduleName", &hasKey);
2677 if (hasKey) {
2678 napi_valuetype valueType;
2679 napi_value prop = nullptr;
2680 napi_get_named_property(env, param, "moduleName", &prop);
2681 napi_typeof(env, prop, &valueType);
2682 if (valueType == napi_undefined) {
2683 APP_LOGE("begin to parse moduleName failed");
2684 return false;
2685 }
2686 moduleName = GetStringFromNAPI(env, prop);
2687 }
2688 return true;
2689 }
2690
UnwrapAbilityInfo(napi_env env,napi_value param,OHOS::AppExecFwk::AbilityInfo & abilityInfo)2691 bool UnwrapAbilityInfo(napi_env env, napi_value param, OHOS::AppExecFwk::AbilityInfo& abilityInfo)
2692 {
2693 napi_valuetype valueType;
2694 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
2695 if (valueType != napi_object) {
2696 APP_LOGE("param type mismatch");
2697 return false;
2698 }
2699
2700 napi_value prop = nullptr;
2701 // parse bundleName
2702 napi_get_named_property(env, param, "bundleName", &prop);
2703 napi_typeof(env, prop, &valueType);
2704 if (valueType == napi_undefined) {
2705 return false;
2706 }
2707 std::string bundleName = GetStringFromNAPI(env, prop);
2708 abilityInfo.bundleName = bundleName;
2709
2710 // parse moduleName
2711 std::string moduleName;
2712 if (!ParseModuleName(env, param, moduleName)) {
2713 return false;
2714 }
2715 abilityInfo.moduleName = moduleName;
2716
2717 // parse abilityName
2718 napi_get_named_property(env, param, "name", &prop);
2719 napi_typeof(env, prop, &valueType);
2720 if (valueType == napi_undefined) {
2721 return false;
2722 }
2723 std::string name = GetStringFromNAPI(env, prop);
2724 abilityInfo.name = name;
2725 return true;
2726 }
2727
InnerGetNameForUid(int32_t uid,std::string & bundleName)2728 static bool InnerGetNameForUid(int32_t uid, std::string &bundleName)
2729 {
2730 auto iBundleMgr = GetBundleMgr();
2731 if (iBundleMgr == nullptr) {
2732 APP_LOGE("can not get iBundleMgr");
2733 return false;
2734 }
2735 if (iBundleMgr->GetNameForUid(uid, bundleName) != ERR_OK) {
2736 APP_LOGE("GetNameForUid failed, uid is %{public}d, bundleName is %{public}s", uid, bundleName.c_str());
2737 return false;
2738 }
2739 return true;
2740 }
2741
ClearBundleCache(napi_env env,napi_callback_info info)2742 napi_value ClearBundleCache(napi_env env, napi_callback_info info)
2743 {
2744 size_t requireArgc = ARGS_SIZE_ONE;
2745 size_t argc = ARGS_SIZE_TWO;
2746 napi_value argv[ARGS_SIZE_TWO] = { 0 };
2747 napi_value thisArg = nullptr;
2748 void *data = nullptr;
2749
2750 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
2751 NAPI_CALL(env, (argc >= requireArgc) ? napi_ok : napi_invalid_arg);
2752
2753 AsyncHandleBundleContext *asyncCallbackInfo = new (std::nothrow) AsyncHandleBundleContext(env);
2754 if (asyncCallbackInfo == nullptr) {
2755 return nullptr;
2756 }
2757 std::unique_ptr<AsyncHandleBundleContext> callbackPtr {asyncCallbackInfo};
2758 for (size_t i = 0; i < argc; ++i) {
2759 napi_valuetype valueType = napi_undefined;
2760 napi_typeof(env, argv[i], &valueType);
2761 if ((i == 0) && (valueType == napi_string)) {
2762 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
2763 } else if ((i == 1) && (valueType == napi_function)) {
2764 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
2765 } else {
2766 asyncCallbackInfo->err = INVALID_PARAM;
2767 }
2768 }
2769 napi_value promise = nullptr;
2770
2771 if (asyncCallbackInfo->callback == nullptr) {
2772 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
2773 } else {
2774 NAPI_CALL(env, napi_get_undefined(env, &promise));
2775 }
2776
2777 napi_value resource = nullptr;
2778 NAPI_CALL(env, napi_create_string_utf8(env, "JSCleanBundleCache", NAPI_AUTO_LENGTH, &resource));
2779 NAPI_CALL(env, napi_create_async_work(
2780 env, nullptr, resource,
2781 [](napi_env env, void* data) {
2782 AsyncHandleBundleContext* asyncCallbackInfo =
2783 reinterpret_cast<AsyncHandleBundleContext*>(data);
2784 if (asyncCallbackInfo->cleanCacheCallback == nullptr) {
2785 asyncCallbackInfo->cleanCacheCallback = new (std::nothrow) CleanCacheCallback(UNDEFINED_ERROR);
2786 }
2787 if (!asyncCallbackInfo->err) {
2788 asyncCallbackInfo->ret =
2789 InnerCleanBundleCacheCallback(asyncCallbackInfo->bundleName, asyncCallbackInfo->cleanCacheCallback);
2790 if (asyncCallbackInfo->ret && asyncCallbackInfo->cleanCacheCallback != nullptr) {
2791 // wait for OnCleanCacheFinished
2792 APP_LOGI("clean exec wait");
2793 if (asyncCallbackInfo->cleanCacheCallback->WaitForCompletion()) {
2794 asyncCallbackInfo->ret = asyncCallbackInfo->cleanCacheCallback->GetErr() ? false : true;
2795 } else {
2796 APP_LOGI("clean exec timeout");
2797 asyncCallbackInfo->ret = false;
2798 }
2799 APP_LOGI("clean exec end");
2800 }
2801 }
2802 },
2803 [](napi_env env, napi_status status, void* data) {
2804 AsyncHandleBundleContext* asyncCallbackInfo =
2805 reinterpret_cast<AsyncHandleBundleContext*>(data);
2806 std::unique_ptr<AsyncHandleBundleContext> callbackPtr {asyncCallbackInfo};
2807 napi_value result[1] = { 0 };
2808 // set error code
2809 if (asyncCallbackInfo->err) {
2810 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[0]));
2811 } else {
2812 if (!asyncCallbackInfo->ret) {
2813 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
2814 } else {
2815 if (asyncCallbackInfo->cleanCacheCallback) {
2816 if (!asyncCallbackInfo->cleanCacheCallback->GetErr()) {
2817 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[0]));
2818 } else {
2819 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
2820 asyncCallbackInfo->cleanCacheCallback->GetErr(), &result[0]));
2821 }
2822 }
2823 }
2824 }
2825 // implement callback or promise
2826 if (asyncCallbackInfo->deferred) {
2827 if (!asyncCallbackInfo->ret) {
2828 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
2829 } else {
2830 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[0]));
2831 }
2832 } else {
2833 napi_value callback = nullptr;
2834 napi_value placeHolder = nullptr;
2835 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2836 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
2837 sizeof(result) / sizeof(result[0]), result, &placeHolder));
2838 }
2839 },
2840 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
2841 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2842 callbackPtr.release();
2843 return promise;
2844 }
2845
CreateAbilityTypeObject(napi_env env)2846 napi_value CreateAbilityTypeObject(napi_env env)
2847 {
2848 APP_LOGD("enter");
2849
2850 napi_value value = nullptr;
2851 NAPI_CALL(env, napi_create_object(env, &value));
2852
2853 napi_value nUnknown = nullptr;
2854 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::UNKNOWN), &nUnknown));
2855 NAPI_CALL(env, napi_set_named_property(env, value, "UNKNOWN", nUnknown));
2856
2857 napi_value nPage = nullptr;
2858 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::PAGE), &nPage));
2859 NAPI_CALL(env, napi_set_named_property(env, value, "PAGE", nPage));
2860
2861 napi_value nService = nullptr;
2862 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::SERVICE), &nService));
2863 NAPI_CALL(env, napi_set_named_property(env, value, "SERVICE", nService));
2864
2865 napi_value nData = nullptr;
2866 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::DATA), &nData));
2867 NAPI_CALL(env, napi_set_named_property(env, value, "DATA", nData));
2868
2869 return value;
2870 }
2871
CreateAbilitySubTypeObject(napi_env env)2872 napi_value CreateAbilitySubTypeObject(napi_env env)
2873 {
2874 APP_LOGD("enter");
2875
2876 napi_value value = nullptr;
2877 NAPI_CALL(env, napi_create_object(env, &value));
2878
2879 napi_value nUnspecified = nullptr;
2880 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nUnspecified));
2881 NAPI_CALL(env, napi_set_named_property(env, value, "UNSPECIFIED", nUnspecified));
2882
2883 napi_value nCa = nullptr;
2884 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nCa));
2885 NAPI_CALL(env, napi_set_named_property(env, value, "CA", nCa));
2886
2887 return value;
2888 }
2889
CreateDisplayOrientationObject(napi_env env)2890 napi_value CreateDisplayOrientationObject(napi_env env)
2891 {
2892 APP_LOGD("enter");
2893
2894 napi_value value = nullptr;
2895 NAPI_CALL(env, napi_create_object(env, &value));
2896
2897 napi_value nUnspecified = nullptr;
2898 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::UNSPECIFIED), &nUnspecified));
2899 NAPI_CALL(env, napi_set_named_property(env, value, "UNSPECIFIED", nUnspecified));
2900
2901 napi_value nLandscape = nullptr;
2902 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LANDSCAPE), &nLandscape));
2903 NAPI_CALL(env, napi_set_named_property(env, value, "LANDSCAPE", nLandscape));
2904
2905 napi_value nPortrait = nullptr;
2906 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::PORTRAIT), &nPortrait));
2907 NAPI_CALL(env, napi_set_named_property(env, value, "PORTRAIT", nPortrait));
2908
2909 napi_value nFollowRecent = nullptr;
2910 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::FOLLOWRECENT), &nFollowRecent));
2911 NAPI_CALL(env, napi_set_named_property(env, value, "FOLLOW_RECENT", nFollowRecent));
2912
2913 napi_value nLandscapeInverted = nullptr;
2914 NAPI_CALL(env,
2915 napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LANDSCAPE_INVERTED), &nLandscapeInverted));
2916 NAPI_CALL(env, napi_set_named_property(env, value, "LANDSCAPE_INVERTED", nLandscapeInverted));
2917
2918 napi_value nPortraitInverted = nullptr;
2919 NAPI_CALL(env,
2920 napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::PORTRAIT_INVERTED), &nPortraitInverted));
2921 NAPI_CALL(env, napi_set_named_property(env, value, "PORTRAIT_INVERTED", nPortraitInverted));
2922
2923 napi_value nAutoRotation = nullptr;
2924 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION), &nAutoRotation));
2925 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION", nAutoRotation));
2926
2927 napi_value nAutoRotationLandscape = nullptr;
2928 NAPI_CALL(env, napi_create_int32(env,
2929 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_LANDSCAPE), &nAutoRotationLandscape));
2930 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_LANDSCAPE", nAutoRotationLandscape));
2931
2932 napi_value nAutoRotationPortrait = nullptr;
2933 NAPI_CALL(env, napi_create_int32(env,
2934 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_PORTRAIT), &nAutoRotationPortrait));
2935 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_PORTRAIT", nAutoRotationPortrait));
2936
2937 napi_value nAutoRotationRestricted = nullptr;
2938 NAPI_CALL(env, napi_create_int32(env,
2939 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_RESTRICTED), &nAutoRotationRestricted));
2940 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_RESTRICTED", nAutoRotationRestricted));
2941
2942 napi_value nAutoRotationLandscapeR = nullptr;
2943 NAPI_CALL(env, napi_create_int32(env,
2944 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED), &nAutoRotationLandscapeR));
2945 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_LANDSCAPE_RESTRICTED", nAutoRotationLandscapeR));
2946
2947 napi_value nAutoRotationPortraitR = nullptr;
2948 NAPI_CALL(env, napi_create_int32(env,
2949 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED), &nAutoRotationPortraitR));
2950 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_PORTRAIT_RESTRICTED", nAutoRotationPortraitR));
2951
2952 napi_value nLocked = nullptr;
2953 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LOCKED), &nLocked));
2954 NAPI_CALL(env, napi_set_named_property(env, value, "LOCKED", nLocked));
2955
2956 return value;
2957 }
2958
CreateLaunchModeObject(napi_env env)2959 napi_value CreateLaunchModeObject(napi_env env)
2960 {
2961 APP_LOGD("enter");
2962
2963 napi_value value = nullptr;
2964 NAPI_CALL(env, napi_create_object(env, &value));
2965
2966 napi_value nSingleton = nullptr;
2967 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(LaunchMode::SINGLETON), &nSingleton));
2968 NAPI_CALL(env, napi_set_named_property(env, value, "SINGLETON", nSingleton));
2969
2970 napi_value nStandard = nullptr;
2971 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(LaunchMode::STANDARD), &nStandard));
2972 NAPI_CALL(env, napi_set_named_property(env, value, "STANDARD", nStandard));
2973
2974 return value;
2975 }
2976
CreateFormTypeObject(napi_env env,napi_value value)2977 void CreateFormTypeObject(napi_env env, napi_value value)
2978 {
2979 napi_value nJava;
2980 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nJava));
2981 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "JAVA", nJava));
2982 napi_value nJs;
2983 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_RETURN_ONE, &nJs));
2984 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "JS", nJs));
2985 }
2986
CreateColorModeObject(napi_env env)2987 napi_value CreateColorModeObject(napi_env env)
2988 {
2989 APP_LOGD("enter");
2990
2991 napi_value value = nullptr;
2992 NAPI_CALL(env, napi_create_object(env, &value));
2993
2994 napi_value nAutoMode = nullptr;
2995 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_FAILED, &nAutoMode));
2996 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_MODE", nAutoMode));
2997
2998 napi_value nDarkMode = nullptr;
2999 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nDarkMode));
3000 NAPI_CALL(env, napi_set_named_property(env, value, "DARK_MODE", nDarkMode));
3001
3002 napi_value nLightMode = nullptr;
3003 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nLightMode));
3004 NAPI_CALL(env, napi_set_named_property(env, value, "LIGHT_MODE", nLightMode));
3005
3006 return value;
3007 }
3008
CreateGrantStatusObject(napi_env env)3009 napi_value CreateGrantStatusObject(napi_env env)
3010 {
3011 APP_LOGD("enter");
3012
3013 napi_value value = nullptr;
3014 NAPI_CALL(env, napi_create_object(env, &value));
3015
3016 napi_value nPermissionDenied = nullptr;
3017 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_FAILED, &nPermissionDenied));
3018 NAPI_CALL(env, napi_set_named_property(env, value, "PERMISSION_DENIED", nPermissionDenied));
3019
3020 napi_value nPermissionGranted = nullptr;
3021 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nPermissionGranted));
3022 NAPI_CALL(env, napi_set_named_property(env, value, "PERMISSION_GRANTED", nPermissionGranted));
3023
3024 return value;
3025 }
3026
CreateModuleRemoveFlagObject(napi_env env)3027 napi_value CreateModuleRemoveFlagObject(napi_env env)
3028 {
3029 APP_LOGD("enter");
3030
3031 napi_value value = nullptr;
3032 NAPI_CALL(env, napi_create_object(env, &value));
3033
3034 napi_value nNotUsedByForm = nullptr;
3035 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nNotUsedByForm));
3036 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_NOT_USED_BY_FORM", nNotUsedByForm));
3037
3038 napi_value nUsedByForm = nullptr;
3039 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nUsedByForm));
3040 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_USED_BY_FORM", nUsedByForm));
3041
3042 napi_value nNotUsedByShortcut = nullptr;
3043 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nNotUsedByShortcut));
3044 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_NOT_USED_BY_SHORTCUT", nNotUsedByShortcut));
3045
3046 napi_value nUsedByShortcut = nullptr;
3047 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_THREE, &nUsedByShortcut));
3048 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_USED_BY_SHORTCUT", nUsedByShortcut));
3049
3050 return value;
3051 }
3052
CreateSignatureCompareResultObject(napi_env env)3053 napi_value CreateSignatureCompareResultObject(napi_env env)
3054 {
3055 APP_LOGD("enter");
3056
3057 napi_value value = nullptr;
3058 NAPI_CALL(env, napi_create_object(env, &value));
3059
3060 napi_value nMatched = nullptr;
3061 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nMatched));
3062 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_MATCHED", nMatched));
3063
3064 napi_value nNotMatched = nullptr;
3065 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nNotMatched));
3066 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_NOT_MATCHED", nNotMatched));
3067
3068 napi_value nUnknownBundle = nullptr;
3069 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nUnknownBundle));
3070 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_UNKNOWN_BUNDLE", nUnknownBundle));
3071
3072 return value;
3073 }
3074
CreateShortcutExistenceObject(napi_env env)3075 napi_value CreateShortcutExistenceObject(napi_env env)
3076 {
3077 APP_LOGD("enter");
3078
3079 napi_value value = nullptr;
3080 NAPI_CALL(env, napi_create_object(env, &value));
3081
3082 napi_value nExists = nullptr;
3083 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nExists));
3084 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_EXISTS", nExists));
3085
3086 napi_value nNotExists = nullptr;
3087 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nNotExists));
3088 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_NOT_EXISTS", nNotExists));
3089
3090 napi_value nUnknown = nullptr;
3091 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nUnknown));
3092 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_UNKNOW", nUnknown));
3093
3094 return value;
3095 }
3096
CreateQueryShortCutFlagObject(napi_env env)3097 napi_value CreateQueryShortCutFlagObject(napi_env env)
3098 {
3099 APP_LOGD("enter");
3100
3101 napi_value value = nullptr;
3102 NAPI_CALL(env, napi_create_object(env, &value));
3103
3104 napi_value nShortcutHome = nullptr;
3105 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nShortcutHome));
3106 NAPI_CALL(env, napi_set_named_property(env, value, "QUERY_SHORTCUT_HOME", nShortcutHome));
3107
3108 return value;
3109 }
3110
CreateBundleFlagObject(napi_env env)3111 napi_value CreateBundleFlagObject(napi_env env)
3112 {
3113 APP_LOGD("enter");
3114
3115 napi_value value = nullptr;
3116 NAPI_CALL(env, napi_create_object(env, &value));
3117
3118 napi_value nAllApplictionInfo = nullptr;
3119 NAPI_CALL(env, napi_create_int32(env,
3120 static_cast<int32_t>(ApplicationFlag::GET_ALL_APPLICATION_INFO), &nAllApplictionInfo));
3121 NAPI_CALL(env, napi_set_named_property(env, value, "GET_ALL_APPLICATION_INFO", nAllApplictionInfo));
3122
3123 napi_value nBundleDefault = nullptr;
3124 NAPI_CALL(env, napi_create_int32(env,
3125 static_cast<int32_t>(BundleFlag::GET_BUNDLE_DEFAULT), &nBundleDefault));
3126 NAPI_CALL(env, napi_set_named_property(env, value, "GET_BUNDLE_DEFAULT", nBundleDefault));
3127
3128 napi_value nBundleWithAbilities = nullptr;
3129 NAPI_CALL(env, napi_create_int32(env,
3130 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_ABILITIES), &nBundleWithAbilities));
3131 NAPI_CALL(env, napi_set_named_property(env, value, "GET_BUNDLE_WITH_ABILITIES", nBundleWithAbilities));
3132
3133 napi_value nBundleWithRequestedPermission = nullptr;
3134 NAPI_CALL(env, napi_create_int32(env,
3135 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_REQUESTED_PERMISSION), &nBundleWithRequestedPermission));
3136 NAPI_CALL(env, napi_set_named_property(env, value,
3137 "GET_BUNDLE_WITH_REQUESTED_PERMISSION", nBundleWithRequestedPermission));
3138
3139 napi_value nAbilityInfoWithPermission = nullptr;
3140 NAPI_CALL(env, napi_create_int32(env,
3141 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_PERMISSION), &nAbilityInfoWithPermission));
3142 NAPI_CALL(env, napi_set_named_property(env, value,
3143 "GET_ABILITY_INFO_WITH_PERMISSION", nAbilityInfoWithPermission));
3144
3145 napi_value nAbilityInfoWithApplication = nullptr;
3146 NAPI_CALL(env, napi_create_int32(env,
3147 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION), &nAbilityInfoWithApplication));
3148 NAPI_CALL(env, napi_set_named_property(env, value,
3149 "GET_ABILITY_INFO_WITH_APPLICATION", nAbilityInfoWithApplication));
3150
3151 napi_value nAbilityInfoSystemAppOnly = nullptr;
3152 NAPI_CALL(env, napi_create_int32(env,
3153 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_SYSTEMAPP_ONLY), &nAbilityInfoSystemAppOnly));
3154 NAPI_CALL(env, napi_set_named_property(env, value,
3155 "GET_ABILITY_INFO_SYSTEMAPP_ONLY", nAbilityInfoSystemAppOnly));
3156
3157 napi_value nAbilityInfoWithMetaData = nullptr;
3158 NAPI_CALL(env, napi_create_int32(env,
3159 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_METADATA), &nAbilityInfoWithMetaData));
3160 NAPI_CALL(env, napi_set_named_property(env, value,
3161 "GET_ABILITY_INFO_WITH_METADATA", nAbilityInfoWithMetaData));
3162
3163 napi_value nBundleWithHashValue = nullptr;
3164 NAPI_CALL(env, napi_create_int32(env,
3165 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_HASH_VALUE), &nBundleWithHashValue));
3166 NAPI_CALL(env, napi_set_named_property(env, value,
3167 "GET_BUNDLE_WITH_HASH_VALUE", nBundleWithHashValue));
3168
3169 napi_value nAbilityInfoWithDisable = nullptr;
3170 NAPI_CALL(env, napi_create_int32(env,
3171 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_DISABLE), &nAbilityInfoWithDisable));
3172 NAPI_CALL(env, napi_set_named_property(env, value,
3173 "GET_ABILITY_INFO_WITH_DISABLE", nAbilityInfoWithDisable));
3174
3175 napi_value nAppInfoWithPermission = nullptr;
3176 NAPI_CALL(env, napi_create_int32(env,
3177 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION), &nAppInfoWithPermission));
3178 NAPI_CALL(env, napi_set_named_property(env, value,
3179 "GET_APPLICATION_INFO_WITH_PERMISSION", nAppInfoWithPermission));
3180
3181 napi_value nAppInfoWithMetaData = nullptr;
3182 NAPI_CALL(env, napi_create_int32(env,
3183 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), &nAppInfoWithMetaData));
3184 NAPI_CALL(env, napi_set_named_property(env, value,
3185 "GET_APPLICATION_INFO_WITH_METADATA", nAppInfoWithMetaData));
3186
3187 napi_value nAppInfoWithDisable = nullptr;
3188 NAPI_CALL(env, napi_create_int32(env,
3189 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_DISABLE), &nAppInfoWithDisable));
3190 NAPI_CALL(env, napi_set_named_property(env, value,
3191 "GET_APPLICATION_INFO_WITH_DISABLE", nAppInfoWithDisable));
3192
3193 napi_value nAppInfoWithCertificate = nullptr;
3194 NAPI_CALL(env, napi_create_int32(env,
3195 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT),
3196 &nAppInfoWithCertificate));
3197 NAPI_CALL(env, napi_set_named_property(env, value,
3198 "GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT", nAppInfoWithCertificate));
3199
3200 return value;
3201 }
3202
3203
CreateInstallErrorCodeObject(napi_env env,napi_value value)3204 void CreateInstallErrorCodeObject(napi_env env, napi_value value)
3205 {
3206 napi_value nSuccess;
3207 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::SUCCESS), &nSuccess));
3208 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "SUCCESS", nSuccess));
3209 napi_value nStatusInstallFailure;
3210 NAPI_CALL_RETURN_VOID(env,
3211 napi_create_int32(
3212 env, static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE), &nStatusInstallFailure));
3213 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE", nStatusInstallFailure));
3214 napi_value nStatusInstallFailureAborted;
3215 NAPI_CALL_RETURN_VOID(env,
3216 napi_create_int32(env,
3217 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_ABORTED),
3218 &nStatusInstallFailureAborted));
3219 NAPI_CALL_RETURN_VOID(
3220 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_ABORTED", nStatusInstallFailureAborted));
3221 napi_value nStatusInstallFailureInvalid;
3222 NAPI_CALL_RETURN_VOID(env,
3223 napi_create_int32(env,
3224 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INVALID),
3225 &nStatusInstallFailureInvalid));
3226 NAPI_CALL_RETURN_VOID(
3227 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_INVALID", nStatusInstallFailureInvalid));
3228 napi_value nStatusInstallFailureConflict;
3229 NAPI_CALL_RETURN_VOID(env,
3230 napi_create_int32(env,
3231 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_CONFLICT),
3232 &nStatusInstallFailureConflict));
3233 NAPI_CALL_RETURN_VOID(
3234 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_CONFLICT", nStatusInstallFailureConflict));
3235 napi_value nStatusInstallFailureStorage;
3236 NAPI_CALL_RETURN_VOID(env,
3237 napi_create_int32(env,
3238 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_STORAGE),
3239 &nStatusInstallFailureStorage));
3240 NAPI_CALL_RETURN_VOID(
3241 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_STORAGE", nStatusInstallFailureStorage));
3242 napi_value nStatusInstallFailureIncompatible;
3243 NAPI_CALL_RETURN_VOID(env,
3244 napi_create_int32(env,
3245 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INCOMPATIBLE),
3246 &nStatusInstallFailureIncompatible));
3247 NAPI_CALL_RETURN_VOID(env,
3248 napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_INCOMPATIBLE", nStatusInstallFailureIncompatible));
3249 napi_value nStatusUninstallFailure;
3250 NAPI_CALL_RETURN_VOID(env,
3251 napi_create_int32(
3252 env, static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE), &nStatusUninstallFailure));
3253 NAPI_CALL_RETURN_VOID(
3254 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE", nStatusUninstallFailure));
3255 napi_value nStatusUninstallFailureBlocked;
3256 NAPI_CALL_RETURN_VOID(env,
3257 napi_create_int32(env,
3258 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_BLOCKED),
3259 &nStatusUninstallFailureBlocked));
3260 NAPI_CALL_RETURN_VOID(
3261 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE_BLOCKED", nStatusUninstallFailureBlocked));
3262 napi_value nStatusUninstallFailureAborted;
3263 NAPI_CALL_RETURN_VOID(env,
3264 napi_create_int32(env,
3265 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_ABORTED),
3266 &nStatusUninstallFailureAborted));
3267 NAPI_CALL_RETURN_VOID(
3268 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE_ABORTED", nStatusUninstallFailureAborted));
3269 napi_value nStatusUninstallFailureConflict;
3270 NAPI_CALL_RETURN_VOID(env,
3271 napi_create_int32(env,
3272 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_CONFLICT),
3273 &nStatusUninstallFailureConflict));
3274 NAPI_CALL_RETURN_VOID(
3275 env, napi_set_named_property(
3276 env, value, "STATUS_UNINSTALL_FAILURE_CONFLICT", nStatusUninstallFailureConflict));
3277 napi_value nStatusInstallFailureDownloadTimeout;
3278 NAPI_CALL_RETURN_VOID(env,
3279 napi_create_int32(env,
3280 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_DOWNLOAD_TIMEOUT),
3281 &nStatusInstallFailureDownloadTimeout));
3282 NAPI_CALL_RETURN_VOID(env,
3283 napi_set_named_property(
3284 env, value, "STATUS_INSTALL_FAILURE_DOWNLOAD_TIMEOUT", nStatusInstallFailureDownloadTimeout));
3285 napi_value nStatusInstallFailureDownloadFailed;
3286 NAPI_CALL_RETURN_VOID(env,
3287 napi_create_int32(env,
3288 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_DOWNLOAD_FAILED),
3289 &nStatusInstallFailureDownloadFailed));
3290 NAPI_CALL_RETURN_VOID(env,
3291 napi_set_named_property(
3292 env, value, "STATUS_INSTALL_FAILURE_DOWNLOAD_FAILED", nStatusInstallFailureDownloadFailed));
3293 napi_value nStatusAbilityNotFound;
3294 NAPI_CALL_RETURN_VOID(env,
3295 napi_create_int32(
3296 env, static_cast<int32_t>(InstallErrorCode::STATUS_ABILITY_NOT_FOUND), &nStatusAbilityNotFound));
3297 NAPI_CALL_RETURN_VOID(
3298 env, napi_set_named_property(env, value, "STATUS_ABILITY_NOT_FOUND", nStatusAbilityNotFound));
3299 napi_value nBmsServiceError;
3300 NAPI_CALL_RETURN_VOID(env,
3301 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR), &nBmsServiceError));
3302 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_BMS_SERVICE_ERROR", nBmsServiceError));
3303 napi_value nStatusGrantRequestPermissionsFailed;
3304 NAPI_CALL_RETURN_VOID(env,
3305 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_GRANT_REQUEST_PERMISSIONS_FAILED),
3306 &nStatusGrantRequestPermissionsFailed));
3307 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_GRANT_REQUEST_PERMISSIONS_FAILED",
3308 nStatusGrantRequestPermissionsFailed));
3309 napi_value nStatusInstallPermissionDenied;
3310 NAPI_CALL_RETURN_VOID(env,
3311 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_PERMISSION_DENIED),
3312 &nStatusInstallPermissionDenied));
3313 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_INSTALL_PERMISSION_DENIED",
3314 nStatusInstallPermissionDenied));
3315 napi_value nStatusUnInstallPermissionDenied;
3316 NAPI_CALL_RETURN_VOID(env,
3317 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_PERMISSION_DENIED),
3318 &nStatusUnInstallPermissionDenied));
3319 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_UNINSTALL_PERMISSION_DENIED",
3320 nStatusUnInstallPermissionDenied));
3321 napi_value nNoSpaceLeft;
3322 NAPI_CALL_RETURN_VOID(env,
3323 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_FAILED_NO_SPACE_LEFT), &nNoSpaceLeft));
3324 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_FAILED_NO_SPACE_LEFT", nNoSpaceLeft));
3325 napi_value nRecoverFailure;
3326 NAPI_CALL_RETURN_VOID(env,
3327 napi_create_int32(env,
3328 static_cast<int32_t>(InstallErrorCode::STATUS_RECOVER_FAILURE_INVALID), &nRecoverFailure));
3329 NAPI_CALL_RETURN_VOID(env,
3330 napi_set_named_property(env, value, "STATUS_RECOVER_FAILURE_INVALID", nRecoverFailure));
3331 }
3332
InnerGetApplicationInfo(const std::string & bundleName,int32_t flags,const int userId,ApplicationInfo & appInfo)3333 static bool InnerGetApplicationInfo(
3334 const std::string &bundleName, int32_t flags, const int userId, ApplicationInfo &appInfo)
3335 {
3336 auto iBundleMgr = GetBundleMgr();
3337 if (!iBundleMgr) {
3338 APP_LOGE("can not get iBundleMgr");
3339 return false;
3340 }
3341 return iBundleMgr->GetApplicationInfo(bundleName, flags, userId, appInfo);
3342 }
3343
InnerGetBundleInfo(napi_env env,const std::string & bundleName,int32_t flags,BundleOptions bundleOptions,BundleInfo & bundleInfo)3344 static bool InnerGetBundleInfo(
3345 napi_env env, const std::string &bundleName, int32_t flags, BundleOptions bundleOptions, BundleInfo &bundleInfo)
3346 {
3347 auto iBundleMgr = GetBundleMgr();
3348 if (iBundleMgr == nullptr) {
3349 APP_LOGE("can not get iBundleMgr");
3350 return false;
3351 }
3352 bool ret = iBundleMgr->GetBundleInfo(bundleName, flags, bundleInfo, bundleOptions.userId);
3353 if (!ret) {
3354 APP_LOGE("bundleInfo is not find, bundleName is %{public}s, flags is %{public}d, userId is %{public}d",
3355 bundleName.c_str(), flags, bundleOptions.userId);
3356 }
3357 return ret;
3358 }
3359
GetAllApplicationInfoExec(napi_env env,void * data)3360 void GetAllApplicationInfoExec(napi_env env, void *data)
3361 {
3362 APP_LOGD("NAPI begin");
3363 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
3364 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
3365 if (asyncCallbackInfo == nullptr) {
3366 APP_LOGE("asyncCallbackInfo is null");
3367 return;
3368 }
3369 if (asyncCallbackInfo->err == NO_ERROR) {
3370 asyncCallbackInfo->ret = InnerGetApplicationInfos(asyncCallbackInfo->env,
3371 asyncCallbackInfo->flags,
3372 asyncCallbackInfo->userId,
3373 asyncCallbackInfo->appInfos);
3374 }
3375 APP_LOGD("NAPI end");
3376 }
3377
GetAllApplicationInfoComplete(napi_env env,napi_status status,void * data)3378 void GetAllApplicationInfoComplete(napi_env env, napi_status status, void* data)
3379 {
3380 APP_LOGD("NAPI begin");
3381 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
3382 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
3383 if (asyncCallbackInfo == nullptr) {
3384 APP_LOGE("asyncCallbackInfo is null");
3385 return;
3386 }
3387 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
3388 napi_value result[ARGS_SIZE_TWO] = { 0 };
3389 if (asyncCallbackInfo->err != NO_ERROR) {
3390 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "");
3391 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
3392 NAPI_AUTO_LENGTH, &result[1]));
3393 } else {
3394 if (asyncCallbackInfo->ret) {
3395 result[0] = BusinessError::CreateError(env, 0, "");
3396 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
3397 ProcessApplicationInfos(env, result[1], asyncCallbackInfo->appInfos);
3398 } else {
3399 result[0] = BusinessError::CreateError(env, 1, "");
3400 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3401 }
3402 }
3403 if (asyncCallbackInfo->deferred) {
3404 if (asyncCallbackInfo->ret != NO_ERROR) {
3405 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
3406 } else {
3407 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
3408 }
3409 } else {
3410 napi_value callback = nullptr;
3411 napi_value placeHolder = nullptr;
3412 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
3413 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
3414 sizeof(result) / sizeof(result[0]), result, &placeHolder));
3415 }
3416 APP_LOGD("NAPI end");
3417 }
3418
GetAllApplicationInfo(napi_env env,napi_callback_info info)3419 napi_value GetAllApplicationInfo(napi_env env, napi_callback_info info)
3420 {
3421 APP_LOGD("NAPI begin");
3422 size_t argc = ARGS_SIZE_THREE;
3423 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
3424 napi_value thisArg = nullptr;
3425 void *data = nullptr;
3426 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
3427 APP_LOGI("argc = [%{public}zu]", argc);
3428 AsyncApplicationInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncApplicationInfosCallbackInfo(env);
3429 if (asyncCallbackInfo == nullptr) {
3430 APP_LOGE("asyncCallbackInfo is null");
3431 return nullptr;
3432 }
3433 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
3434 for (size_t i = 0; i < argc; ++i) {
3435 napi_valuetype valueType = napi_undefined;
3436 napi_typeof(env, argv[i], &valueType);
3437 if ((i == 0) && (valueType == napi_number)) {
3438 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
3439 if (argc == ARGS_SIZE_ONE) {
3440 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3441 }
3442 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_number)) {
3443 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
3444 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_function)) {
3445 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3446 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3447 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_function)) {
3448 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3449 break;
3450 } else {
3451 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3452 asyncCallbackInfo->message = TYPE_MISMATCH;
3453 }
3454 }
3455
3456 if (argc == 0) {
3457 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3458 asyncCallbackInfo->message = TYPE_MISMATCH;
3459 }
3460 napi_value promise = nullptr;
3461 if (asyncCallbackInfo->callback == nullptr) {
3462 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
3463 } else {
3464 NAPI_CALL(env, napi_get_undefined(env, &promise));
3465 }
3466
3467 napi_value resource = nullptr;
3468 NAPI_CALL(env, napi_create_string_utf8(env, NAPI_GET_APPLICATION_INFO, NAPI_AUTO_LENGTH, &resource));
3469 NAPI_CALL(env, napi_create_async_work(
3470 env, nullptr, resource, GetAllApplicationInfoExec, GetAllApplicationInfoComplete,
3471 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
3472 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3473 callbackPtr.release();
3474 APP_LOGD("NAPI end");
3475 return promise;
3476 }
3477
GetApplicationInfoExec(napi_env env,void * data)3478 void GetApplicationInfoExec(napi_env env, void *data)
3479 {
3480 APP_LOGD("NAPI begin");
3481 AsyncApplicationInfoCallbackInfo* asyncCallbackInfo =
3482 reinterpret_cast<AsyncApplicationInfoCallbackInfo*>(data);
3483 if (asyncCallbackInfo == nullptr) {
3484 APP_LOGE("asyncCallbackInfo is null");
3485 return;
3486 }
3487 if (asyncCallbackInfo->err == NO_ERROR) {
3488 asyncCallbackInfo->ret = InnerGetApplicationInfo(asyncCallbackInfo->bundleName,
3489 asyncCallbackInfo->flags,
3490 asyncCallbackInfo->userId,
3491 asyncCallbackInfo->appInfo);
3492 }
3493 APP_LOGD("NAPI end");
3494 }
3495
GetApplicationInfoComplete(napi_env env,napi_status status,void * data)3496 void GetApplicationInfoComplete(napi_env env, napi_status status, void *data)
3497 {
3498 APP_LOGD("NAPI begin");
3499 AsyncApplicationInfoCallbackInfo* asyncCallbackInfo =
3500 reinterpret_cast<AsyncApplicationInfoCallbackInfo*>(data);
3501 if (asyncCallbackInfo == nullptr) {
3502 APP_LOGE("asyncCallbackInfo is null");
3503 return;
3504 }
3505 std::unique_ptr<AsyncApplicationInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3506 napi_value result[ARGS_SIZE_TWO] = { 0 };
3507 if (asyncCallbackInfo->err != NO_ERROR) {
3508 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "");
3509 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
3510 NAPI_AUTO_LENGTH, &result[1]));
3511 } else {
3512 if (asyncCallbackInfo->ret) {
3513 result[0] = BusinessError::CreateError(env, 0, "");
3514 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
3515 ConvertApplicationInfo(env, result[1], asyncCallbackInfo->appInfo);
3516 } else {
3517 result[0] = BusinessError::CreateError(env, 1, "");
3518 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3519 }
3520 }
3521 if (asyncCallbackInfo->deferred) {
3522 if (asyncCallbackInfo->ret) {
3523 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
3524 } else {
3525 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
3526 }
3527 } else {
3528 napi_value callback = nullptr;
3529 napi_value placeHolder = nullptr;
3530 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
3531 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
3532 sizeof(result) / sizeof(result[0]), result, &placeHolder));
3533 }
3534 APP_LOGD("NAPI end");
3535 }
3536
GetApplicationInfo(napi_env env,napi_callback_info info)3537 napi_value GetApplicationInfo(napi_env env, napi_callback_info info)
3538 {
3539 APP_LOGD("NAPI begin");
3540 size_t argc = ARGS_SIZE_FOUR;
3541 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
3542 napi_value thisArg = nullptr;
3543 void *data = nullptr;
3544 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
3545 APP_LOGD("argc = [%{public}zu]", argc);
3546 AsyncApplicationInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncApplicationInfoCallbackInfo(env);
3547 if (asyncCallbackInfo == nullptr) {
3548 APP_LOGE("asyncCallbackInfo is nullptr");
3549 return nullptr;
3550 }
3551 std::unique_ptr<AsyncApplicationInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3552 for (size_t i = 0; i < argc; ++i) {
3553 napi_valuetype valueType = napi_undefined;
3554 napi_typeof(env, argv[i], &valueType);
3555 if ((i == 0) && (valueType == napi_string)) {
3556 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
3557 } else if ((i == ARGS_SIZE_ONE) && valueType == napi_number) {
3558 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
3559 if (argc == ARGS_SIZE_TWO) {
3560 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3561 }
3562 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_number)) {
3563 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
3564 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_function)) {
3565 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3566 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3567 } else if ((i == ARGS_SIZE_THREE) && (valueType == napi_function)) {
3568 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3569 break;
3570 } else {
3571 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3572 asyncCallbackInfo->message = TYPE_MISMATCH;
3573 }
3574 }
3575 if (argc == 0) {
3576 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3577 asyncCallbackInfo->message = TYPE_MISMATCH;
3578 }
3579 napi_value promise = nullptr;
3580 if (asyncCallbackInfo->callback == nullptr) {
3581 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
3582 } else {
3583 NAPI_CALL(env, napi_get_undefined(env, &promise));
3584 }
3585 napi_value resource = nullptr;
3586 NAPI_CALL(env, napi_create_string_utf8(env, NAPI_GET_APPLICATION_INFO, NAPI_AUTO_LENGTH, &resource));
3587 NAPI_CALL(env, napi_create_async_work(
3588 env, nullptr, resource, GetApplicationInfoExec, GetApplicationInfoComplete,
3589 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
3590 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3591 callbackPtr.release();
3592 APP_LOGD("NAPI end");
3593 return promise;
3594 }
3595
3596 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
GetAbilityIconExec(napi_env env,void * data)3597 void GetAbilityIconExec(napi_env env, void *data)
3598 {
3599 APP_LOGD("NAPI begin");
3600 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3601 if (asyncCallbackInfo == nullptr) {
3602 APP_LOGE("asyncCallbackInfo is null");
3603 return;
3604 }
3605 if (asyncCallbackInfo->err != NO_ERROR) {
3606 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3607 return;
3608 }
3609 BundleGraphicsClient client;
3610 asyncCallbackInfo->ret = client.GetAbilityPixelMapIcon(asyncCallbackInfo->bundleName,
3611 asyncCallbackInfo->moduleName, asyncCallbackInfo->abilityName, asyncCallbackInfo->pixelMap);
3612 APP_LOGD("NAPI end");
3613 }
3614
GetAbilityIconComplete(napi_env env,napi_status status,void * data)3615 void GetAbilityIconComplete(napi_env env, napi_status status, void *data)
3616 {
3617 APP_LOGD("NAPI begin");
3618 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3619 if (asyncCallbackInfo == nullptr) {
3620 APP_LOGE("asyncCallbackInfo is null");
3621 return;
3622 }
3623 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3624 napi_value result[ARGS_SIZE_TWO] = {0};
3625 if (asyncCallbackInfo->err != NO_ERROR) {
3626 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3627 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[0]));
3628 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3629 } else if (asyncCallbackInfo->ret != ERR_OK) {
3630 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3631 asyncCallbackInfo->err = OPERATION_FAILED;
3632 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
3633 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3634 } else {
3635 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NO_ERROR, &result[0]));
3636 result[1] = Media::PixelMapNapi::CreatePixelMap(env, asyncCallbackInfo->pixelMap);
3637 }
3638 CommonFunc::NapiReturnDeferred<AbilityIconCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3639 APP_LOGD("NAPI end");
3640 }
3641
GetAbilityIcon(napi_env env,napi_callback_info info)3642 napi_value GetAbilityIcon(napi_env env, napi_callback_info info)
3643 {
3644 APP_LOGD("NAPI begin");
3645 AbilityIconCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityIconCallbackInfo(env);
3646 if (asyncCallbackInfo == nullptr) {
3647 APP_LOGE("asyncCallbackInfo is null");
3648 return nullptr;
3649 }
3650 asyncCallbackInfo->err = NO_ERROR;
3651 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3652 NapiArg args(env, info);
3653 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_FOUR)) {
3654 APP_LOGE("parameters init failed");
3655 napi_value ret = nullptr;
3656 NAPI_CALL(env, napi_get_undefined(env, &ret));
3657 return ret;
3658 }
3659 asyncCallbackInfo->hasModuleName = false;
3660 napi_valuetype valueType = napi_undefined;
3661 napi_typeof(env, args[args.GetMaxArgc() - 1], &valueType);
3662 if (valueType == napi_function) {
3663 asyncCallbackInfo->hasModuleName = (args.GetMaxArgc() == ARGS_SIZE_FOUR) ? true : false;
3664 } else {
3665 asyncCallbackInfo->hasModuleName = (args.GetMaxArgc() == ARGS_SIZE_THREE) ? true : false;
3666 }
3667 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
3668 APP_LOGE("BundleName parse failed");
3669 asyncCallbackInfo->err = INVALID_PARAM;
3670 }
3671 if (asyncCallbackInfo->hasModuleName) {
3672 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->moduleName)) {
3673 APP_LOGE("ModuleName parse failed");
3674 asyncCallbackInfo->err = INVALID_PARAM;
3675 }
3676 } else {
3677 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->abilityName)) {
3678 APP_LOGE("AbilityName parse failed");
3679 asyncCallbackInfo->err = INVALID_PARAM;
3680 }
3681 }
3682 if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
3683 valueType = napi_undefined;
3684 napi_typeof(env, args[ARGS_POS_TWO], &valueType);
3685 if (valueType != napi_function) {
3686 if (!CommonFunc::ParseString(env, args[ARGS_POS_TWO], asyncCallbackInfo->abilityName)) {
3687 APP_LOGE("AbilityName parse failed");
3688 asyncCallbackInfo->err = INVALID_PARAM;
3689 }
3690 } else {
3691 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_TWO],
3692 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3693 }
3694 }
3695 if (args.GetMaxArgc() >= ARGS_SIZE_FOUR) {
3696 valueType = napi_undefined;
3697 napi_typeof(env, args[ARGS_POS_THREE], &valueType);
3698 if (valueType == napi_function) {
3699 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_THREE],
3700 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3701 }
3702 }
3703
3704 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityIconCallbackInfo>(
3705 env, asyncCallbackInfo, GET_ABILITY_ICON, GetAbilityIconExec, GetAbilityIconComplete);
3706 callbackPtr.release();
3707 APP_LOGD("NAPI end");
3708 return promise;
3709 }
3710 #else
GetAbilityIconComplete(napi_env env,napi_status status,void * data)3711 void GetAbilityIconComplete(napi_env env, napi_status status, void *data)
3712 {
3713 APP_LOGD("NAPI begin");
3714 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3715 if (asyncCallbackInfo == nullptr) {
3716 APP_LOGE("asyncCallbackInfo is null");
3717 return;
3718 }
3719 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3720 APP_LOGE("unsupported BundleManagerService feature");
3721 asyncCallbackInfo->err = UNSUPPORTED_FEATURE_ERRCODE;
3722 napi_value result[ARGS_SIZE_TWO] = {0};
3723 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, UNSUPPORTED_FEATURE_ERRCODE, &result[0]));
3724 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
3725 UNSUPPORTED_FEATURE_MESSAGE.c_str(), NAPI_AUTO_LENGTH, &result[1]));
3726 CommonFunc::NapiReturnDeferred<AbilityIconCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3727 APP_LOGD("NAPI end");
3728 }
3729
GetAbilityIcon(napi_env env,napi_callback_info info)3730 napi_value GetAbilityIcon(napi_env env, napi_callback_info info)
3731 {
3732 APP_LOGD("NAPI begin");
3733 AbilityIconCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityIconCallbackInfo(env);
3734 if (asyncCallbackInfo == nullptr) {
3735 APP_LOGE("asyncCallbackInfo is null");
3736 return nullptr;
3737 }
3738 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3739
3740 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityIconCallbackInfo>(
3741 env, asyncCallbackInfo, GET_BUNDLE_ARCHIVE_INFO, nullptr, GetAbilityIconComplete);
3742 callbackPtr.release();
3743 APP_LOGD("NAPI end");
3744 return promise;
3745 }
3746 #endif
3747
GetBundleArchiveInfoExec(napi_env env,void * data)3748 void GetBundleArchiveInfoExec(napi_env env, void *data)
3749 {
3750 APP_LOGD("NAPI begin");
3751 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetBundleArchiveInfoCallbackInfo *>(data);
3752 if (asyncCallbackInfo == nullptr) {
3753 APP_LOGE("asyncCallbackInfo is null");
3754 return;
3755 }
3756 if (asyncCallbackInfo->err != NO_ERROR) {
3757 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3758 return;
3759 }
3760 auto iBundleMgr = CommonFunc::GetBundleMgr();
3761 if (iBundleMgr == nullptr) {
3762 APP_LOGE("iBundleMgr is null");
3763 return;
3764 }
3765 APP_LOGD("start GetBundleArchiveInfo, hapFilePath %{public}s", asyncCallbackInfo->hapFilePath.c_str());
3766 asyncCallbackInfo->ret = iBundleMgr->GetBundleArchiveInfo(
3767 asyncCallbackInfo->hapFilePath, asyncCallbackInfo->flags, asyncCallbackInfo->bundleInfo);
3768 APP_LOGD("NAPI end");
3769 }
3770
GetBundleArchiveInfoComplete(napi_env env,napi_status status,void * data)3771 void GetBundleArchiveInfoComplete(napi_env env, napi_status status, void *data)
3772 {
3773 APP_LOGD("NAPI begin");
3774 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetBundleArchiveInfoCallbackInfo *>(data);
3775 if (asyncCallbackInfo == nullptr) {
3776 APP_LOGE("asyncCallbackInfo is null");
3777 return;
3778 }
3779 std::unique_ptr<GetBundleArchiveInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3780 napi_value result[ARGS_SIZE_TWO] = {0};
3781 if (asyncCallbackInfo->err != NO_ERROR) {
3782 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3783 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "type mismatch");
3784 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3785 } else if (!asyncCallbackInfo->ret) {
3786 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3787 asyncCallbackInfo->err = OPERATION_FAILED;
3788 result[0] = BusinessError::CreateError(env, OPERATION_FAILED, "GetBundleArchiveInfo falied");
3789 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3790 } else {
3791 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3792 napi_create_object(env, &result[1]);
3793 ConvertBundleInfo(env, result[1], asyncCallbackInfo->bundleInfo);
3794 }
3795 CommonFunc::NapiReturnDeferred<GetBundleArchiveInfoCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3796 APP_LOGD("NAPI end");
3797 }
3798
GetBundleArchiveInfo(napi_env env,napi_callback_info info)3799 napi_value GetBundleArchiveInfo(napi_env env, napi_callback_info info)
3800 {
3801 APP_LOGD("NAPI begin");
3802 NapiArg args(env, info);
3803 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) GetBundleArchiveInfoCallbackInfo(env);
3804 if (asyncCallbackInfo == nullptr) {
3805 APP_LOGE("asyncCallbackInfo is null");
3806 return nullptr;
3807 }
3808 std::unique_ptr<GetBundleArchiveInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3809 asyncCallbackInfo->err = NO_ERROR;
3810 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
3811 APP_LOGE("parameters init failed");
3812 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3813 }
3814 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
3815 napi_valuetype valueType = napi_undefined;
3816 napi_typeof(env, args[i], &valueType);
3817 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
3818 if (!CommonFunc::ParseString(env, args[i], asyncCallbackInfo->hapFilePath)) {
3819 APP_LOGE("hapFilePath %{public}s invalid", asyncCallbackInfo->hapFilePath.c_str());
3820 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3821 }
3822 } else if ((i == ARGS_POS_ONE) && (valueType == napi_number)) {
3823 if (!CommonFunc::ParseInt(env, args[i], asyncCallbackInfo->flags)) {
3824 APP_LOGE("flags %{public}d invalid", asyncCallbackInfo->flags);
3825 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3826 }
3827 } else if (i == ARGS_POS_TWO) {
3828 if (valueType == napi_function) {
3829 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3830 }
3831 break;
3832 } else {
3833 APP_LOGE("parameters number error");
3834 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3835 }
3836 }
3837 auto promise = CommonFunc::AsyncCallNativeMethod<GetBundleArchiveInfoCallbackInfo>(
3838 env, asyncCallbackInfo, GET_BUNDLE_ARCHIVE_INFO, GetBundleArchiveInfoExec, GetBundleArchiveInfoComplete);
3839 callbackPtr.release();
3840 APP_LOGD("NAPI end");
3841 return promise;
3842 }
3843
GetLaunchWantForBundleExec(napi_env env,void * data)3844 void GetLaunchWantForBundleExec(napi_env env, void *data)
3845 {
3846 APP_LOGD("NAPI begin");
3847 LaunchWantCallbackInfo* asyncCallbackInfo = reinterpret_cast<LaunchWantCallbackInfo*>(data);
3848 if (asyncCallbackInfo == nullptr) {
3849 APP_LOGE("asyncCallbackInfo is null");
3850 return;
3851 }
3852 if (asyncCallbackInfo->err != NO_ERROR) {
3853 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3854 return;
3855 }
3856 auto iBundleMgr = CommonFunc::GetBundleMgr();
3857 if (iBundleMgr == nullptr) {
3858 APP_LOGE("iBundleMgr is null");
3859 return;
3860 }
3861 APP_LOGD("start GetLaunchWantForBundle, bundleName %{public}s", asyncCallbackInfo->bundleName.c_str());
3862 asyncCallbackInfo->ret = iBundleMgr->GetLaunchWantForBundle(
3863 asyncCallbackInfo->bundleName, asyncCallbackInfo->want, asyncCallbackInfo->userId);
3864 APP_LOGD("NAPI end");
3865 }
3866
GetLaunchWantForBundleComplete(napi_env env,napi_status status,void * data)3867 void GetLaunchWantForBundleComplete(napi_env env, napi_status status, void *data)
3868 {
3869 APP_LOGD("NAPI begin");
3870 LaunchWantCallbackInfo *asyncCallbackInfo = reinterpret_cast<LaunchWantCallbackInfo *>(data);
3871 if (asyncCallbackInfo == nullptr) {
3872 APP_LOGE("asyncCallbackInfo is null");
3873 return;
3874 }
3875 std::unique_ptr<LaunchWantCallbackInfo> callbackPtr {asyncCallbackInfo};
3876 napi_value result[ARGS_SIZE_TWO] = {0};
3877 if (asyncCallbackInfo->err != NO_ERROR) {
3878 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3879 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
3880 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3881 } else if (asyncCallbackInfo->ret != ERR_OK) {
3882 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3883 asyncCallbackInfo->err = OPERATION_FAILED;
3884 result[0] = BusinessError::CreateError(env, OPERATION_FAILED, "GetLaunchWantForBundle falied");
3885 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3886 } else {
3887 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3888 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
3889 CommonFunc::ConvertWantInfo(env, result[1], asyncCallbackInfo->want);
3890 }
3891 CommonFunc::NapiReturnDeferred<LaunchWantCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3892 APP_LOGD("NAPI end");
3893 }
3894
GetLaunchWantForBundle(napi_env env,napi_callback_info info)3895 napi_value GetLaunchWantForBundle(napi_env env, napi_callback_info info)
3896 {
3897 APP_LOGD("NAPI begin");
3898 LaunchWantCallbackInfo *asyncCallbackInfo = new (std::nothrow) LaunchWantCallbackInfo(env);
3899 if (asyncCallbackInfo == nullptr) {
3900 APP_LOGE("asyncCallbackInfo is null");
3901 return nullptr;
3902 }
3903 std::unique_ptr<LaunchWantCallbackInfo> callbackPtr {asyncCallbackInfo};
3904 asyncCallbackInfo->err = NO_ERROR;
3905 NapiArg args(env, info);
3906 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
3907 APP_LOGE("parameters init failed");
3908 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3909 auto promise = CommonFunc::AsyncCallNativeMethod<LaunchWantCallbackInfo>(env,
3910 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, GetLaunchWantForBundleExec, GetLaunchWantForBundleComplete);
3911 callbackPtr.release();
3912 return promise;
3913 }
3914 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
3915 APP_LOGE("BundleName parse failed");
3916 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3917 }
3918 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
3919 napi_valuetype valueType = napi_undefined;
3920 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
3921 if (valueType == napi_function) {
3922 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
3923 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3924 }
3925 }
3926
3927 auto promise = CommonFunc::AsyncCallNativeMethod<LaunchWantCallbackInfo>(
3928 env, asyncCallbackInfo, GET_LAUNCH_WANT_FOR_BUNDLE, GetLaunchWantForBundleExec, GetLaunchWantForBundleComplete);
3929 callbackPtr.release();
3930 APP_LOGD("NAPI end");
3931 return promise;
3932 }
3933
IsAbilityEnabledExec(napi_env env,void * data)3934 void IsAbilityEnabledExec(napi_env env, void *data)
3935 {
3936 APP_LOGD("NAPI begin");
3937 AbilityEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityEnableCallbackInfo *>(data);
3938 if (asyncCallbackInfo == nullptr) {
3939 APP_LOGE("asyncCallbackInfo is null");
3940 return;
3941 }
3942 if (asyncCallbackInfo->err != NO_ERROR) {
3943 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3944 return;
3945 }
3946 auto bundleMgr = CommonFunc::GetBundleMgr();
3947 if (bundleMgr == nullptr) {
3948 APP_LOGE("CommonFunc::GetBundleMgr failed");
3949 return;
3950 }
3951 bundleMgr->IsAbilityEnabled(asyncCallbackInfo->abilityInfo, asyncCallbackInfo->isEnable);
3952 APP_LOGD("NAPI end");
3953 }
3954
IsAbilityEnabledComplete(napi_env env,napi_status status,void * data)3955 void IsAbilityEnabledComplete(napi_env env, napi_status status, void *data)
3956 {
3957 APP_LOGD("NAPI begin");
3958 AbilityEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityEnableCallbackInfo *>(data);
3959 if (asyncCallbackInfo == nullptr) {
3960 APP_LOGE("asyncCallbackInfo is null");
3961 return;
3962 }
3963 std::unique_ptr<AbilityEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
3964 napi_value result[ARGS_SIZE_TWO] = {0};
3965 if (asyncCallbackInfo->err != NO_ERROR) {
3966 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3967 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
3968 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3969 } else {
3970 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3971 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->isEnable, &result[1]));
3972 }
3973 CommonFunc::NapiReturnDeferred<AbilityEnableCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3974 APP_LOGD("NAPI end");
3975 }
3976
IsAbilityEnabled(napi_env env,napi_callback_info info)3977 napi_value IsAbilityEnabled(napi_env env, napi_callback_info info)
3978 {
3979 APP_LOGD("NAPI begin");
3980 AbilityEnableCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityEnableCallbackInfo(env);
3981 if (asyncCallbackInfo == nullptr) {
3982 APP_LOGE("asyncCallbackInfo is null");
3983 return nullptr;
3984 }
3985 std::unique_ptr<AbilityEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
3986 asyncCallbackInfo->err = NO_ERROR;
3987 NapiArg args(env, info);
3988 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
3989 APP_LOGE("parameters init failed");
3990 asyncCallbackInfo->err = INVALID_PARAM;
3991 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityEnableCallbackInfo>(env,
3992 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsAbilityEnabledExec, IsAbilityEnabledComplete);
3993 callbackPtr.release();
3994 return promise;
3995 }
3996 if (!CommonFunc::ParseAbilityInfo(env, args[ARGS_POS_ZERO], asyncCallbackInfo->abilityInfo)) {
3997 APP_LOGE("AbilityInfo parse failed");
3998 asyncCallbackInfo->err = INVALID_PARAM;
3999 }
4000 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
4001 napi_valuetype valueType = napi_undefined;
4002 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
4003 if (valueType == napi_function) {
4004 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
4005 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4006 }
4007 }
4008
4009 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityEnableCallbackInfo>(
4010 env, asyncCallbackInfo, IS_ABILITY_ENABLED, IsAbilityEnabledExec, IsAbilityEnabledComplete);
4011 callbackPtr.release();
4012 APP_LOGD("NAPI end");
4013 return promise;
4014 }
4015
IsApplicationEnabledExec(napi_env env,void * data)4016 void IsApplicationEnabledExec(napi_env env, void *data)
4017 {
4018 APP_LOGD("NAPI begin");
4019 ApplicationEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<ApplicationEnableCallbackInfo *>(data);
4020 if (asyncCallbackInfo == nullptr) {
4021 APP_LOGE("asyncCallbackInfo is null");
4022 return;
4023 }
4024 if (asyncCallbackInfo->err != NO_ERROR) {
4025 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
4026 return;
4027 }
4028 auto bundleMgr = CommonFunc::GetBundleMgr();
4029 if (bundleMgr == nullptr) {
4030 APP_LOGE("CommonFunc::GetBundleMgr failed");
4031 return;
4032 }
4033 bundleMgr->IsApplicationEnabled(asyncCallbackInfo->bundleName, asyncCallbackInfo->isEnable);
4034 APP_LOGD("NAPI end");
4035 }
4036
IsApplicationEnabledComplete(napi_env env,napi_status status,void * data)4037 void IsApplicationEnabledComplete(napi_env env, napi_status status, void *data)
4038 {
4039 APP_LOGD("NAPI begin");
4040 ApplicationEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<ApplicationEnableCallbackInfo *>(data);
4041 if (asyncCallbackInfo == nullptr) {
4042 APP_LOGE("asyncCallbackInfo is null");
4043 return;
4044 }
4045 std::unique_ptr<ApplicationEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
4046 napi_value result[ARGS_SIZE_TWO] = {0};
4047 if (asyncCallbackInfo->err != NO_ERROR) {
4048 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
4049 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
4050 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4051 } else {
4052 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
4053 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->isEnable, &result[1]));
4054 }
4055 CommonFunc::NapiReturnDeferred<ApplicationEnableCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
4056 APP_LOGD("NAPI end");
4057 }
4058
IsApplicationEnabled(napi_env env,napi_callback_info info)4059 napi_value IsApplicationEnabled(napi_env env, napi_callback_info info)
4060 {
4061 APP_LOGD("NAPI begin");
4062 ApplicationEnableCallbackInfo *asyncCallbackInfo = new (std::nothrow) ApplicationEnableCallbackInfo(env);
4063 if (asyncCallbackInfo == nullptr) {
4064 APP_LOGE("asyncCallbackInfo is null");
4065 return nullptr;
4066 }
4067 std::unique_ptr<ApplicationEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
4068 asyncCallbackInfo->err = NO_ERROR;
4069 NapiArg args(env, info);
4070 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
4071 APP_LOGE("parameters init failed");
4072 asyncCallbackInfo->err = INVALID_PARAM;
4073 auto promise = CommonFunc::AsyncCallNativeMethod<ApplicationEnableCallbackInfo>(env,
4074 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsApplicationEnabledExec, IsApplicationEnabledComplete);
4075 callbackPtr.release();
4076 return promise;
4077 }
4078 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
4079 APP_LOGE("BundleName parse failed");
4080 asyncCallbackInfo->err = INVALID_PARAM;
4081 }
4082 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
4083 napi_valuetype valueType = napi_undefined;
4084 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
4085 if (valueType == napi_function) {
4086 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
4087 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4088 }
4089 }
4090
4091 auto promise = CommonFunc::AsyncCallNativeMethod<ApplicationEnableCallbackInfo>(env,
4092 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsApplicationEnabledExec, IsApplicationEnabledComplete);
4093 callbackPtr.release();
4094 APP_LOGD("NAPI end");
4095 return promise;
4096 }
4097
GetBundleInfoExec(napi_env env,void * data)4098 void GetBundleInfoExec(napi_env env, void *data)
4099 {
4100 AsyncBundleInfoCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfoCallbackInfo*>(data);
4101 if (asyncCallbackInfo == nullptr) {
4102 APP_LOGE("asyncCallbackInfo is nullptr");
4103 return;
4104 }
4105 if (asyncCallbackInfo->err == 0) {
4106 asyncCallbackInfo->ret = InnerGetBundleInfo(asyncCallbackInfo->env, asyncCallbackInfo->param,
4107 asyncCallbackInfo->flags, asyncCallbackInfo->bundleOptions, asyncCallbackInfo->bundleInfo);
4108 }
4109 }
4110
GetBundleInfoForSelfExec(napi_env env,napi_status status,void * data)4111 void GetBundleInfoForSelfExec(napi_env env, napi_status status, void* data)
4112 {
4113 AsyncBundleInfoCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfoCallbackInfo*>(data);
4114 std::unique_ptr<AsyncBundleInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
4115 if (asyncCallbackInfo == nullptr) {
4116 APP_LOGE("asyncCallbackInfo is nullptr");
4117 return;
4118 }
4119 napi_value result[2] = { 0 };
4120 if (asyncCallbackInfo->err != 0) {
4121 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
4122 &result[0]));
4123 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
4124 NAPI_AUTO_LENGTH, &result[1]));
4125 } else {
4126 if (asyncCallbackInfo->ret) {
4127 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
4128 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
4129 ConvertBundleInfo(env, result[1], asyncCallbackInfo->bundleInfo);
4130 } else {
4131 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[0]));
4132 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4133 }
4134 }
4135 if (asyncCallbackInfo->deferred) {
4136 if (asyncCallbackInfo->ret) {
4137 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4138 } else {
4139 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4140 }
4141 } else {
4142 napi_value callback = nullptr;
4143 napi_value placeHolder = nullptr;
4144 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4145 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4146 sizeof(result) / sizeof(result[0]), result, &placeHolder));
4147 }
4148 }
4149
GetBundleInfo(napi_env env,napi_callback_info info)4150 napi_value GetBundleInfo(napi_env env, napi_callback_info info)
4151 {
4152 size_t argc = ARGS_SIZE_FOUR;
4153 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
4154 napi_value thisArg = nullptr;
4155 void *data = nullptr;
4156 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4157 APP_LOGD("argc = [%{public}zu]", argc);
4158 AsyncBundleInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncBundleInfoCallbackInfo(env);
4159 if (asyncCallbackInfo == nullptr) {
4160 APP_LOGE("asyncCallbackInfo is nullptr");
4161 return nullptr;
4162 }
4163 std::unique_ptr<AsyncBundleInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
4164 for (size_t i = 0; i < argc; ++i) {
4165 napi_valuetype valueType = napi_undefined;
4166 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4167 if ((i == PARAM0) && (valueType == napi_string)) {
4168 ParseString(env, asyncCallbackInfo->param, argv[i]);
4169 } else if ((i == PARAM1) && valueType == napi_number) {
4170 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
4171 } else if ((i == PARAM2) && (valueType == napi_function)) {
4172 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4173 break;
4174 } else if ((i == PARAM2) && (valueType == napi_object)) {
4175 bool ret = ParseBundleOptions(env, asyncCallbackInfo->bundleOptions, argv[i]);
4176 if (!ret) {
4177 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
4178 }
4179 } else if ((i == PARAM3) && (valueType == napi_function)) {
4180 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4181 break;
4182 } else {
4183 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
4184 asyncCallbackInfo->message = TYPE_MISMATCH;
4185 }
4186 }
4187
4188 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncBundleInfoCallbackInfo>(
4189 env, asyncCallbackInfo, GET_BUNDLE_INFO, GetBundleInfoExec, GetBundleInfoForSelfExec);
4190 callbackPtr.release();
4191 return promise;
4192 }
4193
GetBundleNameByUidExec(napi_env env,void * data)4194 void GetBundleNameByUidExec(napi_env env, void *data)
4195 {
4196 AsyncGetNameByUidInfo* asyncCallbackInfo =
4197 reinterpret_cast<AsyncGetNameByUidInfo*>(data);
4198 if (asyncCallbackInfo == nullptr) {
4199 APP_LOGE("asyncCallbackInfo is nullptr");
4200 return;
4201 }
4202 if (asyncCallbackInfo->err == 0) {
4203 asyncCallbackInfo->ret = InnerGetNameForUid(asyncCallbackInfo->uid, asyncCallbackInfo->bundleName);
4204 }
4205 }
4206
GetBundleNameByUidComplete(napi_env env,napi_status status,void * data)4207 void GetBundleNameByUidComplete(napi_env env, napi_status status, void *data)
4208 {
4209 AsyncGetNameByUidInfo* asyncCallbackInfo =
4210 reinterpret_cast<AsyncGetNameByUidInfo*>(data);
4211 std::unique_ptr<AsyncGetNameByUidInfo> callbackPtr {asyncCallbackInfo};
4212 if (asyncCallbackInfo == nullptr) {
4213 APP_LOGE("asyncCallbackInfo is nullptr");
4214 return;
4215 }
4216 napi_value result[ARGS_SIZE_TWO] = { 0 };
4217 // set error code
4218 if (asyncCallbackInfo->err) {
4219 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[PARAM0]));
4220 } else {
4221 if (!asyncCallbackInfo->ret) {
4222 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[PARAM0]));
4223 } else {
4224 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, CODE_SUCCESS, &result[PARAM0]));
4225 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->bundleName.c_str(),
4226 NAPI_AUTO_LENGTH, &result[PARAM1]));
4227 }
4228 }
4229 // implement callback or promise
4230 if (asyncCallbackInfo->deferred) {
4231 if (!asyncCallbackInfo->ret) {
4232 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[PARAM0]));
4233 } else {
4234 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[PARAM1]));
4235 }
4236 } else {
4237 napi_value callback = nullptr;
4238 napi_value placeHolder = nullptr;
4239 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4240 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4241 sizeof(result) / sizeof(result[PARAM0]), result, &placeHolder));
4242 }
4243 }
4244
GetNameForUid(napi_env env,napi_callback_info info)4245 napi_value GetNameForUid(napi_env env, napi_callback_info info)
4246 {
4247 size_t requireArgc = ARGS_SIZE_ONE;
4248 size_t argc = ARGS_SIZE_TWO;
4249 napi_value argv[ARGS_SIZE_TWO] = { 0 };
4250 napi_value thisArg = nullptr;
4251 void *data = nullptr;
4252 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4253 NAPI_CALL(env, (argc >= requireArgc) ? napi_ok : napi_invalid_arg);
4254 AsyncGetNameByUidInfo *asyncCallbackInfo = new (std::nothrow) AsyncGetNameByUidInfo(env);
4255 if (asyncCallbackInfo == nullptr) {
4256 APP_LOGE("asyncCallbackInfo is nullptr");
4257 return nullptr;
4258 }
4259 std::unique_ptr<AsyncGetNameByUidInfo> callbackPtr {asyncCallbackInfo};
4260
4261 for (size_t i = 0; i < argc; ++i) {
4262 napi_valuetype valueType = napi_undefined;
4263 napi_typeof(env, argv[i], &valueType);
4264 if ((i == 0) && (valueType == napi_number)) {
4265 ParseInt(env, asyncCallbackInfo->uid, argv[i]);
4266 } else if ((i == 1) && (valueType == napi_function)) {
4267 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4268 } else {
4269 asyncCallbackInfo->err = INVALID_PARAM;
4270 }
4271 }
4272
4273 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncGetNameByUidInfo>(
4274 env, asyncCallbackInfo, "GetNameForUid", GetBundleNameByUidExec, GetBundleNameByUidComplete);
4275 callbackPtr.release();
4276 APP_LOGD("call GetBundleNameByUid done");
4277 return promise;
4278 }
4279
InnerGetAbilityInfo(const std::string & bundleName,const std::string & moduleName,const std::string & abilityName,AbilityInfo & abilityInfo,bool hasModuleName)4280 static bool InnerGetAbilityInfo(const std::string &bundleName, const std::string &moduleName,
4281 const std::string &abilityName, AbilityInfo &abilityInfo, bool hasModuleName)
4282 {
4283 auto iBundleMgr = GetBundleMgr();
4284 if (iBundleMgr == nullptr) {
4285 APP_LOGE("can not get iBundleMgr");
4286 return false;
4287 }
4288 if (hasModuleName) {
4289 return iBundleMgr->GetAbilityInfo(bundleName, moduleName, abilityName, abilityInfo);
4290 }
4291 return iBundleMgr->GetAbilityInfo(bundleName, abilityName, abilityInfo);
4292 }
4293
StartGetAbilityInfoExecuteCB(napi_env env,void * data)4294 void StartGetAbilityInfoExecuteCB(napi_env env, void *data)
4295 {
4296 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo =
4297 reinterpret_cast<AsyncAbilityInfosCallbackInfo *>(data);
4298 if (asyncCallbackInfo == nullptr) {
4299 APP_LOGE("asyncCallbackInfo == nullptr");
4300 return;
4301 }
4302 if (!asyncCallbackInfo->err) {
4303 asyncCallbackInfo->ret = InnerGetAbilityInfo(
4304 asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName,
4305 asyncCallbackInfo->abilityName, asyncCallbackInfo->abilityInfo,
4306 asyncCallbackInfo->hasModuleName);
4307 }
4308 APP_LOGD("end");
4309 }
4310
StartGetAbilityInfoCompletedCB(napi_env env,napi_status status,void * data)4311 void StartGetAbilityInfoCompletedCB(napi_env env, napi_status status, void *data)
4312 {
4313 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo =
4314 reinterpret_cast<AsyncAbilityInfosCallbackInfo *>(data);
4315 if (asyncCallbackInfo == nullptr) {
4316 APP_LOGE("asyncCallbackInfo is nullptr");
4317 return;
4318 }
4319 std::unique_ptr<AsyncAbilityInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
4320 napi_value result[2] = {0};
4321 if (asyncCallbackInfo->err) {
4322 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, asyncCallbackInfo->err, &result[0]));
4323 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
4324 NAPI_AUTO_LENGTH, &result[1]));
4325 } else {
4326 if (asyncCallbackInfo->ret) {
4327 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
4328 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
4329 ConvertAbilityInfo(env, result[1], asyncCallbackInfo->abilityInfo);
4330 } else {
4331 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[0]));
4332 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4333 }
4334 }
4335 if (asyncCallbackInfo->deferred) {
4336 if (asyncCallbackInfo->ret) {
4337 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4338 } else {
4339 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4340 }
4341 } else {
4342 napi_value callback = nullptr;
4343 napi_value placeHolder = nullptr;
4344 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4345 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]),
4346 result, &placeHolder));
4347 }
4348 APP_LOGD("end");
4349 }
4350
HasModuleName(napi_env env,size_t argc,napi_value * argv)4351 static bool HasModuleName(napi_env env, size_t argc, napi_value *argv)
4352 {
4353 bool hasModuleName = false;
4354 if (argc > 0) {
4355 napi_valuetype valueType = napi_undefined;
4356 NAPI_CALL_BASE(env, napi_typeof(env, argv[argc - 1], &valueType), false);
4357 if (valueType == napi_function) {
4358 hasModuleName = (argc == ARGS_SIZE_FOUR) ? true : false;
4359 } else {
4360 hasModuleName = (argc == ARGS_SIZE_THREE) ? true : false;
4361 }
4362 } else {
4363 APP_LOGD("error : argc < 0");
4364 }
4365 return hasModuleName;
4366 }
4367
GetAbilityInfo(napi_env env,napi_callback_info info)4368 napi_value GetAbilityInfo(napi_env env, napi_callback_info info)
4369 {
4370 size_t requireArgc = ARGS_SIZE_TWO;
4371 size_t argc = ARGS_SIZE_FOUR;
4372 napi_value argv[ARGS_SIZE_FOUR] = { 0 };
4373 napi_value thisArg = nullptr;
4374 void *data = nullptr;
4375 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4376 NAPI_CALL(env, (argc >= requireArgc) ? napi_ok : napi_invalid_arg);
4377 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncAbilityInfosCallbackInfo(env);
4378 if (asyncCallbackInfo == nullptr) {
4379 APP_LOGD("asyncCallbackInfo == nullptr");
4380 return nullptr;
4381 }
4382 std::unique_ptr<AsyncAbilityInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
4383 asyncCallbackInfo->hasModuleName = HasModuleName(env, argc, argv);
4384 for (size_t i = 0; i < argc; ++i) {
4385 napi_valuetype valueType = napi_undefined;
4386 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4387 if ((i == PARAM0) && (valueType == napi_string)) {
4388 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
4389 } else if ((i == PARAM1) && (valueType == napi_string)) {
4390 if (asyncCallbackInfo->hasModuleName) {
4391 ParseString(env, asyncCallbackInfo->moduleName, argv[i]);
4392 } else {
4393 ParseString(env, asyncCallbackInfo->abilityName, argv[i]);
4394 }
4395 } else if ((i == PARAM2) && (valueType == napi_string)) {
4396 ParseString(env, asyncCallbackInfo->abilityName, argv[i]);
4397 } else if (((i == PARAM2) || (i == PARAM3)) && (valueType == napi_function)) {
4398 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4399 } else {
4400 asyncCallbackInfo->err = INVALID_PARAM;
4401 asyncCallbackInfo->message = TYPE_MISMATCH;
4402 }
4403 }
4404
4405 napi_value promise = nullptr;
4406 if (asyncCallbackInfo->callback == nullptr) {
4407 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
4408 } else {
4409 NAPI_CALL(env, napi_get_undefined(env, &promise));
4410 }
4411 napi_value resource = nullptr;
4412 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resource));
4413 NAPI_CALL(env, napi_create_async_work(env, nullptr, resource,
4414 StartGetAbilityInfoExecuteCB, StartGetAbilityInfoCompletedCB,
4415 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4416 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4417 callbackPtr.release();
4418 return promise;
4419 }
4420
CreateAbilityLabelCallbackInfo(napi_env env)4421 AsyncAbilityLabelCallbackInfo *CreateAbilityLabelCallbackInfo(napi_env env)
4422 {
4423 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncAbilityLabelCallbackInfo(env);
4424
4425 if (asyncCallbackInfo == nullptr) {
4426 APP_LOGE("asyncCallbackInfo == nullptr");
4427 return nullptr;
4428 }
4429
4430 APP_LOGD("end");
4431 return asyncCallbackInfo;
4432 }
4433
InnerGetAbilityLabel(napi_env env,std::string & bundleName,std::string & moduleName,std::string & abilityName,bool hasModuleName)4434 static std::string InnerGetAbilityLabel(napi_env env, std::string &bundleName, std::string &moduleName,
4435 std::string &abilityName, bool hasModuleName)
4436 {
4437 auto iBundleMgr = GetBundleMgr();
4438 if (iBundleMgr == nullptr) {
4439 APP_LOGE("can not get iBundleMgr");
4440 return Constants::EMPTY_STRING;
4441 }
4442 if (!hasModuleName) {
4443 return iBundleMgr->GetAbilityLabel(bundleName, abilityName);
4444 }
4445 std::string label;
4446 ErrCode ret = iBundleMgr->GetAbilityLabel(bundleName, moduleName, abilityName, label);
4447 if (ret != ERR_OK) {
4448 APP_LOGE("can not GetAbilityLabel, bundleName is %{public}s", bundleName.c_str());
4449 return Constants::EMPTY_STRING;
4450 }
4451 return label;
4452 }
4453
GetAbilityLabelPromiseComplete(napi_env env,napi_status status,void * data)4454 void GetAbilityLabelPromiseComplete(napi_env env, napi_status status, void *data)
4455 {
4456 APP_LOGD("NAPI_GetAbilityLabel, main event thread complete");
4457 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4458 if (asyncCallbackInfo == nullptr) {
4459 APP_LOGE("asyncCallbackInfo is nullptr");
4460 return;
4461 }
4462 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4463 napi_value result = nullptr;
4464 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
4465 NAPI_CALL_RETURN_VOID(
4466 env, napi_create_string_utf8(env, asyncCallbackInfo->abilityLabel.c_str(), NAPI_AUTO_LENGTH, &result));
4467 NAPI_CALL_RETURN_VOID(
4468 env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result));
4469 } else {
4470 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result));
4471 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result));
4472 }
4473 APP_LOGI("NAPI_GetAbilityLabel, main event thread complete end");
4474 }
4475
GetAbilityLabelExecute(napi_env env,void * data)4476 void GetAbilityLabelExecute(napi_env env, void *data)
4477 {
4478 APP_LOGD("NAPI_GetAbilityLabel, worker pool thread execute");
4479 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4480 if (asyncCallbackInfo == nullptr) {
4481 APP_LOGE("NAPI_GetAbilityLabel, asyncCallbackInfo == nullptr");
4482 return;
4483 }
4484 if (!asyncCallbackInfo->err) {
4485 asyncCallbackInfo->abilityLabel =
4486 InnerGetAbilityLabel(env, asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName,
4487 asyncCallbackInfo->className, asyncCallbackInfo->hasModuleName);
4488 if (asyncCallbackInfo->abilityLabel == "") {
4489 asyncCallbackInfo->err = OPERATION_FAILED;
4490 }
4491 }
4492 }
4493
GetAbilityLabelAsyncComplete(napi_env env,napi_status status,void * data)4494 void GetAbilityLabelAsyncComplete(napi_env env, napi_status status, void *data)
4495 {
4496 APP_LOGD("NAPI_GetAbilityLabel, main event thread complete");
4497 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4498 if (asyncCallbackInfo == nullptr) {
4499 APP_LOGE("asyncCallbackInfo is nullptr");
4500 return;
4501 }
4502 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4503 napi_value callback = nullptr;
4504 napi_value result[ARGS_SIZE_TWO] = {nullptr};
4505 napi_value callResult = nullptr;
4506
4507 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
4508 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[PARAM0]));
4509 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->abilityLabel.c_str(),
4510 NAPI_AUTO_LENGTH, &result[PARAM1]));
4511 } else {
4512 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[PARAM0]));
4513 result[PARAM1] = WrapUndefinedToJS(env);
4514 }
4515
4516 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4517 NAPI_CALL_RETURN_VOID(env,
4518 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[PARAM0]), result, &callResult));
4519 APP_LOGI("NAPI_GetAbilityLabel, main event thread complete end");
4520 }
4521
GetAbilityLabelAsync(napi_env env,AsyncAbilityLabelCallbackInfo * asyncCallbackInfo)4522 napi_value GetAbilityLabelAsync(
4523 napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4524 {
4525 if (asyncCallbackInfo == nullptr) {
4526 APP_LOGD("param == nullptr");
4527 return nullptr;
4528 }
4529
4530 napi_value resourceName = nullptr;
4531 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
4532
4533 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetAbilityLabelExecute,
4534 GetAbilityLabelAsyncComplete, reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4535 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4536 napi_value result = nullptr;
4537 NAPI_CALL(env, napi_get_null(env, &result));
4538 APP_LOGD("asyncCallback end");
4539 return result;
4540 }
4541
GetAbilityLabelPromise(napi_env env,AsyncAbilityLabelCallbackInfo * asyncCallbackInfo)4542 napi_value GetAbilityLabelPromise(napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4543 {
4544 if (asyncCallbackInfo == nullptr) {
4545 APP_LOGD("param == nullptr");
4546 return nullptr;
4547 }
4548 napi_value resourceName = nullptr;
4549 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
4550 napi_deferred deferred;
4551 napi_value promise = nullptr;
4552 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
4553 asyncCallbackInfo->deferred = deferred;
4554
4555 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetAbilityLabelExecute,
4556 GetAbilityLabelPromiseComplete,
4557 reinterpret_cast<void*>(asyncCallbackInfo),
4558 &asyncCallbackInfo->asyncWork));
4559 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4560 APP_LOGD("romise end");
4561 return promise;
4562 }
4563
GetAbilityLabelWrap(napi_env env,napi_callback_info info,AsyncAbilityLabelCallbackInfo * asyncCallbackInfo)4564 napi_value GetAbilityLabelWrap(napi_env env, napi_callback_info info, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4565 {
4566 if (asyncCallbackInfo == nullptr) {
4567 APP_LOGE("asyncCallbackInfo == nullptr");
4568 return nullptr;
4569 }
4570
4571 size_t argcAsync = ARGS_SIZE_FOUR;
4572 const size_t argcPromise = ARGS_SIZE_THREE;
4573 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
4574 napi_value args[ARGS_MAX_COUNT] = {nullptr};
4575 napi_value ret = nullptr;
4576
4577 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
4578 if (argcAsync > argCountWithAsync) {
4579 APP_LOGE("Wrong argument count");
4580 return nullptr;
4581 }
4582 asyncCallbackInfo->hasModuleName = HasModuleName(env, argcAsync, args);
4583 for (size_t i = 0; i < argcAsync; ++i) {
4584 napi_valuetype valueType = napi_undefined;
4585 NAPI_CALL(env, napi_typeof(env, args[i], &valueType));
4586 if ((i == PARAM0) && (valueType == napi_string)) {
4587 ParseString(env, asyncCallbackInfo->bundleName, args[i]);
4588 } else if ((i == PARAM1) && (valueType == napi_string)) {
4589 if (asyncCallbackInfo->hasModuleName) {
4590 ParseString(env, asyncCallbackInfo->moduleName, args[i]);
4591 } else {
4592 ParseString(env, asyncCallbackInfo->className, args[i]);
4593 }
4594 } else if ((i == PARAM2) && (valueType == napi_string)) {
4595 ParseString(env, asyncCallbackInfo->className, args[i]);
4596 } else if (((i == PARAM2) || (i == PARAM3)) && (valueType == napi_function)) {
4597 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4598 } else {
4599 asyncCallbackInfo->err = INVALID_PARAM;
4600 asyncCallbackInfo->message = TYPE_MISMATCH;
4601 }
4602 }
4603 if (asyncCallbackInfo->callback) {
4604 ret = GetAbilityLabelAsync(env, asyncCallbackInfo);
4605 } else {
4606 ret = GetAbilityLabelPromise(env, asyncCallbackInfo);
4607 }
4608 APP_LOGD("asyncCallback end");
4609 return ret;
4610 }
4611
GetAbilityLabel(napi_env env,napi_callback_info info)4612 napi_value GetAbilityLabel(napi_env env, napi_callback_info info)
4613 {
4614 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = CreateAbilityLabelCallbackInfo(env);
4615 if (asyncCallbackInfo == nullptr) {
4616 APP_LOGD("asyncCallbackInfo == nullptr");
4617 return WrapVoidToJS(env);
4618 }
4619 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4620 napi_value ret = GetAbilityLabelWrap(env, info, asyncCallbackInfo);
4621 if (ret == nullptr) {
4622 APP_LOGD("ret == nullptr");
4623 ret = WrapVoidToJS(env);
4624 } else {
4625 callbackPtr.release();
4626 }
4627 APP_LOGD("end");
4628 return ret;
4629 }
4630
SetApplicationEnabledExec(napi_env env,void * data)4631 void SetApplicationEnabledExec(napi_env env, void *data)
4632 {
4633 APP_LOGD("NAPI begin");
4634 EnabledInfo* asyncCallbackInfo =
4635 reinterpret_cast<EnabledInfo*>(data);
4636 if (asyncCallbackInfo == nullptr) {
4637 APP_LOGD("asyncCallbackInfo == nullptr");
4638 return;
4639 }
4640 if (!asyncCallbackInfo->errCode) {
4641 asyncCallbackInfo->result = InnerSetApplicationEnabled(asyncCallbackInfo->bundleName,
4642 asyncCallbackInfo->isEnable);
4643 if (!asyncCallbackInfo->result) {
4644 asyncCallbackInfo->errCode = OPERATION_FAILED;
4645 }
4646 }
4647 APP_LOGD("NAPI end");
4648 }
4649
SetApplicationEnabledComplete(napi_env env,napi_status status,void * data)4650 void SetApplicationEnabledComplete(napi_env env, napi_status status, void *data)
4651 {
4652 APP_LOGD("NAPI begin");
4653 EnabledInfo* asyncCallbackInfo =
4654 reinterpret_cast<EnabledInfo*>(data);
4655 if (asyncCallbackInfo == nullptr) {
4656 APP_LOGD("asyncCallbackInfo == nullptr");
4657 return;
4658 }
4659 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4660 napi_value result[ARGS_SIZE_ONE] = { 0 };
4661 if (asyncCallbackInfo->errCode) {
4662 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4663 }
4664 if (asyncCallbackInfo->callback) {
4665 napi_value callback = nullptr;
4666 napi_value placeHolder = nullptr;
4667 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4668 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4669 sizeof(result) / sizeof(result[0]), result, &placeHolder));
4670 } else {
4671 if (asyncCallbackInfo->errCode) {
4672 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4673 } else {
4674 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[0]));
4675 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[0]));
4676 }
4677 }
4678 APP_LOGD("NAPI end");
4679 }
4680
SetApplicationEnabled(napi_env env,napi_callback_info info)4681 napi_value SetApplicationEnabled(napi_env env, napi_callback_info info)
4682 {
4683 {
4684 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
4685 abilityInfoCache.clear();
4686 }
4687 size_t argc = ARGS_SIZE_THREE;
4688 napi_value argv[ARGS_SIZE_THREE] = { 0 };
4689 napi_value thisArg = nullptr;
4690 void *data = nullptr;
4691
4692 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4693 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
4694 APP_LOGE("wrong number of arguments");
4695 return nullptr;
4696 }
4697
4698 EnabledInfo *asyncCallbackInfo = new (std::nothrow) EnabledInfo(env);
4699 if (asyncCallbackInfo == nullptr) {
4700 APP_LOGD("asyncCallbackInfo == nullptr");
4701 return nullptr;
4702 }
4703 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4704 asyncCallbackInfo->env = env;
4705 for (size_t i = 0; i < argc; ++i) {
4706 napi_valuetype valueType = napi_undefined;
4707 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4708 if ((i == PARAM0) && (valueType == napi_string)) {
4709 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
4710 } else if ((i == PARAM1) && (valueType == napi_boolean)) {
4711 bool isEnable = false;
4712 NAPI_CALL(env, napi_get_value_bool(env, argv[i], &isEnable));
4713 asyncCallbackInfo->isEnable = isEnable;
4714 } else if ((i == PARAM2) && (valueType == napi_function)) {
4715 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4716 } else {
4717 asyncCallbackInfo->errCode = INVALID_PARAM;
4718 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4719 }
4720 }
4721 napi_value promise = nullptr;
4722
4723 if (asyncCallbackInfo->callback == nullptr) {
4724 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
4725 } else {
4726 NAPI_CALL(env, napi_get_undefined(env, &promise));
4727 }
4728 napi_value resource = nullptr;
4729 NAPI_CALL(env, napi_create_string_utf8(env, "JSSetApplicationEnabled", NAPI_AUTO_LENGTH, &resource));
4730 NAPI_CALL(env, napi_create_async_work(
4731 env, nullptr, resource, SetApplicationEnabledExec, SetApplicationEnabledComplete,
4732 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4733 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4734 callbackPtr.release();
4735 return promise;
4736 }
4737
SetAbilityEnabledExec(napi_env env,void * data)4738 void SetAbilityEnabledExec(napi_env env, void *data)
4739 {
4740 EnabledInfo* asyncCallbackInfo =
4741 reinterpret_cast<EnabledInfo*>(data);
4742 if (asyncCallbackInfo == nullptr) {
4743 APP_LOGE("asyncCallbackInfo is nullptr");
4744 return;
4745 }
4746 if (!asyncCallbackInfo->errCode) {
4747 asyncCallbackInfo->result = InnerSetAbilityEnabled(asyncCallbackInfo->abilityInfo,
4748 asyncCallbackInfo->isEnable);
4749 if (!asyncCallbackInfo->result) {
4750 asyncCallbackInfo->errCode = OPERATION_FAILED;
4751 }
4752 }
4753 }
4754
SetAbilityEnabledComplete(napi_env env,napi_status status,void * data)4755 void SetAbilityEnabledComplete(napi_env env, napi_status status, void *data)
4756 {
4757 EnabledInfo* asyncCallbackInfo =
4758 reinterpret_cast<EnabledInfo*>(data);
4759 if (asyncCallbackInfo == nullptr) {
4760 APP_LOGE("asyncCallbackInfo is nullptr");
4761 return;
4762 }
4763 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4764 napi_value result[ARGS_SIZE_TWO] = { 0 };
4765 if (asyncCallbackInfo->errCode != ERR_OK) {
4766 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4767 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4768 } else if (!asyncCallbackInfo->result) {
4769 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
4770 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4771 } else {
4772 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4773 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[1]));
4774 }
4775
4776 if (asyncCallbackInfo->deferred) {
4777 if (asyncCallbackInfo->errCode == ERR_OK) {
4778 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4779 } else {
4780 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4781 }
4782 } else {
4783 napi_value callback = nullptr;
4784 napi_value placeHolder = nullptr;
4785 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4786 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, INVALID_PARAM, result, &placeHolder));
4787 }
4788 }
4789
SetAbilityEnabled(napi_env env,napi_callback_info info)4790 napi_value SetAbilityEnabled(napi_env env, napi_callback_info info)
4791 {
4792 {
4793 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
4794 abilityInfoCache.clear();
4795 }
4796 size_t argc = ARGS_SIZE_THREE;
4797 napi_value argv[ARGS_SIZE_THREE] = { 0 };
4798 napi_value thisArg = nullptr;
4799 void* data = nullptr;
4800
4801 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4802 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
4803 APP_LOGE("wrong number of arguments");
4804 return nullptr;
4805 }
4806
4807 EnabledInfo* asyncCallbackInfo = new (std::nothrow) EnabledInfo(env);
4808 if (asyncCallbackInfo == nullptr) {
4809 return nullptr;
4810 }
4811 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4812 asyncCallbackInfo->env = env;
4813 for (size_t i = 0; i < argc; ++i) {
4814 napi_valuetype valueType = napi_undefined;
4815 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4816 if ((i == PARAM0) && (valueType == napi_object)) {
4817 if (!UnwrapAbilityInfo(env, argv[i], asyncCallbackInfo->abilityInfo)) {
4818 asyncCallbackInfo->errCode = INVALID_PARAM;
4819 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4820 }
4821 } else if ((i == PARAM1) && (valueType == napi_boolean)) {
4822 NAPI_CALL(env, napi_get_value_bool(env, argv[i], &(asyncCallbackInfo->isEnable)));
4823 } else if ((i == PARAM2) && (valueType == napi_function)) {
4824 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4825 break;
4826 } else {
4827 asyncCallbackInfo->errCode = INVALID_PARAM;
4828 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4829 }
4830 }
4831 auto promise = CommonFunc::AsyncCallNativeMethod<EnabledInfo>(
4832 env, asyncCallbackInfo, "SetAbilityEnabled", SetAbilityEnabledExec, SetAbilityEnabledComplete);
4833 callbackPtr.release();
4834 return promise;
4835 }
4836
ConvertInstallResult(InstallResult & installResult)4837 static void ConvertInstallResult(InstallResult &installResult)
4838 {
4839 APP_LOGD("ConvertInstallResult = %{public}s", installResult.resultMsg.c_str());
4840 switch (installResult.resultCode) {
4841 case static_cast<int32_t>(IStatusReceiver::SUCCESS):
4842 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::SUCCESS);
4843 installResult.resultMsg = "SUCCESS";
4844 break;
4845 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR):
4846 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_HOST_INSTALLER_FAILED):
4847 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DISALLOWED):
4848 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE);
4849 installResult.resultMsg = "STATUS_INSTALL_FAILURE";
4850 break;
4851 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_FAILED):
4852 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DEBUG_ENCRYPTED_BUNDLE_FAILED):
4853 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERIFICATION_FAILED):
4854 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INCOMPATIBLE_SIGNATURE):
4855 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARAM_ERROR):
4856 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID):
4857 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_HAP_SIZE):
4858 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_HAP_NAME):
4859 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_BUNDLE_FILE):
4860 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_NUMBER_OF_ENTRY_HAP):
4861 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_UNEXPECTED):
4862 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_MISSING_BUNDLE):
4863 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_NO_PROFILE):
4864 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_BAD_PROFILE):
4865 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_PROP_TYPE_ERROR):
4866 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_MISSING_PROP):
4867 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PERMISSION_ERROR):
4868 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_RPCID_FAILED):
4869 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_NATIVE_SO_FAILED):
4870 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INVALID_SIGNATURE_FILE_PATH):
4871 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE_FILE):
4872 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_NO_BUNDLE_SIGNATURE):
4873 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_APP_PKCS7_FAIL):
4874 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_PROFILE_PARSE_FAIL):
4875 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_APP_SOURCE_NOT_TRUESTED):
4876 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_DIGEST):
4877 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_INTEGRITY_VERIFICATION_FAILURE):
4878 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_FILE_SIZE_TOO_LARGE):
4879 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_PUBLICKEY):
4880 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE):
4881 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_NO_PROFILE_BLOCK_FAIL):
4882 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_SIGNATURE_VERIFICATION_FAILURE):
4883 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_EMPTY):
4884 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_DUPLICATE):
4885 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_CHECK_HAP_HASH_PARAM):
4886 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_SOURCE_INIT_FAIL):
4887 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DEPENDENT_MODULE_NOT_EXIST):
4888 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_NATIVE_FAILED):
4889 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_NATIVE_FAILED):
4890 case static_cast<int32_t>(IStatusReceiver::ERR_NATIVE_HNP_EXTRACT_FAILED):
4891 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_DEBUG_NOT_SAME):
4892 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_AND_RESTORE_TO_PREINSTALLED):
4893 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INVALID);
4894 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
4895 break;
4896 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_MISSING_ABILITY):
4897 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_ABILITY_NOT_FOUND);
4898 installResult.resultMsg = "STATUS_ABILITY_NOT_FOUND";
4899 break;
4900 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSION_DOWNGRADE):
4901 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INCONSISTENT_SIGNATURE):
4902 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INCOMPATIBLE);
4903 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INCOMPATIBLE";
4904 break;
4905 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PERMISSION_DENIED):
4906 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_PERMISSION_DENIED);
4907 installResult.resultMsg = "STATUS_INSTALL_PERMISSION_DENIED";
4908 break;
4909 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ENTRY_ALREADY_EXIST):
4910 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ALREADY_EXIST):
4911 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_BUNDLENAME_NOT_SAME):
4912 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSIONCODE_NOT_SAME):
4913 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSIONNAME_NOT_SAME):
4914 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_MINCOMPATIBLE_VERSIONCODE_NOT_SAME):
4915 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VENDOR_NOT_SAME):
4916 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_RELEASETYPE_TARGET_NOT_SAME):
4917 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_RELEASETYPE_COMPATIBLE_NOT_SAME):
4918 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SINGLETON_NOT_SAME):
4919 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ZERO_USER_WITH_NO_SINGLETON):
4920 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_CHECK_SYSCAP_FAILED):
4921 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APPTYPE_NOT_SAME):
4922 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_URI_DUPLICATE):
4923 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSION_NOT_COMPATIBLE):
4924 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APP_DISTRIBUTION_TYPE_NOT_SAME):
4925 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APP_PROVISION_TYPE_NOT_SAME):
4926 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SO_INCOMPATIBLE):
4927 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_TYPE_ERROR):
4928 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_NOT_UNIQUE_DISTRO_MODULE_NAME):
4929 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SINGLETON_INCOMPATIBLE):
4930 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INCONSISTENT_MODULE_NAME):
4931 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_CHECK_SYSCAP_FAILED_AND_DEVICE_TYPE_NOT_SUPPORTED):
4932 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_CONFLICT);
4933 installResult.resultMsg = "STATUS_INSTALL_FAILURE_CONFLICT";
4934 break;
4935 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_PARAM_ERROR):
4936 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_GET_PROXY_ERROR):
4937 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CREATE_DIR_FAILED):
4938 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_SET_SELINUX_LABEL_FAILED):
4939 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CREATE_DIR_EXIST):
4940 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CHOWN_FAILED):
4941 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_REMOVE_DIR_FAILED):
4942 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_EXTRACT_FILES_FAILED):
4943 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_RNAME_DIR_FAILED):
4944 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CLEAN_DIR_FAILED):
4945 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_STATE_ERROR):
4946 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_GENERATE_UID_ERROR):
4947 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INSTALLD_SERVICE_ERROR):
4948 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_STORAGE);
4949 installResult.resultMsg = "STATUS_INSTALL_FAILURE_STORAGE";
4950 break;
4951 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_PERMISSION_DENIED):
4952 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_PERMISSION_DENIED);
4953 installResult.resultMsg = "STATUS_UNINSTALL_PERMISSION_DENIED";
4954 break;
4955 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_INVALID_NAME):
4956 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_PARAM_ERROR):
4957 if (CheckIsSystemApp()) {
4958 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_ABORTED);
4959 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE_ABORTED";
4960 break;
4961 }
4962 [[fallthrough]];
4963 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_SYSTEM_APP_ERROR):
4964 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_KILLING_APP_ERROR):
4965 if (CheckIsSystemApp()) {
4966 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_CONFLICT);
4967 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE_CONFLICT";
4968 break;
4969 }
4970 [[fallthrough]];
4971 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_BUNDLE_MGR_SERVICE_ERROR):
4972 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_BUNDLE):
4973 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_MODULE):
4974 case static_cast<int32_t>(IStatusReceiver::ERR_USER_NOT_INSTALL_HAP):
4975 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_DISALLOWED):
4976 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE);
4977 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE";
4978 break;
4979 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_GET_BUNDLEPATH_ERROR):
4980 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME):
4981 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_NOT_ALLOWED):
4982 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_RECOVER_FAILURE_INVALID);
4983 installResult.resultMsg = "STATUS_RECOVER_FAILURE_INVALID";
4984 break;
4985 case static_cast<int32_t>(IStatusReceiver::ERR_FAILED_SERVICE_DIED):
4986 case static_cast<int32_t>(IStatusReceiver::ERR_FAILED_GET_INSTALLER_PROXY):
4987 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR);
4988 installResult.resultMsg = "STATUS_BMS_SERVICE_ERROR";
4989 break;
4990 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT):
4991 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_FAILED_NO_SPACE_LEFT);
4992 installResult.resultMsg = "STATUS_FAILED_NO_SPACE_LEFT";
4993 break;
4994 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_GRANT_REQUEST_PERMISSIONS_FAILED):
4995 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_UPDATE_HAP_TOKEN_FAILED):
4996 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_GRANT_REQUEST_PERMISSIONS_FAILED);
4997 installResult.resultMsg = "STATUS_GRANT_REQUEST_PERMISSIONS_FAILED";
4998 break;
4999 case static_cast<int32_t>(IStatusReceiver::ERR_USER_NOT_EXIST):
5000 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_NOT_EXIST);
5001 installResult.resultMsg = "STATUS_USER_NOT_EXIST";
5002 break;
5003 case static_cast<int32_t>(IStatusReceiver::ERR_USER_CREATE_FAILED):
5004 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_CREATE_FAILED);
5005 installResult.resultMsg = "STATUS_USER_CREATE_FAILED";
5006 break;
5007 case static_cast<int32_t>(IStatusReceiver::ERR_USER_REMOVE_FAILED):
5008 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_REMOVE_FAILED);
5009 installResult.resultMsg = "STATUS_USER_REMOVE_FAILED";
5010 break;
5011 default:
5012 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR);
5013 installResult.resultMsg = "STATUS_BMS_SERVICE_ERROR";
5014 break;
5015 }
5016 }
5017
InnerInstall(napi_env env,const std::vector<std::string> & bundleFilePath,InstallParam & installParam,InstallResult & installResult)5018 static void InnerInstall(napi_env env, const std::vector<std::string> &bundleFilePath, InstallParam &installParam,
5019 InstallResult &installResult)
5020 {
5021 if (bundleFilePath.empty()) {
5022 installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID);
5023 return;
5024 }
5025 auto iBundleMgr = GetBundleMgr();
5026 if (iBundleMgr == nullptr) {
5027 APP_LOGE("can not get iBundleMgr");
5028 return;
5029 }
5030 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5031 if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
5032 APP_LOGE("can not get iBundleInstaller");
5033 return;
5034 }
5035
5036 if (installParam.installFlag == InstallFlag::NORMAL) {
5037 installParam.installFlag = InstallFlag::REPLACE_EXISTING;
5038 }
5039
5040 sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5041 if (callback == nullptr) {
5042 APP_LOGE("callback nullptr");
5043 return;
5044 }
5045
5046 sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
5047 iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
5048 ErrCode res = iBundleInstaller->StreamInstall(bundleFilePath, installParam, callback);
5049 if (res == ERR_APPEXECFWK_INSTALL_PARAM_ERROR) {
5050 APP_LOGE("install param error");
5051 installResult.resultCode = IStatusReceiver::ERR_INSTALL_PARAM_ERROR;
5052 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
5053 } else if (res == ERR_APPEXECFWK_INSTALL_FILE_PATH_INVALID) {
5054 APP_LOGE("install invalid path");
5055 installResult.resultCode = IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID;
5056 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
5057 } else if (res == ERR_APPEXECFWK_INSTALL_DISK_MEM_INSUFFICIENT) {
5058 APP_LOGE("install failed due to no space left");
5059 installResult.resultCode = IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT;
5060 installResult.resultMsg = "STATUS_FAILED_NO_SPACE_LEFT";
5061 } else {
5062 installResult.resultCode = callback->GetResultCode();
5063 installResult.resultMsg = callback->GetResultMsg();
5064 APP_LOGD("InnerInstall code:%{public}d msg:%{public}s", installResult.resultCode,
5065 installResult.resultMsg.c_str());
5066 }
5067 }
5068
5069 /**
5070 * Promise and async callback
5071 */
GetBundleInstaller(napi_env env,napi_callback_info info)5072 napi_value GetBundleInstaller(napi_env env, napi_callback_info info)
5073 {
5074 APP_LOGI("called");
5075 size_t argc = ARGS_SIZE_ONE;
5076 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
5077 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5078 APP_LOGD("argc = [%{public}zu]", argc);
5079
5080 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5081 new (std::nothrow) AsyncGetBundleInstallerCallbackInfo(env);
5082 if (asyncCallbackInfo == nullptr) {
5083 APP_LOGE("asyncCallbackInfo is nullptr");
5084 return nullptr;
5085 }
5086 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5087 if (argc > (ARGS_SIZE_ONE - CALLBACK_SIZE)) {
5088 APP_LOGI("GetBundleInstaller asyncCallback");
5089 napi_valuetype valuetype = napi_undefined;
5090 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
5091 if (valuetype != napi_function) {
5092 APP_LOGE("Wrong argument type. Function expected");
5093 return nullptr;
5094 }
5095 NAPI_CALL(env, napi_create_reference(env, argv[PARAM0], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5096
5097 napi_value resourceName;
5098 NAPI_CALL(env, napi_create_string_latin1(env, "GetBundleInstaller", NAPI_AUTO_LENGTH, &resourceName));
5099 NAPI_CALL(env, napi_create_async_work(
5100 env,
5101 nullptr,
5102 resourceName,
5103 [](napi_env env, void *data) {},
5104 [](napi_env env, napi_status status, void *data) {
5105 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5106 reinterpret_cast<AsyncGetBundleInstallerCallbackInfo *>(data);
5107 if (asyncCallbackInfo == nullptr) {
5108 APP_LOGE("asyncCallbackInfo is nullptr");
5109 return;
5110 }
5111 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5112 napi_value result[ARGS_SIZE_TWO] = {0};
5113 napi_value callback = 0;
5114 napi_value undefined = 0;
5115 napi_value callResult = 0;
5116 napi_value m_classBundleInstaller = nullptr;
5117 if (VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE) && VerifySystemApi()) {
5118 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, g_classBundleInstaller,
5119 &m_classBundleInstaller));
5120 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5121 NAPI_CALL_RETURN_VOID(env, napi_new_instance(
5122 env, m_classBundleInstaller, 0, nullptr, &result[PARAM1]));
5123
5124 result[PARAM0] = GetCallbackErrorValue(env, CODE_SUCCESS);
5125 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(
5126 env, asyncCallbackInfo->callback, &callback));
5127 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5128 &result[PARAM0], &callResult));
5129 } else {
5130 napi_value placeHolder = nullptr;
5131 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 1, &result[PARAM0]));
5132 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5133 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
5134 sizeof(result) / sizeof(result[0]), result, &placeHolder));
5135 }
5136 },
5137 reinterpret_cast<void*>(asyncCallbackInfo),
5138 &asyncCallbackInfo->asyncWork));
5139 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5140 callbackPtr.release();
5141 napi_value result;
5142 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5143 return result;
5144 } else {
5145 napi_deferred deferred;
5146 napi_value promise;
5147 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5148 asyncCallbackInfo->deferred = deferred;
5149 APP_LOGI("GetBundleInstaller promise");
5150 napi_value resourceName;
5151 NAPI_CALL(env, napi_create_string_latin1(env, "GetBundleInstaller", NAPI_AUTO_LENGTH, &resourceName));
5152 NAPI_CALL(env, napi_create_async_work(
5153 env,
5154 nullptr,
5155 resourceName,
5156 [](napi_env env, void *data) { APP_LOGI("GetBundleInstaller promise async done"); },
5157 [](napi_env env, napi_status status, void *data) {
5158 APP_LOGI("=================load=================");
5159 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5160 reinterpret_cast<AsyncGetBundleInstallerCallbackInfo *>(data);
5161 if (asyncCallbackInfo == nullptr) {
5162 APP_LOGE("asyncCallbackInfo is nullptr");
5163 return;
5164 }
5165 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5166 napi_value result;
5167 napi_value m_classBundleInstaller = nullptr;
5168 if (VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE) && VerifySystemApi()) {
5169 napi_get_reference_value(env, g_classBundleInstaller, &m_classBundleInstaller);
5170 napi_new_instance(env, m_classBundleInstaller, 0, nullptr, &result);
5171 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
5172 } else {
5173 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 1, &result));
5174 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result));
5175 }
5176 },
5177 reinterpret_cast<void*>(asyncCallbackInfo),
5178 &asyncCallbackInfo->asyncWork));
5179 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5180 callbackPtr.release();
5181 return promise;
5182 }
5183 }
5184
5185 /**
5186 * Promise and async callback
5187 */
Install(napi_env env,napi_callback_info info)5188 napi_value Install(napi_env env, napi_callback_info info)
5189 {
5190 APP_LOGI("called");
5191 size_t argc = ARGS_SIZE_THREE;
5192 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5193 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5194 APP_LOGD("argc = [%{public}zu]", argc);
5195 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5196 if (asyncCallbackInfo == nullptr) {
5197 return nullptr;
5198 }
5199 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5200
5201 std::vector<std::string> bundleFilePaths;
5202 InstallParam installParam;
5203 napi_value retFirst = nullptr;
5204 bool retSecond = true;
5205 retFirst = ParseStringArray(env, bundleFilePaths, argv[PARAM0]);
5206 retSecond = ParseInstallParam(env, installParam, argv[PARAM1]);
5207 if (retFirst == nullptr || !retSecond) {
5208 APP_LOGE("Install installParam error");
5209 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5210 }
5211 asyncCallbackInfo->hapFiles = bundleFilePaths;
5212 asyncCallbackInfo->installParam = installParam;
5213 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5214 APP_LOGI("Install asyncCallback");
5215 napi_valuetype valuetype = napi_undefined;
5216 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5217 if (valuetype != napi_function) {
5218 APP_LOGE("Wrong argument type. Function expected");
5219 return nullptr;
5220 }
5221 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5222
5223 napi_value resourceName;
5224 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5225 NAPI_CALL(env, napi_create_async_work(
5226 env,
5227 nullptr,
5228 resourceName,
5229 [](napi_env env, void *data) {
5230 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5231 if (asyncCallbackInfo == nullptr) {
5232 return;
5233 }
5234 if (!asyncCallbackInfo->errCode) {
5235 InnerInstall(env,
5236 asyncCallbackInfo->hapFiles,
5237 asyncCallbackInfo->installParam,
5238 asyncCallbackInfo->installResult);
5239 }
5240 },
5241 [](napi_env env, napi_status status, void *data) {
5242 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5243 if (asyncCallbackInfo == nullptr) {
5244 return;
5245 }
5246 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5247 napi_value result[ARGS_SIZE_TWO] = {0};
5248 napi_value callback = 0;
5249 napi_value undefined = 0;
5250 napi_value callResult = 0;
5251 if (!asyncCallbackInfo->errCode) {
5252 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5253 ConvertInstallResult(asyncCallbackInfo->installResult);
5254 napi_value nResultMsg;
5255 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5256 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5257 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5258 nResultMsg));
5259 napi_value nResultCode;
5260 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5261 &nResultCode));
5262 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5263 result[PARAM0] = GetCallbackErrorValue(
5264 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5265 } else {
5266 napi_value nResultMsg;
5267 std::string msg = "error param type.";
5268 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5269 &nResultMsg));
5270 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5271 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5272 }
5273 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5274 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5275 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5276 &result[PARAM0], &callResult));
5277 },
5278 reinterpret_cast<void*>(asyncCallbackInfo),
5279 &asyncCallbackInfo->asyncWork));
5280 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5281 callbackPtr.release();
5282 napi_value result;
5283 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5284 return result;
5285 } else {
5286 napi_deferred deferred;
5287 napi_value promise;
5288 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5289 asyncCallbackInfo->deferred = deferred;
5290
5291 napi_value resourceName;
5292 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5293 NAPI_CALL(env, napi_create_async_work(
5294 env,
5295 nullptr,
5296 resourceName,
5297 [](napi_env env, void *data) {
5298 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5299 if (asyncCallbackInfo == nullptr) {
5300 return;
5301 }
5302 InnerInstall(env,
5303 asyncCallbackInfo->hapFiles,
5304 asyncCallbackInfo->installParam,
5305 asyncCallbackInfo->installResult);
5306 },
5307 [](napi_env env, napi_status status, void *data) {
5308 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5309 if (asyncCallbackInfo == nullptr) {
5310 return;
5311 }
5312 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5313 ConvertInstallResult(asyncCallbackInfo->installResult);
5314 napi_value result;
5315 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5316 napi_value nResultMsg;
5317 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5318 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5319 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5320 napi_value nResultCode;
5321 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5322 &nResultCode));
5323 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5324 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5325 result));
5326 },
5327 reinterpret_cast<void*>(asyncCallbackInfo),
5328 &asyncCallbackInfo->asyncWork));
5329 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5330 callbackPtr.release();
5331 return promise;
5332 }
5333 }
5334
InnerRecover(napi_env env,const std::string & bundleName,InstallParam & installParam,InstallResult & installResult)5335 static void InnerRecover(napi_env env, const std::string &bundleName, InstallParam &installParam,
5336 InstallResult &installResult)
5337 {
5338 if (bundleName.empty()) {
5339 installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME);
5340 return;
5341 }
5342 auto iBundleMgr = GetBundleMgr();
5343 if (iBundleMgr == nullptr) {
5344 APP_LOGE("can not get iBundleMgr");
5345 return;
5346 }
5347 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5348 if (iBundleInstaller == nullptr) {
5349 APP_LOGE("can not get iBundleInstaller");
5350 return;
5351 }
5352
5353 OHOS::sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5354 if (callback == nullptr) {
5355 APP_LOGE("callback nullptr");
5356 return;
5357 }
5358 iBundleInstaller->Recover(bundleName, installParam, callback);
5359 installResult.resultMsg = callback->GetResultMsg();
5360 APP_LOGD("InnerRecover resultMsg %{public}s", installResult.resultMsg.c_str());
5361 installResult.resultCode = callback->GetResultCode();
5362 APP_LOGD("InnerRecover resultCode %{public}d", installResult.resultCode);
5363 }
5364
Recover(napi_env env,napi_callback_info info)5365 napi_value Recover(napi_env env, napi_callback_info info)
5366 {
5367 size_t argc = ARGS_SIZE_THREE;
5368 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5369 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5370 APP_LOGD("argc = [%{public}zu]", argc);
5371 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5372 if (asyncCallbackInfo == nullptr) {
5373 return nullptr;
5374 }
5375 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5376 std::string bundleName;
5377 ParseString(env, bundleName, argv[PARAM0]);
5378 InstallParam installParam;
5379 if (!ParseInstallParam(env, installParam, argv[PARAM1])) {
5380 APP_LOGE("Recover installParam error, bundleName is %{public}s", bundleName.c_str());
5381 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5382 }
5383
5384 asyncCallbackInfo->installParam = installParam;
5385 asyncCallbackInfo->bundleName = bundleName;
5386 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5387 APP_LOGD("Recover by bundleName asyncCallback");
5388 napi_valuetype valuetype = napi_undefined;
5389 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5390 if (valuetype != napi_function) {
5391 APP_LOGE("Wrong argument type. Function expected");
5392 return nullptr;
5393 }
5394 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5395
5396 napi_value resourceName;
5397 NAPI_CALL(env, napi_create_string_latin1(env, "Recover", NAPI_AUTO_LENGTH, &resourceName));
5398 NAPI_CALL(env, napi_create_async_work(
5399 env,
5400 nullptr,
5401 resourceName,
5402 [](napi_env env, void *data) {
5403 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5404 if (asyncCallbackInfo == nullptr) {
5405 return;
5406 }
5407 if (!asyncCallbackInfo->errCode) {
5408 InnerRecover(env,
5409 asyncCallbackInfo->bundleName,
5410 asyncCallbackInfo->installParam,
5411 asyncCallbackInfo->installResult);
5412 }
5413 },
5414 [](napi_env env, napi_status status, void *data) {
5415 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5416 if (asyncCallbackInfo == nullptr) {
5417 return;
5418 }
5419 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5420 napi_value result[ARGS_SIZE_TWO] = {0};
5421 napi_value callback = 0;
5422 napi_value undefined = 0;
5423 napi_value callResult = 0;
5424 if (!asyncCallbackInfo->errCode) {
5425 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5426 ConvertInstallResult(asyncCallbackInfo->installResult);
5427 napi_value nResultMsg;
5428 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5429 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5430 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5431 nResultMsg));
5432 napi_value nResultCode;
5433 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5434 &nResultCode));
5435 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5436 result[PARAM0] = GetCallbackErrorValue(
5437 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5438 } else {
5439 napi_value nResultMsg;
5440 std::string msg = "error param type.";
5441 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5442 &nResultMsg));
5443 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5444 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5445 }
5446 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5447 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5448 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5449 &result[PARAM0], &callResult));
5450 },
5451 reinterpret_cast<void*>(asyncCallbackInfo),
5452 &asyncCallbackInfo->asyncWork));
5453 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5454 callbackPtr.release();
5455 napi_value result;
5456 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5457 return result;
5458 } else {
5459 napi_deferred deferred;
5460 napi_value promise;
5461 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5462 asyncCallbackInfo->deferred = deferred;
5463
5464 napi_value resourceName;
5465 NAPI_CALL(env, napi_create_string_latin1(env, "Recover", NAPI_AUTO_LENGTH, &resourceName));
5466 NAPI_CALL(env, napi_create_async_work(
5467 env,
5468 nullptr,
5469 resourceName,
5470 [](napi_env env, void *data) {
5471 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5472 if (asyncCallbackInfo == nullptr) {
5473 return;
5474 }
5475 InnerRecover(env,
5476 asyncCallbackInfo->bundleName,
5477 asyncCallbackInfo->installParam,
5478 asyncCallbackInfo->installResult);
5479 },
5480 [](napi_env env, napi_status status, void *data) {
5481 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5482 if (asyncCallbackInfo == nullptr) {
5483 return;
5484 }
5485 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5486 ConvertInstallResult(asyncCallbackInfo->installResult);
5487 napi_value result;
5488 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5489 napi_value nResultMsg;
5490 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5491 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5492 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5493 napi_value nResultCode;
5494 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5495 &nResultCode));
5496 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5497 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5498 result));
5499 },
5500 reinterpret_cast<void*>(asyncCallbackInfo),
5501 &asyncCallbackInfo->asyncWork));
5502 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5503 callbackPtr.release();
5504 return promise;
5505 }
5506 }
5507
InnerUninstall(napi_env env,const std::string & bundleName,InstallParam & installParam,InstallResult & installResult)5508 static void InnerUninstall(
5509 napi_env env, const std::string &bundleName, InstallParam &installParam, InstallResult &installResult)
5510 {
5511 auto iBundleMgr = GetBundleMgr();
5512 if (iBundleMgr == nullptr) {
5513 APP_LOGE("can not get iBundleMgr");
5514 return;
5515 }
5516 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5517 if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
5518 APP_LOGE("can not get iBundleInstaller");
5519 return;
5520 }
5521 installParam.installFlag = InstallFlag::NORMAL;
5522 OHOS::sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5523 if (callback == nullptr) {
5524 APP_LOGE("callback nullptr");
5525 return;
5526 }
5527
5528 sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
5529 iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
5530 iBundleInstaller->Uninstall(bundleName, installParam, callback);
5531 installResult.resultMsg = callback->GetResultMsg();
5532 APP_LOGD("-----InnerUninstall resultMsg %{public}s-----", installResult.resultMsg.c_str());
5533 installResult.resultCode = callback->GetResultCode();
5534 APP_LOGD("-----InnerUninstall resultCode %{public}d-----", installResult.resultCode);
5535 }
5536
5537 /**
5538 * Promise and async callback
5539 */
Uninstall(napi_env env,napi_callback_info info)5540 napi_value Uninstall(napi_env env, napi_callback_info info)
5541 {
5542 APP_LOGI("called");
5543 size_t argc = ARGS_SIZE_THREE;
5544 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5545 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5546 APP_LOGD("argc = [%{public}zu]", argc);
5547 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5548 if (asyncCallbackInfo == nullptr) {
5549 return nullptr;
5550 }
5551 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5552 std::string bundleName;
5553 ParseString(env, bundleName, argv[PARAM0]);
5554 InstallParam installParam;
5555 if (!ParseInstallParam(env, installParam, argv[PARAM1])) {
5556 APP_LOGE("Uninstall installParam error, bundleName is %{public}s", bundleName.c_str());
5557 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5558 }
5559
5560 asyncCallbackInfo->installParam = installParam;
5561 asyncCallbackInfo->bundleName = bundleName;
5562 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5563 APP_LOGI("Uninstall asyncCallback");
5564 napi_valuetype valuetype = napi_undefined;
5565 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5566 if (valuetype != napi_function) {
5567 APP_LOGE("Wrong argument type. Function expected");
5568 return nullptr;
5569 }
5570 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5571
5572 napi_value resourceName;
5573 NAPI_CALL(env, napi_create_string_latin1(env, "Uninstall", NAPI_AUTO_LENGTH, &resourceName));
5574 NAPI_CALL(env, napi_create_async_work(
5575 env,
5576 nullptr,
5577 resourceName,
5578 [](napi_env env, void *data) {
5579 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5580 if (asyncCallbackInfo == nullptr) {
5581 return;
5582 }
5583 if (!asyncCallbackInfo->errCode) {
5584 InnerUninstall(env,
5585 asyncCallbackInfo->bundleName,
5586 asyncCallbackInfo->installParam,
5587 asyncCallbackInfo->installResult);
5588 }
5589 },
5590 [](napi_env env, napi_status status, void *data) {
5591 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5592 if (asyncCallbackInfo == nullptr) {
5593 return;
5594 }
5595 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5596 napi_value result[ARGS_SIZE_TWO] = {0};
5597 napi_value callback = 0;
5598 napi_value undefined = 0;
5599 napi_value callResult = 0;
5600 if (!asyncCallbackInfo->errCode) {
5601 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5602 ConvertInstallResult(asyncCallbackInfo->installResult);
5603 napi_value nResultMsg;
5604 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5605 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5606 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5607 nResultMsg));
5608 napi_value nResultCode;
5609 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5610 &nResultCode));
5611 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5612 result[PARAM0] = GetCallbackErrorValue(
5613 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5614 } else {
5615 napi_value nResultMsg;
5616 std::string msg = "error param type.";
5617 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5618 &nResultMsg));
5619 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5620 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5621 }
5622 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5623 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5624 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5625 &result[PARAM0], &callResult));
5626 },
5627 reinterpret_cast<void*>(asyncCallbackInfo),
5628 &asyncCallbackInfo->asyncWork));
5629 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5630 callbackPtr.release();
5631 napi_value result;
5632 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5633 return result;
5634 } else {
5635 napi_deferred deferred;
5636 napi_value promise;
5637 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5638 asyncCallbackInfo->deferred = deferred;
5639
5640 napi_value resourceName;
5641 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5642 NAPI_CALL(env, napi_create_async_work(
5643 env,
5644 nullptr,
5645 resourceName,
5646 [](napi_env env, void *data) {
5647 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5648 if (asyncCallbackInfo == nullptr) {
5649 return;
5650 }
5651 InnerUninstall(
5652 env, asyncCallbackInfo->param, asyncCallbackInfo->installParam, asyncCallbackInfo->installResult);
5653 },
5654 [](napi_env env, napi_status status, void *data) {
5655 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5656 if (asyncCallbackInfo == nullptr) {
5657 return;
5658 }
5659 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5660 ConvertInstallResult(asyncCallbackInfo->installResult);
5661 napi_value result;
5662 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5663 napi_value nResultMsg;
5664 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5665 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5666 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5667 napi_value nResultCode;
5668 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5669 &nResultCode));
5670 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5671 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5672 result));
5673 },
5674 reinterpret_cast<void*>(asyncCallbackInfo),
5675 &asyncCallbackInfo->asyncWork));
5676 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5677 callbackPtr.release();
5678 return promise;
5679 }
5680 }
5681
BundleInstallerConstructor(napi_env env,napi_callback_info info)5682 napi_value BundleInstallerConstructor(napi_env env, napi_callback_info info)
5683 {
5684 napi_value jsthis = nullptr;
5685 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
5686 return jsthis;
5687 }
5688 } // namespace AppExecFwk
5689 } // namespace OHOS
5690