1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #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::__anon3991::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([[maybe_unused]] 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 ¶m, 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 ¶m, 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 }
2791 },
2792 [](napi_env env, napi_status status, void* data) {
2793 AsyncHandleBundleContext* asyncCallbackInfo =
2794 reinterpret_cast<AsyncHandleBundleContext*>(data);
2795 std::unique_ptr<AsyncHandleBundleContext> callbackPtr {asyncCallbackInfo};
2796 napi_value result[1] = { 0 };
2797 // set error code
2798 if (asyncCallbackInfo->err) {
2799 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[0]));
2800 } else {
2801 if (!asyncCallbackInfo->ret) {
2802 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
2803 } else {
2804 if (asyncCallbackInfo->cleanCacheCallback) {
2805 // wait for OnCleanCacheFinished
2806 uv_sem_wait(&(asyncCallbackInfo->cleanCacheCallback->uvSem_));
2807 asyncCallbackInfo->ret = asyncCallbackInfo->cleanCacheCallback->GetErr() ? false : true;
2808 if (!asyncCallbackInfo->cleanCacheCallback->GetErr()) {
2809 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[0]));
2810 } else {
2811 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
2812 asyncCallbackInfo->cleanCacheCallback->GetErr(), &result[0]));
2813 }
2814 }
2815 }
2816 }
2817 // implement callback or promise
2818 if (asyncCallbackInfo->deferred) {
2819 if (!asyncCallbackInfo->ret) {
2820 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
2821 } else {
2822 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[0]));
2823 }
2824 } else {
2825 napi_value callback = nullptr;
2826 napi_value placeHolder = nullptr;
2827 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
2828 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
2829 sizeof(result) / sizeof(result[0]), result, &placeHolder));
2830 }
2831 },
2832 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
2833 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
2834 callbackPtr.release();
2835 return promise;
2836 }
2837
CreateAbilityTypeObject(napi_env env)2838 napi_value CreateAbilityTypeObject(napi_env env)
2839 {
2840 APP_LOGD("enter");
2841
2842 napi_value value = nullptr;
2843 NAPI_CALL(env, napi_create_object(env, &value));
2844
2845 napi_value nUnknown = nullptr;
2846 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::UNKNOWN), &nUnknown));
2847 NAPI_CALL(env, napi_set_named_property(env, value, "UNKNOWN", nUnknown));
2848
2849 napi_value nPage = nullptr;
2850 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::PAGE), &nPage));
2851 NAPI_CALL(env, napi_set_named_property(env, value, "PAGE", nPage));
2852
2853 napi_value nService = nullptr;
2854 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::SERVICE), &nService));
2855 NAPI_CALL(env, napi_set_named_property(env, value, "SERVICE", nService));
2856
2857 napi_value nData = nullptr;
2858 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(AbilityType::DATA), &nData));
2859 NAPI_CALL(env, napi_set_named_property(env, value, "DATA", nData));
2860
2861 return value;
2862 }
2863
CreateAbilitySubTypeObject(napi_env env)2864 napi_value CreateAbilitySubTypeObject(napi_env env)
2865 {
2866 APP_LOGD("enter");
2867
2868 napi_value value = nullptr;
2869 NAPI_CALL(env, napi_create_object(env, &value));
2870
2871 napi_value nUnspecified = nullptr;
2872 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nUnspecified));
2873 NAPI_CALL(env, napi_set_named_property(env, value, "UNSPECIFIED", nUnspecified));
2874
2875 napi_value nCa = nullptr;
2876 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nCa));
2877 NAPI_CALL(env, napi_set_named_property(env, value, "CA", nCa));
2878
2879 return value;
2880 }
2881
CreateDisplayOrientationObject(napi_env env)2882 napi_value CreateDisplayOrientationObject(napi_env env)
2883 {
2884 APP_LOGD("enter");
2885
2886 napi_value value = nullptr;
2887 NAPI_CALL(env, napi_create_object(env, &value));
2888
2889 napi_value nUnspecified = nullptr;
2890 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::UNSPECIFIED), &nUnspecified));
2891 NAPI_CALL(env, napi_set_named_property(env, value, "UNSPECIFIED", nUnspecified));
2892
2893 napi_value nLandscape = nullptr;
2894 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LANDSCAPE), &nLandscape));
2895 NAPI_CALL(env, napi_set_named_property(env, value, "LANDSCAPE", nLandscape));
2896
2897 napi_value nPortrait = nullptr;
2898 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::PORTRAIT), &nPortrait));
2899 NAPI_CALL(env, napi_set_named_property(env, value, "PORTRAIT", nPortrait));
2900
2901 napi_value nFollowRecent = nullptr;
2902 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::FOLLOWRECENT), &nFollowRecent));
2903 NAPI_CALL(env, napi_set_named_property(env, value, "FOLLOW_RECENT", nFollowRecent));
2904
2905 napi_value nLandscapeInverted = nullptr;
2906 NAPI_CALL(env,
2907 napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LANDSCAPE_INVERTED), &nLandscapeInverted));
2908 NAPI_CALL(env, napi_set_named_property(env, value, "LANDSCAPE_INVERTED", nLandscapeInverted));
2909
2910 napi_value nPortraitInverted = nullptr;
2911 NAPI_CALL(env,
2912 napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::PORTRAIT_INVERTED), &nPortraitInverted));
2913 NAPI_CALL(env, napi_set_named_property(env, value, "PORTRAIT_INVERTED", nPortraitInverted));
2914
2915 napi_value nAutoRotation = nullptr;
2916 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION), &nAutoRotation));
2917 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION", nAutoRotation));
2918
2919 napi_value nAutoRotationLandscape = nullptr;
2920 NAPI_CALL(env, napi_create_int32(env,
2921 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_LANDSCAPE), &nAutoRotationLandscape));
2922 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_LANDSCAPE", nAutoRotationLandscape));
2923
2924 napi_value nAutoRotationPortrait = nullptr;
2925 NAPI_CALL(env, napi_create_int32(env,
2926 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_PORTRAIT), &nAutoRotationPortrait));
2927 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_PORTRAIT", nAutoRotationPortrait));
2928
2929 napi_value nAutoRotationRestricted = nullptr;
2930 NAPI_CALL(env, napi_create_int32(env,
2931 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_RESTRICTED), &nAutoRotationRestricted));
2932 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_RESTRICTED", nAutoRotationRestricted));
2933
2934 napi_value nAutoRotationLandscapeR = nullptr;
2935 NAPI_CALL(env, napi_create_int32(env,
2936 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED), &nAutoRotationLandscapeR));
2937 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_LANDSCAPE_RESTRICTED", nAutoRotationLandscapeR));
2938
2939 napi_value nAutoRotationPortraitR = nullptr;
2940 NAPI_CALL(env, napi_create_int32(env,
2941 static_cast<int32_t>(DisplayOrientation::AUTO_ROTATION_PORTRAIT_RESTRICTED), &nAutoRotationPortraitR));
2942 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_ROTATION_PORTRAIT_RESTRICTED", nAutoRotationPortraitR));
2943
2944 napi_value nLocked = nullptr;
2945 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(DisplayOrientation::LOCKED), &nLocked));
2946 NAPI_CALL(env, napi_set_named_property(env, value, "LOCKED", nLocked));
2947
2948 return value;
2949 }
2950
CreateLaunchModeObject(napi_env env)2951 napi_value CreateLaunchModeObject(napi_env env)
2952 {
2953 APP_LOGD("enter");
2954
2955 napi_value value = nullptr;
2956 NAPI_CALL(env, napi_create_object(env, &value));
2957
2958 napi_value nSingleton = nullptr;
2959 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(LaunchMode::SINGLETON), &nSingleton));
2960 NAPI_CALL(env, napi_set_named_property(env, value, "SINGLETON", nSingleton));
2961
2962 napi_value nStandard = nullptr;
2963 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(LaunchMode::STANDARD), &nStandard));
2964 NAPI_CALL(env, napi_set_named_property(env, value, "STANDARD", nStandard));
2965
2966 return value;
2967 }
2968
CreateFormTypeObject(napi_env env, napi_value value)2969 void CreateFormTypeObject(napi_env env, napi_value value)
2970 {
2971 napi_value nJava;
2972 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nJava));
2973 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "JAVA", nJava));
2974 napi_value nJs;
2975 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NAPI_RETURN_ONE, &nJs));
2976 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "JS", nJs));
2977 }
2978
CreateColorModeObject(napi_env env)2979 napi_value CreateColorModeObject(napi_env env)
2980 {
2981 APP_LOGD("enter");
2982
2983 napi_value value = nullptr;
2984 NAPI_CALL(env, napi_create_object(env, &value));
2985
2986 napi_value nAutoMode = nullptr;
2987 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_FAILED, &nAutoMode));
2988 NAPI_CALL(env, napi_set_named_property(env, value, "AUTO_MODE", nAutoMode));
2989
2990 napi_value nDarkMode = nullptr;
2991 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nDarkMode));
2992 NAPI_CALL(env, napi_set_named_property(env, value, "DARK_MODE", nDarkMode));
2993
2994 napi_value nLightMode = nullptr;
2995 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nLightMode));
2996 NAPI_CALL(env, napi_set_named_property(env, value, "LIGHT_MODE", nLightMode));
2997
2998 return value;
2999 }
3000
CreateGrantStatusObject(napi_env env)3001 napi_value CreateGrantStatusObject(napi_env env)
3002 {
3003 APP_LOGD("enter");
3004
3005 napi_value value = nullptr;
3006 NAPI_CALL(env, napi_create_object(env, &value));
3007
3008 napi_value nPermissionDenied = nullptr;
3009 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_FAILED, &nPermissionDenied));
3010 NAPI_CALL(env, napi_set_named_property(env, value, "PERMISSION_DENIED", nPermissionDenied));
3011
3012 napi_value nPermissionGranted = nullptr;
3013 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nPermissionGranted));
3014 NAPI_CALL(env, napi_set_named_property(env, value, "PERMISSION_GRANTED", nPermissionGranted));
3015
3016 return value;
3017 }
3018
CreateModuleRemoveFlagObject(napi_env env)3019 napi_value CreateModuleRemoveFlagObject(napi_env env)
3020 {
3021 APP_LOGD("enter");
3022
3023 napi_value value = nullptr;
3024 NAPI_CALL(env, napi_create_object(env, &value));
3025
3026 napi_value nNotUsedByForm = nullptr;
3027 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nNotUsedByForm));
3028 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_NOT_USED_BY_FORM", nNotUsedByForm));
3029
3030 napi_value nUsedByForm = nullptr;
3031 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nUsedByForm));
3032 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_USED_BY_FORM", nUsedByForm));
3033
3034 napi_value nNotUsedByShortcut = nullptr;
3035 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nNotUsedByShortcut));
3036 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_NOT_USED_BY_SHORTCUT", nNotUsedByShortcut));
3037
3038 napi_value nUsedByShortcut = nullptr;
3039 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_THREE, &nUsedByShortcut));
3040 NAPI_CALL(env, napi_set_named_property(env, value, "FLAG_MODULE_USED_BY_SHORTCUT", nUsedByShortcut));
3041
3042 return value;
3043 }
3044
CreateSignatureCompareResultObject(napi_env env)3045 napi_value CreateSignatureCompareResultObject(napi_env env)
3046 {
3047 APP_LOGD("enter");
3048
3049 napi_value value = nullptr;
3050 NAPI_CALL(env, napi_create_object(env, &value));
3051
3052 napi_value nMatched = nullptr;
3053 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nMatched));
3054 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_MATCHED", nMatched));
3055
3056 napi_value nNotMatched = nullptr;
3057 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nNotMatched));
3058 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_NOT_MATCHED", nNotMatched));
3059
3060 napi_value nUnknownBundle = nullptr;
3061 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nUnknownBundle));
3062 NAPI_CALL(env, napi_set_named_property(env, value, "SIGNATURE_UNKNOWN_BUNDLE", nUnknownBundle));
3063
3064 return value;
3065 }
3066
CreateShortcutExistenceObject(napi_env env)3067 napi_value CreateShortcutExistenceObject(napi_env env)
3068 {
3069 APP_LOGD("enter");
3070
3071 napi_value value = nullptr;
3072 NAPI_CALL(env, napi_create_object(env, &value));
3073
3074 napi_value nExists = nullptr;
3075 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nExists));
3076 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_EXISTS", nExists));
3077
3078 napi_value nNotExists = nullptr;
3079 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ONE, &nNotExists));
3080 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_NOT_EXISTS", nNotExists));
3081
3082 napi_value nUnknown = nullptr;
3083 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_TWO, &nUnknown));
3084 NAPI_CALL(env, napi_set_named_property(env, value, "SHORTCUT_EXISTENCE_UNKNOW", nUnknown));
3085
3086 return value;
3087 }
3088
CreateQueryShortCutFlagObject(napi_env env)3089 napi_value CreateQueryShortCutFlagObject(napi_env env)
3090 {
3091 APP_LOGD("enter");
3092
3093 napi_value value = nullptr;
3094 NAPI_CALL(env, napi_create_object(env, &value));
3095
3096 napi_value nShortcutHome = nullptr;
3097 NAPI_CALL(env, napi_create_int32(env, NAPI_RETURN_ZERO, &nShortcutHome));
3098 NAPI_CALL(env, napi_set_named_property(env, value, "QUERY_SHORTCUT_HOME", nShortcutHome));
3099
3100 return value;
3101 }
3102
CreateBundleFlagObject(napi_env env)3103 napi_value CreateBundleFlagObject(napi_env env)
3104 {
3105 APP_LOGD("enter");
3106
3107 napi_value value = nullptr;
3108 NAPI_CALL(env, napi_create_object(env, &value));
3109
3110 napi_value nAllApplictionInfo = nullptr;
3111 NAPI_CALL(env, napi_create_int32(env,
3112 static_cast<int32_t>(ApplicationFlag::GET_ALL_APPLICATION_INFO), &nAllApplictionInfo));
3113 NAPI_CALL(env, napi_set_named_property(env, value, "GET_ALL_APPLICATION_INFO", nAllApplictionInfo));
3114
3115 napi_value nBundleDefault = nullptr;
3116 NAPI_CALL(env, napi_create_int32(env,
3117 static_cast<int32_t>(BundleFlag::GET_BUNDLE_DEFAULT), &nBundleDefault));
3118 NAPI_CALL(env, napi_set_named_property(env, value, "GET_BUNDLE_DEFAULT", nBundleDefault));
3119
3120 napi_value nBundleWithAbilities = nullptr;
3121 NAPI_CALL(env, napi_create_int32(env,
3122 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_ABILITIES), &nBundleWithAbilities));
3123 NAPI_CALL(env, napi_set_named_property(env, value, "GET_BUNDLE_WITH_ABILITIES", nBundleWithAbilities));
3124
3125 napi_value nBundleWithRequestedPermission = nullptr;
3126 NAPI_CALL(env, napi_create_int32(env,
3127 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_REQUESTED_PERMISSION), &nBundleWithRequestedPermission));
3128 NAPI_CALL(env, napi_set_named_property(env, value,
3129 "GET_BUNDLE_WITH_REQUESTED_PERMISSION", nBundleWithRequestedPermission));
3130
3131 napi_value nAbilityInfoWithPermission = nullptr;
3132 NAPI_CALL(env, napi_create_int32(env,
3133 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_PERMISSION), &nAbilityInfoWithPermission));
3134 NAPI_CALL(env, napi_set_named_property(env, value,
3135 "GET_ABILITY_INFO_WITH_PERMISSION", nAbilityInfoWithPermission));
3136
3137 napi_value nAbilityInfoWithApplication = nullptr;
3138 NAPI_CALL(env, napi_create_int32(env,
3139 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION), &nAbilityInfoWithApplication));
3140 NAPI_CALL(env, napi_set_named_property(env, value,
3141 "GET_ABILITY_INFO_WITH_APPLICATION", nAbilityInfoWithApplication));
3142
3143 napi_value nAbilityInfoSystemAppOnly = nullptr;
3144 NAPI_CALL(env, napi_create_int32(env,
3145 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_SYSTEMAPP_ONLY), &nAbilityInfoSystemAppOnly));
3146 NAPI_CALL(env, napi_set_named_property(env, value,
3147 "GET_ABILITY_INFO_SYSTEMAPP_ONLY", nAbilityInfoSystemAppOnly));
3148
3149 napi_value nAbilityInfoWithMetaData = nullptr;
3150 NAPI_CALL(env, napi_create_int32(env,
3151 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_METADATA), &nAbilityInfoWithMetaData));
3152 NAPI_CALL(env, napi_set_named_property(env, value,
3153 "GET_ABILITY_INFO_WITH_METADATA", nAbilityInfoWithMetaData));
3154
3155 napi_value nBundleWithHashValue = nullptr;
3156 NAPI_CALL(env, napi_create_int32(env,
3157 static_cast<int32_t>(BundleFlag::GET_BUNDLE_WITH_HASH_VALUE), &nBundleWithHashValue));
3158 NAPI_CALL(env, napi_set_named_property(env, value,
3159 "GET_BUNDLE_WITH_HASH_VALUE", nBundleWithHashValue));
3160
3161 napi_value nAbilityInfoWithDisable = nullptr;
3162 NAPI_CALL(env, napi_create_int32(env,
3163 static_cast<int32_t>(AbilityInfoFlag::GET_ABILITY_INFO_WITH_DISABLE), &nAbilityInfoWithDisable));
3164 NAPI_CALL(env, napi_set_named_property(env, value,
3165 "GET_ABILITY_INFO_WITH_DISABLE", nAbilityInfoWithDisable));
3166
3167 napi_value nAppInfoWithPermission = nullptr;
3168 NAPI_CALL(env, napi_create_int32(env,
3169 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION), &nAppInfoWithPermission));
3170 NAPI_CALL(env, napi_set_named_property(env, value,
3171 "GET_APPLICATION_INFO_WITH_PERMISSION", nAppInfoWithPermission));
3172
3173 napi_value nAppInfoWithMetaData = nullptr;
3174 NAPI_CALL(env, napi_create_int32(env,
3175 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), &nAppInfoWithMetaData));
3176 NAPI_CALL(env, napi_set_named_property(env, value,
3177 "GET_APPLICATION_INFO_WITH_METADATA", nAppInfoWithMetaData));
3178
3179 napi_value nAppInfoWithDisable = nullptr;
3180 NAPI_CALL(env, napi_create_int32(env,
3181 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_DISABLE), &nAppInfoWithDisable));
3182 NAPI_CALL(env, napi_set_named_property(env, value,
3183 "GET_APPLICATION_INFO_WITH_DISABLE", nAppInfoWithDisable));
3184
3185 napi_value nAppInfoWithCertificate = nullptr;
3186 NAPI_CALL(env, napi_create_int32(env,
3187 static_cast<int32_t>(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT),
3188 &nAppInfoWithCertificate));
3189 NAPI_CALL(env, napi_set_named_property(env, value,
3190 "GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT", nAppInfoWithCertificate));
3191
3192 return value;
3193 }
3194
3195
CreateInstallErrorCodeObject(napi_env env, napi_value value)3196 void CreateInstallErrorCodeObject(napi_env env, napi_value value)
3197 {
3198 napi_value nSuccess;
3199 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::SUCCESS), &nSuccess));
3200 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "SUCCESS", nSuccess));
3201 napi_value nStatusInstallFailure;
3202 NAPI_CALL_RETURN_VOID(env,
3203 napi_create_int32(
3204 env, static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE), &nStatusInstallFailure));
3205 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE", nStatusInstallFailure));
3206 napi_value nStatusInstallFailureAborted;
3207 NAPI_CALL_RETURN_VOID(env,
3208 napi_create_int32(env,
3209 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_ABORTED),
3210 &nStatusInstallFailureAborted));
3211 NAPI_CALL_RETURN_VOID(
3212 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_ABORTED", nStatusInstallFailureAborted));
3213 napi_value nStatusInstallFailureInvalid;
3214 NAPI_CALL_RETURN_VOID(env,
3215 napi_create_int32(env,
3216 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INVALID),
3217 &nStatusInstallFailureInvalid));
3218 NAPI_CALL_RETURN_VOID(
3219 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_INVALID", nStatusInstallFailureInvalid));
3220 napi_value nStatusInstallFailureConflict;
3221 NAPI_CALL_RETURN_VOID(env,
3222 napi_create_int32(env,
3223 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_CONFLICT),
3224 &nStatusInstallFailureConflict));
3225 NAPI_CALL_RETURN_VOID(
3226 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_CONFLICT", nStatusInstallFailureConflict));
3227 napi_value nStatusInstallFailureStorage;
3228 NAPI_CALL_RETURN_VOID(env,
3229 napi_create_int32(env,
3230 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_STORAGE),
3231 &nStatusInstallFailureStorage));
3232 NAPI_CALL_RETURN_VOID(
3233 env, napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_STORAGE", nStatusInstallFailureStorage));
3234 napi_value nStatusInstallFailureIncompatible;
3235 NAPI_CALL_RETURN_VOID(env,
3236 napi_create_int32(env,
3237 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INCOMPATIBLE),
3238 &nStatusInstallFailureIncompatible));
3239 NAPI_CALL_RETURN_VOID(env,
3240 napi_set_named_property(env, value, "STATUS_INSTALL_FAILURE_INCOMPATIBLE", nStatusInstallFailureIncompatible));
3241 napi_value nStatusUninstallFailure;
3242 NAPI_CALL_RETURN_VOID(env,
3243 napi_create_int32(
3244 env, static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE), &nStatusUninstallFailure));
3245 NAPI_CALL_RETURN_VOID(
3246 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE", nStatusUninstallFailure));
3247 napi_value nStatusUninstallFailureBlocked;
3248 NAPI_CALL_RETURN_VOID(env,
3249 napi_create_int32(env,
3250 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_BLOCKED),
3251 &nStatusUninstallFailureBlocked));
3252 NAPI_CALL_RETURN_VOID(
3253 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE_BLOCKED", nStatusUninstallFailureBlocked));
3254 napi_value nStatusUninstallFailureAborted;
3255 NAPI_CALL_RETURN_VOID(env,
3256 napi_create_int32(env,
3257 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_ABORTED),
3258 &nStatusUninstallFailureAborted));
3259 NAPI_CALL_RETURN_VOID(
3260 env, napi_set_named_property(env, value, "STATUS_UNINSTALL_FAILURE_ABORTED", nStatusUninstallFailureAborted));
3261 napi_value nStatusUninstallFailureConflict;
3262 NAPI_CALL_RETURN_VOID(env,
3263 napi_create_int32(env,
3264 static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_CONFLICT),
3265 &nStatusUninstallFailureConflict));
3266 NAPI_CALL_RETURN_VOID(
3267 env, napi_set_named_property(
3268 env, value, "STATUS_UNINSTALL_FAILURE_CONFLICT", nStatusUninstallFailureConflict));
3269 napi_value nStatusInstallFailureDownloadTimeout;
3270 NAPI_CALL_RETURN_VOID(env,
3271 napi_create_int32(env,
3272 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_DOWNLOAD_TIMEOUT),
3273 &nStatusInstallFailureDownloadTimeout));
3274 NAPI_CALL_RETURN_VOID(env,
3275 napi_set_named_property(
3276 env, value, "STATUS_INSTALL_FAILURE_DOWNLOAD_TIMEOUT", nStatusInstallFailureDownloadTimeout));
3277 napi_value nStatusInstallFailureDownloadFailed;
3278 NAPI_CALL_RETURN_VOID(env,
3279 napi_create_int32(env,
3280 static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_DOWNLOAD_FAILED),
3281 &nStatusInstallFailureDownloadFailed));
3282 NAPI_CALL_RETURN_VOID(env,
3283 napi_set_named_property(
3284 env, value, "STATUS_INSTALL_FAILURE_DOWNLOAD_FAILED", nStatusInstallFailureDownloadFailed));
3285 napi_value nStatusAbilityNotFound;
3286 NAPI_CALL_RETURN_VOID(env,
3287 napi_create_int32(
3288 env, static_cast<int32_t>(InstallErrorCode::STATUS_ABILITY_NOT_FOUND), &nStatusAbilityNotFound));
3289 NAPI_CALL_RETURN_VOID(
3290 env, napi_set_named_property(env, value, "STATUS_ABILITY_NOT_FOUND", nStatusAbilityNotFound));
3291 napi_value nBmsServiceError;
3292 NAPI_CALL_RETURN_VOID(env,
3293 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR), &nBmsServiceError));
3294 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_BMS_SERVICE_ERROR", nBmsServiceError));
3295 napi_value nStatusGrantRequestPermissionsFailed;
3296 NAPI_CALL_RETURN_VOID(env,
3297 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_GRANT_REQUEST_PERMISSIONS_FAILED),
3298 &nStatusGrantRequestPermissionsFailed));
3299 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_GRANT_REQUEST_PERMISSIONS_FAILED",
3300 nStatusGrantRequestPermissionsFailed));
3301 napi_value nStatusInstallPermissionDenied;
3302 NAPI_CALL_RETURN_VOID(env,
3303 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_PERMISSION_DENIED),
3304 &nStatusInstallPermissionDenied));
3305 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_INSTALL_PERMISSION_DENIED",
3306 nStatusInstallPermissionDenied));
3307 napi_value nStatusUnInstallPermissionDenied;
3308 NAPI_CALL_RETURN_VOID(env,
3309 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_PERMISSION_DENIED),
3310 &nStatusUnInstallPermissionDenied));
3311 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_UNINSTALL_PERMISSION_DENIED",
3312 nStatusUnInstallPermissionDenied));
3313 napi_value nNoSpaceLeft;
3314 NAPI_CALL_RETURN_VOID(env,
3315 napi_create_int32(env, static_cast<int32_t>(InstallErrorCode::STATUS_FAILED_NO_SPACE_LEFT), &nNoSpaceLeft));
3316 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "STATUS_FAILED_NO_SPACE_LEFT", nNoSpaceLeft));
3317 napi_value nRecoverFailure;
3318 NAPI_CALL_RETURN_VOID(env,
3319 napi_create_int32(env,
3320 static_cast<int32_t>(InstallErrorCode::STATUS_RECOVER_FAILURE_INVALID), &nRecoverFailure));
3321 NAPI_CALL_RETURN_VOID(env,
3322 napi_set_named_property(env, value, "STATUS_RECOVER_FAILURE_INVALID", nRecoverFailure));
3323 }
3324
InnerGetApplicationInfo( const std::string &bundleName, int32_t flags, const int userId, ApplicationInfo &appInfo)3325 static bool InnerGetApplicationInfo(
3326 const std::string &bundleName, int32_t flags, const int userId, ApplicationInfo &appInfo)
3327 {
3328 auto iBundleMgr = GetBundleMgr();
3329 if (!iBundleMgr) {
3330 APP_LOGE("can not get iBundleMgr");
3331 return false;
3332 }
3333 return iBundleMgr->GetApplicationInfo(bundleName, flags, userId, appInfo);
3334 }
3335
InnerGetBundleInfo( napi_env env, const std::string &bundleName, int32_t flags, BundleOptions bundleOptions, BundleInfo &bundleInfo)3336 static bool InnerGetBundleInfo(
3337 napi_env env, const std::string &bundleName, int32_t flags, BundleOptions bundleOptions, BundleInfo &bundleInfo)
3338 {
3339 auto iBundleMgr = GetBundleMgr();
3340 if (iBundleMgr == nullptr) {
3341 APP_LOGE("can not get iBundleMgr");
3342 return false;
3343 }
3344 bool ret = iBundleMgr->GetBundleInfo(bundleName, flags, bundleInfo, bundleOptions.userId);
3345 if (!ret) {
3346 APP_LOGE("bundleInfo is not find, bundleName is %{public}s, flags is %{public}d, userId is %{public}d",
3347 bundleName.c_str(), flags, bundleOptions.userId);
3348 }
3349 return ret;
3350 }
3351
GetAllApplicationInfoExec(napi_env env, void *data)3352 void GetAllApplicationInfoExec(napi_env env, void *data)
3353 {
3354 APP_LOGD("NAPI begin");
3355 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
3356 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
3357 if (asyncCallbackInfo == nullptr) {
3358 APP_LOGE("asyncCallbackInfo is null");
3359 return;
3360 }
3361 if (asyncCallbackInfo->err == NO_ERROR) {
3362 asyncCallbackInfo->ret = InnerGetApplicationInfos(asyncCallbackInfo->env,
3363 asyncCallbackInfo->flags,
3364 asyncCallbackInfo->userId,
3365 asyncCallbackInfo->appInfos);
3366 }
3367 APP_LOGD("NAPI end");
3368 }
3369
GetAllApplicationInfoComplete(napi_env env, napi_status status, void* data)3370 void GetAllApplicationInfoComplete(napi_env env, napi_status status, void* data)
3371 {
3372 APP_LOGD("NAPI begin");
3373 AsyncApplicationInfosCallbackInfo* asyncCallbackInfo =
3374 reinterpret_cast<AsyncApplicationInfosCallbackInfo*>(data);
3375 if (asyncCallbackInfo == nullptr) {
3376 APP_LOGE("asyncCallbackInfo is null");
3377 return;
3378 }
3379 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
3380 napi_value result[ARGS_SIZE_TWO] = { 0 };
3381 if (asyncCallbackInfo->err != NO_ERROR) {
3382 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "");
3383 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
3384 NAPI_AUTO_LENGTH, &result[1]));
3385 } else {
3386 if (asyncCallbackInfo->ret) {
3387 result[0] = BusinessError::CreateError(env, 0, "");
3388 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result[1]));
3389 ProcessApplicationInfos(env, result[1], asyncCallbackInfo->appInfos);
3390 } else {
3391 result[0] = BusinessError::CreateError(env, 1, "");
3392 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3393 }
3394 }
3395 if (asyncCallbackInfo->deferred) {
3396 if (asyncCallbackInfo->ret != NO_ERROR) {
3397 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
3398 } else {
3399 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
3400 }
3401 } else {
3402 napi_value callback = nullptr;
3403 napi_value placeHolder = nullptr;
3404 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
3405 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
3406 sizeof(result) / sizeof(result[0]), result, &placeHolder));
3407 }
3408 APP_LOGD("NAPI end");
3409 }
3410
GetAllApplicationInfo(napi_env env, napi_callback_info info)3411 napi_value GetAllApplicationInfo(napi_env env, napi_callback_info info)
3412 {
3413 APP_LOGD("NAPI begin");
3414 size_t argc = ARGS_SIZE_THREE;
3415 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
3416 napi_value thisArg = nullptr;
3417 void *data = nullptr;
3418 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
3419 APP_LOGI("argc = [%{public}zu]", argc);
3420 AsyncApplicationInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncApplicationInfosCallbackInfo(env);
3421 if (asyncCallbackInfo == nullptr) {
3422 APP_LOGE("asyncCallbackInfo is null");
3423 return nullptr;
3424 }
3425 std::unique_ptr<AsyncApplicationInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
3426 for (size_t i = 0; i < argc; ++i) {
3427 napi_valuetype valueType = napi_undefined;
3428 napi_typeof(env, argv[i], &valueType);
3429 if ((i == 0) && (valueType == napi_number)) {
3430 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
3431 if (argc == ARGS_SIZE_ONE) {
3432 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3433 }
3434 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_number)) {
3435 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
3436 } else if ((i == ARGS_SIZE_ONE) && (valueType == napi_function)) {
3437 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3438 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3439 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_function)) {
3440 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3441 break;
3442 } else {
3443 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3444 asyncCallbackInfo->message = TYPE_MISMATCH;
3445 }
3446 }
3447
3448 if (argc == 0) {
3449 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3450 asyncCallbackInfo->message = TYPE_MISMATCH;
3451 }
3452 napi_value promise = nullptr;
3453 if (asyncCallbackInfo->callback == nullptr) {
3454 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
3455 } else {
3456 NAPI_CALL(env, napi_get_undefined(env, &promise));
3457 }
3458
3459 napi_value resource = nullptr;
3460 NAPI_CALL(env, napi_create_string_utf8(env, NAPI_GET_APPLICATION_INFO, NAPI_AUTO_LENGTH, &resource));
3461 NAPI_CALL(env, napi_create_async_work(
3462 env, nullptr, resource, GetAllApplicationInfoExec, GetAllApplicationInfoComplete,
3463 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
3464 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3465 callbackPtr.release();
3466 APP_LOGD("NAPI end");
3467 return promise;
3468 }
3469
GetApplicationInfoExec(napi_env env, void *data)3470 void GetApplicationInfoExec(napi_env env, void *data)
3471 {
3472 APP_LOGD("NAPI begin");
3473 AsyncApplicationInfoCallbackInfo* asyncCallbackInfo =
3474 reinterpret_cast<AsyncApplicationInfoCallbackInfo*>(data);
3475 if (asyncCallbackInfo == nullptr) {
3476 APP_LOGE("asyncCallbackInfo is null");
3477 return;
3478 }
3479 if (asyncCallbackInfo->err == NO_ERROR) {
3480 asyncCallbackInfo->ret = InnerGetApplicationInfo(asyncCallbackInfo->bundleName,
3481 asyncCallbackInfo->flags,
3482 asyncCallbackInfo->userId,
3483 asyncCallbackInfo->appInfo);
3484 }
3485 APP_LOGD("NAPI end");
3486 }
3487
GetApplicationInfoComplete(napi_env env, napi_status status, void *data)3488 void GetApplicationInfoComplete(napi_env env, napi_status status, void *data)
3489 {
3490 APP_LOGD("NAPI begin");
3491 AsyncApplicationInfoCallbackInfo* asyncCallbackInfo =
3492 reinterpret_cast<AsyncApplicationInfoCallbackInfo*>(data);
3493 if (asyncCallbackInfo == nullptr) {
3494 APP_LOGE("asyncCallbackInfo is null");
3495 return;
3496 }
3497 std::unique_ptr<AsyncApplicationInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3498 napi_value result[ARGS_SIZE_TWO] = { 0 };
3499 if (asyncCallbackInfo->err != NO_ERROR) {
3500 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "");
3501 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
3502 NAPI_AUTO_LENGTH, &result[1]));
3503 } else {
3504 if (asyncCallbackInfo->ret) {
3505 result[0] = BusinessError::CreateError(env, 0, "");
3506 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
3507 ConvertApplicationInfo(env, result[1], asyncCallbackInfo->appInfo);
3508 } else {
3509 result[0] = BusinessError::CreateError(env, 1, "");
3510 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3511 }
3512 }
3513 if (asyncCallbackInfo->deferred) {
3514 if (asyncCallbackInfo->ret) {
3515 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
3516 } else {
3517 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
3518 }
3519 } else {
3520 napi_value callback = nullptr;
3521 napi_value placeHolder = nullptr;
3522 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
3523 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
3524 sizeof(result) / sizeof(result[0]), result, &placeHolder));
3525 }
3526 APP_LOGD("NAPI end");
3527 }
3528
GetApplicationInfo(napi_env env, napi_callback_info info)3529 napi_value GetApplicationInfo(napi_env env, napi_callback_info info)
3530 {
3531 APP_LOGD("NAPI begin");
3532 size_t argc = ARGS_SIZE_FOUR;
3533 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
3534 napi_value thisArg = nullptr;
3535 void *data = nullptr;
3536 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
3537 APP_LOGD("argc = [%{public}zu]", argc);
3538 AsyncApplicationInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncApplicationInfoCallbackInfo(env);
3539 if (asyncCallbackInfo == nullptr) {
3540 APP_LOGE("asyncCallbackInfo is nullptr");
3541 return nullptr;
3542 }
3543 std::unique_ptr<AsyncApplicationInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3544 for (size_t i = 0; i < argc; ++i) {
3545 napi_valuetype valueType = napi_undefined;
3546 napi_typeof(env, argv[i], &valueType);
3547 if ((i == 0) && (valueType == napi_string)) {
3548 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
3549 } else if ((i == ARGS_SIZE_ONE) && valueType == napi_number) {
3550 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
3551 if (argc == ARGS_SIZE_TWO) {
3552 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3553 }
3554 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_number)) {
3555 ParseInt(env, asyncCallbackInfo->userId, argv[i]);
3556 } else if ((i == ARGS_SIZE_TWO) && (valueType == napi_function)) {
3557 asyncCallbackInfo->userId = IPCSkeleton::GetCallingUid() / Constants::BASE_USER_RANGE;
3558 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3559 } else if ((i == ARGS_SIZE_THREE) && (valueType == napi_function)) {
3560 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3561 break;
3562 } else {
3563 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3564 asyncCallbackInfo->message = TYPE_MISMATCH;
3565 }
3566 }
3567 if (argc == 0) {
3568 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3569 asyncCallbackInfo->message = TYPE_MISMATCH;
3570 }
3571 napi_value promise = nullptr;
3572 if (asyncCallbackInfo->callback == nullptr) {
3573 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
3574 } else {
3575 NAPI_CALL(env, napi_get_undefined(env, &promise));
3576 }
3577 napi_value resource = nullptr;
3578 NAPI_CALL(env, napi_create_string_utf8(env, NAPI_GET_APPLICATION_INFO, NAPI_AUTO_LENGTH, &resource));
3579 NAPI_CALL(env, napi_create_async_work(
3580 env, nullptr, resource, GetApplicationInfoExec, GetApplicationInfoComplete,
3581 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
3582 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
3583 callbackPtr.release();
3584 APP_LOGD("NAPI end");
3585 return promise;
3586 }
3587
3588 #ifdef BUNDLE_FRAMEWORK_GRAPHICS
GetAbilityIconExec(napi_env env, void *data)3589 void GetAbilityIconExec(napi_env env, void *data)
3590 {
3591 APP_LOGD("NAPI begin");
3592 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3593 if (asyncCallbackInfo == nullptr) {
3594 APP_LOGE("asyncCallbackInfo is null");
3595 return;
3596 }
3597 if (asyncCallbackInfo->err != NO_ERROR) {
3598 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3599 return;
3600 }
3601 BundleGraphicsClient client;
3602 asyncCallbackInfo->ret = client.GetAbilityPixelMapIcon(asyncCallbackInfo->bundleName,
3603 asyncCallbackInfo->moduleName, asyncCallbackInfo->abilityName, asyncCallbackInfo->pixelMap);
3604 APP_LOGD("NAPI end");
3605 }
3606
GetAbilityIconComplete(napi_env env, napi_status status, void *data)3607 void GetAbilityIconComplete(napi_env env, napi_status status, void *data)
3608 {
3609 APP_LOGD("NAPI begin");
3610 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3611 if (asyncCallbackInfo == nullptr) {
3612 APP_LOGE("asyncCallbackInfo is null");
3613 return;
3614 }
3615 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3616 napi_value result[ARGS_SIZE_TWO] = {0};
3617 if (asyncCallbackInfo->err != NO_ERROR) {
3618 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3619 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[0]));
3620 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3621 } else if (asyncCallbackInfo->ret != ERR_OK) {
3622 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3623 asyncCallbackInfo->err = OPERATION_FAILED;
3624 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
3625 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3626 } else {
3627 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, NO_ERROR, &result[0]));
3628 result[1] = Media::PixelMapNapi::CreatePixelMap(env, asyncCallbackInfo->pixelMap);
3629 }
3630 CommonFunc::NapiReturnDeferred<AbilityIconCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3631 APP_LOGD("NAPI end");
3632 }
3633
GetAbilityIcon(napi_env env, napi_callback_info info)3634 napi_value GetAbilityIcon(napi_env env, napi_callback_info info)
3635 {
3636 APP_LOGD("NAPI begin");
3637 AbilityIconCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityIconCallbackInfo(env);
3638 if (asyncCallbackInfo == nullptr) {
3639 APP_LOGE("asyncCallbackInfo is null");
3640 return nullptr;
3641 }
3642 asyncCallbackInfo->err = NO_ERROR;
3643 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3644 NapiArg args(env, info);
3645 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_FOUR)) {
3646 APP_LOGE("parameters init failed");
3647 napi_value ret = nullptr;
3648 NAPI_CALL(env, napi_get_undefined(env, &ret));
3649 return ret;
3650 }
3651 asyncCallbackInfo->hasModuleName = false;
3652 napi_valuetype valueType = napi_undefined;
3653 napi_typeof(env, args[args.GetMaxArgc() - 1], &valueType);
3654 if (valueType == napi_function) {
3655 asyncCallbackInfo->hasModuleName = (args.GetMaxArgc() == ARGS_SIZE_FOUR) ? true : false;
3656 } else {
3657 asyncCallbackInfo->hasModuleName = (args.GetMaxArgc() == ARGS_SIZE_THREE) ? true : false;
3658 }
3659 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
3660 APP_LOGE("BundleName parse failed");
3661 asyncCallbackInfo->err = INVALID_PARAM;
3662 }
3663 if (asyncCallbackInfo->hasModuleName) {
3664 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->moduleName)) {
3665 APP_LOGE("ModuleName parse failed");
3666 asyncCallbackInfo->err = INVALID_PARAM;
3667 }
3668 } else {
3669 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->abilityName)) {
3670 APP_LOGE("AbilityName parse failed");
3671 asyncCallbackInfo->err = INVALID_PARAM;
3672 }
3673 }
3674 if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
3675 valueType = napi_undefined;
3676 napi_typeof(env, args[ARGS_POS_TWO], &valueType);
3677 if (valueType != napi_function) {
3678 if (!CommonFunc::ParseString(env, args[ARGS_POS_TWO], asyncCallbackInfo->abilityName)) {
3679 APP_LOGE("AbilityName parse failed");
3680 asyncCallbackInfo->err = INVALID_PARAM;
3681 }
3682 } else {
3683 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_TWO],
3684 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3685 }
3686 }
3687 if (args.GetMaxArgc() >= ARGS_SIZE_FOUR) {
3688 valueType = napi_undefined;
3689 napi_typeof(env, args[ARGS_POS_THREE], &valueType);
3690 if (valueType == napi_function) {
3691 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_THREE],
3692 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3693 }
3694 }
3695
3696 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityIconCallbackInfo>(
3697 env, asyncCallbackInfo, GET_ABILITY_ICON, GetAbilityIconExec, GetAbilityIconComplete);
3698 callbackPtr.release();
3699 APP_LOGD("NAPI end");
3700 return promise;
3701 }
3702 #else
GetAbilityIconComplete(napi_env env, napi_status status, void *data)3703 void GetAbilityIconComplete(napi_env env, napi_status status, void *data)
3704 {
3705 APP_LOGD("NAPI begin");
3706 AbilityIconCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityIconCallbackInfo *>(data);
3707 if (asyncCallbackInfo == nullptr) {
3708 APP_LOGE("asyncCallbackInfo is null");
3709 return;
3710 }
3711 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3712 APP_LOGE("unsupported BundleManagerService feature");
3713 asyncCallbackInfo->err = UNSUPPORTED_FEATURE_ERRCODE;
3714 napi_value result[ARGS_SIZE_TWO] = {0};
3715 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, UNSUPPORTED_FEATURE_ERRCODE, &result[0]));
3716 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
3717 UNSUPPORTED_FEATURE_MESSAGE.c_str(), NAPI_AUTO_LENGTH, &result[1]));
3718 CommonFunc::NapiReturnDeferred<AbilityIconCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3719 APP_LOGD("NAPI end");
3720 }
3721
GetAbilityIcon(napi_env env, napi_callback_info info)3722 napi_value GetAbilityIcon(napi_env env, napi_callback_info info)
3723 {
3724 APP_LOGD("NAPI begin");
3725 AbilityIconCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityIconCallbackInfo(env);
3726 if (asyncCallbackInfo == nullptr) {
3727 APP_LOGE("asyncCallbackInfo is null");
3728 return nullptr;
3729 }
3730 std::unique_ptr<AbilityIconCallbackInfo> callbackPtr {asyncCallbackInfo};
3731
3732 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityIconCallbackInfo>(
3733 env, asyncCallbackInfo, GET_BUNDLE_ARCHIVE_INFO, nullptr, GetAbilityIconComplete);
3734 callbackPtr.release();
3735 APP_LOGD("NAPI end");
3736 return promise;
3737 }
3738 #endif
3739
GetBundleArchiveInfoExec(napi_env env, void *data)3740 void GetBundleArchiveInfoExec(napi_env env, void *data)
3741 {
3742 APP_LOGD("NAPI begin");
3743 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetBundleArchiveInfoCallbackInfo *>(data);
3744 if (asyncCallbackInfo == nullptr) {
3745 APP_LOGE("asyncCallbackInfo is null");
3746 return;
3747 }
3748 if (asyncCallbackInfo->err != NO_ERROR) {
3749 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3750 return;
3751 }
3752 auto iBundleMgr = CommonFunc::GetBundleMgr();
3753 if (iBundleMgr == nullptr) {
3754 APP_LOGE("iBundleMgr is null");
3755 return;
3756 }
3757 APP_LOGD("start GetBundleArchiveInfo, hapFilePath %{public}s", asyncCallbackInfo->hapFilePath.c_str());
3758 asyncCallbackInfo->ret = iBundleMgr->GetBundleArchiveInfo(
3759 asyncCallbackInfo->hapFilePath, asyncCallbackInfo->flags, asyncCallbackInfo->bundleInfo);
3760 APP_LOGD("NAPI end");
3761 }
3762
GetBundleArchiveInfoComplete(napi_env env, napi_status status, void *data)3763 void GetBundleArchiveInfoComplete(napi_env env, napi_status status, void *data)
3764 {
3765 APP_LOGD("NAPI begin");
3766 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetBundleArchiveInfoCallbackInfo *>(data);
3767 if (asyncCallbackInfo == nullptr) {
3768 APP_LOGE("asyncCallbackInfo is null");
3769 return;
3770 }
3771 std::unique_ptr<GetBundleArchiveInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3772 napi_value result[ARGS_SIZE_TWO] = {0};
3773 if (asyncCallbackInfo->err != NO_ERROR) {
3774 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3775 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, "type mismatch");
3776 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3777 } else if (!asyncCallbackInfo->ret) {
3778 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3779 asyncCallbackInfo->err = OPERATION_FAILED;
3780 result[0] = BusinessError::CreateError(env, OPERATION_FAILED, "GetBundleArchiveInfo falied");
3781 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3782 } else {
3783 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3784 napi_create_object(env, &result[1]);
3785 ConvertBundleInfo(env, result[1], asyncCallbackInfo->bundleInfo);
3786 }
3787 CommonFunc::NapiReturnDeferred<GetBundleArchiveInfoCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3788 APP_LOGD("NAPI end");
3789 }
3790
GetBundleArchiveInfo(napi_env env, napi_callback_info info)3791 napi_value GetBundleArchiveInfo(napi_env env, napi_callback_info info)
3792 {
3793 APP_LOGD("NAPI begin");
3794 NapiArg args(env, info);
3795 GetBundleArchiveInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) GetBundleArchiveInfoCallbackInfo(env);
3796 if (asyncCallbackInfo == nullptr) {
3797 APP_LOGE("asyncCallbackInfo is null");
3798 return nullptr;
3799 }
3800 std::unique_ptr<GetBundleArchiveInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
3801 asyncCallbackInfo->err = NO_ERROR;
3802 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
3803 APP_LOGE("parameters init failed");
3804 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3805 }
3806 for (size_t i = 0; i < args.GetMaxArgc(); ++i) {
3807 napi_valuetype valueType = napi_undefined;
3808 napi_typeof(env, args[i], &valueType);
3809 if ((i == ARGS_POS_ZERO) && (valueType == napi_string)) {
3810 if (!CommonFunc::ParseString(env, args[i], asyncCallbackInfo->hapFilePath)) {
3811 APP_LOGE("hapFilePath %{public}s invalid", asyncCallbackInfo->hapFilePath.c_str());
3812 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3813 }
3814 } else if ((i == ARGS_POS_ONE) && (valueType == napi_number)) {
3815 if (!CommonFunc::ParseInt(env, args[i], asyncCallbackInfo->flags)) {
3816 APP_LOGE("flags %{public}d invalid", asyncCallbackInfo->flags);
3817 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3818 }
3819 } else if (i == ARGS_POS_TWO) {
3820 if (valueType == napi_function) {
3821 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3822 }
3823 break;
3824 } else {
3825 APP_LOGE("parameters number error");
3826 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3827 }
3828 }
3829 auto promise = CommonFunc::AsyncCallNativeMethod<GetBundleArchiveInfoCallbackInfo>(
3830 env, asyncCallbackInfo, GET_BUNDLE_ARCHIVE_INFO, GetBundleArchiveInfoExec, GetBundleArchiveInfoComplete);
3831 callbackPtr.release();
3832 APP_LOGD("NAPI end");
3833 return promise;
3834 }
3835
GetLaunchWantForBundleExec(napi_env env, void *data)3836 void GetLaunchWantForBundleExec(napi_env env, void *data)
3837 {
3838 APP_LOGD("NAPI begin");
3839 LaunchWantCallbackInfo* asyncCallbackInfo = reinterpret_cast<LaunchWantCallbackInfo*>(data);
3840 if (asyncCallbackInfo == nullptr) {
3841 APP_LOGE("asyncCallbackInfo is null");
3842 return;
3843 }
3844 if (asyncCallbackInfo->err != NO_ERROR) {
3845 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3846 return;
3847 }
3848 auto iBundleMgr = CommonFunc::GetBundleMgr();
3849 if (iBundleMgr == nullptr) {
3850 APP_LOGE("iBundleMgr is null");
3851 return;
3852 }
3853 APP_LOGD("start GetLaunchWantForBundle, bundleName %{public}s", asyncCallbackInfo->bundleName.c_str());
3854 asyncCallbackInfo->ret = iBundleMgr->GetLaunchWantForBundle(
3855 asyncCallbackInfo->bundleName, asyncCallbackInfo->want, asyncCallbackInfo->userId);
3856 APP_LOGD("NAPI end");
3857 }
3858
GetLaunchWantForBundleComplete(napi_env env, napi_status status, void *data)3859 void GetLaunchWantForBundleComplete(napi_env env, napi_status status, void *data)
3860 {
3861 APP_LOGD("NAPI begin");
3862 LaunchWantCallbackInfo *asyncCallbackInfo = reinterpret_cast<LaunchWantCallbackInfo *>(data);
3863 if (asyncCallbackInfo == nullptr) {
3864 APP_LOGE("asyncCallbackInfo is null");
3865 return;
3866 }
3867 std::unique_ptr<LaunchWantCallbackInfo> callbackPtr {asyncCallbackInfo};
3868 napi_value result[ARGS_SIZE_TWO] = {0};
3869 if (asyncCallbackInfo->err != NO_ERROR) {
3870 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3871 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
3872 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3873 } else if (asyncCallbackInfo->ret != ERR_OK) {
3874 APP_LOGE("asyncCallbackInfo->ret is %{public}d", asyncCallbackInfo->ret);
3875 asyncCallbackInfo->err = OPERATION_FAILED;
3876 result[0] = BusinessError::CreateError(env, OPERATION_FAILED, "GetLaunchWantForBundle falied");
3877 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3878 } else {
3879 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3880 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
3881 CommonFunc::ConvertWantInfo(env, result[1], asyncCallbackInfo->want);
3882 }
3883 CommonFunc::NapiReturnDeferred<LaunchWantCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3884 APP_LOGD("NAPI end");
3885 }
3886
GetLaunchWantForBundle(napi_env env, napi_callback_info info)3887 napi_value GetLaunchWantForBundle(napi_env env, napi_callback_info info)
3888 {
3889 APP_LOGD("NAPI begin");
3890 LaunchWantCallbackInfo *asyncCallbackInfo = new (std::nothrow) LaunchWantCallbackInfo(env);
3891 if (asyncCallbackInfo == nullptr) {
3892 APP_LOGE("asyncCallbackInfo is null");
3893 return nullptr;
3894 }
3895 std::unique_ptr<LaunchWantCallbackInfo> callbackPtr {asyncCallbackInfo};
3896 asyncCallbackInfo->err = NO_ERROR;
3897 NapiArg args(env, info);
3898 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
3899 APP_LOGE("parameters init failed");
3900 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3901 auto promise = CommonFunc::AsyncCallNativeMethod<LaunchWantCallbackInfo>(env,
3902 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, GetLaunchWantForBundleExec, GetLaunchWantForBundleComplete);
3903 callbackPtr.release();
3904 return promise;
3905 }
3906 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
3907 APP_LOGE("BundleName parse failed");
3908 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
3909 }
3910 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
3911 napi_valuetype valueType = napi_undefined;
3912 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
3913 if (valueType == napi_function) {
3914 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
3915 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3916 }
3917 }
3918
3919 auto promise = CommonFunc::AsyncCallNativeMethod<LaunchWantCallbackInfo>(
3920 env, asyncCallbackInfo, GET_LAUNCH_WANT_FOR_BUNDLE, GetLaunchWantForBundleExec, GetLaunchWantForBundleComplete);
3921 callbackPtr.release();
3922 APP_LOGD("NAPI end");
3923 return promise;
3924 }
3925
IsAbilityEnabledExec(napi_env env, void *data)3926 void IsAbilityEnabledExec(napi_env env, void *data)
3927 {
3928 APP_LOGD("NAPI begin");
3929 AbilityEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityEnableCallbackInfo *>(data);
3930 if (asyncCallbackInfo == nullptr) {
3931 APP_LOGE("asyncCallbackInfo is null");
3932 return;
3933 }
3934 if (asyncCallbackInfo->err != NO_ERROR) {
3935 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
3936 return;
3937 }
3938 auto bundleMgr = CommonFunc::GetBundleMgr();
3939 if (bundleMgr == nullptr) {
3940 APP_LOGE("CommonFunc::GetBundleMgr failed");
3941 return;
3942 }
3943 bundleMgr->IsAbilityEnabled(asyncCallbackInfo->abilityInfo, asyncCallbackInfo->isEnable);
3944 APP_LOGD("NAPI end");
3945 }
3946
IsAbilityEnabledComplete(napi_env env, napi_status status, void *data)3947 void IsAbilityEnabledComplete(napi_env env, napi_status status, void *data)
3948 {
3949 APP_LOGD("NAPI begin");
3950 AbilityEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<AbilityEnableCallbackInfo *>(data);
3951 if (asyncCallbackInfo == nullptr) {
3952 APP_LOGE("asyncCallbackInfo is null");
3953 return;
3954 }
3955 std::unique_ptr<AbilityEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
3956 napi_value result[ARGS_SIZE_TWO] = {0};
3957 if (asyncCallbackInfo->err != NO_ERROR) {
3958 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
3959 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
3960 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
3961 } else {
3962 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
3963 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->isEnable, &result[1]));
3964 }
3965 CommonFunc::NapiReturnDeferred<AbilityEnableCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
3966 APP_LOGD("NAPI end");
3967 }
3968
IsAbilityEnabled(napi_env env, napi_callback_info info)3969 napi_value IsAbilityEnabled(napi_env env, napi_callback_info info)
3970 {
3971 APP_LOGD("NAPI begin");
3972 AbilityEnableCallbackInfo *asyncCallbackInfo = new (std::nothrow) AbilityEnableCallbackInfo(env);
3973 if (asyncCallbackInfo == nullptr) {
3974 APP_LOGE("asyncCallbackInfo is null");
3975 return nullptr;
3976 }
3977 std::unique_ptr<AbilityEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
3978 asyncCallbackInfo->err = NO_ERROR;
3979 NapiArg args(env, info);
3980 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
3981 APP_LOGE("parameters init failed");
3982 asyncCallbackInfo->err = INVALID_PARAM;
3983 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityEnableCallbackInfo>(env,
3984 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsAbilityEnabledExec, IsAbilityEnabledComplete);
3985 callbackPtr.release();
3986 return promise;
3987 }
3988 if (!CommonFunc::ParseAbilityInfo(env, args[ARGS_POS_ZERO], asyncCallbackInfo->abilityInfo)) {
3989 APP_LOGE("AbilityInfo parse failed");
3990 asyncCallbackInfo->err = INVALID_PARAM;
3991 }
3992 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
3993 napi_valuetype valueType = napi_undefined;
3994 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
3995 if (valueType == napi_function) {
3996 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
3997 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
3998 }
3999 }
4000
4001 auto promise = CommonFunc::AsyncCallNativeMethod<AbilityEnableCallbackInfo>(
4002 env, asyncCallbackInfo, IS_ABILITY_ENABLED, IsAbilityEnabledExec, IsAbilityEnabledComplete);
4003 callbackPtr.release();
4004 APP_LOGD("NAPI end");
4005 return promise;
4006 }
4007
IsApplicationEnabledExec(napi_env env, void *data)4008 void IsApplicationEnabledExec(napi_env env, void *data)
4009 {
4010 APP_LOGD("NAPI begin");
4011 ApplicationEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<ApplicationEnableCallbackInfo *>(data);
4012 if (asyncCallbackInfo == nullptr) {
4013 APP_LOGE("asyncCallbackInfo is null");
4014 return;
4015 }
4016 if (asyncCallbackInfo->err != NO_ERROR) {
4017 APP_LOGE("asyncCallbackInfo->err is not NO_ERROR, but %{public}d", asyncCallbackInfo->err);
4018 return;
4019 }
4020 auto bundleMgr = CommonFunc::GetBundleMgr();
4021 if (bundleMgr == nullptr) {
4022 APP_LOGE("CommonFunc::GetBundleMgr failed");
4023 return;
4024 }
4025 bundleMgr->IsApplicationEnabled(asyncCallbackInfo->bundleName, asyncCallbackInfo->isEnable);
4026 APP_LOGD("NAPI end");
4027 }
4028
IsApplicationEnabledComplete(napi_env env, napi_status status, void *data)4029 void IsApplicationEnabledComplete(napi_env env, napi_status status, void *data)
4030 {
4031 APP_LOGD("NAPI begin");
4032 ApplicationEnableCallbackInfo *asyncCallbackInfo = reinterpret_cast<ApplicationEnableCallbackInfo *>(data);
4033 if (asyncCallbackInfo == nullptr) {
4034 APP_LOGE("asyncCallbackInfo is null");
4035 return;
4036 }
4037 std::unique_ptr<ApplicationEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
4038 napi_value result[ARGS_SIZE_TWO] = {0};
4039 if (asyncCallbackInfo->err != NO_ERROR) {
4040 APP_LOGE("asyncCallbackInfo->err is %{public}d", asyncCallbackInfo->err);
4041 result[0] = BusinessError::CreateError(env, asyncCallbackInfo->err, TYPE_MISMATCH);
4042 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4043 } else {
4044 result[0] = BusinessError::CreateError(env, NO_ERROR, "");
4045 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->isEnable, &result[1]));
4046 }
4047 CommonFunc::NapiReturnDeferred<ApplicationEnableCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
4048 APP_LOGD("NAPI end");
4049 }
4050
IsApplicationEnabled(napi_env env, napi_callback_info info)4051 napi_value IsApplicationEnabled(napi_env env, napi_callback_info info)
4052 {
4053 APP_LOGD("NAPI begin");
4054 ApplicationEnableCallbackInfo *asyncCallbackInfo = new (std::nothrow) ApplicationEnableCallbackInfo(env);
4055 if (asyncCallbackInfo == nullptr) {
4056 APP_LOGE("asyncCallbackInfo is null");
4057 return nullptr;
4058 }
4059 std::unique_ptr<ApplicationEnableCallbackInfo> callbackPtr {asyncCallbackInfo};
4060 asyncCallbackInfo->err = NO_ERROR;
4061 NapiArg args(env, info);
4062 if (!args.Init(ARGS_SIZE_ONE, ARGS_SIZE_TWO)) {
4063 APP_LOGE("parameters init failed");
4064 asyncCallbackInfo->err = INVALID_PARAM;
4065 auto promise = CommonFunc::AsyncCallNativeMethod<ApplicationEnableCallbackInfo>(env,
4066 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsApplicationEnabledExec, IsApplicationEnabledComplete);
4067 callbackPtr.release();
4068 return promise;
4069 }
4070 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
4071 APP_LOGE("BundleName parse failed");
4072 asyncCallbackInfo->err = INVALID_PARAM;
4073 }
4074 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
4075 napi_valuetype valueType = napi_undefined;
4076 napi_typeof(env, args[ARGS_POS_ONE], &valueType);
4077 if (valueType == napi_function) {
4078 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ONE],
4079 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4080 }
4081 }
4082
4083 auto promise = CommonFunc::AsyncCallNativeMethod<ApplicationEnableCallbackInfo>(env,
4084 asyncCallbackInfo, IS_SET_APPLICATION_ENABLED, IsApplicationEnabledExec, IsApplicationEnabledComplete);
4085 callbackPtr.release();
4086 APP_LOGD("NAPI end");
4087 return promise;
4088 }
4089
GetBundleInfoExec(napi_env env, void *data)4090 void GetBundleInfoExec(napi_env env, void *data)
4091 {
4092 AsyncBundleInfoCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfoCallbackInfo*>(data);
4093 if (asyncCallbackInfo == nullptr) {
4094 APP_LOGE("asyncCallbackInfo is nullptr");
4095 return;
4096 }
4097 if (asyncCallbackInfo->err == 0) {
4098 asyncCallbackInfo->ret = InnerGetBundleInfo(asyncCallbackInfo->env, asyncCallbackInfo->param,
4099 asyncCallbackInfo->flags, asyncCallbackInfo->bundleOptions, asyncCallbackInfo->bundleInfo);
4100 }
4101 }
4102
GetBundleInfoForSelfExec(napi_env env, napi_status status, void* data)4103 void GetBundleInfoForSelfExec(napi_env env, napi_status status, void* data)
4104 {
4105 AsyncBundleInfoCallbackInfo* asyncCallbackInfo = reinterpret_cast<AsyncBundleInfoCallbackInfo*>(data);
4106 std::unique_ptr<AsyncBundleInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
4107 if (asyncCallbackInfo == nullptr) {
4108 APP_LOGE("asyncCallbackInfo is nullptr");
4109 return;
4110 }
4111 napi_value result[2] = { 0 };
4112 if (asyncCallbackInfo->err != 0) {
4113 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, static_cast<uint32_t>(asyncCallbackInfo->err),
4114 &result[0]));
4115 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
4116 NAPI_AUTO_LENGTH, &result[1]));
4117 } else {
4118 if (asyncCallbackInfo->ret) {
4119 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
4120 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
4121 ConvertBundleInfo(env, result[1], asyncCallbackInfo->bundleInfo);
4122 } else {
4123 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[0]));
4124 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4125 }
4126 }
4127 if (asyncCallbackInfo->deferred) {
4128 if (asyncCallbackInfo->ret) {
4129 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4130 } else {
4131 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4132 }
4133 } else {
4134 napi_value callback = nullptr;
4135 napi_value placeHolder = nullptr;
4136 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4137 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4138 sizeof(result) / sizeof(result[0]), result, &placeHolder));
4139 }
4140 }
4141
GetBundleInfo(napi_env env, napi_callback_info info)4142 napi_value GetBundleInfo(napi_env env, napi_callback_info info)
4143 {
4144 size_t argc = ARGS_SIZE_FOUR;
4145 napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
4146 napi_value thisArg = nullptr;
4147 void *data = nullptr;
4148 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4149 APP_LOGD("argc = [%{public}zu]", argc);
4150 AsyncBundleInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncBundleInfoCallbackInfo(env);
4151 if (asyncCallbackInfo == nullptr) {
4152 APP_LOGE("asyncCallbackInfo is nullptr");
4153 return nullptr;
4154 }
4155 std::unique_ptr<AsyncBundleInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
4156 for (size_t i = 0; i < argc; ++i) {
4157 napi_valuetype valueType = napi_undefined;
4158 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4159 if ((i == PARAM0) && (valueType == napi_string)) {
4160 ParseString(env, asyncCallbackInfo->param, argv[i]);
4161 } else if ((i == PARAM1) && valueType == napi_number) {
4162 ParseInt(env, asyncCallbackInfo->flags, argv[i]);
4163 } else if ((i == PARAM2) && (valueType == napi_function)) {
4164 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4165 break;
4166 } else if ((i == PARAM2) && (valueType == napi_object)) {
4167 bool ret = ParseBundleOptions(env, asyncCallbackInfo->bundleOptions, argv[i]);
4168 if (!ret) {
4169 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
4170 }
4171 } else if ((i == PARAM3) && (valueType == napi_function)) {
4172 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4173 break;
4174 } else {
4175 asyncCallbackInfo->err = PARAM_TYPE_ERROR;
4176 asyncCallbackInfo->message = TYPE_MISMATCH;
4177 }
4178 }
4179
4180 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncBundleInfoCallbackInfo>(
4181 env, asyncCallbackInfo, GET_BUNDLE_INFO, GetBundleInfoExec, GetBundleInfoForSelfExec);
4182 callbackPtr.release();
4183 return promise;
4184 }
4185
GetBundleNameByUidExec(napi_env env, void *data)4186 void GetBundleNameByUidExec(napi_env env, void *data)
4187 {
4188 AsyncGetNameByUidInfo* asyncCallbackInfo =
4189 reinterpret_cast<AsyncGetNameByUidInfo*>(data);
4190 if (asyncCallbackInfo == nullptr) {
4191 APP_LOGE("asyncCallbackInfo is nullptr");
4192 return;
4193 }
4194 if (asyncCallbackInfo->err == 0) {
4195 asyncCallbackInfo->ret = InnerGetNameForUid(asyncCallbackInfo->uid, asyncCallbackInfo->bundleName);
4196 }
4197 }
4198
GetBundleNameByUidComplete(napi_env env, napi_status status, void *data)4199 void GetBundleNameByUidComplete(napi_env env, napi_status status, void *data)
4200 {
4201 AsyncGetNameByUidInfo* asyncCallbackInfo =
4202 reinterpret_cast<AsyncGetNameByUidInfo*>(data);
4203 std::unique_ptr<AsyncGetNameByUidInfo> callbackPtr {asyncCallbackInfo};
4204 if (asyncCallbackInfo == nullptr) {
4205 APP_LOGE("asyncCallbackInfo is nullptr");
4206 return;
4207 }
4208 napi_value result[ARGS_SIZE_TWO] = { 0 };
4209 // set error code
4210 if (asyncCallbackInfo->err) {
4211 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[PARAM0]));
4212 } else {
4213 if (!asyncCallbackInfo->ret) {
4214 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[PARAM0]));
4215 } else {
4216 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, CODE_SUCCESS, &result[PARAM0]));
4217 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->bundleName.c_str(),
4218 NAPI_AUTO_LENGTH, &result[PARAM1]));
4219 }
4220 }
4221 // implement callback or promise
4222 if (asyncCallbackInfo->deferred) {
4223 if (!asyncCallbackInfo->ret) {
4224 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[PARAM0]));
4225 } else {
4226 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[PARAM1]));
4227 }
4228 } else {
4229 napi_value callback = nullptr;
4230 napi_value placeHolder = nullptr;
4231 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4232 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4233 sizeof(result) / sizeof(result[PARAM0]), result, &placeHolder));
4234 }
4235 }
4236
GetNameForUid(napi_env env, napi_callback_info info)4237 napi_value GetNameForUid(napi_env env, napi_callback_info info)
4238 {
4239 size_t requireArgc = ARGS_SIZE_ONE;
4240 size_t argc = ARGS_SIZE_TWO;
4241 napi_value argv[ARGS_SIZE_TWO] = { 0 };
4242 napi_value thisArg = nullptr;
4243 void *data = nullptr;
4244 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4245 NAPI_CALL(env, (argc >= requireArgc) ? napi_ok : napi_invalid_arg);
4246 AsyncGetNameByUidInfo *asyncCallbackInfo = new (std::nothrow) AsyncGetNameByUidInfo(env);
4247 if (asyncCallbackInfo == nullptr) {
4248 APP_LOGE("asyncCallbackInfo is nullptr");
4249 return nullptr;
4250 }
4251 std::unique_ptr<AsyncGetNameByUidInfo> callbackPtr {asyncCallbackInfo};
4252
4253 for (size_t i = 0; i < argc; ++i) {
4254 napi_valuetype valueType = napi_undefined;
4255 napi_typeof(env, argv[i], &valueType);
4256 if ((i == 0) && (valueType == napi_number)) {
4257 ParseInt(env, asyncCallbackInfo->uid, argv[i]);
4258 } else if ((i == 1) && (valueType == napi_function)) {
4259 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4260 } else {
4261 asyncCallbackInfo->err = INVALID_PARAM;
4262 }
4263 }
4264
4265 auto promise = CommonFunc::AsyncCallNativeMethod<AsyncGetNameByUidInfo>(
4266 env, asyncCallbackInfo, "GetNameForUid", GetBundleNameByUidExec, GetBundleNameByUidComplete);
4267 callbackPtr.release();
4268 APP_LOGD("call GetBundleNameByUid done");
4269 return promise;
4270 }
4271
InnerGetAbilityInfo(const std::string &bundleName, const std::string &moduleName, const std::string &abilityName, AbilityInfo &abilityInfo, bool hasModuleName)4272 static bool InnerGetAbilityInfo(const std::string &bundleName, const std::string &moduleName,
4273 const std::string &abilityName, AbilityInfo &abilityInfo, bool hasModuleName)
4274 {
4275 auto iBundleMgr = GetBundleMgr();
4276 if (iBundleMgr == nullptr) {
4277 APP_LOGE("can not get iBundleMgr");
4278 return false;
4279 }
4280 if (hasModuleName) {
4281 return iBundleMgr->GetAbilityInfo(bundleName, moduleName, abilityName, abilityInfo);
4282 }
4283 return iBundleMgr->GetAbilityInfo(bundleName, abilityName, abilityInfo);
4284 }
4285
StartGetAbilityInfoExecuteCB(napi_env env, void *data)4286 void StartGetAbilityInfoExecuteCB(napi_env env, void *data)
4287 {
4288 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo =
4289 reinterpret_cast<AsyncAbilityInfosCallbackInfo *>(data);
4290 if (asyncCallbackInfo == nullptr) {
4291 APP_LOGE("asyncCallbackInfo == nullptr");
4292 return;
4293 }
4294 if (!asyncCallbackInfo->err) {
4295 asyncCallbackInfo->ret = InnerGetAbilityInfo(
4296 asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName,
4297 asyncCallbackInfo->abilityName, asyncCallbackInfo->abilityInfo,
4298 asyncCallbackInfo->hasModuleName);
4299 }
4300 APP_LOGD("end");
4301 }
4302
StartGetAbilityInfoCompletedCB(napi_env env, napi_status status, void *data)4303 void StartGetAbilityInfoCompletedCB(napi_env env, napi_status status, void *data)
4304 {
4305 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo =
4306 reinterpret_cast<AsyncAbilityInfosCallbackInfo *>(data);
4307 if (asyncCallbackInfo == nullptr) {
4308 APP_LOGE("asyncCallbackInfo is nullptr");
4309 return;
4310 }
4311 std::unique_ptr<AsyncAbilityInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
4312 napi_value result[2] = {0};
4313 if (asyncCallbackInfo->err) {
4314 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, asyncCallbackInfo->err, &result[0]));
4315 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->message.c_str(),
4316 NAPI_AUTO_LENGTH, &result[1]));
4317 } else {
4318 if (asyncCallbackInfo->ret) {
4319 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 0, &result[0]));
4320 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[1]));
4321 ConvertAbilityInfo(env, result[1], asyncCallbackInfo->abilityInfo);
4322 } else {
4323 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 1, &result[0]));
4324 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4325 }
4326 }
4327 if (asyncCallbackInfo->deferred) {
4328 if (asyncCallbackInfo->ret) {
4329 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4330 } else {
4331 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4332 }
4333 } else {
4334 napi_value callback = nullptr;
4335 napi_value placeHolder = nullptr;
4336 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4337 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[0]),
4338 result, &placeHolder));
4339 }
4340 APP_LOGD("end");
4341 }
4342
HasModuleName(napi_env env, size_t argc, napi_value *argv)4343 static bool HasModuleName(napi_env env, size_t argc, napi_value *argv)
4344 {
4345 bool hasModuleName = false;
4346 if (argc > 0) {
4347 napi_valuetype valueType = napi_undefined;
4348 NAPI_CALL_BASE(env, napi_typeof(env, argv[argc - 1], &valueType), false);
4349 if (valueType == napi_function) {
4350 hasModuleName = (argc == ARGS_SIZE_FOUR) ? true : false;
4351 } else {
4352 hasModuleName = (argc == ARGS_SIZE_THREE) ? true : false;
4353 }
4354 } else {
4355 APP_LOGD("error : argc < 0");
4356 }
4357 return hasModuleName;
4358 }
4359
GetAbilityInfo(napi_env env, napi_callback_info info)4360 napi_value GetAbilityInfo(napi_env env, napi_callback_info info)
4361 {
4362 size_t requireArgc = ARGS_SIZE_TWO;
4363 size_t argc = ARGS_SIZE_FOUR;
4364 napi_value argv[ARGS_SIZE_FOUR] = { 0 };
4365 napi_value thisArg = nullptr;
4366 void *data = nullptr;
4367 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4368 NAPI_CALL(env, (argc >= requireArgc) ? napi_ok : napi_invalid_arg);
4369 AsyncAbilityInfosCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncAbilityInfosCallbackInfo(env);
4370 if (asyncCallbackInfo == nullptr) {
4371 APP_LOGD("asyncCallbackInfo == nullptr");
4372 return nullptr;
4373 }
4374 std::unique_ptr<AsyncAbilityInfosCallbackInfo> callbackPtr {asyncCallbackInfo};
4375 asyncCallbackInfo->hasModuleName = HasModuleName(env, argc, argv);
4376 for (size_t i = 0; i < argc; ++i) {
4377 napi_valuetype valueType = napi_undefined;
4378 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4379 if ((i == PARAM0) && (valueType == napi_string)) {
4380 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
4381 } else if ((i == PARAM1) && (valueType == napi_string)) {
4382 if (asyncCallbackInfo->hasModuleName) {
4383 ParseString(env, asyncCallbackInfo->moduleName, argv[i]);
4384 } else {
4385 ParseString(env, asyncCallbackInfo->abilityName, argv[i]);
4386 }
4387 } else if ((i == PARAM2) && (valueType == napi_string)) {
4388 ParseString(env, asyncCallbackInfo->abilityName, argv[i]);
4389 } else if (((i == PARAM2) || (i == PARAM3)) && (valueType == napi_function)) {
4390 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4391 } else {
4392 asyncCallbackInfo->err = INVALID_PARAM;
4393 asyncCallbackInfo->message = TYPE_MISMATCH;
4394 }
4395 }
4396
4397 napi_value promise = nullptr;
4398 if (asyncCallbackInfo->callback == nullptr) {
4399 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
4400 } else {
4401 NAPI_CALL(env, napi_get_undefined(env, &promise));
4402 }
4403 napi_value resource = nullptr;
4404 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resource));
4405 NAPI_CALL(env, napi_create_async_work(env, nullptr, resource,
4406 StartGetAbilityInfoExecuteCB, StartGetAbilityInfoCompletedCB,
4407 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4408 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4409 callbackPtr.release();
4410 return promise;
4411 }
4412
CreateAbilityLabelCallbackInfo(napi_env env)4413 AsyncAbilityLabelCallbackInfo *CreateAbilityLabelCallbackInfo(napi_env env)
4414 {
4415 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncAbilityLabelCallbackInfo(env);
4416
4417 if (asyncCallbackInfo == nullptr) {
4418 APP_LOGE("asyncCallbackInfo == nullptr");
4419 return nullptr;
4420 }
4421
4422 APP_LOGD("end");
4423 return asyncCallbackInfo;
4424 }
4425
InnerGetAbilityLabel(napi_env env, std::string &bundleName, std::string &moduleName, std::string &abilityName, bool hasModuleName)4426 static std::string InnerGetAbilityLabel(napi_env env, std::string &bundleName, std::string &moduleName,
4427 std::string &abilityName, bool hasModuleName)
4428 {
4429 auto iBundleMgr = GetBundleMgr();
4430 if (iBundleMgr == nullptr) {
4431 APP_LOGE("can not get iBundleMgr");
4432 return Constants::EMPTY_STRING;
4433 }
4434 if (!hasModuleName) {
4435 return iBundleMgr->GetAbilityLabel(bundleName, abilityName);
4436 }
4437 std::string label;
4438 ErrCode ret = iBundleMgr->GetAbilityLabel(bundleName, moduleName, abilityName, label);
4439 if (ret != ERR_OK) {
4440 APP_LOGE("can not GetAbilityLabel, bundleName is %{public}s", bundleName.c_str());
4441 return Constants::EMPTY_STRING;
4442 }
4443 return label;
4444 }
4445
GetAbilityLabelPromiseComplete(napi_env env, napi_status status, void *data)4446 void GetAbilityLabelPromiseComplete(napi_env env, napi_status status, void *data)
4447 {
4448 APP_LOGD("NAPI_GetAbilityLabel, main event thread complete");
4449 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4450 if (asyncCallbackInfo == nullptr) {
4451 APP_LOGE("asyncCallbackInfo is nullptr");
4452 return;
4453 }
4454 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4455 napi_value result = nullptr;
4456 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
4457 NAPI_CALL_RETURN_VOID(
4458 env, napi_create_string_utf8(env, asyncCallbackInfo->abilityLabel.c_str(), NAPI_AUTO_LENGTH, &result));
4459 NAPI_CALL_RETURN_VOID(
4460 env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result));
4461 } else {
4462 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result));
4463 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result));
4464 }
4465 APP_LOGI("NAPI_GetAbilityLabel, main event thread complete end");
4466 }
4467
GetAbilityLabelExecute(napi_env env, void *data)4468 void GetAbilityLabelExecute(napi_env env, void *data)
4469 {
4470 APP_LOGD("NAPI_GetAbilityLabel, worker pool thread execute");
4471 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4472 if (asyncCallbackInfo == nullptr) {
4473 APP_LOGE("NAPI_GetAbilityLabel, asyncCallbackInfo == nullptr");
4474 return;
4475 }
4476 if (!asyncCallbackInfo->err) {
4477 asyncCallbackInfo->abilityLabel =
4478 InnerGetAbilityLabel(env, asyncCallbackInfo->bundleName, asyncCallbackInfo->moduleName,
4479 asyncCallbackInfo->className, asyncCallbackInfo->hasModuleName);
4480 if (asyncCallbackInfo->abilityLabel == "") {
4481 asyncCallbackInfo->err = OPERATION_FAILED;
4482 }
4483 }
4484 }
4485
GetAbilityLabelAsyncComplete(napi_env env, napi_status status, void *data)4486 void GetAbilityLabelAsyncComplete(napi_env env, napi_status status, void *data)
4487 {
4488 APP_LOGD("NAPI_GetAbilityLabel, main event thread complete");
4489 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = static_cast<AsyncAbilityLabelCallbackInfo *>(data);
4490 if (asyncCallbackInfo == nullptr) {
4491 APP_LOGE("asyncCallbackInfo is nullptr");
4492 return;
4493 }
4494 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4495 napi_value callback = nullptr;
4496 napi_value result[ARGS_SIZE_TWO] = {nullptr};
4497 napi_value callResult = nullptr;
4498
4499 if (asyncCallbackInfo->err == NAPI_ERR_NO_ERROR) {
4500 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[PARAM0]));
4501 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, asyncCallbackInfo->abilityLabel.c_str(),
4502 NAPI_AUTO_LENGTH, &result[PARAM1]));
4503 } else {
4504 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->err, &result[PARAM0]));
4505 result[PARAM1] = WrapUndefinedToJS(env);
4506 }
4507
4508 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4509 NAPI_CALL_RETURN_VOID(env,
4510 napi_call_function(env, nullptr, callback, sizeof(result) / sizeof(result[PARAM0]), result, &callResult));
4511 APP_LOGI("NAPI_GetAbilityLabel, main event thread complete end");
4512 }
4513
GetAbilityLabelAsync( napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)4514 napi_value GetAbilityLabelAsync(
4515 napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4516 {
4517 if (asyncCallbackInfo == nullptr) {
4518 APP_LOGD("param == nullptr");
4519 return nullptr;
4520 }
4521
4522 napi_value resourceName = nullptr;
4523 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
4524
4525 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetAbilityLabelExecute,
4526 GetAbilityLabelAsyncComplete, reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4527 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4528 napi_value result = nullptr;
4529 NAPI_CALL(env, napi_get_null(env, &result));
4530 APP_LOGD("asyncCallback end");
4531 return result;
4532 }
4533
GetAbilityLabelPromise(napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)4534 napi_value GetAbilityLabelPromise(napi_env env, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4535 {
4536 if (asyncCallbackInfo == nullptr) {
4537 APP_LOGD("param == nullptr");
4538 return nullptr;
4539 }
4540 napi_value resourceName = nullptr;
4541 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
4542 napi_deferred deferred;
4543 napi_value promise = nullptr;
4544 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
4545 asyncCallbackInfo->deferred = deferred;
4546
4547 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, GetAbilityLabelExecute,
4548 GetAbilityLabelPromiseComplete,
4549 reinterpret_cast<void*>(asyncCallbackInfo),
4550 &asyncCallbackInfo->asyncWork));
4551 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4552 APP_LOGD("romise end");
4553 return promise;
4554 }
4555
GetAbilityLabelWrap(napi_env env, napi_callback_info info, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)4556 napi_value GetAbilityLabelWrap(napi_env env, napi_callback_info info, AsyncAbilityLabelCallbackInfo *asyncCallbackInfo)
4557 {
4558 if (asyncCallbackInfo == nullptr) {
4559 APP_LOGE("asyncCallbackInfo == nullptr");
4560 return nullptr;
4561 }
4562
4563 size_t argcAsync = ARGS_SIZE_FOUR;
4564 const size_t argcPromise = ARGS_SIZE_THREE;
4565 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
4566 napi_value args[ARGS_MAX_COUNT] = {nullptr};
4567 napi_value ret = nullptr;
4568
4569 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
4570 if (argcAsync > argCountWithAsync) {
4571 APP_LOGE("Wrong argument count");
4572 return nullptr;
4573 }
4574 asyncCallbackInfo->hasModuleName = HasModuleName(env, argcAsync, args);
4575 for (size_t i = 0; i < argcAsync; ++i) {
4576 napi_valuetype valueType = napi_undefined;
4577 NAPI_CALL(env, napi_typeof(env, args[i], &valueType));
4578 if ((i == PARAM0) && (valueType == napi_string)) {
4579 ParseString(env, asyncCallbackInfo->bundleName, args[i]);
4580 } else if ((i == PARAM1) && (valueType == napi_string)) {
4581 if (asyncCallbackInfo->hasModuleName) {
4582 ParseString(env, asyncCallbackInfo->moduleName, args[i]);
4583 } else {
4584 ParseString(env, asyncCallbackInfo->className, args[i]);
4585 }
4586 } else if ((i == PARAM2) && (valueType == napi_string)) {
4587 ParseString(env, asyncCallbackInfo->className, args[i]);
4588 } else if (((i == PARAM2) || (i == PARAM3)) && (valueType == napi_function)) {
4589 NAPI_CALL(env, napi_create_reference(env, args[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4590 } else {
4591 asyncCallbackInfo->err = INVALID_PARAM;
4592 asyncCallbackInfo->message = TYPE_MISMATCH;
4593 }
4594 }
4595 if (asyncCallbackInfo->callback) {
4596 ret = GetAbilityLabelAsync(env, asyncCallbackInfo);
4597 } else {
4598 ret = GetAbilityLabelPromise(env, asyncCallbackInfo);
4599 }
4600 APP_LOGD("asyncCallback end");
4601 return ret;
4602 }
4603
GetAbilityLabel(napi_env env, napi_callback_info info)4604 napi_value GetAbilityLabel(napi_env env, napi_callback_info info)
4605 {
4606 AsyncAbilityLabelCallbackInfo *asyncCallbackInfo = CreateAbilityLabelCallbackInfo(env);
4607 if (asyncCallbackInfo == nullptr) {
4608 APP_LOGD("asyncCallbackInfo == nullptr");
4609 return WrapVoidToJS(env);
4610 }
4611 std::unique_ptr<AsyncAbilityLabelCallbackInfo> callbackPtr {asyncCallbackInfo};
4612 napi_value ret = GetAbilityLabelWrap(env, info, asyncCallbackInfo);
4613 if (ret == nullptr) {
4614 APP_LOGD("ret == nullptr");
4615 ret = WrapVoidToJS(env);
4616 } else {
4617 callbackPtr.release();
4618 }
4619 APP_LOGD("end");
4620 return ret;
4621 }
4622
SetApplicationEnabledExec(napi_env env, void *data)4623 void SetApplicationEnabledExec(napi_env env, void *data)
4624 {
4625 APP_LOGD("NAPI begin");
4626 EnabledInfo* asyncCallbackInfo =
4627 reinterpret_cast<EnabledInfo*>(data);
4628 if (asyncCallbackInfo == nullptr) {
4629 APP_LOGD("asyncCallbackInfo == nullptr");
4630 return;
4631 }
4632 if (!asyncCallbackInfo->errCode) {
4633 asyncCallbackInfo->result = InnerSetApplicationEnabled(asyncCallbackInfo->bundleName,
4634 asyncCallbackInfo->isEnable);
4635 if (!asyncCallbackInfo->result) {
4636 asyncCallbackInfo->errCode = OPERATION_FAILED;
4637 }
4638 }
4639 APP_LOGD("NAPI end");
4640 }
4641
SetApplicationEnabledComplete(napi_env env, napi_status status, void *data)4642 void SetApplicationEnabledComplete(napi_env env, napi_status status, void *data)
4643 {
4644 APP_LOGD("NAPI begin");
4645 EnabledInfo* asyncCallbackInfo =
4646 reinterpret_cast<EnabledInfo*>(data);
4647 if (asyncCallbackInfo == nullptr) {
4648 APP_LOGD("asyncCallbackInfo == nullptr");
4649 return;
4650 }
4651 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4652 napi_value result[ARGS_SIZE_ONE] = { 0 };
4653 if (asyncCallbackInfo->errCode) {
4654 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4655 }
4656 if (asyncCallbackInfo->callback) {
4657 napi_value callback = nullptr;
4658 napi_value placeHolder = nullptr;
4659 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4660 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
4661 sizeof(result) / sizeof(result[0]), result, &placeHolder));
4662 } else {
4663 if (asyncCallbackInfo->errCode) {
4664 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4665 } else {
4666 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[0]));
4667 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[0]));
4668 }
4669 }
4670 APP_LOGD("NAPI end");
4671 }
4672
SetApplicationEnabled(napi_env env, napi_callback_info info)4673 napi_value SetApplicationEnabled(napi_env env, napi_callback_info info)
4674 {
4675 {
4676 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
4677 abilityInfoCache.clear();
4678 }
4679 size_t argc = ARGS_SIZE_THREE;
4680 napi_value argv[ARGS_SIZE_THREE] = { 0 };
4681 napi_value thisArg = nullptr;
4682 void *data = nullptr;
4683
4684 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4685 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
4686 APP_LOGE("wrong number of arguments");
4687 return nullptr;
4688 }
4689
4690 EnabledInfo *asyncCallbackInfo = new (std::nothrow) EnabledInfo(env);
4691 if (asyncCallbackInfo == nullptr) {
4692 APP_LOGD("asyncCallbackInfo == nullptr");
4693 return nullptr;
4694 }
4695 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4696 asyncCallbackInfo->env = env;
4697 for (size_t i = 0; i < argc; ++i) {
4698 napi_valuetype valueType = napi_undefined;
4699 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4700 if ((i == PARAM0) && (valueType == napi_string)) {
4701 ParseString(env, asyncCallbackInfo->bundleName, argv[i]);
4702 } else if ((i == PARAM1) && (valueType == napi_boolean)) {
4703 bool isEnable = false;
4704 NAPI_CALL(env, napi_get_value_bool(env, argv[i], &isEnable));
4705 asyncCallbackInfo->isEnable = isEnable;
4706 } else if ((i == PARAM2) && (valueType == napi_function)) {
4707 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4708 } else {
4709 asyncCallbackInfo->errCode = INVALID_PARAM;
4710 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4711 }
4712 }
4713 napi_value promise = nullptr;
4714
4715 if (asyncCallbackInfo->callback == nullptr) {
4716 NAPI_CALL(env, napi_create_promise(env, &asyncCallbackInfo->deferred, &promise));
4717 } else {
4718 NAPI_CALL(env, napi_get_undefined(env, &promise));
4719 }
4720 napi_value resource = nullptr;
4721 NAPI_CALL(env, napi_create_string_utf8(env, "JSSetApplicationEnabled", NAPI_AUTO_LENGTH, &resource));
4722 NAPI_CALL(env, napi_create_async_work(
4723 env, nullptr, resource, SetApplicationEnabledExec, SetApplicationEnabledComplete,
4724 reinterpret_cast<void*>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork));
4725 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
4726 callbackPtr.release();
4727 return promise;
4728 }
4729
SetAbilityEnabledExec(napi_env env, void *data)4730 void SetAbilityEnabledExec(napi_env env, void *data)
4731 {
4732 EnabledInfo* asyncCallbackInfo =
4733 reinterpret_cast<EnabledInfo*>(data);
4734 if (asyncCallbackInfo == nullptr) {
4735 APP_LOGE("asyncCallbackInfo is nullptr");
4736 return;
4737 }
4738 if (!asyncCallbackInfo->errCode) {
4739 asyncCallbackInfo->result = InnerSetAbilityEnabled(asyncCallbackInfo->abilityInfo,
4740 asyncCallbackInfo->isEnable);
4741 if (!asyncCallbackInfo->result) {
4742 asyncCallbackInfo->errCode = OPERATION_FAILED;
4743 }
4744 }
4745 }
4746
SetAbilityEnabledComplete(napi_env env, napi_status status, void *data)4747 void SetAbilityEnabledComplete(napi_env env, napi_status status, void *data)
4748 {
4749 EnabledInfo* asyncCallbackInfo =
4750 reinterpret_cast<EnabledInfo*>(data);
4751 if (asyncCallbackInfo == nullptr) {
4752 APP_LOGE("asyncCallbackInfo is nullptr");
4753 return;
4754 }
4755 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4756 napi_value result[ARGS_SIZE_TWO] = { 0 };
4757 if (asyncCallbackInfo->errCode != ERR_OK) {
4758 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4759 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4760 } else if (!asyncCallbackInfo->result) {
4761 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, OPERATION_FAILED, &result[0]));
4762 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &result[1]));
4763 } else {
4764 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[0]));
4765 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->errCode, &result[1]));
4766 }
4767
4768 if (asyncCallbackInfo->deferred) {
4769 if (asyncCallbackInfo->errCode == ERR_OK) {
4770 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, asyncCallbackInfo->deferred, result[1]));
4771 } else {
4772 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result[0]));
4773 }
4774 } else {
4775 napi_value callback = nullptr;
4776 napi_value placeHolder = nullptr;
4777 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
4778 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, INVALID_PARAM, result, &placeHolder));
4779 }
4780 }
4781
SetAbilityEnabled(napi_env env, napi_callback_info info)4782 napi_value SetAbilityEnabled(napi_env env, napi_callback_info info)
4783 {
4784 {
4785 std::lock_guard<std::mutex> lock(abilityInfoCacheMutex_);
4786 abilityInfoCache.clear();
4787 }
4788 size_t argc = ARGS_SIZE_THREE;
4789 napi_value argv[ARGS_SIZE_THREE] = { 0 };
4790 napi_value thisArg = nullptr;
4791 void* data = nullptr;
4792
4793 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
4794 if (argc > ARGS_SIZE_THREE || argc < ARGS_SIZE_TWO) {
4795 APP_LOGE("wrong number of arguments");
4796 return nullptr;
4797 }
4798
4799 EnabledInfo* asyncCallbackInfo = new (std::nothrow) EnabledInfo(env);
4800 if (asyncCallbackInfo == nullptr) {
4801 return nullptr;
4802 }
4803 std::unique_ptr<EnabledInfo> callbackPtr {asyncCallbackInfo};
4804 asyncCallbackInfo->env = env;
4805 for (size_t i = 0; i < argc; ++i) {
4806 napi_valuetype valueType = napi_undefined;
4807 NAPI_CALL(env, napi_typeof(env, argv[i], &valueType));
4808 if ((i == PARAM0) && (valueType == napi_object)) {
4809 if (!UnwrapAbilityInfo(env, argv[i], asyncCallbackInfo->abilityInfo)) {
4810 asyncCallbackInfo->errCode = INVALID_PARAM;
4811 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4812 }
4813 } else if ((i == PARAM1) && (valueType == napi_boolean)) {
4814 NAPI_CALL(env, napi_get_value_bool(env, argv[i], &(asyncCallbackInfo->isEnable)));
4815 } else if ((i == PARAM2) && (valueType == napi_function)) {
4816 NAPI_CALL(env, napi_create_reference(env, argv[i], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
4817 break;
4818 } else {
4819 asyncCallbackInfo->errCode = INVALID_PARAM;
4820 asyncCallbackInfo->errMssage = TYPE_MISMATCH;
4821 }
4822 }
4823 auto promise = CommonFunc::AsyncCallNativeMethod<EnabledInfo>(
4824 env, asyncCallbackInfo, "SetAbilityEnabled", SetAbilityEnabledExec, SetAbilityEnabledComplete);
4825 callbackPtr.release();
4826 return promise;
4827 }
4828
ConvertInstallResult(InstallResult &installResult)4829 static void ConvertInstallResult(InstallResult &installResult)
4830 {
4831 APP_LOGD("ConvertInstallResult = %{public}s", installResult.resultMsg.c_str());
4832 switch (installResult.resultCode) {
4833 case static_cast<int32_t>(IStatusReceiver::SUCCESS):
4834 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::SUCCESS);
4835 installResult.resultMsg = "SUCCESS";
4836 break;
4837 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INTERNAL_ERROR):
4838 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_HOST_INSTALLER_FAILED):
4839 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DISALLOWED):
4840 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE);
4841 installResult.resultMsg = "STATUS_INSTALL_FAILURE";
4842 break;
4843 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_FAILED):
4844 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DEBUG_ENCRYPTED_BUNDLE_FAILED):
4845 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERIFICATION_FAILED):
4846 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INCOMPATIBLE_SIGNATURE):
4847 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARAM_ERROR):
4848 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID):
4849 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_HAP_SIZE):
4850 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_HAP_NAME):
4851 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_BUNDLE_FILE):
4852 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INVALID_NUMBER_OF_ENTRY_HAP):
4853 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_UNEXPECTED):
4854 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_MISSING_BUNDLE):
4855 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_NO_PROFILE):
4856 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_BAD_PROFILE):
4857 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_PROP_TYPE_ERROR):
4858 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PROFILE_MISSING_PROP):
4859 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_PERMISSION_ERROR):
4860 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_RPCID_FAILED):
4861 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_NATIVE_SO_FAILED):
4862 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INVALID_SIGNATURE_FILE_PATH):
4863 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE_FILE):
4864 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_NO_BUNDLE_SIGNATURE):
4865 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_APP_PKCS7_FAIL):
4866 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_PROFILE_PARSE_FAIL):
4867 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_APP_SOURCE_NOT_TRUESTED):
4868 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_DIGEST):
4869 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_INTEGRITY_VERIFICATION_FAILURE):
4870 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_FILE_SIZE_TOO_LARGE):
4871 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_PUBLICKEY):
4872 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BAD_BUNDLE_SIGNATURE):
4873 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_NO_PROFILE_BLOCK_FAIL):
4874 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_BUNDLE_SIGNATURE_VERIFICATION_FAILURE):
4875 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_EMPTY):
4876 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_MODULE_NAME_DUPLICATE):
4877 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_CHECK_HAP_HASH_PARAM):
4878 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_VERIFY_SOURCE_INIT_FAIL):
4879 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DEPENDENT_MODULE_NOT_EXIST):
4880 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_NATIVE_FAILED):
4881 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_NATIVE_FAILED):
4882 case static_cast<int32_t>(IStatusReceiver::ERR_NATIVE_HNP_EXTRACT_FAILED):
4883 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_DEBUG_NOT_SAME):
4884 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INVALID);
4885 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
4886 break;
4887 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PARSE_MISSING_ABILITY):
4888 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_ABILITY_NOT_FOUND);
4889 installResult.resultMsg = "STATUS_ABILITY_NOT_FOUND";
4890 break;
4891 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSION_DOWNGRADE):
4892 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FAILED_INCONSISTENT_SIGNATURE):
4893 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_INCOMPATIBLE);
4894 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INCOMPATIBLE";
4895 break;
4896 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_PERMISSION_DENIED):
4897 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_PERMISSION_DENIED);
4898 installResult.resultMsg = "STATUS_INSTALL_PERMISSION_DENIED";
4899 break;
4900 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ENTRY_ALREADY_EXIST):
4901 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ALREADY_EXIST):
4902 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_BUNDLENAME_NOT_SAME):
4903 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSIONCODE_NOT_SAME):
4904 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSIONNAME_NOT_SAME):
4905 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_MINCOMPATIBLE_VERSIONCODE_NOT_SAME):
4906 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VENDOR_NOT_SAME):
4907 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_RELEASETYPE_TARGET_NOT_SAME):
4908 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_RELEASETYPE_COMPATIBLE_NOT_SAME):
4909 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SINGLETON_NOT_SAME):
4910 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_ZERO_USER_WITH_NO_SINGLETON):
4911 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_CHECK_SYSCAP_FAILED):
4912 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APPTYPE_NOT_SAME):
4913 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_URI_DUPLICATE):
4914 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_VERSION_NOT_COMPATIBLE):
4915 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APP_DISTRIBUTION_TYPE_NOT_SAME):
4916 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_APP_PROVISION_TYPE_NOT_SAME):
4917 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SO_INCOMPATIBLE):
4918 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_TYPE_ERROR):
4919 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_NOT_UNIQUE_DISTRO_MODULE_NAME):
4920 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_SINGLETON_INCOMPATIBLE):
4921 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INCONSISTENT_MODULE_NAME):
4922 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_CHECK_SYSCAP_FAILED_AND_DEVICE_TYPE_NOT_SUPPORTED):
4923 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_CONFLICT);
4924 installResult.resultMsg = "STATUS_INSTALL_FAILURE_CONFLICT";
4925 break;
4926 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_PARAM_ERROR):
4927 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_GET_PROXY_ERROR):
4928 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CREATE_DIR_FAILED):
4929 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_SET_SELINUX_LABEL_FAILED):
4930 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CREATE_DIR_EXIST):
4931 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CHOWN_FAILED):
4932 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_REMOVE_DIR_FAILED):
4933 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_EXTRACT_FILES_FAILED):
4934 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_RNAME_DIR_FAILED):
4935 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALLD_CLEAN_DIR_FAILED):
4936 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_STATE_ERROR):
4937 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_GENERATE_UID_ERROR):
4938 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_INSTALLD_SERVICE_ERROR):
4939 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_INSTALL_FAILURE_STORAGE);
4940 installResult.resultMsg = "STATUS_INSTALL_FAILURE_STORAGE";
4941 break;
4942 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_PERMISSION_DENIED):
4943 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_PERMISSION_DENIED);
4944 installResult.resultMsg = "STATUS_UNINSTALL_PERMISSION_DENIED";
4945 break;
4946 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_INVALID_NAME):
4947 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_PARAM_ERROR):
4948 if (CheckIsSystemApp()) {
4949 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_ABORTED);
4950 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE_ABORTED";
4951 break;
4952 }
4953 [[fallthrough]];
4954 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_SYSTEM_APP_ERROR):
4955 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_KILLING_APP_ERROR):
4956 if (CheckIsSystemApp()) {
4957 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE_CONFLICT);
4958 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE_CONFLICT";
4959 break;
4960 }
4961 [[fallthrough]];
4962 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_BUNDLE_MGR_SERVICE_ERROR):
4963 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_BUNDLE):
4964 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_MISSING_INSTALLED_MODULE):
4965 case static_cast<int32_t>(IStatusReceiver::ERR_USER_NOT_INSTALL_HAP):
4966 case static_cast<int32_t>(IStatusReceiver::ERR_UNINSTALL_DISALLOWED):
4967 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_UNINSTALL_FAILURE);
4968 installResult.resultMsg = "STATUS_UNINSTALL_FAILURE";
4969 break;
4970 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_GET_BUNDLEPATH_ERROR):
4971 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME):
4972 case static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_NOT_ALLOWED):
4973 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_RECOVER_FAILURE_INVALID);
4974 installResult.resultMsg = "STATUS_RECOVER_FAILURE_INVALID";
4975 break;
4976 case static_cast<int32_t>(IStatusReceiver::ERR_FAILED_SERVICE_DIED):
4977 case static_cast<int32_t>(IStatusReceiver::ERR_FAILED_GET_INSTALLER_PROXY):
4978 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR);
4979 installResult.resultMsg = "STATUS_BMS_SERVICE_ERROR";
4980 break;
4981 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT):
4982 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_FAILED_NO_SPACE_LEFT);
4983 installResult.resultMsg = "STATUS_FAILED_NO_SPACE_LEFT";
4984 break;
4985 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_GRANT_REQUEST_PERMISSIONS_FAILED):
4986 case static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_UPDATE_HAP_TOKEN_FAILED):
4987 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_GRANT_REQUEST_PERMISSIONS_FAILED);
4988 installResult.resultMsg = "STATUS_GRANT_REQUEST_PERMISSIONS_FAILED";
4989 break;
4990 case static_cast<int32_t>(IStatusReceiver::ERR_USER_NOT_EXIST):
4991 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_NOT_EXIST);
4992 installResult.resultMsg = "STATUS_USER_NOT_EXIST";
4993 break;
4994 case static_cast<int32_t>(IStatusReceiver::ERR_USER_CREATE_FAILED):
4995 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_CREATE_FAILED);
4996 installResult.resultMsg = "STATUS_USER_CREATE_FAILED";
4997 break;
4998 case static_cast<int32_t>(IStatusReceiver::ERR_USER_REMOVE_FAILED):
4999 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_USER_REMOVE_FAILED);
5000 installResult.resultMsg = "STATUS_USER_REMOVE_FAILED";
5001 break;
5002 default:
5003 installResult.resultCode = static_cast<int32_t>(InstallErrorCode::STATUS_BMS_SERVICE_ERROR);
5004 installResult.resultMsg = "STATUS_BMS_SERVICE_ERROR";
5005 break;
5006 }
5007 }
5008
InnerInstall(napi_env env, const std::vector<std::string> &bundleFilePath, InstallParam &installParam, InstallResult &installResult)5009 static void InnerInstall(napi_env env, const std::vector<std::string> &bundleFilePath, InstallParam &installParam,
5010 InstallResult &installResult)
5011 {
5012 if (bundleFilePath.empty()) {
5013 installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID);
5014 return;
5015 }
5016 auto iBundleMgr = GetBundleMgr();
5017 if (iBundleMgr == nullptr) {
5018 APP_LOGE("can not get iBundleMgr");
5019 return;
5020 }
5021 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5022 if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
5023 APP_LOGE("can not get iBundleInstaller");
5024 return;
5025 }
5026
5027 if (installParam.installFlag == InstallFlag::NORMAL) {
5028 installParam.installFlag = InstallFlag::REPLACE_EXISTING;
5029 }
5030
5031 sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5032 if (callback == nullptr) {
5033 APP_LOGE("callback nullptr");
5034 return;
5035 }
5036
5037 sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
5038 iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
5039 ErrCode res = iBundleInstaller->StreamInstall(bundleFilePath, installParam, callback);
5040 if (res == ERR_APPEXECFWK_INSTALL_PARAM_ERROR) {
5041 APP_LOGE("install param error");
5042 installResult.resultCode = IStatusReceiver::ERR_INSTALL_PARAM_ERROR;
5043 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
5044 } else if (res == ERR_APPEXECFWK_INSTALL_FILE_PATH_INVALID) {
5045 APP_LOGE("install invalid path");
5046 installResult.resultCode = IStatusReceiver::ERR_INSTALL_FILE_PATH_INVALID;
5047 installResult.resultMsg = "STATUS_INSTALL_FAILURE_INVALID";
5048 } else if (res == ERR_APPEXECFWK_INSTALL_DISK_MEM_INSUFFICIENT) {
5049 APP_LOGE("install failed due to no space left");
5050 installResult.resultCode = IStatusReceiver::ERR_INSTALL_DISK_MEM_INSUFFICIENT;
5051 installResult.resultMsg = "STATUS_FAILED_NO_SPACE_LEFT";
5052 } else {
5053 installResult.resultCode = callback->GetResultCode();
5054 installResult.resultMsg = callback->GetResultMsg();
5055 APP_LOGD("InnerInstall code:%{public}d msg:%{public}s", installResult.resultCode,
5056 installResult.resultMsg.c_str());
5057 }
5058 }
5059
5060 /**
5061 * Promise and async callback
5062 */
GetBundleInstaller(napi_env env, napi_callback_info info)5063 napi_value GetBundleInstaller(napi_env env, napi_callback_info info)
5064 {
5065 APP_LOGI("called");
5066 size_t argc = ARGS_SIZE_ONE;
5067 napi_value argv[ARGS_SIZE_ONE] = {nullptr};
5068 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5069 APP_LOGD("argc = [%{public}zu]", argc);
5070
5071 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5072 new (std::nothrow) AsyncGetBundleInstallerCallbackInfo(env);
5073 if (asyncCallbackInfo == nullptr) {
5074 APP_LOGE("asyncCallbackInfo is nullptr");
5075 return nullptr;
5076 }
5077 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5078 if (argc > (ARGS_SIZE_ONE - CALLBACK_SIZE)) {
5079 APP_LOGI("GetBundleInstaller asyncCallback");
5080 napi_valuetype valuetype = napi_undefined;
5081 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
5082 if (valuetype != napi_function) {
5083 APP_LOGE("Wrong argument type. Function expected");
5084 return nullptr;
5085 }
5086 NAPI_CALL(env, napi_create_reference(env, argv[PARAM0], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5087
5088 napi_value resourceName;
5089 NAPI_CALL(env, napi_create_string_latin1(env, "GetBundleInstaller", NAPI_AUTO_LENGTH, &resourceName));
5090 NAPI_CALL(env, napi_create_async_work(
5091 env,
5092 nullptr,
5093 resourceName,
5094 [](napi_env env, void *data) {},
5095 [](napi_env env, napi_status status, void *data) {
5096 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5097 reinterpret_cast<AsyncGetBundleInstallerCallbackInfo *>(data);
5098 if (asyncCallbackInfo == nullptr) {
5099 APP_LOGE("asyncCallbackInfo is nullptr");
5100 return;
5101 }
5102 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5103 napi_value result[ARGS_SIZE_TWO] = {0};
5104 napi_value callback = 0;
5105 napi_value undefined = 0;
5106 napi_value callResult = 0;
5107 napi_value m_classBundleInstaller = nullptr;
5108 if (VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE) && VerifySystemApi()) {
5109 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, g_classBundleInstaller,
5110 &m_classBundleInstaller));
5111 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5112 NAPI_CALL_RETURN_VOID(env, napi_new_instance(
5113 env, m_classBundleInstaller, 0, nullptr, &result[PARAM1]));
5114
5115 result[PARAM0] = GetCallbackErrorValue(env, CODE_SUCCESS);
5116 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(
5117 env, asyncCallbackInfo->callback, &callback));
5118 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5119 &result[PARAM0], &callResult));
5120 } else {
5121 napi_value placeHolder = nullptr;
5122 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 1, &result[PARAM0]));
5123 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5124 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback,
5125 sizeof(result) / sizeof(result[0]), result, &placeHolder));
5126 }
5127 },
5128 reinterpret_cast<void*>(asyncCallbackInfo),
5129 &asyncCallbackInfo->asyncWork));
5130 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5131 callbackPtr.release();
5132 napi_value result;
5133 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5134 return result;
5135 } else {
5136 napi_deferred deferred;
5137 napi_value promise;
5138 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5139 asyncCallbackInfo->deferred = deferred;
5140 APP_LOGI("GetBundleInstaller promise");
5141 napi_value resourceName;
5142 NAPI_CALL(env, napi_create_string_latin1(env, "GetBundleInstaller", NAPI_AUTO_LENGTH, &resourceName));
5143 NAPI_CALL(env, napi_create_async_work(
5144 env,
5145 nullptr,
5146 resourceName,
5147 [](napi_env env, void *data) { APP_LOGI("GetBundleInstaller promise async done"); },
5148 [](napi_env env, napi_status status, void *data) {
5149 APP_LOGI("=================load=================");
5150 AsyncGetBundleInstallerCallbackInfo *asyncCallbackInfo =
5151 reinterpret_cast<AsyncGetBundleInstallerCallbackInfo *>(data);
5152 if (asyncCallbackInfo == nullptr) {
5153 APP_LOGE("asyncCallbackInfo is nullptr");
5154 return;
5155 }
5156 std::unique_ptr<AsyncGetBundleInstallerCallbackInfo> callbackPtr {asyncCallbackInfo};
5157 napi_value result;
5158 napi_value m_classBundleInstaller = nullptr;
5159 if (VerifyCallingPermission(Constants::PERMISSION_INSTALL_BUNDLE) && VerifySystemApi()) {
5160 napi_get_reference_value(env, g_classBundleInstaller, &m_classBundleInstaller);
5161 napi_new_instance(env, m_classBundleInstaller, 0, nullptr, &result);
5162 napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred, result);
5163 } else {
5164 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, 1, &result));
5165 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, asyncCallbackInfo->deferred, result));
5166 }
5167 },
5168 reinterpret_cast<void*>(asyncCallbackInfo),
5169 &asyncCallbackInfo->asyncWork));
5170 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5171 callbackPtr.release();
5172 return promise;
5173 }
5174 }
5175
5176 /**
5177 * Promise and async callback
5178 */
Install(napi_env env, napi_callback_info info)5179 napi_value Install(napi_env env, napi_callback_info info)
5180 {
5181 APP_LOGI("called");
5182 size_t argc = ARGS_SIZE_THREE;
5183 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5184 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5185 APP_LOGD("argc = [%{public}zu]", argc);
5186 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5187 if (asyncCallbackInfo == nullptr) {
5188 return nullptr;
5189 }
5190 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5191
5192 std::vector<std::string> bundleFilePaths;
5193 InstallParam installParam;
5194 napi_value retFirst = nullptr;
5195 bool retSecond = true;
5196 retFirst = ParseStringArray(env, bundleFilePaths, argv[PARAM0]);
5197 retSecond = ParseInstallParam(env, installParam, argv[PARAM1]);
5198 if (retFirst == nullptr || !retSecond) {
5199 APP_LOGE("Install installParam error");
5200 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5201 }
5202 asyncCallbackInfo->hapFiles = bundleFilePaths;
5203 asyncCallbackInfo->installParam = installParam;
5204 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5205 APP_LOGI("Install asyncCallback");
5206 napi_valuetype valuetype = napi_undefined;
5207 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5208 if (valuetype != napi_function) {
5209 APP_LOGE("Wrong argument type. Function expected");
5210 return nullptr;
5211 }
5212 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5213
5214 napi_value resourceName;
5215 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5216 NAPI_CALL(env, napi_create_async_work(
5217 env,
5218 nullptr,
5219 resourceName,
5220 [](napi_env env, void *data) {
5221 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5222 if (asyncCallbackInfo == nullptr) {
5223 return;
5224 }
5225 if (!asyncCallbackInfo->errCode) {
5226 InnerInstall(env,
5227 asyncCallbackInfo->hapFiles,
5228 asyncCallbackInfo->installParam,
5229 asyncCallbackInfo->installResult);
5230 }
5231 },
5232 [](napi_env env, napi_status status, void *data) {
5233 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5234 if (asyncCallbackInfo == nullptr) {
5235 return;
5236 }
5237 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5238 napi_value result[ARGS_SIZE_TWO] = {0};
5239 napi_value callback = 0;
5240 napi_value undefined = 0;
5241 napi_value callResult = 0;
5242 if (!asyncCallbackInfo->errCode) {
5243 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5244 ConvertInstallResult(asyncCallbackInfo->installResult);
5245 napi_value nResultMsg;
5246 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5247 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5248 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5249 nResultMsg));
5250 napi_value nResultCode;
5251 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5252 &nResultCode));
5253 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5254 result[PARAM0] = GetCallbackErrorValue(
5255 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5256 } else {
5257 napi_value nResultMsg;
5258 std::string msg = "error param type.";
5259 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5260 &nResultMsg));
5261 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5262 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5263 }
5264 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5265 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5266 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5267 &result[PARAM0], &callResult));
5268 },
5269 reinterpret_cast<void*>(asyncCallbackInfo),
5270 &asyncCallbackInfo->asyncWork));
5271 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5272 callbackPtr.release();
5273 napi_value result;
5274 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5275 return result;
5276 } else {
5277 napi_deferred deferred;
5278 napi_value promise;
5279 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5280 asyncCallbackInfo->deferred = deferred;
5281
5282 napi_value resourceName;
5283 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5284 NAPI_CALL(env, napi_create_async_work(
5285 env,
5286 nullptr,
5287 resourceName,
5288 [](napi_env env, void *data) {
5289 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5290 if (asyncCallbackInfo == nullptr) {
5291 return;
5292 }
5293 InnerInstall(env,
5294 asyncCallbackInfo->hapFiles,
5295 asyncCallbackInfo->installParam,
5296 asyncCallbackInfo->installResult);
5297 },
5298 [](napi_env env, napi_status status, void *data) {
5299 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5300 if (asyncCallbackInfo == nullptr) {
5301 return;
5302 }
5303 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5304 ConvertInstallResult(asyncCallbackInfo->installResult);
5305 napi_value result;
5306 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5307 napi_value nResultMsg;
5308 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5309 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5310 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5311 napi_value nResultCode;
5312 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5313 &nResultCode));
5314 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5315 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5316 result));
5317 },
5318 reinterpret_cast<void*>(asyncCallbackInfo),
5319 &asyncCallbackInfo->asyncWork));
5320 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5321 callbackPtr.release();
5322 return promise;
5323 }
5324 }
5325
InnerRecover(napi_env env, const std::string &bundleName, InstallParam &installParam, InstallResult &installResult)5326 static void InnerRecover(napi_env env, const std::string &bundleName, InstallParam &installParam,
5327 InstallResult &installResult)
5328 {
5329 if (bundleName.empty()) {
5330 installResult.resultCode = static_cast<int32_t>(IStatusReceiver::ERR_RECOVER_INVALID_BUNDLE_NAME);
5331 return;
5332 }
5333 auto iBundleMgr = GetBundleMgr();
5334 if (iBundleMgr == nullptr) {
5335 APP_LOGE("can not get iBundleMgr");
5336 return;
5337 }
5338 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5339 if (iBundleInstaller == nullptr) {
5340 APP_LOGE("can not get iBundleInstaller");
5341 return;
5342 }
5343
5344 OHOS::sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5345 if (callback == nullptr) {
5346 APP_LOGE("callback nullptr");
5347 return;
5348 }
5349 iBundleInstaller->Recover(bundleName, installParam, callback);
5350 installResult.resultMsg = callback->GetResultMsg();
5351 APP_LOGD("InnerRecover resultMsg %{public}s", installResult.resultMsg.c_str());
5352 installResult.resultCode = callback->GetResultCode();
5353 APP_LOGD("InnerRecover resultCode %{public}d", installResult.resultCode);
5354 }
5355
Recover(napi_env env, napi_callback_info info)5356 napi_value Recover(napi_env env, napi_callback_info info)
5357 {
5358 size_t argc = ARGS_SIZE_THREE;
5359 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5360 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5361 APP_LOGD("argc = [%{public}zu]", argc);
5362 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5363 if (asyncCallbackInfo == nullptr) {
5364 return nullptr;
5365 }
5366 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5367 std::string bundleName;
5368 ParseString(env, bundleName, argv[PARAM0]);
5369 InstallParam installParam;
5370 if (!ParseInstallParam(env, installParam, argv[PARAM1])) {
5371 APP_LOGE("Recover installParam error, bundleName is %{public}s", bundleName.c_str());
5372 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5373 }
5374
5375 asyncCallbackInfo->installParam = installParam;
5376 asyncCallbackInfo->bundleName = bundleName;
5377 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5378 APP_LOGD("Recover by bundleName asyncCallback");
5379 napi_valuetype valuetype = napi_undefined;
5380 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5381 if (valuetype != napi_function) {
5382 APP_LOGE("Wrong argument type. Function expected");
5383 return nullptr;
5384 }
5385 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5386
5387 napi_value resourceName;
5388 NAPI_CALL(env, napi_create_string_latin1(env, "Recover", NAPI_AUTO_LENGTH, &resourceName));
5389 NAPI_CALL(env, napi_create_async_work(
5390 env,
5391 nullptr,
5392 resourceName,
5393 [](napi_env env, void *data) {
5394 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5395 if (asyncCallbackInfo == nullptr) {
5396 return;
5397 }
5398 if (!asyncCallbackInfo->errCode) {
5399 InnerRecover(env,
5400 asyncCallbackInfo->bundleName,
5401 asyncCallbackInfo->installParam,
5402 asyncCallbackInfo->installResult);
5403 }
5404 },
5405 [](napi_env env, napi_status status, void *data) {
5406 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5407 if (asyncCallbackInfo == nullptr) {
5408 return;
5409 }
5410 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5411 napi_value result[ARGS_SIZE_TWO] = {0};
5412 napi_value callback = 0;
5413 napi_value undefined = 0;
5414 napi_value callResult = 0;
5415 if (!asyncCallbackInfo->errCode) {
5416 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5417 ConvertInstallResult(asyncCallbackInfo->installResult);
5418 napi_value nResultMsg;
5419 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5420 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5421 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5422 nResultMsg));
5423 napi_value nResultCode;
5424 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5425 &nResultCode));
5426 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5427 result[PARAM0] = GetCallbackErrorValue(
5428 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5429 } else {
5430 napi_value nResultMsg;
5431 std::string msg = "error param type.";
5432 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5433 &nResultMsg));
5434 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5435 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5436 }
5437 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5438 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5439 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5440 &result[PARAM0], &callResult));
5441 },
5442 reinterpret_cast<void*>(asyncCallbackInfo),
5443 &asyncCallbackInfo->asyncWork));
5444 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5445 callbackPtr.release();
5446 napi_value result;
5447 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5448 return result;
5449 } else {
5450 napi_deferred deferred;
5451 napi_value promise;
5452 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5453 asyncCallbackInfo->deferred = deferred;
5454
5455 napi_value resourceName;
5456 NAPI_CALL(env, napi_create_string_latin1(env, "Recover", NAPI_AUTO_LENGTH, &resourceName));
5457 NAPI_CALL(env, napi_create_async_work(
5458 env,
5459 nullptr,
5460 resourceName,
5461 [](napi_env env, void *data) {
5462 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5463 if (asyncCallbackInfo == nullptr) {
5464 return;
5465 }
5466 InnerRecover(env,
5467 asyncCallbackInfo->bundleName,
5468 asyncCallbackInfo->installParam,
5469 asyncCallbackInfo->installResult);
5470 },
5471 [](napi_env env, napi_status status, void *data) {
5472 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5473 if (asyncCallbackInfo == nullptr) {
5474 return;
5475 }
5476 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5477 ConvertInstallResult(asyncCallbackInfo->installResult);
5478 napi_value result;
5479 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5480 napi_value nResultMsg;
5481 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5482 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5483 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5484 napi_value nResultCode;
5485 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5486 &nResultCode));
5487 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5488 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5489 result));
5490 },
5491 reinterpret_cast<void*>(asyncCallbackInfo),
5492 &asyncCallbackInfo->asyncWork));
5493 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5494 callbackPtr.release();
5495 return promise;
5496 }
5497 }
5498
InnerUninstall( napi_env env, const std::string &bundleName, InstallParam &installParam, InstallResult &installResult)5499 static void InnerUninstall(
5500 napi_env env, const std::string &bundleName, InstallParam &installParam, InstallResult &installResult)
5501 {
5502 auto iBundleMgr = GetBundleMgr();
5503 if (iBundleMgr == nullptr) {
5504 APP_LOGE("can not get iBundleMgr");
5505 return;
5506 }
5507 auto iBundleInstaller = iBundleMgr->GetBundleInstaller();
5508 if ((iBundleInstaller == nullptr) || (iBundleInstaller->AsObject() == nullptr)) {
5509 APP_LOGE("can not get iBundleInstaller");
5510 return;
5511 }
5512 installParam.installFlag = InstallFlag::NORMAL;
5513 OHOS::sptr<InstallerCallback> callback = new (std::nothrow) InstallerCallback();
5514 if (callback == nullptr) {
5515 APP_LOGE("callback nullptr");
5516 return;
5517 }
5518
5519 sptr<BundleDeathRecipient> recipient(new (std::nothrow) BundleDeathRecipient(callback));
5520 iBundleInstaller->AsObject()->AddDeathRecipient(recipient);
5521 iBundleInstaller->Uninstall(bundleName, installParam, callback);
5522 installResult.resultMsg = callback->GetResultMsg();
5523 APP_LOGD("-----InnerUninstall resultMsg %{public}s-----", installResult.resultMsg.c_str());
5524 installResult.resultCode = callback->GetResultCode();
5525 APP_LOGD("-----InnerUninstall resultCode %{public}d-----", installResult.resultCode);
5526 }
5527
5528 /**
5529 * Promise and async callback
5530 */
Uninstall(napi_env env, napi_callback_info info)5531 napi_value Uninstall(napi_env env, napi_callback_info info)
5532 {
5533 APP_LOGI("called");
5534 size_t argc = ARGS_SIZE_THREE;
5535 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
5536 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
5537 APP_LOGD("argc = [%{public}zu]", argc);
5538 AsyncInstallCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo(env);
5539 if (asyncCallbackInfo == nullptr) {
5540 return nullptr;
5541 }
5542 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5543 std::string bundleName;
5544 ParseString(env, bundleName, argv[PARAM0]);
5545 InstallParam installParam;
5546 if (!ParseInstallParam(env, installParam, argv[PARAM1])) {
5547 APP_LOGE("Uninstall installParam error, bundleName is %{public}s", bundleName.c_str());
5548 asyncCallbackInfo->errCode = PARAM_TYPE_ERROR;
5549 }
5550
5551 asyncCallbackInfo->installParam = installParam;
5552 asyncCallbackInfo->bundleName = bundleName;
5553 if (argc > (ARGS_SIZE_THREE - CALLBACK_SIZE)) {
5554 APP_LOGI("Uninstall asyncCallback");
5555 napi_valuetype valuetype = napi_undefined;
5556 NAPI_CALL(env, napi_typeof(env, argv[ARGS_SIZE_TWO], &valuetype));
5557 if (valuetype != napi_function) {
5558 APP_LOGE("Wrong argument type. Function expected");
5559 return nullptr;
5560 }
5561 NAPI_CALL(env, napi_create_reference(env, argv[ARGS_SIZE_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
5562
5563 napi_value resourceName;
5564 NAPI_CALL(env, napi_create_string_latin1(env, "Uninstall", NAPI_AUTO_LENGTH, &resourceName));
5565 NAPI_CALL(env, napi_create_async_work(
5566 env,
5567 nullptr,
5568 resourceName,
5569 [](napi_env env, void *data) {
5570 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5571 if (asyncCallbackInfo == nullptr) {
5572 return;
5573 }
5574 if (!asyncCallbackInfo->errCode) {
5575 InnerUninstall(env,
5576 asyncCallbackInfo->bundleName,
5577 asyncCallbackInfo->installParam,
5578 asyncCallbackInfo->installResult);
5579 }
5580 },
5581 [](napi_env env, napi_status status, void *data) {
5582 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5583 if (asyncCallbackInfo == nullptr) {
5584 return;
5585 }
5586 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5587 napi_value result[ARGS_SIZE_TWO] = {0};
5588 napi_value callback = 0;
5589 napi_value undefined = 0;
5590 napi_value callResult = 0;
5591 if (!asyncCallbackInfo->errCode) {
5592 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result[PARAM1]));
5593 ConvertInstallResult(asyncCallbackInfo->installResult);
5594 napi_value nResultMsg;
5595 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5596 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5597 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "statusMessage",
5598 nResultMsg));
5599 napi_value nResultCode;
5600 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5601 &nResultCode));
5602 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM1], "status", nResultCode));
5603 result[PARAM0] = GetCallbackErrorValue(
5604 env, (asyncCallbackInfo->installResult.resultCode == 0) ? CODE_SUCCESS : CODE_FAILED);
5605 } else {
5606 napi_value nResultMsg;
5607 std::string msg = "error param type.";
5608 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH,
5609 &nResultMsg));
5610 result[PARAM0] = GetCallbackErrorValue(env, CODE_FAILED);
5611 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result[PARAM0], "message", nResultMsg));
5612 }
5613 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
5614 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, asyncCallbackInfo->callback, &callback));
5615 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_SIZE_TWO,
5616 &result[PARAM0], &callResult));
5617 },
5618 reinterpret_cast<void*>(asyncCallbackInfo),
5619 &asyncCallbackInfo->asyncWork));
5620 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5621 callbackPtr.release();
5622 napi_value result;
5623 napi_create_int32(env, NAPI_RETURN_ONE, &result);
5624 return result;
5625 } else {
5626 napi_deferred deferred;
5627 napi_value promise;
5628 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
5629 asyncCallbackInfo->deferred = deferred;
5630
5631 napi_value resourceName;
5632 NAPI_CALL(env, napi_create_string_latin1(env, "Install", NAPI_AUTO_LENGTH, &resourceName));
5633 NAPI_CALL(env, napi_create_async_work(
5634 env,
5635 nullptr,
5636 resourceName,
5637 [](napi_env env, void *data) {
5638 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5639 if (asyncCallbackInfo == nullptr) {
5640 return;
5641 }
5642 InnerUninstall(
5643 env, asyncCallbackInfo->param, asyncCallbackInfo->installParam, asyncCallbackInfo->installResult);
5644 },
5645 [](napi_env env, napi_status status, void *data) {
5646 AsyncInstallCallbackInfo *asyncCallbackInfo = reinterpret_cast<AsyncInstallCallbackInfo *>(data);
5647 if (asyncCallbackInfo == nullptr) {
5648 return;
5649 }
5650 std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr {asyncCallbackInfo};
5651 ConvertInstallResult(asyncCallbackInfo->installResult);
5652 napi_value result;
5653 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
5654 napi_value nResultMsg;
5655 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
5656 env, asyncCallbackInfo->installResult.resultMsg.c_str(), NAPI_AUTO_LENGTH, &nResultMsg));
5657 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "statusMessage", nResultMsg));
5658 napi_value nResultCode;
5659 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncCallbackInfo->installResult.resultCode,
5660 &nResultCode));
5661 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "status", nResultCode));
5662 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(asyncCallbackInfo->env, asyncCallbackInfo->deferred,
5663 result));
5664 },
5665 reinterpret_cast<void*>(asyncCallbackInfo),
5666 &asyncCallbackInfo->asyncWork));
5667 NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
5668 callbackPtr.release();
5669 return promise;
5670 }
5671 }
5672
BundleInstallerConstructor(napi_env env, napi_callback_info info)5673 napi_value BundleInstallerConstructor(napi_env env, napi_callback_info info)
5674 {
5675 napi_value jsthis = nullptr;
5676 NAPI_CALL(env, napi_get_cb_info(env, info, nullptr, nullptr, &jsthis, nullptr));
5677 return jsthis;
5678 }
5679 } // namespace AppExecFwk
5680 } // namespace OHOS