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