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