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