1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "free_install.h"
16
17 #include <string>
18
19 #include "app_log_wrapper.h"
20 #include "bundle_errors.h"
21 #include "bundle_mgr_interface.h"
22 #include "bundle_mgr_proxy.h"
23 #include "business_error.h"
24 #include "common_func.h"
25 #include "napi_arg.h"
26 #include "napi_constants.h"
27
28 namespace OHOS {
29 namespace AppExecFwk {
30 namespace {
31 enum class UpgradeFlag {
32 NOT_UPGRADE = 0,
33 SINGLE_UPGRADE = 1,
34 RELATION_UPGRADE = 2,
35 };
36 const std::vector<int32_t> BUNDLE_PACK_FLAGS = {
37 BundlePackFlag::GET_PACK_INFO_ALL,
38 BundlePackFlag::GET_PACKAGES,
39 BundlePackFlag::GET_BUNDLE_SUMMARY,
40 BundlePackFlag::GET_MODULE_SUMMARY,
41 };
42 }
43
InnerIsHapModuleRemovable(const std::string & bundleName,const std::string & moduleName,bool & isRemovable)44 static ErrCode InnerIsHapModuleRemovable(const std::string &bundleName,
45 const std::string &moduleName, bool &isRemovable)
46 {
47 auto iBundleMgr = CommonFunc::GetBundleMgr();
48 if (iBundleMgr == nullptr) {
49 APP_LOGE("can not get iBundleMgr");
50 return ERROR_BUNDLE_SERVICE_EXCEPTION;
51 }
52 auto result = iBundleMgr->IsModuleRemovable(bundleName, moduleName, isRemovable);
53 if (result != ERR_OK) {
54 APP_LOGE("InnerIsHapModuleRemovable::IsModuleRemovable failed, bundleName is %{public}s", bundleName.c_str());
55 }
56 return CommonFunc::ConvertErrCode(result);
57 }
58
IsHapModuleRemovableExec(napi_env env,void * data)59 void IsHapModuleRemovableExec(napi_env env, void *data)
60 {
61 HapModuleRemovableCallbackInfo *asyncCallbackInfo = reinterpret_cast<HapModuleRemovableCallbackInfo*>(data);
62 if (asyncCallbackInfo == nullptr) {
63 APP_LOGE("asyncCallbackInfo is nullptr");
64 return;
65 }
66 asyncCallbackInfo->err = InnerIsHapModuleRemovable(asyncCallbackInfo->bundleName,
67 asyncCallbackInfo->moduleName, asyncCallbackInfo->result);
68 }
69
IsHapModuleRemovableComplete(napi_env env,napi_status status,void * data)70 void IsHapModuleRemovableComplete(napi_env env, napi_status status, void *data)
71 {
72 HapModuleRemovableCallbackInfo *asyncCallbackInfo = reinterpret_cast<HapModuleRemovableCallbackInfo*>(data);
73 if (asyncCallbackInfo == nullptr) {
74 APP_LOGE("asyncCallbackInfo is null");
75 return;
76 }
77 std::unique_ptr<HapModuleRemovableCallbackInfo> callbackPtr {asyncCallbackInfo};
78 napi_value result[ARGS_SIZE_TWO] = {0};
79 if (asyncCallbackInfo->err == SUCCESS) {
80 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
81 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, asyncCallbackInfo->result, &result[ARGS_SIZE_ONE]));
82 } else {
83 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
84 RESOURCE_NAME_OF_IS_HAP_MODULE_REMOVABLE, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
85 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_SIZE_ONE]));
86 }
87 CommonFunc::NapiReturnDeferred<HapModuleRemovableCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
88 }
89
IsHapModuleRemovable(napi_env env,napi_callback_info info)90 napi_value IsHapModuleRemovable(napi_env env, napi_callback_info info)
91 {
92 APP_LOGD("NAPI_IsHapModuleRemovable start");
93 NapiArg args(env, info);
94 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
95 APP_LOGE("param count invalid");
96 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
97 return nullptr;
98 }
99 HapModuleRemovableCallbackInfo *asyncCallbackInfo = new (std::nothrow) HapModuleRemovableCallbackInfo(env);
100 if (asyncCallbackInfo == nullptr) {
101 APP_LOGE("asyncCallbackInfo is null");
102 return nullptr;
103 }
104 std::unique_ptr<HapModuleRemovableCallbackInfo> callbackPtr {asyncCallbackInfo};
105 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
106 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
107 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
108 return nullptr;
109 }
110 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->moduleName)) {
111 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
112 return nullptr;
113 }
114 if (args.GetMaxArgc() == ARGS_SIZE_THREE) {
115 napi_valuetype valueType = napi_undefined;
116 napi_typeof(env, args[ARGS_POS_TWO], &valueType);
117 if (valueType == napi_function) {
118 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_TWO],
119 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
120 }
121 }
122 } else {
123 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
124 return nullptr;
125 }
126 auto promise = CommonFunc::AsyncCallNativeMethod<HapModuleRemovableCallbackInfo>(
127 env, asyncCallbackInfo, RESOURCE_NAME_OF_IS_HAP_MODULE_REMOVABLE,
128 IsHapModuleRemovableExec, IsHapModuleRemovableComplete);
129 callbackPtr.release();
130 APP_LOGD("call IsHapModuleRemovable done");
131 return promise;
132 }
133
InnerSetHapModuleUpgradeFlag(const std::string & bundleName,const std::string & moduleName,int32_t upgradeFlag)134 static ErrCode InnerSetHapModuleUpgradeFlag(const std::string &bundleName,
135 const std::string &moduleName, int32_t upgradeFlag)
136 {
137 auto iBundleMgr = CommonFunc::GetBundleMgr();
138 if (iBundleMgr == nullptr) {
139 APP_LOGE("can not get iBundleMgr");
140 return ERROR_BUNDLE_SERVICE_EXCEPTION;
141 }
142 auto result = iBundleMgr->SetModuleUpgradeFlag(bundleName, moduleName, upgradeFlag);
143 if (result != ERR_OK) {
144 APP_LOGE("InnerSetHapModuleUpgradeFlag::SetModuleUpgradeFlag failed, bundleName is %{public}s",
145 bundleName.c_str());
146 }
147 return CommonFunc::ConvertErrCode(result);
148 }
149
SetHapModuleUpgradeFlagExec(napi_env env,void * data)150 void SetHapModuleUpgradeFlagExec(napi_env env, void *data)
151 {
152 SetHapModuleUpgradeFlagCallbackInfo *asyncCallbackInfo =
153 reinterpret_cast<SetHapModuleUpgradeFlagCallbackInfo*>(data);
154 if (asyncCallbackInfo == nullptr) {
155 APP_LOGE("asyncCallbackInfo is nullptr");
156 return;
157 }
158 asyncCallbackInfo->err = InnerSetHapModuleUpgradeFlag(asyncCallbackInfo->bundleName,
159 asyncCallbackInfo->moduleName, asyncCallbackInfo->upgradeFlag);
160 }
161
SetHapModuleUpgradeFlagComplete(napi_env env,napi_status status,void * data)162 void SetHapModuleUpgradeFlagComplete(napi_env env, napi_status status, void *data)
163 {
164 SetHapModuleUpgradeFlagCallbackInfo *asyncCallbackInfo =
165 reinterpret_cast<SetHapModuleUpgradeFlagCallbackInfo*>(data);
166 if (asyncCallbackInfo == nullptr) {
167 APP_LOGE("asyncCallbackInfo is null");
168 return;
169 }
170 std::unique_ptr<SetHapModuleUpgradeFlagCallbackInfo> callbackPtr {asyncCallbackInfo};
171 napi_value result[ARGS_SIZE_ONE] = {0};
172 if (asyncCallbackInfo->err == SUCCESS) {
173 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
174 } else {
175 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
176 RESOURCE_NAME_OF_SET_HAP_MODULE_UPGRADE_FLAG, Constants::PERMISSION_INSTALL_BUNDLE);
177 }
178 CommonFunc::NapiReturnDeferred<SetHapModuleUpgradeFlagCallbackInfo>(env,
179 asyncCallbackInfo, result, ARGS_SIZE_ONE);
180 }
181
SetHapModuleUpgradeFlag(napi_env env,napi_callback_info info)182 napi_value SetHapModuleUpgradeFlag(napi_env env, napi_callback_info info)
183 {
184 APP_LOGD("NAPI_SetHapModuleUpgradeFlag start");
185 NapiArg args(env, info);
186 if (!args.Init(ARGS_SIZE_THREE, ARGS_SIZE_FOUR)) {
187 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
188 return nullptr;
189 }
190 SetHapModuleUpgradeFlagCallbackInfo *asyncCallbackInfo =
191 new (std::nothrow) SetHapModuleUpgradeFlagCallbackInfo(env);
192 if (asyncCallbackInfo == nullptr) {
193 return nullptr;
194 }
195 std::unique_ptr<SetHapModuleUpgradeFlagCallbackInfo> callbackPtr {asyncCallbackInfo};
196 if (args.GetMaxArgc() >= ARGS_SIZE_THREE) {
197 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
198 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
199 return nullptr;
200 }
201 if (!CommonFunc::ParseString(env, args[ARGS_POS_ONE], asyncCallbackInfo->moduleName)) {
202 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, MODULE_NAME, TYPE_STRING);
203 return nullptr;
204 }
205 if (!CommonFunc::ParseInt(env, args[ARGS_POS_TWO], asyncCallbackInfo->upgradeFlag)) {
206 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, UPGRADE_FLAG, TYPE_NUMBER);
207 return nullptr;
208 }
209 if (args.GetMaxArgc() == ARGS_SIZE_FOUR) {
210 napi_valuetype valueType = napi_undefined;
211 napi_typeof(env, args[ARGS_POS_THREE], &valueType);
212 if (valueType == napi_function) {
213 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_THREE],
214 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
215 }
216 }
217 } else {
218 APP_LOGE("parameters error");
219 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
220 return nullptr;
221 }
222
223 auto promise = CommonFunc::AsyncCallNativeMethod<SetHapModuleUpgradeFlagCallbackInfo>(
224 env, asyncCallbackInfo, RESOURCE_NAME_OF_SET_HAP_MODULE_UPGRADE_FLAG,
225 SetHapModuleUpgradeFlagExec, SetHapModuleUpgradeFlagComplete);
226 callbackPtr.release();
227 APP_LOGD("call SetHapModuleUpgradeFlag done");
228 return promise;
229 }
230
CreateUpgradeFlagObject(napi_env env,napi_value value)231 void CreateUpgradeFlagObject(napi_env env, napi_value value)
232 {
233 napi_value nNotUpgrade;
234 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(UpgradeFlag::NOT_UPGRADE), &nNotUpgrade));
235 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "NOT_UPGRADE", nNotUpgrade));
236
237 napi_value nSingleUpgrade;
238 NAPI_CALL_RETURN_VOID(
239 env, napi_create_int32(env, static_cast<int32_t>(UpgradeFlag::SINGLE_UPGRADE), &nSingleUpgrade));
240 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "SINGLE_UPGRADE", nSingleUpgrade));
241
242 napi_value nRelationUpgrade;
243 NAPI_CALL_RETURN_VOID(
244 env, napi_create_int32(env, static_cast<int32_t>(UpgradeFlag::RELATION_UPGRADE), &nRelationUpgrade));
245 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "RELATION_UPGRADE", nRelationUpgrade));
246 }
247
CreateBundlePackFlagObject(napi_env env,napi_value value)248 void CreateBundlePackFlagObject(napi_env env, napi_value value)
249 {
250 napi_value nGetPackInfoAll;
251 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(BundlePackFlag::GET_PACK_INFO_ALL),
252 &nGetPackInfoAll));
253 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "GET_PACK_INFO_ALL", nGetPackInfoAll));
254
255 napi_value nGetPackages;
256 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(BundlePackFlag::GET_PACKAGES),
257 &nGetPackages));
258 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "GET_PACKAGES", nGetPackages));
259
260 napi_value nGetBundleSummary;
261 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(BundlePackFlag::GET_BUNDLE_SUMMARY),
262 &nGetBundleSummary));
263 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "GET_BUNDLE_SUMMARY", nGetBundleSummary));
264
265 napi_value nGetModuleSummary;
266 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(BundlePackFlag::GET_MODULE_SUMMARY),
267 &nGetModuleSummary));
268 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "GET_MODULE_SUMMARY", nGetModuleSummary));
269 }
270
ConvertSummaryApp(napi_env env,napi_value & app,const BundlePackInfo & bundlePackInfo)271 static void ConvertSummaryApp(napi_env env, napi_value &app, const BundlePackInfo &bundlePackInfo)
272 {
273 napi_value bundleName;
274 NAPI_CALL_RETURN_VOID(env,
275 napi_create_string_utf8(env, bundlePackInfo.summary.app.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName));
276 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, app, "bundleName", bundleName));
277 napi_value version;
278 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &version));
279 napi_value versionName;
280 NAPI_CALL_RETURN_VOID(env,
281 napi_create_string_utf8(env, bundlePackInfo.summary.app.version.name.c_str(), NAPI_AUTO_LENGTH, &versionName));
282 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, version, "name", versionName));
283 napi_value versionCode;
284 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundlePackInfo.summary.app.version.code, &versionCode));
285 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, version, "code", versionCode));
286 napi_value minCompatibleVersionCode;
287 NAPI_CALL_RETURN_VOID(env,
288 napi_create_int32(env, bundlePackInfo.summary.app.version.minCompatibleVersionCode, &minCompatibleVersionCode));
289 NAPI_CALL_RETURN_VOID(
290 env, napi_set_named_property(env, version, "minCompatibleVersionCode", minCompatibleVersionCode));
291 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, app, "version", version));
292 }
293
ConvertModulesApiVersion(napi_env env,napi_value & modulesObject,const OHOS::AppExecFwk::PackageModule & module)294 static void ConvertModulesApiVersion(
295 napi_env env, napi_value &modulesObject, const OHOS::AppExecFwk::PackageModule &module)
296 {
297 napi_value apiVersion;
298 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &apiVersion));
299 napi_value releaseType;
300 NAPI_CALL_RETURN_VOID(
301 env, napi_create_string_utf8(env, module.apiVersion.releaseType.c_str(), NAPI_AUTO_LENGTH, &releaseType));
302 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, apiVersion, "releaseType", releaseType));
303 napi_value compatible;
304 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, module.apiVersion.compatible, &compatible));
305 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, apiVersion, "compatible", compatible));
306 napi_value target;
307 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, module.apiVersion.target, &target));
308 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, apiVersion, "target", target));
309
310 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, modulesObject, "apiVersion", apiVersion));
311 }
312
ConvertDeviceType(napi_env env,napi_value & object,std::vector<std::string> deviceTypes)313 static void ConvertDeviceType(napi_env env, napi_value &object, std::vector<std::string> deviceTypes)
314 {
315 napi_value nDeviceTypes;
316 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
317 size_t typeIndex = 0;
318 for (const auto &type : deviceTypes) {
319 napi_value typeValue;
320 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, type.c_str(), NAPI_AUTO_LENGTH, &typeValue));
321 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, typeIndex, typeValue));
322 typeIndex++;
323 }
324 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, object, "deviceTypes", nDeviceTypes));
325 }
326
ConvertDistro(napi_env env,napi_value & modulesObject,const PackageModule & module)327 static void ConvertDistro(napi_env env, napi_value &modulesObject, const PackageModule &module)
328 {
329 napi_value distro;
330 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &distro));
331 napi_value deliveryWithInstall;
332 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, module.distro.deliveryWithInstall, &deliveryWithInstall));
333 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, distro, "deliveryWithInstall", deliveryWithInstall));
334 napi_value installationFree;
335 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, module.distro.installationFree, &installationFree));
336 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, distro, "installationFree", installationFree));
337 napi_value moduleName;
338 NAPI_CALL_RETURN_VOID(
339 env, napi_create_string_utf8(env, module.distro.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName));
340 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, distro, "moduleName", moduleName));
341 napi_value moduleType;
342 NAPI_CALL_RETURN_VOID(
343 env, napi_create_string_utf8(env, module.distro.moduleType.c_str(), NAPI_AUTO_LENGTH, &moduleType));
344 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, distro, "moduleType", moduleType));
345
346 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, modulesObject, "distro", distro));
347 }
348
ConvertFormsInfo(napi_env env,napi_value & abilityObject,const std::vector<OHOS::AppExecFwk::AbilityFormInfo> & forms)349 static void ConvertFormsInfo(napi_env env, napi_value &abilityObject,
350 const std::vector<OHOS::AppExecFwk::AbilityFormInfo> &forms)
351 {
352 napi_value formsArray;
353 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &formsArray));
354 size_t index = 0;
355 for (const auto &form : forms) {
356 napi_value formObject;
357 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &formObject));
358 napi_value name;
359 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, form.name.c_str(), NAPI_AUTO_LENGTH, &name));
360 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "name", name));
361 napi_value type;
362 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, form.type.c_str(), NAPI_AUTO_LENGTH, &type));
363 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "type", type));
364 napi_value updateEnabled;
365 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, form.updateEnabled, &updateEnabled));
366 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "updateEnabled", updateEnabled));
367 napi_value scheduledUpdateTime;
368 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, form.scheduledUpdateTime.c_str(),
369 NAPI_AUTO_LENGTH, &scheduledUpdateTime));
370 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "scheduledUpdateTime",
371 scheduledUpdateTime));
372 napi_value updateDuration;
373 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, form.updateDuration, &updateDuration));
374 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "updateDuration", updateDuration));
375 napi_value supportDimensions;
376 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &supportDimensions));
377 size_t indexValue = 0;
378 for (const auto &dimension : form.supportDimensions) {
379 napi_value value;
380 NAPI_CALL_RETURN_VOID(
381 env, napi_create_string_utf8(env, dimension.c_str(), NAPI_AUTO_LENGTH, &value));
382 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, supportDimensions, indexValue, value));
383 indexValue++;
384 }
385 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "supportDimensions", supportDimensions));
386 napi_value defaultDimension;
387 NAPI_CALL_RETURN_VOID(
388 env, napi_create_string_utf8(env, form.defaultDimension.c_str(), NAPI_AUTO_LENGTH, &defaultDimension));
389 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, formObject, "defaultDimension", defaultDimension));
390 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, formsArray, index, formObject));
391 index++;
392 }
393 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "forms", formsArray));
394 }
395
ConvertAbilities(napi_env env,napi_value & modulesObject,const PackageModule & module)396 static void ConvertAbilities(napi_env env, napi_value &modulesObject, const PackageModule &module)
397 {
398 napi_value abilities;
399 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &abilities));
400 size_t index = 0;
401 for (const auto &ability : module.abilities) {
402 napi_value abilityObject;
403 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &abilityObject));
404 napi_value name;
405 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, ability.name.c_str(), NAPI_AUTO_LENGTH, &name));
406 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "name", name));
407 napi_value label;
408 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, ability.label.c_str(), NAPI_AUTO_LENGTH, &label));
409 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "label", label));
410 napi_value visible;
411 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, ability.visible, &visible));
412 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "visible", visible));
413 napi_value nExported;
414 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, ability.visible, &nExported));
415 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "exported", nExported));
416 ConvertFormsInfo(env, abilityObject, ability.forms);
417 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, abilities, index, abilityObject));
418 index++;
419 }
420 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, modulesObject, "abilities", abilities));
421 }
422
ConvertExtensionAbilities(napi_env env,napi_value & modulesObject,const OHOS::AppExecFwk::PackageModule & module)423 static void ConvertExtensionAbilities(
424 napi_env env, napi_value &modulesObject, const OHOS::AppExecFwk::PackageModule &module)
425 {
426 napi_value extensionAbilities;
427 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &extensionAbilities));
428 size_t index = 0;
429 for (const auto &extensionAbility : module.extensionAbilities) {
430 napi_value abilityObject;
431 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &abilityObject));
432 napi_value name;
433 NAPI_CALL_RETURN_VOID(
434 env, napi_create_string_utf8(env, extensionAbility.name.c_str(), NAPI_AUTO_LENGTH, &name));
435 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, abilityObject, "name", name));
436 ConvertFormsInfo(env, abilityObject, extensionAbility.forms);
437 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, extensionAbilities, index, abilityObject));
438 index++;
439 }
440 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, modulesObject, "extensionAbilities", extensionAbilities));
441 }
442
ConvertSummaryModules(napi_env env,napi_value & modulesArray,const BundlePackInfo & bundlePackInfo)443 static void ConvertSummaryModules(
444 napi_env env, napi_value &modulesArray, const BundlePackInfo &bundlePackInfo)
445 {
446 size_t index = 0;
447 for (const auto &module : bundlePackInfo.summary.modules) {
448 napi_value modulesObject;
449 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &modulesObject));
450 napi_value mainAbility;
451 NAPI_CALL_RETURN_VOID(
452 env, napi_create_string_utf8(env, module.mainAbility.c_str(), NAPI_AUTO_LENGTH, &mainAbility));
453 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, modulesObject, "mainAbility", mainAbility));
454 ConvertModulesApiVersion(env, modulesObject, module);
455 ConvertDeviceType(env, modulesObject, module.deviceType);
456 ConvertDistro(env, modulesObject, module);
457 ConvertAbilities(env, modulesObject, module);
458 ConvertExtensionAbilities(env, modulesObject, module);
459 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, modulesArray, index, modulesObject));
460 index++;
461 }
462 }
463
ConvertPackageSummary(napi_env env,napi_value & jsSummary,const BundlePackInfo & bundlePackInfo)464 static void ConvertPackageSummary(
465 napi_env env, napi_value &jsSummary, const BundlePackInfo &bundlePackInfo)
466 {
467 napi_value app;
468 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &app));
469 ConvertSummaryApp(env, app, bundlePackInfo);
470 napi_value modules;
471 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &modules));
472 ConvertSummaryModules(env, modules, bundlePackInfo);
473 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, jsSummary, "app", app));
474 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, jsSummary, "modules", modules));
475 }
476
ConvertPackages(napi_env env,napi_value & jsPackagesArray,const BundlePackInfo & bundlePackInfo)477 static void ConvertPackages(
478 napi_env env, napi_value &jsPackagesArray, const BundlePackInfo &bundlePackInfo)
479 {
480 size_t index = 0;
481 for (const auto &package : bundlePackInfo.packages) {
482 napi_value jsPackagesObject;
483 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsPackagesObject));
484 ConvertDeviceType(env, jsPackagesObject, package.deviceType);
485 napi_value packageName;
486 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, package.name.c_str(), NAPI_AUTO_LENGTH, &packageName));
487 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, jsPackagesObject, "name", packageName));
488 napi_value moduleType;
489 NAPI_CALL_RETURN_VOID(
490 env, napi_create_string_utf8(env, package.moduleType.c_str(), NAPI_AUTO_LENGTH, &moduleType));
491 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, jsPackagesObject, "moduleType", moduleType));
492 napi_value deliveryWithInstall;
493 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, package.deliveryWithInstall, &deliveryWithInstall));
494 NAPI_CALL_RETURN_VOID(
495 env, napi_set_named_property(env, jsPackagesObject, "deliveryWithInstall", deliveryWithInstall));
496 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, jsPackagesArray, index, jsPackagesObject));
497 index++;
498 }
499 }
500
ConvertBundlePackInfo(napi_env env,napi_value & result,int32_t flag,const BundlePackInfo & bundlePackInfo)501 static void ConvertBundlePackInfo(
502 napi_env env, napi_value &result, int32_t flag, const BundlePackInfo &bundlePackInfo)
503 {
504 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &result));
505 if (static_cast<uint32_t>(flag) & BundlePackFlag::GET_PACKAGES) {
506 napi_value jsPackagesArray;
507 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &jsPackagesArray));
508 ConvertPackages(env, jsPackagesArray, bundlePackInfo);
509 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "packages", jsPackagesArray));
510 return;
511 }
512 if (static_cast<uint32_t>(flag) & BundlePackFlag::GET_BUNDLE_SUMMARY) {
513 napi_value jsSummary;
514 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsSummary));
515 ConvertPackageSummary(env, jsSummary, bundlePackInfo);
516 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "summary", jsSummary));
517 return;
518 }
519 if (static_cast<uint32_t>(flag) & BundlePackFlag::GET_MODULE_SUMMARY) {
520 napi_value jsSummary;
521 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsSummary));
522 napi_value modules;
523 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &modules));
524 ConvertSummaryModules(env, modules, bundlePackInfo);
525 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, jsSummary, "modules", modules));
526 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "summary", jsSummary));
527 return;
528 }
529 napi_value jsSummary;
530 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsSummary));
531 ConvertPackageSummary(env, jsSummary, bundlePackInfo);
532 napi_value jsPackagesArray;
533 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &jsPackagesArray));
534 ConvertPackages(env, jsPackagesArray, bundlePackInfo);
535 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "packages", jsPackagesArray));
536 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "summary", jsSummary));
537 }
538
InnerGetBundlePackInfo(const std::string & bundleName,int32_t flags,BundlePackInfo & bundlePackInfo)539 static ErrCode InnerGetBundlePackInfo(const std::string &bundleName, int32_t flags, BundlePackInfo &bundlePackInfo)
540 {
541 auto iBundleMgr = CommonFunc::GetBundleMgr();
542 if (iBundleMgr == nullptr) {
543 APP_LOGE("can not get iBundleMgr");
544 return ERROR_BUNDLE_SERVICE_EXCEPTION;
545 }
546 auto ret = iBundleMgr->GetBundlePackInfo(bundleName, flags, bundlePackInfo);
547 if (ret != ERR_OK) {
548 APP_LOGE("InnerGetBundlePackInfo failed, bundleName is %{public}s", bundleName.c_str());
549 }
550 return CommonFunc::ConvertErrCode(ret);
551 }
552
GetBundlePackInfoExec(napi_env env,void * data)553 void GetBundlePackInfoExec(napi_env env, void *data)
554 {
555 GetBundlePackInfoCallbackInfo *asyncCallbackInfo =
556 reinterpret_cast<GetBundlePackInfoCallbackInfo*>(data);
557 if (asyncCallbackInfo == nullptr) {
558 APP_LOGE("asyncCallbackInfo is nullptr");
559 return;
560 }
561 asyncCallbackInfo->err = InnerGetBundlePackInfo(asyncCallbackInfo->bundleName,
562 asyncCallbackInfo->bundlePackFlag, asyncCallbackInfo->bundlePackInfo);
563 }
564
GetBundlePackInfoComplete(napi_env env,napi_status status,void * data)565 void GetBundlePackInfoComplete(napi_env env, napi_status status, void *data)
566 {
567 GetBundlePackInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetBundlePackInfoCallbackInfo*>(data);
568 if (asyncCallbackInfo == nullptr) {
569 APP_LOGE("asyncCallbackInfo is null");
570 return;
571 }
572 std::unique_ptr<GetBundlePackInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
573 napi_value result[ARGS_SIZE_TWO] = {0};
574 if (asyncCallbackInfo->err == SUCCESS) {
575 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
576 ConvertBundlePackInfo(env, result[ARGS_SIZE_ONE],
577 asyncCallbackInfo->bundlePackFlag, asyncCallbackInfo->bundlePackInfo);
578 } else {
579 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
580 RESOURCE_NAME_OF_GET_BUNDLE_PACK_INFO, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
581 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_SIZE_ONE]));
582 }
583 CommonFunc::NapiReturnDeferred<GetBundlePackInfoCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
584 }
585
GetBundlePackInfo(napi_env env,napi_callback_info info)586 napi_value GetBundlePackInfo(napi_env env, napi_callback_info info)
587 {
588 APP_LOGD("NAPI_GetBundlePackInfo start");
589 NapiArg args(env, info);
590 if (!args.Init(ARGS_SIZE_TWO, ARGS_SIZE_THREE)) {
591 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
592 return nullptr;
593 }
594 GetBundlePackInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) GetBundlePackInfoCallbackInfo(env);
595 if (asyncCallbackInfo == nullptr) {
596 return nullptr;
597 }
598 std::unique_ptr<GetBundlePackInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
599 if (args.GetMaxArgc() >= ARGS_SIZE_TWO) {
600 if (!CommonFunc::ParseString(env, args[ARGS_POS_ZERO], asyncCallbackInfo->bundleName)) {
601 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_NAME, TYPE_STRING);
602 return nullptr;
603 }
604 if (!CommonFunc::ParseInt(env, args[ARGS_POS_ONE], asyncCallbackInfo->bundlePackFlag)) {
605 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_PACK_FLAG, TYPE_NUMBER);
606 return nullptr;
607 }
608 if (args.GetMaxArgc() == ARGS_SIZE_THREE) {
609 napi_valuetype valueType = napi_undefined;
610 napi_typeof(env, args[ARGS_POS_TWO], &valueType);
611 if (valueType == napi_function) {
612 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_TWO],
613 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
614 }
615 }
616 } else {
617 APP_LOGE("parameters error");
618 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
619 return nullptr;
620 }
621 if (std::find(BUNDLE_PACK_FLAGS.begin(), BUNDLE_PACK_FLAGS.end(), asyncCallbackInfo->bundlePackFlag) ==
622 BUNDLE_PACK_FLAGS.end()) {
623 BusinessError::ThrowParameterTypeError(env, ERROR_PARAM_CHECK_ERROR, BUNDLE_PACK_FLAG, "BundlePackFlag");
624 return nullptr;
625 }
626 auto promise = CommonFunc::AsyncCallNativeMethod<GetBundlePackInfoCallbackInfo>(
627 env, asyncCallbackInfo, RESOURCE_NAME_OF_GET_BUNDLE_PACK_INFO,
628 GetBundlePackInfoExec, GetBundlePackInfoComplete);
629 callbackPtr.release();
630 APP_LOGD("call GetBundlePackInfo end");
631 return promise;
632 }
633
ConvertDispatcherVersion(napi_env env,napi_value & value,const std::string & version,const std::string & dispatchAPI)634 static void ConvertDispatcherVersion(
635 napi_env env, napi_value &value, const std::string &version, const std::string &dispatchAPI)
636 {
637 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &value));
638 napi_value napiVersion;
639 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, version.c_str(), NAPI_AUTO_LENGTH, &napiVersion));
640 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "version", napiVersion));
641 napi_value napiDispatchAPIVersion;
642 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, dispatchAPI.c_str(), NAPI_AUTO_LENGTH,
643 &napiDispatchAPIVersion));
644 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "dispatchAPIVersion", napiDispatchAPIVersion));
645 }
646
InnerGetDispatchInfo(std::string & version,std::string & dispatchAPI)647 static ErrCode InnerGetDispatchInfo(std::string &version, std::string &dispatchAPI)
648 {
649 auto iBundleMgr = CommonFunc::GetBundleMgr();
650 if (iBundleMgr == nullptr) {
651 APP_LOGE("can not get iBundleMgr");
652 return ERROR_BUNDLE_SERVICE_EXCEPTION;
653 }
654 if (!iBundleMgr->VerifySystemApi(Constants::INVALID_API_VERSION)) {
655 APP_LOGE("non-system app calling system api");
656 return ERROR_NOT_SYSTEM_APP;
657 }
658 if (!iBundleMgr->VerifyCallingPermission(Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED)) {
659 APP_LOGE("GetDispatchInfo failed due to permission denied");
660 return ERROR_PERMISSION_DENIED_ERROR;
661 }
662 version = DISPATCH_INFO_VERSION;
663 dispatchAPI = DISPATCH_INFO_DISPATCH_API;
664 return SUCCESS;
665 }
666
GetDispatchInfoExec(napi_env env,void * data)667 void GetDispatchInfoExec(napi_env env, void *data)
668 {
669 GetDispatchInfoCallbackInfo *asyncCallbackInfo =
670 reinterpret_cast<GetDispatchInfoCallbackInfo*>(data);
671 if (asyncCallbackInfo == nullptr) {
672 APP_LOGE("asyncCallbackInfo is nullptr");
673 return;
674 }
675 asyncCallbackInfo->err = InnerGetDispatchInfo(asyncCallbackInfo->version, asyncCallbackInfo->dispatchAPI);
676 }
677
GetDispatchInfoComplete(napi_env env,napi_status status,void * data)678 void GetDispatchInfoComplete(napi_env env, napi_status status, void *data)
679 {
680 GetDispatchInfoCallbackInfo *asyncCallbackInfo = reinterpret_cast<GetDispatchInfoCallbackInfo*>(data);
681 if (asyncCallbackInfo == nullptr) {
682 APP_LOGE("asyncCallbackInfo is null");
683 return;
684 }
685 std::unique_ptr<GetDispatchInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
686 napi_value result[ARGS_SIZE_TWO] = {0};
687 if (asyncCallbackInfo->err == SUCCESS) {
688 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[0]));
689 ConvertDispatcherVersion(env, result[ARGS_SIZE_ONE],
690 asyncCallbackInfo->version, asyncCallbackInfo->dispatchAPI);
691 } else {
692 result[0] = BusinessError::CreateCommonError(env, asyncCallbackInfo->err,
693 RESOURCE_NAME_OF_GET_DISPATCH_INFO, Constants::PERMISSION_GET_BUNDLE_INFO_PRIVILEGED);
694 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &result[ARGS_SIZE_ONE]));
695 }
696 CommonFunc::NapiReturnDeferred<GetDispatchInfoCallbackInfo>(env, asyncCallbackInfo, result, ARGS_SIZE_TWO);
697 }
698
GetDispatchInfo(napi_env env,napi_callback_info info)699 napi_value GetDispatchInfo(napi_env env, napi_callback_info info)
700 {
701 APP_LOGD("NAPI_GetDispatchInfo start");
702 NapiArg args(env, info);
703 if (!args.Init(ARGS_SIZE_ZERO, ARGS_SIZE_ONE)) {
704 BusinessError::ThrowTooFewParametersError(env, ERROR_PARAM_CHECK_ERROR);
705 return nullptr;
706 }
707 GetDispatchInfoCallbackInfo *asyncCallbackInfo = new (std::nothrow) GetDispatchInfoCallbackInfo(env);
708 if (asyncCallbackInfo == nullptr) {
709 return nullptr;
710 }
711 std::unique_ptr<GetDispatchInfoCallbackInfo> callbackPtr {asyncCallbackInfo};
712 if (args.GetMaxArgc() >= ARGS_SIZE_ONE) {
713 napi_valuetype valueType = napi_undefined;
714 napi_typeof(env, args[ARGS_POS_ZERO], &valueType);
715 if (valueType == napi_function) {
716 NAPI_CALL(env, napi_create_reference(env, args[ARGS_POS_ZERO],
717 NAPI_RETURN_ONE, &asyncCallbackInfo->callback));
718 }
719 }
720 auto promise = CommonFunc::AsyncCallNativeMethod<GetDispatchInfoCallbackInfo>(
721 env, asyncCallbackInfo, RESOURCE_NAME_OF_GET_DISPATCH_INFO,
722 GetDispatchInfoExec, GetDispatchInfoComplete);
723 callbackPtr.release();
724 APP_LOGD("call GetDispatchInfo end");
725 return promise;
726 }
727 } // AppExecFwk
728 } // OHOS