• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023-2024 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 
16 #include "bundle_manager_addon.h"
17 
18 #include <unordered_map>
19 
20 #include "app_distribution_type.h"
21 #include "edm_constants.h"
22 #include "edm_log.h"
23 #include "napi_edm_adapter.h"
24 #include "napi_edm_common.h"
25 #include "os_account_manager.h"
26 #include "policy_type.h"
27 
28 using namespace OHOS::EDM;
29 
30 constexpr const char* VENDOR = "vendor";
31 constexpr const char* VERSION_CODE = "versionCode";
32 constexpr const char* VERSION_NAME = "versionName";
33 constexpr const char* MIN_COMPATIBLE_VERSION_CODE = "minCompatibleVersionCode";
34 constexpr const char* TARGET_VERSION = "targetVersion";
35 constexpr const char* APP_INFO = "appInfo";
36 constexpr const char* SIGNATURE_INFO = "signatureInfo";
37 constexpr const char* INSTALL_TIME = "installTime";
38 constexpr const char* FIRST_INSTALL_TIME = "firstInstallTime";
39 constexpr const char* UPDATE_TIME = "updateTime";
40 constexpr const char* APP_ID = "appId";
41 constexpr const char* FINGERPRINT = "fingerprint";
42 constexpr const char* APP_IDENTIFIER = "appIdentifier";
43 constexpr const char* CERTIFICATE = "certificate";
44 constexpr const char* PROCESS = "process";
45 constexpr const char* CODE_PATH = "codePath";
46 constexpr const char* REMOVABLE = "removable";
47 constexpr const char* ACCESS_TOKEN_ID = "accessTokenId";
48 constexpr const char* UID = "uid";
49 constexpr const char* ICON_RESOURCE = "iconResource";
50 constexpr const char* LABEL_RESOURCE = "labelResource";
51 constexpr const char* DESCRIPTION_RESOURCE = "descriptionResource";
52 constexpr const char* APP_DISTRIBUTION_TYPE = "appDistributionType";
53 constexpr const char* APP_PROVISION_TYPE = "appProvisionType";
54 constexpr const char* SYSTEM_APP = "systemApp";
55 constexpr const char* DATA_UNCLEARABLE = "dataUnclearable";
56 constexpr const char* NATIVE_LIBRARY_PATH = "nativeLibraryPath";
57 constexpr const char* INSTALL_SOURCE = "installSource";
58 constexpr const char* RELEASE_TYPE = "releaseType";
59 constexpr const char* ID = "id";
60 constexpr const char* BUNDLE_NAME = "bundleName";
61 constexpr const char* MODULE_NAME = "moduleName";
62 constexpr const char* NAME = "name";
63 constexpr const char* ENABLED = "enabled";
64 constexpr const char* LABEL = "label";
65 constexpr const char* LABEL_ID = "labelId";
66 constexpr const char* DESCRIPTION = "description";
67 constexpr const char* DESCRIPTION_ID = "descriptionId";
68 constexpr const char* ICON = "icon";
69 constexpr const char* ICON_ID = "iconId";
70 constexpr const char* DEBUG = "debug";
71 constexpr const char* APP_INDEX = "appIndex";
72 static const std::string CONTEXT_DATA_STORAGE_BUNDLE("/data/storage/el1/bundle/");
73 
74 static const std::unordered_map<std::string, int32_t> POLICY_TYPE_MAP = {
75     {"AddAllowedInstallBundles", static_cast<int32_t>(PolicyType::ALLOW_INSTALL)},
76     {"AddDisallowedInstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_INSTALL)},
77     {"AddDisallowedUninstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_UNINSTALL)},
78     {"RemoveAllowedInstallBundles", static_cast<int32_t>(PolicyType::ALLOW_INSTALL)},
79     {"RemoveDisallowedInstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_INSTALL)},
80     {"RemoveDisallowedUninstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_UNINSTALL)},
81     {"GetAllowedInstallBundles", static_cast<int32_t>(PolicyType::ALLOW_INSTALL)},
82     {"GetDisallowedInstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_INSTALL)},
83     {"GetDisallowedUninstallBundles", static_cast<int32_t>(PolicyType::DISALLOW_UNINSTALL)},
84 };
85 
Init(napi_env env,napi_value exports)86 napi_value BundleManagerAddon::Init(napi_env env, napi_value exports)
87 {
88     napi_value nAppDistributionType = nullptr;
89     NAPI_CALL(env, napi_create_object(env, &nAppDistributionType));
90     CreateAppDistributionTypeObject(env, nAppDistributionType);
91     napi_property_descriptor property[] = {
92         DECLARE_NAPI_FUNCTION("addAllowedInstallBundles", AddAllowedInstallBundles),
93         DECLARE_NAPI_FUNCTION("removeAllowedInstallBundles", RemoveAllowedInstallBundles),
94         DECLARE_NAPI_FUNCTION("getAllowedInstallBundles", GetAllowedInstallBundles),
95         DECLARE_NAPI_FUNCTION("addDisallowedInstallBundles", AddDisallowedInstallBundles),
96         DECLARE_NAPI_FUNCTION("removeDisallowedInstallBundles", RemoveDisallowedInstallBundles),
97         DECLARE_NAPI_FUNCTION("getDisallowedInstallBundles", GetDisallowedInstallBundles),
98         DECLARE_NAPI_FUNCTION("addDisallowedUninstallBundles", AddDisallowedUninstallBundles),
99         DECLARE_NAPI_FUNCTION("removeDisallowedUninstallBundles", RemoveDisallowedUninstallBundles),
100         DECLARE_NAPI_FUNCTION("getDisallowedUninstallBundles", GetDisallowedUninstallBundles),
101         DECLARE_NAPI_FUNCTION("uninstall", Uninstall),
102         DECLARE_NAPI_FUNCTION("install", Install),
103         DECLARE_NAPI_FUNCTION("addAllowedInstallBundlesSync", AddAllowedInstallBundlesSync),
104         DECLARE_NAPI_FUNCTION("removeAllowedInstallBundlesSync", RemoveAllowedInstallBundlesSync),
105         DECLARE_NAPI_FUNCTION("getAllowedInstallBundlesSync", GetAllowedInstallBundlesSync),
106         DECLARE_NAPI_FUNCTION("addDisallowedInstallBundlesSync", AddDisallowedInstallBundlesSync),
107         DECLARE_NAPI_FUNCTION("removeDisallowedInstallBundlesSync", RemoveDisallowedInstallBundlesSync),
108         DECLARE_NAPI_FUNCTION("getDisallowedInstallBundlesSync", GetDisallowedInstallBundlesSync),
109         DECLARE_NAPI_FUNCTION("addDisallowedUninstallBundlesSync", AddDisallowedUninstallBundlesSync),
110         DECLARE_NAPI_FUNCTION("removeDisallowedUninstallBundlesSync", RemoveDisallowedUninstallBundlesSync),
111         DECLARE_NAPI_FUNCTION("getDisallowedUninstallBundlesSync", GetDisallowedUninstallBundlesSync),
112         DECLARE_NAPI_FUNCTION("getInstalledBundleList", GetInstalledBundleList),
113         DECLARE_NAPI_FUNCTION("addInstallationAllowedAppDistributionTypes",
114             AddInstallationAllowedAppDistributionTypes),
115         DECLARE_NAPI_FUNCTION("removeInstallationAllowedAppDistributionTypes",
116             RemoveInstallationAllowedAppDistributionTypes),
117         DECLARE_NAPI_FUNCTION("getInstallationAllowedAppDistributionTypes",
118             GetInstallationAllowedAppDistributionTypes),
119         DECLARE_NAPI_PROPERTY("AppDistributionType", nAppDistributionType),
120     };
121     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
122     return exports;
123 }
124 
GetAllowedInstallBundles(napi_env env,napi_callback_info info)125 napi_value BundleManagerAddon::GetAllowedInstallBundles(napi_env env, napi_callback_info info)
126 {
127     EDMLOGI("NAPI_GetAllowedInstallBundles called");
128     return GetAllowedOrDisallowedInstallBundles(env, info, "GetAllowedInstallBundles", NativeGetBundlesByPolicyType);
129 }
130 
GetDisallowedInstallBundles(napi_env env,napi_callback_info info)131 napi_value BundleManagerAddon::GetDisallowedInstallBundles(napi_env env, napi_callback_info info)
132 {
133     EDMLOGI("NAPI_GetDisallowedInstallBundles called");
134     return GetAllowedOrDisallowedInstallBundles(env, info, "GetDisallowedInstallBundles", NativeGetBundlesByPolicyType);
135 }
136 
GetDisallowedUninstallBundles(napi_env env,napi_callback_info info)137 napi_value BundleManagerAddon::GetDisallowedUninstallBundles(napi_env env, napi_callback_info info)
138 {
139     EDMLOGI("NAPI_GetDisallowedUninstallBundles called");
140     return GetAllowedOrDisallowedInstallBundles(env, info, "GetDisallowedUninstallBundles",
141         NativeGetBundlesByPolicyType);
142 }
143 
Uninstall(napi_env env,napi_callback_info info)144 napi_value BundleManagerAddon::Uninstall(napi_env env, napi_callback_info info)
145 {
146     EDMLOGI("NAPI_Uninstall called");
147     size_t argc = ARGS_SIZE_FIVE;
148     napi_value argv[ARGS_SIZE_FIVE] = {nullptr};
149     napi_value thisArg = nullptr;
150     void *data = nullptr;
151     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
152 
153     auto asyncCallbackInfo = new (std::nothrow) AsyncUninstallCallbackInfo();
154     if (asyncCallbackInfo == nullptr) {
155         return nullptr;
156     }
157     std::unique_ptr<AsyncUninstallCallbackInfo> callbackPtr{asyncCallbackInfo};
158     if (!CheckAndParseUninstallParamType(env, argc, argv, asyncCallbackInfo)) {
159         if (asyncCallbackInfo->callback != nullptr) {
160             napi_delete_reference(env, asyncCallbackInfo->callback);
161         }
162         return nullptr;
163     }
164 
165     napi_value asyncWorkReturn =
166         HandleAsyncWork(env, asyncCallbackInfo, "NativeUninstall", NativeUninstall, NativeUninstallCallbackComplete);
167     callbackPtr.release();
168     return asyncWorkReturn;
169 }
170 
NativeUninstall(napi_env env,void * data)171 void BundleManagerAddon::NativeUninstall(napi_env env, void *data)
172 {
173     EDMLOGI("NAPI_NativeGetBundlesByPolicyType called");
174     if (data == nullptr) {
175         EDMLOGE("data is nullptr");
176         return;
177     }
178     AsyncUninstallCallbackInfo *asyncCallbackInfo = static_cast<AsyncUninstallCallbackInfo *>(data);
179     auto proxy = BundleManagerProxy::GetBundleManagerProxy();
180     if (proxy == nullptr) {
181         EDMLOGE("can not get BundleManagerProxy");
182         return;
183     }
184 
185     asyncCallbackInfo->ret = proxy->Uninstall(asyncCallbackInfo->elementName, asyncCallbackInfo->bundleName,
186         asyncCallbackInfo->userId, asyncCallbackInfo->isKeepData, asyncCallbackInfo->errMessage);
187 }
188 
Install(napi_env env,napi_callback_info info)189 napi_value BundleManagerAddon::Install(napi_env env, napi_callback_info info)
190 {
191 #ifdef BUNDLE_FRAMEWORK_EDM_ENABLE
192     EDMLOGI("NAPI_Install called");
193     size_t argc = ARGS_SIZE_FOUR;
194     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
195     napi_value thisArg = nullptr;
196     void *data = nullptr;
197     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
198 
199     auto asyncCallbackInfo = new (std::nothrow) AsyncInstallCallbackInfo();
200     if (asyncCallbackInfo == nullptr) {
201         return nullptr;
202     }
203     std::unique_ptr<AsyncInstallCallbackInfo> callbackPtr{asyncCallbackInfo};
204     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
205     if (!CheckAndParseInstallParamType(env, argc, argv, asyncCallbackInfo)) {
206         if (asyncCallbackInfo->callback != nullptr) {
207             NAPI_CALL(env, napi_delete_reference(env, asyncCallbackInfo->callback));
208         }
209         callbackPtr.release();
210         return nullptr;
211     }
212 
213     napi_value asyncWorkReturn =
214         HandleAsyncWork(env, asyncCallbackInfo, "NativeInstall", NativeInstall, NativeVoidCallbackComplete);
215     callbackPtr.release();
216     return asyncWorkReturn;
217 #else
218     EDMLOGW("BundleManagerAddon::Install Unsupported Capabilities.");
219     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
220     return nullptr;
221 #endif
222 }
223 
NativeInstall(napi_env env,void * data)224 void BundleManagerAddon::NativeInstall(napi_env env, void *data)
225 {
226 #ifdef BUNDLE_FRAMEWORK_EDM_ENABLE
227     EDMLOGI("NAPI_NativeInstall called");
228     if (data == nullptr) {
229         EDMLOGE("data is nullptr");
230         return;
231     }
232     AsyncInstallCallbackInfo *asyncCallbackInfo = static_cast<AsyncInstallCallbackInfo *>(data);
233     auto proxy = BundleManagerProxy::GetBundleManagerProxy();
234     if (proxy == nullptr) {
235         EDMLOGE("can not get BundleManagerProxy");
236         return;
237     }
238 
239     asyncCallbackInfo->ret = proxy->Install(asyncCallbackInfo->elementName, asyncCallbackInfo->hapFilePaths,
240         asyncCallbackInfo->installParam, asyncCallbackInfo->innerCodeMsg);
241     EDMLOGI("NAPI_NativeInstall asyncCallbackInfo->ret : %{public}d", asyncCallbackInfo->ret);
242 #endif
243 }
244 
NativeUninstallCallbackComplete(napi_env env,napi_status status,void * data)245 void BundleManagerAddon::NativeUninstallCallbackComplete(napi_env env, napi_status status, void *data)
246 {
247     if (data == nullptr) {
248         EDMLOGE("data is nullptr");
249         return;
250     }
251     AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
252     napi_value error = nullptr;
253     if (asyncCallbackInfo->callback == nullptr) {
254         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
255         if (asyncCallbackInfo->ret == ERR_OK) {
256             napi_get_null(env, &error);
257             napi_resolve_deferred(env, asyncCallbackInfo->deferred, error);
258         } else {
259             if (asyncCallbackInfo->ret == EdmReturnErrCode::PARAM_ERROR) {
260                 napi_reject_deferred(env, asyncCallbackInfo->deferred,
261                     CreateError(env, asyncCallbackInfo->ret, asyncCallbackInfo->errMessage));
262             } else {
263                 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
264             }
265         }
266     } else {
267         if (asyncCallbackInfo->ret == ERR_OK) {
268             napi_get_null(env, &error);
269         } else {
270             if (asyncCallbackInfo->ret == EdmReturnErrCode::PARAM_ERROR) {
271                 error = CreateError(env, asyncCallbackInfo->ret, asyncCallbackInfo->errMessage);
272             } else {
273                 error = CreateError(env, asyncCallbackInfo->ret);
274             }
275         }
276         napi_value callback = nullptr;
277         napi_value result = nullptr;
278         napi_get_reference_value(env, asyncCallbackInfo->callback, &callback);
279         napi_call_function(env, nullptr, callback, ARGS_SIZE_ONE, &error, &result);
280         napi_delete_reference(env, asyncCallbackInfo->callback);
281     }
282     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
283     delete asyncCallbackInfo;
284 }
285 
CheckAndParseUninstallParamType(napi_env env,size_t argc,napi_value * argv,AsyncUninstallCallbackInfo * asyncCallbackInfo)286 bool BundleManagerAddon::CheckAndParseUninstallParamType(napi_env env, size_t argc, napi_value *argv,
287     AsyncUninstallCallbackInfo *asyncCallbackInfo)
288 {
289     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
290     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
291         "Parameter want error");
292     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->bundleName, argv[ARR_INDEX_ONE]),
293         "Parameter bundle name error");
294     AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
295     if (argc == ARGS_SIZE_TWO) {
296         return true;
297     }
298     bool hasCallback = argc <= ARGS_SIZE_FIVE ? MatchValueType(env, argv[argc - 1], napi_function) :
299                                                 MatchValueType(env, argv[ARR_INDEX_FOUR], napi_function);
300     if (hasCallback) {
301         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback,
302             argc <= ARGS_SIZE_FIVE ? argv[argc - 1] : argv[ARR_INDEX_FOUR]), "Parameter callback error");
303         switch (argc) {
304             case ARGS_SIZE_THREE:
305                 break;
306             case ARGS_SIZE_FOUR:
307                 if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_number)) {
308                     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
309                         "Parameter userId error");
310                 } else if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean)) {
311                     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, asyncCallbackInfo->isKeepData,
312                         argv[ARR_INDEX_TWO]), "Parameter isKeepData error");
313                 } else {
314                     ASSERT_AND_THROW_PARAM_ERROR(env, false, "Parameter three type error");
315                 }
316                 break;
317             default:
318                 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
319                     "Parameter userId error");
320                 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, asyncCallbackInfo->isKeepData, argv[ARR_INDEX_THREE]),
321                     "Parameter isKeepData error");
322         }
323         return true;
324     }
325     if (argc == ARGS_SIZE_THREE) {
326         if (!ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO])) {
327             AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
328             ParseBool(env, asyncCallbackInfo->isKeepData, argv[ARR_INDEX_TWO]);
329         }
330         return true;
331     }
332     if (!ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO])) {
333         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
334     }
335     ParseBool(env, asyncCallbackInfo->isKeepData, argv[ARR_INDEX_THREE]);
336     return true;
337 }
338 
339 #ifdef BUNDLE_FRAMEWORK_EDM_ENABLE
ParseParameters(napi_env env,napi_value object,std::map<std::string,std::string> & parameters)340 bool BundleManagerAddon::ParseParameters(napi_env env, napi_value object,
341     std::map<std::string, std::string> &parameters)
342 {
343     bool hasProperty = false;
344     bool isNecessaryProp = false;
345     if (napi_has_named_property(env, object, "parameters", &hasProperty) != napi_ok) {
346         EDMLOGE("get js property failed");
347         return false;
348     }
349     if (isNecessaryProp && !hasProperty) {
350         return false;
351     }
352     napi_value prop = nullptr;
353     if (hasProperty) {
354         return napi_get_named_property(env, object, "parameters", &prop) == napi_ok &&
355             ParseMapStringAndString(env, parameters, prop);
356     }
357     return true;
358 }
359 
jsObjectToInstallParam(napi_env env,napi_value object,OHOS::AppExecFwk::InstallParam & installParam)360 bool BundleManagerAddon::jsObjectToInstallParam(napi_env env, napi_value object,
361     OHOS::AppExecFwk::InstallParam &installParam)
362 {
363     int32_t installFlag = 0;
364     if (!JsObjectToInt(env, object, "userId", false, installParam.userId) ||
365         !JsObjectToInt(env, object, "installFlag", false, installFlag)) {
366         return false;
367     }
368     bool hasProperty = false;
369     if (napi_has_named_property(env, object, "userId", &hasProperty) == napi_ok && !hasProperty) {
370         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(installParam.userId);
371     }
372     if ((installFlag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::NORMAL)) &&
373         (installFlag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::REPLACE_EXISTING)) &&
374         (installFlag != static_cast<int32_t>(OHOS::AppExecFwk::InstallFlag::FREE_INSTALL))) {
375         EDMLOGE("invalid installFlag param");
376         return false;
377     }
378     installParam.installFlag = static_cast<OHOS::AppExecFwk::InstallFlag>(installFlag);
379     if (!ParseParameters(env, object, installParam.parameters)) {
380         EDMLOGE("parse parameters fail");
381         return false;
382     }
383     return true;
384 }
385 
CheckAndParseInstallParamType(napi_env env,size_t argc,napi_value * argv,AsyncInstallCallbackInfo * asyncCallbackInfo)386 bool BundleManagerAddon::CheckAndParseInstallParamType(napi_env env, size_t argc, napi_value *argv,
387     AsyncInstallCallbackInfo *asyncCallbackInfo)
388 {
389     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
390         "Parameter want error");
391     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->hapFilePaths, argv[ARR_INDEX_ONE]),
392         "Parameter bundleFilePaths error");
393     if (argc == ARGS_SIZE_TWO) {
394         return true;
395     }
396     bool hasCallback = argc <= ARGS_SIZE_FOUR ? MatchValueType(env, argv[argc - 1], napi_function) :
397                                                 MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
398     if (hasCallback) {
399         ASSERT_AND_THROW_PARAM_ERROR(env,
400             ParseCallback(env, asyncCallbackInfo->callback,
401                 argc <= ARGS_SIZE_FOUR ? argv[argc - 1] : argv[ARGS_SIZE_THREE]),
402             "Parameter callback error");
403         EDMLOGI("CheckAndParseInstallParamType ParseCallback success");
404         if (argc == ARGS_SIZE_FOUR) {
405             ASSERT_AND_THROW_PARAM_ERROR(env,
406                 jsObjectToInstallParam(env, argv[ARR_INDEX_TWO], asyncCallbackInfo->installParam),
407                 "installParam param error");
408         }
409         return true;
410     }
411     ASSERT_AND_THROW_PARAM_ERROR(env, jsObjectToInstallParam(env, argv[ARR_INDEX_TWO], asyncCallbackInfo->installParam),
412         "installParam param error");
413     return true;
414 }
415 #endif
416 
GetAllowedOrDisallowedInstallBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)417 napi_value BundleManagerAddon::GetAllowedOrDisallowedInstallBundles(napi_env env, napi_callback_info info,
418     const std::string &workName, napi_async_execute_callback execute)
419 {
420     size_t argc = ARGS_SIZE_THREE;
421     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
422     napi_value thisArg = nullptr;
423     void *data = nullptr;
424     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
425     bool hasCallback = false;
426     bool hasUserId = false;
427     auto asyncCallbackInfo = new (std::nothrow) AsyncBundlesCallbackInfo();
428     if (asyncCallbackInfo == nullptr) {
429         return nullptr;
430     }
431     std::unique_ptr<AsyncBundlesCallbackInfo> callbackPtr{asyncCallbackInfo};
432     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "Parameter count error");
433     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAdminWithUserIdParamType(env, argc, argv, hasCallback, hasUserId),
434         "Parameter type error");
435     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
436         "Parameter want error");
437 
438     EDMLOGD("GetInstallBundles bundlename %{public}s, abilityname:%{public}s",
439         asyncCallbackInfo->elementName.GetBundleName().c_str(),
440         asyncCallbackInfo->elementName.GetAbilityName().c_str());
441     if (hasUserId) {
442         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
443             "Parameter user id error");
444     } else {
445         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
446     }
447     if (hasCallback) {
448         ASSERT_AND_THROW_PARAM_ERROR(env,
449             ParseCallback(env, asyncCallbackInfo->callback,
450                 argc <= ARR_INDEX_THREE ? argv[argc - 1] : argv[ARR_INDEX_TWO]),
451             "Parameter callback error");
452     }
453     InitCallbackInfoPolicyType(workName, asyncCallbackInfo);
454     EDMLOGI("GetInstallBundles::%{public}s policyType = %{public}d", workName.c_str(), asyncCallbackInfo->policyType);
455     napi_value asyncWorkReturn =
456         HandleAsyncWork(env, asyncCallbackInfo, workName, execute, NativeArrayStringCallbackComplete);
457     callbackPtr.release();
458     return asyncWorkReturn;
459 }
460 
InitCallbackInfoPolicyType(const std::string & workName,AsyncBundlesCallbackInfo * callbackInfo)461 void BundleManagerAddon::InitCallbackInfoPolicyType(const std::string &workName, AsyncBundlesCallbackInfo *callbackInfo)
462 {
463     auto iter = POLICY_TYPE_MAP.find(workName);
464     if (iter != POLICY_TYPE_MAP.end()) {
465         callbackInfo->policyType = iter->second;
466     } else {
467         EDMLOGI("policy type map get error");
468         callbackInfo->policyType = static_cast<int32_t>(PolicyType::INVALID_TYPE);
469     }
470 }
471 
NativeGetBundlesByPolicyType(napi_env env,void * data)472 void BundleManagerAddon::NativeGetBundlesByPolicyType(napi_env env, void *data)
473 {
474     EDMLOGI("NAPI_NativeGetBundlesByPolicyType called");
475     if (data == nullptr) {
476         EDMLOGE("data is nullptr");
477         return;
478     }
479     AsyncBundlesCallbackInfo *asyncCallbackInfo = static_cast<AsyncBundlesCallbackInfo *>(data);
480     auto proxy = BundleManagerProxy::GetBundleManagerProxy();
481     if (proxy == nullptr) {
482         EDMLOGE("can not get BundleManagerProxy");
483         return;
484     }
485 
486     asyncCallbackInfo->ret = proxy->GetBundlesByPolicyType(asyncCallbackInfo->elementName, asyncCallbackInfo->userId,
487         asyncCallbackInfo->arrayStringRet, asyncCallbackInfo->policyType);
488 }
489 
AddAllowedInstallBundles(napi_env env,napi_callback_info info)490 napi_value BundleManagerAddon::AddAllowedInstallBundles(napi_env env, napi_callback_info info)
491 {
492     return AddOrRemoveInstallBundles(env, info, "AddAllowedInstallBundles", NativeAddBundlesByPolicyType);
493 }
494 
AddDisallowedInstallBundles(napi_env env,napi_callback_info info)495 napi_value BundleManagerAddon::AddDisallowedInstallBundles(napi_env env, napi_callback_info info)
496 {
497     return AddOrRemoveInstallBundles(env, info, "AddDisallowedInstallBundles", NativeAddBundlesByPolicyType);
498 }
499 
AddDisallowedUninstallBundles(napi_env env,napi_callback_info info)500 napi_value BundleManagerAddon::AddDisallowedUninstallBundles(napi_env env, napi_callback_info info)
501 {
502     return AddOrRemoveInstallBundles(env, info, "AddDisallowedUninstallBundles", NativeAddBundlesByPolicyType);
503 }
504 
RemoveAllowedInstallBundles(napi_env env,napi_callback_info info)505 napi_value BundleManagerAddon::RemoveAllowedInstallBundles(napi_env env, napi_callback_info info)
506 {
507     return AddOrRemoveInstallBundles(env, info, "RemoveAllowedInstallBundles", NativeRemoveBundlesByPolicyType);
508 }
509 
RemoveDisallowedInstallBundles(napi_env env,napi_callback_info info)510 napi_value BundleManagerAddon::RemoveDisallowedInstallBundles(napi_env env, napi_callback_info info)
511 {
512     return AddOrRemoveInstallBundles(env, info, "RemoveDisallowedInstallBundles", NativeRemoveBundlesByPolicyType);
513 }
514 
RemoveDisallowedUninstallBundles(napi_env env,napi_callback_info info)515 napi_value BundleManagerAddon::RemoveDisallowedUninstallBundles(napi_env env, napi_callback_info info)
516 {
517     return AddOrRemoveInstallBundles(env, info, "RemoveDisallowedUninstallBundles", NativeRemoveBundlesByPolicyType);
518 }
519 
CheckAddInstallBundlesParamType(napi_env env,size_t argc,napi_value * argv,bool & hasCallback,bool & hasUserId)520 bool BundleManagerAddon::CheckAddInstallBundlesParamType(napi_env env, size_t argc, napi_value *argv, bool &hasCallback,
521     bool &hasUserId)
522 {
523     if (!MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) ||
524         !MatchValueType(env, argv[ARR_INDEX_ONE], napi_object)) {
525         EDMLOGE("CheckAddInstallBundlesParamType admin or array type check failed");
526         return false;
527     }
528     EDMLOGI("CheckAddInstallBundlesParamType argc = %{public}zu", argc);
529     if (argc == ARGS_SIZE_TWO) {
530         hasCallback = false;
531         hasUserId = false;
532         EDMLOGI("hasCallback = false; hasUserId = false;");
533         return true;
534     }
535 
536     if (argc == ARGS_SIZE_THREE) {
537         if (MatchValueType(env, argv[ARR_INDEX_TWO], napi_function)) {
538             hasCallback = true;
539             hasUserId = false;
540             EDMLOGI("hasCallback = true; hasUserId = false;");
541             return true;
542         } else {
543             hasCallback = false;
544             hasUserId = true;
545             EDMLOGI("hasCallback = false;  hasUserId = true;");
546             return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number);
547         }
548     }
549     hasCallback = true;
550     hasUserId = true;
551     EDMLOGI("hasCallback = true; hasUserId = true;");
552     return MatchValueType(env, argv[ARR_INDEX_TWO], napi_number) &&
553         MatchValueType(env, argv[ARR_INDEX_THREE], napi_function);
554 }
555 
AddOrRemoveInstallBundles(napi_env env,napi_callback_info info,const std::string & workName,napi_async_execute_callback execute)556 napi_value BundleManagerAddon::AddOrRemoveInstallBundles(napi_env env, napi_callback_info info,
557     const std::string &workName, napi_async_execute_callback execute)
558 {
559     size_t argc = ARGS_SIZE_FOUR;
560     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
561     napi_value thisArg = nullptr;
562     void *data = nullptr;
563     bool hasCallback = false;
564     bool hasUserId = false;
565     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
566     auto asyncCallbackInfo = new (std::nothrow) AsyncBundlesCallbackInfo();
567     if (asyncCallbackInfo == nullptr) {
568         return nullptr;
569     }
570     std::unique_ptr<AsyncBundlesCallbackInfo> callbackPtr{asyncCallbackInfo};
571     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
572     ASSERT_AND_THROW_PARAM_ERROR(env, CheckAddInstallBundlesParamType(env, argc, argv, hasCallback, hasUserId),
573         "Parameter type error");
574     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
575         "Parameter want error");
576     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, asyncCallbackInfo->bundles, argv[ARR_INDEX_ONE]),
577         "Parameter bundles error");
578     ASSERT_AND_THROW_PARAM_ERROR(env, asyncCallbackInfo->bundles.size() <= EdmConstants::APPID_MAX_SIZE,
579         "Parameter bundles too large");
580     EDMLOGD("EnableAdmin::asyncCallbackInfo->elementName.bundlename %{public}s, "
581         "asyncCallbackInfo->abilityname:%{public}s", asyncCallbackInfo->elementName.GetBundleName().c_str(),
582         asyncCallbackInfo->elementName.GetAbilityName().c_str());
583     if (hasUserId) {
584         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_TWO]),
585             "Parameter user id error");
586     } else {
587         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(asyncCallbackInfo->userId);
588     }
589     if (hasCallback) {
590         ASSERT_AND_THROW_PARAM_ERROR(env, ParseCallback(env, asyncCallbackInfo->callback,
591             argc <= ARGS_SIZE_FOUR ? argv[argc - 1] : argv[ARR_INDEX_THREE]), "Parameter callback error");
592     }
593     InitCallbackInfoPolicyType(workName, asyncCallbackInfo);
594     EDMLOGI("AddOrRemoveInstallBundles::%{public}s policyType = %{public}d", workName.c_str(),
595         asyncCallbackInfo->policyType);
596     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, workName, execute, NativeVoidCallbackComplete);
597     callbackPtr.release();
598     return asyncWorkReturn;
599 }
600 
NativeRemoveBundlesByPolicyType(napi_env env,void * data)601 void BundleManagerAddon::NativeRemoveBundlesByPolicyType(napi_env env, void *data)
602 {
603     EDMLOGI("NativeRemoveBundlesByPolicyType called");
604     if (data == nullptr) {
605         EDMLOGE("data is nullptr");
606         return;
607     }
608     AsyncBundlesCallbackInfo *asyncCallbackInfo = static_cast<AsyncBundlesCallbackInfo *>(data);
609     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
610     if (bundleManagerProxy == nullptr) {
611         EDMLOGE("can not get BundleManagerProxy");
612         return;
613     }
614     asyncCallbackInfo->ret = bundleManagerProxy->RemoveBundlesByPolicyType(asyncCallbackInfo->elementName,
615         asyncCallbackInfo->bundles, asyncCallbackInfo->userId, asyncCallbackInfo->policyType);
616 }
617 
NativeAddBundlesByPolicyType(napi_env env,void * data)618 void BundleManagerAddon::NativeAddBundlesByPolicyType(napi_env env, void *data)
619 {
620     EDMLOGI("NAPI_NativeAddBundlesByPolicyType called");
621     if (data == nullptr) {
622         EDMLOGE("data is nullptr");
623         return;
624     }
625     AsyncBundlesCallbackInfo *asyncCallbackInfo = static_cast<AsyncBundlesCallbackInfo *>(data);
626     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
627     if (bundleManagerProxy == nullptr) {
628         EDMLOGE("can not get BundleManagerProxy");
629         return;
630     }
631     asyncCallbackInfo->ret = bundleManagerProxy->AddBundlesByPolicyType(asyncCallbackInfo->elementName,
632         asyncCallbackInfo->bundles, asyncCallbackInfo->userId, asyncCallbackInfo->policyType);
633 }
634 
AddAllowedInstallBundlesSync(napi_env env,napi_callback_info info)635 napi_value BundleManagerAddon::AddAllowedInstallBundlesSync(napi_env env, napi_callback_info info)
636 {
637     EDMLOGI("NAPI_AddAllowedInstallBundlesSync called");
638     return AddOrRemoveInstallBundlesSync(env, info, "AddAllowedInstallBundles", true);
639 }
640 
AddDisallowedInstallBundlesSync(napi_env env,napi_callback_info info)641 napi_value BundleManagerAddon::AddDisallowedInstallBundlesSync(napi_env env, napi_callback_info info)
642 {
643     EDMLOGI("NAPI_AddDisallowedInstallBundlesSync called");
644     return AddOrRemoveInstallBundlesSync(env, info, "AddDisallowedInstallBundles", true);
645 }
646 
AddDisallowedUninstallBundlesSync(napi_env env,napi_callback_info info)647 napi_value BundleManagerAddon::AddDisallowedUninstallBundlesSync(napi_env env, napi_callback_info info)
648 {
649     EDMLOGI("NAPI_AddDisallowedUninstallBundlesSync called");
650     return AddOrRemoveInstallBundlesSync(env, info, "AddDisallowedUninstallBundles", true);
651 }
652 
RemoveAllowedInstallBundlesSync(napi_env env,napi_callback_info info)653 napi_value BundleManagerAddon::RemoveAllowedInstallBundlesSync(napi_env env, napi_callback_info info)
654 {
655     EDMLOGI("NAPI_RemoveAllowedInstallBundlesSync called");
656     return AddOrRemoveInstallBundlesSync(env, info, "RemoveAllowedInstallBundles", false);
657 }
658 
RemoveDisallowedInstallBundlesSync(napi_env env,napi_callback_info info)659 napi_value BundleManagerAddon::RemoveDisallowedInstallBundlesSync(napi_env env, napi_callback_info info)
660 {
661     EDMLOGI("NAPI_RemoveDisallowedInstallBundlesSync called");
662     return AddOrRemoveInstallBundlesSync(env, info, "RemoveDisallowedInstallBundles", false);
663 }
664 
RemoveDisallowedUninstallBundlesSync(napi_env env,napi_callback_info info)665 napi_value BundleManagerAddon::RemoveDisallowedUninstallBundlesSync(napi_env env, napi_callback_info info)
666 {
667     EDMLOGI("NAPI_RemoveDisallowedUninstallBundlesSync called");
668     return AddOrRemoveInstallBundlesSync(env, info, "RemoveDisallowedUninstallBundles", false);
669 }
670 
AddOrRemoveInstallBundlesSync(napi_env env,napi_callback_info info,const std::string & workName,bool isAdd)671 napi_value BundleManagerAddon::AddOrRemoveInstallBundlesSync(napi_env env, napi_callback_info info,
672     const std::string &workName, bool isAdd)
673 {
674     size_t argc = ARGS_SIZE_THREE;
675     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
676     napi_value thisArg = nullptr;
677     void *data = nullptr;
678     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
679 
680     bool hasAccountId = (argc == ARGS_SIZE_THREE);
681     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
682     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
683     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_object), "parameter appIds error");
684     OHOS::AppExecFwk::ElementName elementName;
685     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
686         "parameter admin parse error");
687     std::vector<std::string> appIds;
688     ASSERT_AND_THROW_PARAM_ERROR(env, ParseStringArray(env, appIds, argv[ARR_INDEX_ONE]),
689         "parameter appIds parse error");
690     ASSERT_AND_THROW_PARAM_ERROR(env, appIds.size() <= EdmConstants::APPID_MAX_SIZE,
691         "parameter appIds too large");
692     EDMLOGD("CheckAddOrRemoveInstallBundlesParam: "
693         "elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
694         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
695     int32_t accountId = 0;
696     if (hasAccountId) {
697         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
698             "parameter accountId error");
699         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
700             "parameter accountId parse error");
701     } else {
702         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
703     }
704     int32_t policyType = 0;
705     InitPolicyType(workName, policyType);
706     EDMLOGI("AddOrRemoveInstallBundlesSync::%{public}s policyType = %{public}d", workName.c_str(), policyType);
707 
708     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
709     if (bundleManagerProxy == nullptr) {
710         EDMLOGE("can not get BundleManagerProxy");
711         return nullptr;
712     }
713     int32_t ret = ERR_OK;
714     if (isAdd) {
715         ret = bundleManagerProxy->AddBundlesByPolicyType(elementName, appIds, accountId, policyType);
716     } else {
717         ret = bundleManagerProxy->RemoveBundlesByPolicyType(elementName, appIds, accountId, policyType);
718     }
719     if (FAILED(ret)) {
720         napi_throw(env, CreateError(env, ret));
721     }
722     return nullptr;
723 }
724 
InitPolicyType(const std::string & workName,int32_t & policyType)725 void BundleManagerAddon::InitPolicyType(const std::string &workName, int32_t &policyType)
726 {
727     auto iter = POLICY_TYPE_MAP.find(workName);
728     if (iter != POLICY_TYPE_MAP.end()) {
729         policyType = iter->second;
730     } else {
731         EDMLOGI("policy type map get error");
732         policyType = static_cast<int32_t>(PolicyType::INVALID_TYPE);
733     }
734 }
735 
CreateAppDistributionTypeObject(napi_env env,napi_value value)736 void BundleManagerAddon::CreateAppDistributionTypeObject(napi_env env, napi_value value)
737 {
738     napi_value nAppGallery;
739     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
740         static_cast<int32_t>(AppDistributionType::APP_GALLERY), &nAppGallery));
741     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "APP_GALLERY", nAppGallery));
742     napi_value nEnterprise;
743     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
744         static_cast<int32_t>(AppDistributionType::ENTERPRISE), &nEnterprise));
745     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ENTERPRISE", nEnterprise));
746     napi_value nEnterpriseNormal;
747     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
748         static_cast<int32_t>(AppDistributionType::ENTERPRISE_NORMAL), &nEnterpriseNormal));
749     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ENTERPRISE_NORMAL", nEnterpriseNormal));
750     napi_value nEnterpriseMdm;
751     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
752         static_cast<int32_t>(AppDistributionType::ENTERPRISE_MDM), &nEnterpriseMdm));
753     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "ENTERPRISE_MDM", nEnterpriseMdm));
754     napi_value nInternalTesting;
755     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
756         static_cast<int32_t>(AppDistributionType::INTERNALTESTING), &nInternalTesting));
757     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "INTERNALTESTING", nInternalTesting));
758     napi_value nCrowdTesting;
759     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
760         static_cast<int32_t>(AppDistributionType::CROWDTESTING), &nCrowdTesting));
761     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "CROWDTESTING", nCrowdTesting));
762 }
763 
AddInstallationAllowedAppDistributionTypes(napi_env env,napi_callback_info info)764 napi_value BundleManagerAddon::AddInstallationAllowedAppDistributionTypes(napi_env env, napi_callback_info info)
765 {
766     EDMLOGI("NAPI_AddInstallationAllowedAppDistributionTypes called");
767     return AddOrRemoveInstallationAllowedAppDistributionTypes(env, info, FuncOperateType::SET);
768 }
769 
RemoveInstallationAllowedAppDistributionTypes(napi_env env,napi_callback_info info)770 napi_value BundleManagerAddon::RemoveInstallationAllowedAppDistributionTypes(napi_env env, napi_callback_info info)
771 {
772     EDMLOGI("NAPI_RemoveAllowedInstallAppDistributionTypes called");
773     return AddOrRemoveInstallationAllowedAppDistributionTypes(env, info, FuncOperateType::REMOVE);
774 }
775 
AddOrRemoveInstallationAllowedAppDistributionTypes(napi_env env,napi_callback_info info,FuncOperateType operateType)776 napi_value BundleManagerAddon::AddOrRemoveInstallationAllowedAppDistributionTypes(napi_env env,
777     napi_callback_info info, FuncOperateType operateType)
778 {
779     AddonMethodSign addonMethodSign;
780     addonMethodSign.name = "AddOrRemoveInstallationAllowedAppDistributionTypes";
781     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::ARRAY_INT32};
782     addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
783     AdapterAddonData adapterAddonData{};
784     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
785         return nullptr;
786     }
787     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
788     if (bundleManagerProxy == nullptr) {
789         EDMLOGE("can not get BundleManagerProxy");
790         return nullptr;
791     }
792     int32_t retCode = bundleManagerProxy->AddOrRemoveInstallationAllowedAppDistributionTypes(adapterAddonData.data,
793         operateType);
794     if (FAILED(retCode)) {
795         napi_throw(env, CreateError(env, retCode));
796     }
797     return nullptr;
798 }
799 
GetInstallationAllowedAppDistributionTypes(napi_env env,napi_callback_info info)800 napi_value BundleManagerAddon::GetInstallationAllowedAppDistributionTypes(napi_env env, napi_callback_info info)
801 {
802     AddonMethodSign addonMethodSign;
803     addonMethodSign.name = "GetInstallationAllowedAppDistributionTypes";
804     addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT};
805     addonMethodSign.methodAttribute = MethodAttribute::GET;
806     AdapterAddonData adapterAddonData{};
807     if (JsObjectToData(env, info, addonMethodSign, &adapterAddonData) == nullptr) {
808         return nullptr;
809     }
810     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
811     if (bundleManagerProxy == nullptr) {
812         EDMLOGE("can not get BundleManagerProxy");
813         return nullptr;
814     }
815     std::vector<int32_t> installationAllowedAppDistributionTypes;
816     int32_t retCode = bundleManagerProxy->GetInstallationAllowedAppDistributionTypes(adapterAddonData.data,
817         installationAllowedAppDistributionTypes);
818     if (FAILED(retCode)) {
819         napi_throw(env, CreateError(env, retCode));
820         return nullptr;
821     }
822     napi_value result = nullptr;
823     NAPI_CALL(env, napi_create_array(env, &result));
824     for (size_t i = 0; i < installationAllowedAppDistributionTypes.size(); i++) {
825         napi_value allowedType = nullptr;
826         NAPI_CALL(env, napi_create_int32(env, installationAllowedAppDistributionTypes[i], &allowedType));
827         NAPI_CALL(env, napi_set_element(env, result, i, allowedType));
828     }
829     return result;
830 }
831 
GetAllowedInstallBundlesSync(napi_env env,napi_callback_info info)832 napi_value BundleManagerAddon::GetAllowedInstallBundlesSync(napi_env env, napi_callback_info info)
833 {
834     EDMLOGI("NAPI_GetAllowedInstallBundles called");
835     return GetAllowedOrDisallowedInstallBundlesSync(env, info, "GetAllowedInstallBundles");
836 }
837 
GetDisallowedInstallBundlesSync(napi_env env,napi_callback_info info)838 napi_value BundleManagerAddon::GetDisallowedInstallBundlesSync(napi_env env, napi_callback_info info)
839 {
840     EDMLOGI("NAPI_GetDisallowedInstallBundles called");
841     return GetAllowedOrDisallowedInstallBundlesSync(env, info, "GetDisallowedInstallBundles");
842 }
843 
GetDisallowedUninstallBundlesSync(napi_env env,napi_callback_info info)844 napi_value BundleManagerAddon::GetDisallowedUninstallBundlesSync(napi_env env, napi_callback_info info)
845 {
846     EDMLOGI("NAPI_GetDisallowedUninstallBundles called");
847     return GetAllowedOrDisallowedInstallBundlesSync(env, info, "GetDisallowedUninstallBundles");
848 }
849 
GetAllowedOrDisallowedInstallBundlesSync(napi_env env,napi_callback_info info,const std::string & workName)850 napi_value BundleManagerAddon::GetAllowedOrDisallowedInstallBundlesSync(napi_env env, napi_callback_info info,
851     const std::string &workName)
852 {
853     EDMLOGI("NAPI_GetAllowedOrDisallowedInstallBundlesSync called");
854     size_t argc = ARGS_SIZE_TWO;
855     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
856     napi_value thisArg = nullptr;
857     void *data = nullptr;
858     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
859     bool hasAccountId = (argc == ARGS_SIZE_TWO);
860     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
861     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
862     OHOS::AppExecFwk::ElementName elementName;
863     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
864         "parameter admin parse error");
865     EDMLOGD("GetAllowedOrDisallowedInstallBundlesSync: "
866         "elementName.bundleName %{public}s, elementName.abilityName:%{public}s",
867         elementName.GetBundleName().c_str(), elementName.GetAbilityName().c_str());
868     int32_t accountId = 0;
869     if (hasAccountId) {
870         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
871             "parameter accountId error");
872         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
873             "parameter accountId parse error");
874     } else {
875         AccountSA::OsAccountManager::GetOsAccountLocalIdFromProcess(accountId);
876     }
877     int32_t policyType = 0;
878     InitPolicyType(workName, policyType);
879     EDMLOGI("GetAllowedOrDisallowedInstallBundlesSync::%{public}s "
880         "policyType = %{public}d", workName.c_str(), policyType);
881 
882     auto bundleManagerProxy = BundleManagerProxy::GetBundleManagerProxy();
883     if (bundleManagerProxy == nullptr) {
884         EDMLOGE("can not get BundleManagerProxy");
885         return nullptr;
886     }
887     std::vector<std::string> appIds;
888     int32_t ret = bundleManagerProxy->GetBundlesByPolicyType(elementName, accountId, appIds, policyType);
889     if (FAILED(ret)) {
890         napi_throw(env, CreateError(env, ret));
891         return nullptr;
892     }
893     napi_value result = nullptr;
894     NAPI_CALL(env, napi_create_array(env, &result));
895     ConvertStringVectorToJS(env, appIds, result);
896     return result;
897 }
898 
GetInstalledBundleList(napi_env env,napi_callback_info info)899 napi_value BundleManagerAddon::GetInstalledBundleList(napi_env env, napi_callback_info info)
900 {
901     EDMLOGI("GetInstalledBundleList called");
902     size_t argc = ARGS_SIZE_TWO;
903     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
904     napi_value thisArg = nullptr;
905     void *data = nullptr;
906     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
907     auto asyncCallbackInfo = new (std::nothrow) AsyncBundleInfoCallbackInfo();
908     if (asyncCallbackInfo == nullptr) {
909         return nullptr;
910     }
911     std::unique_ptr<AsyncBundleInfoCallbackInfo> callbackPtr{asyncCallbackInfo};
912     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
913     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
914     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
915         "parameter admin parse error");
916     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
917         "parameter accountId error");
918     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, asyncCallbackInfo->userId, argv[ARR_INDEX_ONE]),
919         "parameter accountId parse error");
920 
921     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "NativeGetInstalledBundleList",
922         NativeGetInstalledBundleList, NativeGetInstalledBundleListComplete);
923     callbackPtr.release();
924     return asyncWorkReturn;
925 }
926 
NativeGetInstalledBundleList(napi_env env,void * data)927 void BundleManagerAddon::NativeGetInstalledBundleList(napi_env env, void *data)
928 {
929     EDMLOGI("NAPI_NativeGetBundlesByPolicyType called");
930     if (data == nullptr) {
931         EDMLOGE("data is nullptr");
932         return;
933     }
934     AsyncBundleInfoCallbackInfo *asyncCallbackInfo = static_cast<AsyncBundleInfoCallbackInfo *>(data);
935     auto proxy = BundleManagerProxy::GetBundleManagerProxy();
936     if (proxy == nullptr) {
937         EDMLOGE("can not get BundleManagerProxy");
938         return;
939     }
940     asyncCallbackInfo->ret = proxy->GetInstalledBundleInfoList(asyncCallbackInfo->elementName,
941         asyncCallbackInfo->userId, asyncCallbackInfo->bundleInfos);
942 }
943 
NativeGetInstalledBundleListComplete(napi_env env,napi_status status,void * data)944 void BundleManagerAddon::NativeGetInstalledBundleListComplete(napi_env env, napi_status status, void *data)
945 {
946     if (data == nullptr) {
947         EDMLOGE("data is nullptr");
948         return;
949     }
950     EDMLOGI("NativeGetInstalledBundleListComplete start");
951     auto *asyncCallbackInfo = static_cast<AsyncBundleInfoCallbackInfo *>(data);
952     if (asyncCallbackInfo->deferred != nullptr) {
953         EDMLOGE("asyncCallbackInfo->deferred != nullptr");
954         if (asyncCallbackInfo->ret == ERR_OK) {
955             napi_value nBundleInfos;
956             NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nBundleInfos));
957             ConvertVectorBundleToJs(env, asyncCallbackInfo->bundleInfos, nBundleInfos);
958             napi_resolve_deferred(env, asyncCallbackInfo->deferred, nBundleInfos);
959         } else {
960             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
961         }
962     }
963     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
964     delete asyncCallbackInfo;
965 }
966 
ConvertVectorBundleToJs(napi_env env,const std::vector<EdmBundleInfo> & bundleInfos,napi_value & result)967 void BundleManagerAddon::ConvertVectorBundleToJs(napi_env env, const std::vector<EdmBundleInfo> &bundleInfos,
968     napi_value &result)
969 {
970     if (bundleInfos.size() == 0) {
971         EDMLOGI("bundleInfos is null");
972         return;
973     }
974     size_t index = 0;
975     for (const auto &item : bundleInfos) {
976         napi_value objBundleInfo;
977         NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objBundleInfo));
978         ConvertBundleInfo(env, item, objBundleInfo);
979         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, index, objBundleInfo));
980         index++;
981     }
982 }
983 
ConvertBundleInfo(napi_env env,const EdmBundleInfo & bundleInfo,napi_value objBundleInfo)984 void BundleManagerAddon::ConvertBundleInfo(napi_env env, const EdmBundleInfo &bundleInfo, napi_value objBundleInfo)
985 {
986     napi_value nName;
987     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
988     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, NAME, nName));
989 
990     napi_value nVendor;
991     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.vendor.c_str(), NAPI_AUTO_LENGTH, &nVendor));
992     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, VENDOR, nVendor));
993 
994     napi_value nVersionCode;
995     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, bundleInfo.versionCode, &nVersionCode));
996     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, VERSION_CODE, nVersionCode));
997 
998     napi_value nVersionName;
999     NAPI_CALL_RETURN_VOID(
1000         env, napi_create_string_utf8(env, bundleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
1001     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, VERSION_NAME, nVersionName));
1002 
1003     napi_value nMinCompatibleVersionCode;
1004     NAPI_CALL_RETURN_VOID(
1005         env, napi_create_int32(env, bundleInfo.minCompatibleVersionCode, &nMinCompatibleVersionCode));
1006     NAPI_CALL_RETURN_VOID(
1007         env, napi_set_named_property(env, objBundleInfo, MIN_COMPATIBLE_VERSION_CODE, nMinCompatibleVersionCode));
1008 
1009     napi_value nTargetVersion;
1010     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.targetVersion, &nTargetVersion));
1011     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, TARGET_VERSION, nTargetVersion));
1012 
1013     napi_value nAppInfo;
1014     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nAppInfo));
1015     ConvertApplicationInfo(env, nAppInfo, bundleInfo.applicationInfo);
1016     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, APP_INFO, nAppInfo));
1017 
1018     napi_value nSignatureInfo;
1019     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nSignatureInfo));
1020     ConvertSignatureInfo(env, bundleInfo.signatureInfo, nSignatureInfo);
1021     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, SIGNATURE_INFO, nSignatureInfo));
1022 
1023     napi_value nInstallTime;
1024     NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.installTime, &nInstallTime));
1025     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, INSTALL_TIME, nInstallTime));
1026 
1027     napi_value nFirstInstallTime;
1028     NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.firstInstallTime, &nFirstInstallTime));
1029     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, FIRST_INSTALL_TIME, nFirstInstallTime));
1030 
1031     napi_value nUpdateTime;
1032     NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.updateTime, &nUpdateTime));
1033     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, UPDATE_TIME, nUpdateTime));
1034 
1035     napi_value nAppIndex;
1036     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.appIndex, &nAppIndex));
1037     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, APP_INDEX, nAppIndex));
1038 }
1039 
ConvertSignatureInfo(napi_env env,const EdmSignatureInfo & signatureInfo,napi_value value)1040 void BundleManagerAddon::ConvertSignatureInfo(napi_env env, const EdmSignatureInfo &signatureInfo, napi_value value)
1041 {
1042     napi_value nAppId;
1043     NAPI_CALL_RETURN_VOID(
1044         env, napi_create_string_utf8(env, signatureInfo.appId.c_str(), NAPI_AUTO_LENGTH, &nAppId));
1045     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, APP_ID, nAppId));
1046 
1047     napi_value nFingerprint;
1048     NAPI_CALL_RETURN_VOID(
1049         env, napi_create_string_utf8(env, signatureInfo.fingerprint.c_str(), NAPI_AUTO_LENGTH, &nFingerprint));
1050     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, FINGERPRINT, nFingerprint));
1051 
1052     napi_value nAppIdentifier;
1053     NAPI_CALL_RETURN_VOID(
1054         env, napi_create_string_utf8(env, signatureInfo.appIdentifier.c_str(), NAPI_AUTO_LENGTH, &nAppIdentifier));
1055     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, APP_IDENTIFIER, nAppIdentifier));
1056 
1057     napi_value nCertificate;
1058     NAPI_CALL_RETURN_VOID(
1059         env, napi_create_string_utf8(env, signatureInfo.certificate.c_str(), NAPI_AUTO_LENGTH, &nCertificate));
1060     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, CERTIFICATE, nCertificate));
1061 }
1062 
ConvertApplicationInfo(napi_env env,napi_value objAppInfo,const EdmApplicationInfo & appInfo)1063 void BundleManagerAddon::ConvertApplicationInfo(napi_env env, napi_value objAppInfo, const EdmApplicationInfo &appInfo)
1064 {
1065     napi_value nName;
1066     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1067     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, NAME, nName));
1068     EDMLOGD("ConvertApplicationInfo name=%{public}s", appInfo.name.c_str());
1069 
1070     napi_value nDescription;
1071     NAPI_CALL_RETURN_VOID(
1072         env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1073     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION, nDescription));
1074 
1075     napi_value nDescriptionId;
1076     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.descriptionId, &nDescriptionId));
1077     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION_ID, nDescriptionId));
1078 
1079     napi_value nEnabled;
1080     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.enabled, &nEnabled));
1081     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ENABLED, nEnabled));
1082 
1083     napi_value nLabel;
1084     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
1085     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL, nLabel));
1086 
1087     napi_value nLabelId;
1088     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.labelId, &nLabelId));
1089     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL_ID, nLabelId));
1090 
1091     napi_value nIcon;
1092     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.icon.c_str(), NAPI_AUTO_LENGTH, &nIcon));
1093     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON, nIcon));
1094 
1095     napi_value nIconId;
1096     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.iconId, &nIconId));
1097     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON_ID, nIconId));
1098 
1099     napi_value nProcess;
1100     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
1101     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, PROCESS, nProcess));
1102 
1103     napi_value nCodePath;
1104     NAPI_CALL_RETURN_VOID(
1105         env, napi_create_string_utf8(env, appInfo.codePath.c_str(), NAPI_AUTO_LENGTH, &nCodePath));
1106     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, CODE_PATH, nCodePath));
1107 
1108     napi_value nRemovable;
1109     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.removable, &nRemovable));
1110     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, REMOVABLE, nRemovable));
1111 
1112     napi_value nAccessTokenId;
1113     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.accessTokenId, &nAccessTokenId));
1114     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ACCESS_TOKEN_ID, nAccessTokenId));
1115 
1116     napi_value nUid;
1117     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.uid, &nUid));
1118     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, UID, nUid));
1119 
1120     napi_value nIconResource;
1121     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nIconResource));
1122     ConvertResource(env, appInfo.iconResource, nIconResource);
1123     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON_RESOURCE, nIconResource));
1124 
1125     napi_value nLabelResource;
1126     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nLabelResource));
1127     ConvertResource(env, appInfo.labelResource, nLabelResource);
1128     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL_RESOURCE, nLabelResource));
1129 
1130     napi_value nDescriptionResource;
1131     NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDescriptionResource));
1132     ConvertResource(env, appInfo.descriptionResource, nDescriptionResource);
1133     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION_RESOURCE, nDescriptionResource));
1134 
1135     napi_value nAppDistributionType;
1136     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appDistributionType.c_str(), NAPI_AUTO_LENGTH,
1137         &nAppDistributionType));
1138     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, APP_DISTRIBUTION_TYPE, nAppDistributionType));
1139 
1140     napi_value nAppProvisionType;
1141     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appProvisionType.c_str(), NAPI_AUTO_LENGTH,
1142         &nAppProvisionType));
1143     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, APP_PROVISION_TYPE, nAppProvisionType));
1144 
1145     napi_value nIsSystemApp;
1146     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.isSystemApp, &nIsSystemApp));
1147     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, SYSTEM_APP, nIsSystemApp));
1148 
1149     napi_value ndataUnclearable;
1150     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, !appInfo.userDataClearable, &ndataUnclearable));
1151     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DATA_UNCLEARABLE, ndataUnclearable));
1152 
1153     std::string externalNativeLibraryPath = "";
1154     if (!appInfo.nativeLibraryPath.empty()) {
1155         externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + appInfo.nativeLibraryPath;
1156     }
1157     napi_value nativeLibraryPath;
1158     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, externalNativeLibraryPath.c_str(), NAPI_AUTO_LENGTH,
1159         &nativeLibraryPath));
1160     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, NATIVE_LIBRARY_PATH, nativeLibraryPath));
1161 
1162     napi_value nAppIndex;
1163     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.appIndex, &nAppIndex));
1164     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, APP_INDEX, nAppIndex));
1165 
1166     napi_value nInstallSource;
1167     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.installSource.c_str(), NAPI_AUTO_LENGTH,
1168         &nInstallSource));
1169     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, INSTALL_SOURCE, nInstallSource));
1170 
1171     napi_value nReleaseType;
1172     NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.apiReleaseType.c_str(), NAPI_AUTO_LENGTH,
1173         &nReleaseType));
1174     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, RELEASE_TYPE, nReleaseType));
1175 
1176     napi_value nDebug;
1177     NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.debug, &nDebug));
1178     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DEBUG, nDebug));
1179 }
1180 
ConvertResource(napi_env env,const EdmResource & resource,napi_value objResource)1181 void BundleManagerAddon::ConvertResource(napi_env env, const EdmResource &resource, napi_value objResource)
1182 {
1183     napi_value nBundleName;
1184     NAPI_CALL_RETURN_VOID(
1185         env, napi_create_string_utf8(env, resource.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1186     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, BUNDLE_NAME, nBundleName));
1187 
1188     napi_value nModuleName;
1189     NAPI_CALL_RETURN_VOID(
1190         env, napi_create_string_utf8(env, resource.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1191     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, MODULE_NAME, nModuleName));
1192 
1193     napi_value nId;
1194     NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, resource.id, &nId));
1195     NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, ID, nId));
1196 }
1197 
1198 static napi_module g_bundleManagerModule = {
1199     .nm_version = 1,
1200     .nm_flags = 0,
1201     .nm_filename = nullptr,
1202     .nm_register_func = BundleManagerAddon::Init,
1203     .nm_modname = "enterprise.bundleManager",
1204     .nm_priv = ((void *)0),
1205     .reserved = {0},
1206 };
1207 
BundleManagerRegister()1208 extern "C" __attribute__((constructor)) void BundleManagerRegister()
1209 {
1210     napi_module_register(&g_bundleManagerModule);
1211 }