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