1 /*
2  * Copyright (c) 2021-2023 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 "inner_bundle_info.h"
17 
18 #include <regex>
19 
20 #ifdef BUNDLE_FRAMEWORK_APP_CONTROL
21 #include "app_control_constants.h"
22 #include "app_control_manager.h"
23 #endif
24 #include "app_log_tag_wrapper.h"
25 #include "bundle_mgr_client.h"
26 #include "bundle_permission_mgr.h"
27 #include "bundle_util.h"
28 #include "free_install_params.h"
29 
30 namespace OHOS {
31 namespace AppExecFwk {
32 namespace {
33 constexpr const char* APP_TYPE = "appType";
34 constexpr const char* BUNDLE_STATUS = "bundleStatus";
35 constexpr const char* BASE_APPLICATION_INFO = "baseApplicationInfo";
36 constexpr const char* BASE_BUNDLE_INFO = "baseBundleInfo";
37 constexpr const char* BASE_ABILITY_INFO = "baseAbilityInfos";
38 constexpr const char* INNER_MODULE_INFO = "innerModuleInfos";
39 constexpr const char* SKILL_INFOS = "skillInfos";
40 constexpr const char* USER_ID = "userId_";
41 constexpr const char* APP_FEATURE = "appFeature";
42 constexpr const char* NAME = "name";
43 constexpr const char* MODULE_PACKAGE = "modulePackage";
44 constexpr const char* MODULE_PATH = "modulePath";
45 constexpr const char* MODULE_NAME = "moduleName";
46 constexpr const char* MODULE_DESCRIPTION = "description";
47 constexpr const char* MODULE_DESCRIPTION_ID = "descriptionId";
48 constexpr const char* MODULE_ICON = "icon";
49 constexpr const char* MODULE_ICON_ID = "iconId";
50 constexpr const char* MODULE_LABEL = "label";
51 constexpr const char* MODULE_LABEL_ID = "labelId";
52 constexpr const char* MODULE_DESCRIPTION_INSTALLATION_FREE = "installationFree";
53 constexpr const char* MODULE_IS_REMOVABLE = "isRemovable";
54 constexpr const char* MODULE_UPGRADE_FLAG = "upgradeFlag";
55 constexpr const char* MODULE_IS_ENTRY = "isEntry";
56 constexpr const char* MODULE_METADATA = "metaData";
57 constexpr const char* MODULE_HNP_PACKAGE = "hnpPackage";
58 constexpr const char* MODULE_COLOR_MODE = "colorMode";
59 constexpr const char* MODULE_DISTRO = "distro";
60 constexpr const char* MODULE_REQ_CAPABILITIES = "reqCapabilities";
61 constexpr const char* MODULE_DATA_DIR = "moduleDataDir";
62 constexpr const char* MODULE_RES_PATH = "moduleResPath";
63 constexpr const char* MODULE_HAP_PATH = "hapPath";
64 constexpr const char* MODULE_ABILITY_KEYS = "abilityKeys";
65 constexpr const char* MODULE_SKILL_KEYS = "skillKeys";
66 constexpr const char* MODULE_FORMS = "formInfos";
67 constexpr const char* MODULE_SHORTCUT = "shortcutInfos";
68 constexpr const char* MODULE_COMMON_EVENT = "commonEvents";
69 constexpr const char* MODULE_MAIN_ABILITY = "mainAbility";
70 constexpr const char* MODULE_ENTRY_ABILITY_KEY = "entryAbilityKey";
71 constexpr const char* MODULE_DEPENDENCIES = "dependencies";
72 constexpr const char* MODULE_IS_LIB_ISOLATED = "isLibIsolated";
73 constexpr const char* MODULE_NATIVE_LIBRARY_PATH = "nativeLibraryPath";
74 constexpr const char* MODULE_CPU_ABI = "cpuAbi";
75 constexpr const char* MODULE_SRC_PATH = "srcPath";
76 constexpr const char* MODULE_HASH_VALUE = "hashValue";
77 constexpr const char* PORT_SEPARATOR = ":";
78 constexpr const char* INSTALL_MARK = "installMark";
79 constexpr const char* INNER_BUNDLE_USER_INFOS = "innerBundleUserInfos";
80 constexpr const char* MODULE_PROCESS = "process";
81 constexpr const char* MODULE_SRC_ENTRANCE = "srcEntrance";
82 constexpr const char* MODULE_DEVICE_TYPES = "deviceTypes";
83 constexpr const char* MODULE_VIRTUAL_MACHINE = "virtualMachine";
84 constexpr const char* MODULE_UI_SYNTAX = "uiSyntax";
85 constexpr const char* MODULE_PAGES = "pages";
86 constexpr const char* MODULE_META_DATA = "metadata";
87 constexpr const char* MODULE_REQUEST_PERMISSIONS = "requestPermissions";
88 constexpr const char* MODULE_DEFINE_PERMISSIONS = "definePermissions";
89 constexpr const char* MODULE_EXTENSION_KEYS = "extensionKeys";
90 constexpr const char* MODULE_EXTENSION_SKILL_KEYS = "extensionSkillKeys";
91 constexpr const char* MODULE_IS_MODULE_JSON = "isModuleJson";
92 constexpr const char* MODULE_IS_STAGE_BASED_MODEL = "isStageBasedModel";
93 constexpr const char* BUNDLE_IS_NEW_VERSION = "isNewVersion";
94 constexpr const char* BUNDLE_BASE_EXTENSION_INFOS = "baseExtensionInfos";
95 constexpr const char* BUNDLE_EXTENSION_SKILL_INFOS = "extensionSkillInfos";
96 constexpr const char* BUNDLE_EXTEND_RESOURCES = "extendResources";
97 constexpr const char* CUR_DYNAMIC_ICON_MODULE = "curDynamicIconModule";
98 constexpr const char* BUNDLE_PACK_INFO = "bundlePackInfo";
99 constexpr const char* ALLOWED_ACLS = "allowedAcls";
100 constexpr const char* APP_INDEX = "appIndex";
101 constexpr const char* BUNDLE_IS_SANDBOX_APP = "isSandboxApp";
102 constexpr const char* MODULE_COMPILE_MODE = "compileMode";
103 constexpr const char* BUNDLE_HQF_INFOS = "hqfInfos";
104 constexpr const char* MODULE_TARGET_MODULE_NAME = "targetModuleName";
105 constexpr const char* MODULE_TARGET_PRIORITY = "targetPriority";
106 constexpr const char* MODULE_OVERLAY_MODULE_INFO = "overlayModuleInfo";
107 constexpr const char* OVERLAY_BUNDLE_INFO = "overlayBundleInfo";
108 constexpr const char* OVERLAY_TYPE = "overlayType";
109 constexpr const char* APPLY_QUICK_FIX_FREQUENCY = "applyQuickFixFrequency";
110 constexpr const char* MODULE_PRELOADS = "preloads";
111 constexpr const char* INNER_SHARED_MODULE_INFO = "innerSharedModuleInfos";
112 constexpr const char* MODULE_BUNDLE_TYPE = "bundleType";
113 constexpr const char* MODULE_VERSION_CODE = "versionCode";
114 constexpr const char* MODULE_VERSION_NAME = "versionName";
115 constexpr const char* MODULE_PROXY_DATAS = "proxyDatas";
116 constexpr const char* MODULE_BUILD_HASH = "buildHash";
117 constexpr const char* MODULE_ISOLATION_MODE = "isolationMode";
118 constexpr const char* MODULE_COMPRESS_NATIVE_LIBS = "compressNativeLibs";
119 constexpr const char* MODULE_NATIVE_LIBRARY_FILE_NAMES = "nativeLibraryFileNames";
120 constexpr const char* MODULE_AOT_COMPILE_STATUS = "aotCompileStatus";
121 constexpr const char* DATA_GROUP_INFOS = "dataGroupInfos";
122 constexpr const char* MODULE_FILE_CONTEXT_MENU = "fileContextMenu";
123 constexpr const char* MODULE_IS_ENCRYPTED = "isEncrypted";
124 constexpr const char* MODULE_ROUTER_MAP = "routerMap";
125 constexpr const char* EXT_RESOURCE_MODULE_NAME = "moduleName";
126 constexpr const char* EXT_RESOURCE_ICON_ID = "iconId";
127 constexpr const char* EXT_RESOURCE_FILE_PATH = "filePath";
128 constexpr const char* DEVELOPER_ID = "developerId";
129 constexpr const char* ODID = "odid";
130 constexpr const char* UNINSTALL_STATE = "uninstallState";
131 const int32_t SINGLE_HSP_VERSION = 1;
132 const std::map<std::string, IsolationMode> ISOLATION_MODE_MAP = {
133     {"isolationOnly", IsolationMode::ISOLATION_ONLY},
134     {"nonisolationOnly", IsolationMode::NONISOLATION_ONLY},
135     {"isolationFirst", IsolationMode::ISOLATION_FIRST},
136 };
137 constexpr const char* NATIVE_LIBRARY_PATH_SYMBOL = "!/";
138 
139 constexpr const char* MODULE_QUERY_SCHEMES = "querySchemes";
140 constexpr const char* MODULE_APP_ENVIRONMENTS = "appEnvironments";
141 constexpr const char* MODULE_ASAN_ENABLED = "asanEnabled";
142 constexpr const char* MODULE_GWP_ASAN_ENABLED = "gwpAsanEnabled";
143 constexpr const char* MODULE_TSAN_ENABLED = "tsanEnabled";
144 constexpr const char* MODULE_PACKAGE_NAME = "packageName";
145 constexpr const char* MODULE_APP_STARTUP = "appStartup";
146 constexpr const char* MODULE_HWASAN_ENABLED = "hwasanEnabled";
147 constexpr uint32_t PREINSTALL_SOURCE_CLEAN_MASK = ~0B1110;
148 
ConvertCompileMode(const std::string & compileMode)149 inline CompileMode ConvertCompileMode(const std::string& compileMode)
150 {
151     if (compileMode == Profile::COMPILE_MODE_ES_MODULE) {
152         return CompileMode::ES_MODULE;
153     } else {
154         return CompileMode::JS_BUNDLE;
155     }
156 }
157 
NameAndUserIdToKey(const std::string & bundleName,int32_t userId)158 const std::string NameAndUserIdToKey(const std::string &bundleName, int32_t userId)
159 {
160     return bundleName + Constants::FILE_UNDERLINE + std::to_string(userId);
161 }
162 }  // namespace
163 
from_json(const nlohmann::json & jsonObject,ExtendResourceInfo & extendResourceInfo)164 void from_json(const nlohmann::json &jsonObject, ExtendResourceInfo &extendResourceInfo)
165 {
166     const auto &jsonObjectEnd = jsonObject.end();
167     int32_t parseResult = ERR_OK;
168     GetValueIfFindKey<std::string>(jsonObject,
169         jsonObjectEnd,
170         EXT_RESOURCE_MODULE_NAME,
171         extendResourceInfo.moduleName,
172         JsonType::STRING,
173         false,
174         parseResult,
175         ArrayType::NOT_ARRAY);
176     GetValueIfFindKey<int32_t>(jsonObject,
177         jsonObjectEnd,
178         EXT_RESOURCE_ICON_ID,
179         extendResourceInfo.iconId,
180         JsonType::NUMBER,
181         false,
182         parseResult,
183         ArrayType::NOT_ARRAY);
184     GetValueIfFindKey<std::string>(jsonObject,
185         jsonObjectEnd,
186         EXT_RESOURCE_FILE_PATH,
187         extendResourceInfo.filePath,
188         JsonType::STRING,
189         false,
190         parseResult,
191         ArrayType::NOT_ARRAY);
192     if (parseResult != ERR_OK) {
193         APP_LOGE("read ExtendResourceInfo from json error, error code : %{public}d", parseResult);
194     }
195 }
196 
to_json(nlohmann::json & jsonObject,const ExtendResourceInfo & extendResourceInfo)197 void to_json(nlohmann::json &jsonObject, const ExtendResourceInfo &extendResourceInfo)
198 {
199     jsonObject = nlohmann::json {
200         {EXT_RESOURCE_MODULE_NAME, extendResourceInfo.moduleName},
201         {EXT_RESOURCE_ICON_ID, extendResourceInfo.iconId},
202         {EXT_RESOURCE_FILE_PATH, extendResourceInfo.filePath}
203     };
204 }
205 
SetAOTCompileStatus(const std::string & moduleName,AOTCompileStatus aotCompileStatus)206 void InnerBundleInfo::SetAOTCompileStatus(const std::string &moduleName, AOTCompileStatus aotCompileStatus)
207 {
208     auto item = innerModuleInfos_.find(moduleName);
209     if (item == innerModuleInfos_.end()) {
210         APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
211         return;
212     }
213     item->second.aotCompileStatus = aotCompileStatus;
214 }
215 
GetAOTCompileStatus(const std::string & moduleName) const216 AOTCompileStatus InnerBundleInfo::GetAOTCompileStatus(const std::string &moduleName) const
217 {
218     auto item = innerModuleInfos_.find(moduleName);
219     if (item == innerModuleInfos_.end()) {
220         APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
221         return AOTCompileStatus::NOT_COMPILED;
222     }
223     return item->second.aotCompileStatus;
224 }
225 
ResetAOTFlags()226 void InnerBundleInfo::ResetAOTFlags()
227 {
228     baseApplicationInfo_->arkNativeFilePath.clear();
229     baseApplicationInfo_->arkNativeFileAbi.clear();
230     std::for_each(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](auto &item) {
231         item.second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
232     });
233 }
234 
ResetAOTCompileStatus(const std::string & moduleName)235 ErrCode InnerBundleInfo::ResetAOTCompileStatus(const std::string &moduleName)
236 {
237     auto item = innerModuleInfos_.find(moduleName);
238     if (item == innerModuleInfos_.end()) {
239         APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
240         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
241     }
242     item->second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
243     return ERR_OK;
244 }
245 
GetInternalDependentHspInfo(const std::string & moduleName,std::vector<HspInfo> & hspInfoVector) const246 void InnerBundleInfo::GetInternalDependentHspInfo(
247     const std::string &moduleName, std::vector<HspInfo> &hspInfoVector) const
248 {
249     std::vector<std::string> dependentModuleNames;
250     if (!GetAllDependentModuleNames(moduleName, dependentModuleNames)) {
251         return;
252     }
253     for (const auto &name : dependentModuleNames) {
254         auto item = innerModuleInfos_.find(name);
255         if (item == innerModuleInfos_.end()) {
256             continue;
257         }
258         HspInfo hspInfo;
259         hspInfo.bundleName = baseApplicationInfo_->bundleName;
260         hspInfo.moduleName = item->second.moduleName;
261         hspInfo.hapPath = item->second.hapPath;
262         hspInfoVector.emplace_back(hspInfo);
263     }
264 }
265 
InnerBundleInfo()266 InnerBundleInfo::InnerBundleInfo()
267 {
268     baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
269     if (baseApplicationInfo_ == nullptr) {
270         APP_LOGE("baseApplicationInfo_ is nullptr, create failed");
271     }
272     baseBundleInfo_ = std::make_shared<BundleInfo>();
273     if (baseBundleInfo_ == nullptr) {
274         APP_LOGE("baseBundleInfo_ is nullptr, create failed");
275     }
276     bundlePackInfo_ = std::make_shared<BundlePackInfo>();
277     if (bundlePackInfo_ == nullptr) {
278         APP_LOGE("bundlePackInfo_ is nullptr, create failed");
279     }
280     APP_LOGD("inner bundle info instance is created");
281 }
282 
operator =(const InnerBundleInfo & info)283 InnerBundleInfo &InnerBundleInfo::operator=(const InnerBundleInfo &info)
284 {
285     if (this == &info) {
286         return *this;
287     }
288     this->appType_ = info.appType_;
289 
290     this->userId_ = info.userId_;
291     this->bundleStatus_ = info.bundleStatus_;
292     this->appFeature_ = info.appFeature_;
293     this->allowedAcls_ = info.allowedAcls_;
294     this->mark_ = info.mark_;
295     this->appIndex_ = info.appIndex_;
296     this->isSandboxApp_ = info.isSandboxApp_;
297     this->currentPackage_ = info.currentPackage_;
298     this->onlyCreateBundleUser_ = info.onlyCreateBundleUser_;
299     this->innerModuleInfos_ = info.innerModuleInfos_;
300     this->innerSharedModuleInfos_ = info.innerSharedModuleInfos_;
301     this->formInfos_ = info.formInfos_;
302     this->commonEvents_ = info.commonEvents_;
303     this->shortcutInfos_ = info.shortcutInfos_;
304     this->baseAbilityInfos_ = info.baseAbilityInfos_;
305     this->skillInfos_ = info.skillInfos_;
306     this->innerBundleUserInfos_ = info.innerBundleUserInfos_;
307     this->bundlePackInfo_ = std::make_shared<BundlePackInfo>();
308     if (info.bundlePackInfo_ != nullptr) {
309         *(this->bundlePackInfo_) = *(info.bundlePackInfo_);
310     }
311     this->isNewVersion_ = info.isNewVersion_;
312     this->baseExtensionInfos_= info.baseExtensionInfos_;
313     this->extensionSkillInfos_ = info.extensionSkillInfos_;
314     this->extendResourceInfos_ = info.extendResourceInfos_;
315     this->curDynamicIconModule_ = info.curDynamicIconModule_;
316     this->baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
317     if (info.baseApplicationInfo_ != nullptr) {
318         *(this->baseApplicationInfo_) = *(info.baseApplicationInfo_);
319     }
320     this->baseBundleInfo_ = std::make_shared<BundleInfo>();
321     if (info.baseBundleInfo_ != nullptr) {
322         *(this->baseBundleInfo_) = *(info.baseBundleInfo_);
323     }
324     this->hqfInfos_ = info.hqfInfos_;
325     this->overlayBundleInfo_ = info.overlayBundleInfo_;
326     this->overlayType_ = info.overlayType_;
327     this->applyQuickFixFrequency_ = info.applyQuickFixFrequency_;
328     this->provisionMetadatas_ = info.provisionMetadatas_;
329     this->dataGroupInfos_ = info.dataGroupInfos_;
330     this->developerId_ = info.developerId_;
331     this->odid_ = info.odid_;
332     this->uninstallState_ = info.uninstallState_;
333     return *this;
334 }
335 
~InnerBundleInfo()336 InnerBundleInfo::~InnerBundleInfo()
337 {
338     APP_LOGD("inner bundle info instance is destroyed");
339 }
340 
to_json(nlohmann::json & jsonObject,const Distro & distro)341 void to_json(nlohmann::json &jsonObject, const Distro &distro)
342 {
343     jsonObject = nlohmann::json {
344             {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_DELIVERY_WITH_INSTALL, distro.deliveryWithInstall},
345             {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_NAME, distro.moduleName},
346             {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_TYPE, distro.moduleType},
347             {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_INSTALLATION_FREE, distro.installationFree}
348     };
349 }
350 
to_json(nlohmann::json & jsonObject,const DefinePermission & definePermission)351 void to_json(nlohmann::json &jsonObject, const DefinePermission &definePermission)
352 {
353     jsonObject = nlohmann::json {
354         {Profile::DEFINEPERMISSION_NAME, definePermission.name},
355         {Profile::DEFINEPERMISSION_GRANT_MODE, definePermission.grantMode},
356         {Profile::DEFINEPERMISSION_AVAILABLE_LEVEL, definePermission.availableLevel},
357         {Profile::DEFINEPERMISSION_PROVISION_ENABLE, definePermission.provisionEnable},
358         {Profile::DEFINEPERMISSION_DISTRIBUTED_SCENE_ENABLE, definePermission.distributedSceneEnable},
359         {Profile::LABEL, definePermission.label},
360         {Profile::LABEL_ID, definePermission.labelId},
361         {Profile::DESCRIPTION, definePermission.description},
362         {Profile::DESCRIPTION_ID, definePermission.descriptionId},
363         {Profile::DEFINEPERMISSION_AVAILABLE_TYPE, definePermission.availableType}
364     };
365 }
366 
to_json(nlohmann::json & jsonObject,const Dependency & dependency)367 void to_json(nlohmann::json &jsonObject, const Dependency &dependency)
368 {
369     jsonObject = nlohmann::json {
370         {Profile::DEPENDENCIES_MODULE_NAME, dependency.moduleName},
371         {Profile::DEPENDENCIES_BUNDLE_NAME, dependency.bundleName},
372         {Profile::APP_VERSION_CODE, dependency.versionCode}
373     };
374 }
375 
to_json(nlohmann::json & jsonObject,const InnerModuleInfo & info)376 void to_json(nlohmann::json &jsonObject, const InnerModuleInfo &info)
377 {
378     jsonObject = nlohmann::json {
379         {NAME, info.name},
380         {MODULE_PACKAGE, info.modulePackage},
381         {MODULE_NAME, info.moduleName},
382         {MODULE_PATH, info.modulePath},
383         {MODULE_DATA_DIR, info.moduleDataDir},
384         {MODULE_RES_PATH, info.moduleResPath},
385         {MODULE_IS_ENTRY, info.isEntry},
386         {MODULE_METADATA, info.metaData},
387         {MODULE_COLOR_MODE, info.colorMode},
388         {MODULE_DISTRO, info.distro},
389         {MODULE_DESCRIPTION, info.description},
390         {MODULE_DESCRIPTION_ID, info.descriptionId},
391         {MODULE_ICON, info.icon},
392         {MODULE_ICON_ID, info.iconId},
393         {MODULE_LABEL, info.label},
394         {MODULE_LABEL_ID, info.labelId},
395         {MODULE_DESCRIPTION_INSTALLATION_FREE, info.installationFree},
396         {MODULE_IS_REMOVABLE, info.isRemovable},
397         {MODULE_UPGRADE_FLAG, info.upgradeFlag},
398         {MODULE_REQ_CAPABILITIES, info.reqCapabilities},
399         {MODULE_ABILITY_KEYS, info.abilityKeys},
400         {MODULE_SKILL_KEYS, info.skillKeys},
401         {MODULE_MAIN_ABILITY, info.mainAbility},
402         {MODULE_ENTRY_ABILITY_KEY, info.entryAbilityKey},
403         {MODULE_SRC_PATH, info.srcPath},
404         {MODULE_HASH_VALUE, info.hashValue},
405         {MODULE_PROCESS, info.process},
406         {MODULE_SRC_ENTRANCE, info.srcEntrance},
407         {MODULE_DEVICE_TYPES, info.deviceTypes},
408         {MODULE_VIRTUAL_MACHINE, info.virtualMachine},
409         {MODULE_UI_SYNTAX, info.uiSyntax},
410         {MODULE_PAGES, info.pages},
411         {MODULE_META_DATA, info.metadata},
412         {MODULE_HNP_PACKAGE, info.hnpPackages},
413         {MODULE_REQUEST_PERMISSIONS, info.requestPermissions},
414         {MODULE_DEFINE_PERMISSIONS, info.definePermissions},
415         {MODULE_EXTENSION_KEYS, info.extensionKeys},
416         {MODULE_EXTENSION_SKILL_KEYS, info.extensionSkillKeys},
417         {MODULE_IS_MODULE_JSON, info.isModuleJson},
418         {MODULE_IS_STAGE_BASED_MODEL, info.isStageBasedModel},
419         {MODULE_DEPENDENCIES, info.dependencies},
420         {MODULE_IS_LIB_ISOLATED, info.isLibIsolated},
421         {MODULE_NATIVE_LIBRARY_PATH, info.nativeLibraryPath},
422         {MODULE_CPU_ABI, info.cpuAbi},
423         {MODULE_HAP_PATH, info.hapPath},
424         {MODULE_COMPILE_MODE, info.compileMode},
425         {MODULE_TARGET_MODULE_NAME, info.targetModuleName},
426         {MODULE_TARGET_PRIORITY, info.targetPriority},
427         {MODULE_OVERLAY_MODULE_INFO, info.overlayModuleInfo},
428         {MODULE_PRELOADS, info.preloads},
429         {MODULE_BUNDLE_TYPE, info.bundleType},
430         {MODULE_VERSION_CODE, info.versionCode},
431         {MODULE_VERSION_NAME, info.versionName},
432         {MODULE_PROXY_DATAS, info.proxyDatas},
433         {MODULE_BUILD_HASH, info.buildHash},
434         {MODULE_ISOLATION_MODE, info.isolationMode},
435         {MODULE_COMPRESS_NATIVE_LIBS, info.compressNativeLibs},
436         {MODULE_NATIVE_LIBRARY_FILE_NAMES, info.nativeLibraryFileNames},
437         {MODULE_AOT_COMPILE_STATUS, info.aotCompileStatus},
438         {MODULE_FILE_CONTEXT_MENU, info.fileContextMenu},
439         {MODULE_IS_ENCRYPTED, info.isEncrypted},
440         {MODULE_QUERY_SCHEMES, info.querySchemes},
441         {MODULE_ROUTER_MAP, info.routerMap},
442         {MODULE_APP_ENVIRONMENTS, info.appEnvironments},
443         {MODULE_ASAN_ENABLED, info.asanEnabled},
444         {MODULE_GWP_ASAN_ENABLED, info.gwpAsanEnabled},
445         {MODULE_TSAN_ENABLED, info.tsanEnabled},
446         {MODULE_PACKAGE_NAME, info.packageName},
447         {MODULE_APP_STARTUP, info.appStartup},
448         {MODULE_HWASAN_ENABLED, static_cast<bool>(info.innerModuleInfoFlag &
449             static_cast<uint32_t>(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED))},
450     };
451 }
452 
to_json(nlohmann::json & jsonObject,const InstallMark & installMark)453 void to_json(nlohmann::json &jsonObject, const InstallMark &installMark)
454 {
455     jsonObject = nlohmann::json {
456         {ProfileReader::BUNDLE_INSTALL_MARK_BUNDLE, installMark.bundleName},
457         {ProfileReader::BUNDLE_INSTALL_MARK_PACKAGE, installMark.packageName},
458         {ProfileReader::BUNDLE_INSTALL_MARK_STATUS, installMark.status}
459     };
460 }
461 
ToJson(nlohmann::json & jsonObject) const462 void InnerBundleInfo::ToJson(nlohmann::json &jsonObject) const
463 {
464     jsonObject[APP_TYPE] = appType_;
465     jsonObject[BUNDLE_STATUS] = bundleStatus_;
466     jsonObject[ALLOWED_ACLS] = allowedAcls_;
467     jsonObject[BASE_APPLICATION_INFO] = *baseApplicationInfo_;
468     jsonObject[BASE_BUNDLE_INFO] = *baseBundleInfo_;
469     jsonObject[BASE_ABILITY_INFO] = baseAbilityInfos_;
470     jsonObject[INNER_MODULE_INFO] = innerModuleInfos_;
471     jsonObject[INNER_SHARED_MODULE_INFO] = innerSharedModuleInfos_;
472     jsonObject[SKILL_INFOS] = skillInfos_;
473     jsonObject[USER_ID] = userId_;
474     jsonObject[APP_FEATURE] = appFeature_;
475     jsonObject[MODULE_FORMS] = formInfos_;
476     jsonObject[MODULE_SHORTCUT] = shortcutInfos_;
477     jsonObject[MODULE_COMMON_EVENT] = commonEvents_;
478     jsonObject[INSTALL_MARK] = mark_;
479     jsonObject[INNER_BUNDLE_USER_INFOS] = innerBundleUserInfos_;
480     jsonObject[BUNDLE_IS_NEW_VERSION] = isNewVersion_;
481     jsonObject[BUNDLE_BASE_EXTENSION_INFOS] = baseExtensionInfos_;
482     jsonObject[BUNDLE_EXTENSION_SKILL_INFOS] = extensionSkillInfos_;
483     jsonObject[BUNDLE_EXTEND_RESOURCES] = extendResourceInfos_;
484     jsonObject[CUR_DYNAMIC_ICON_MODULE] = curDynamicIconModule_;
485     jsonObject[BUNDLE_PACK_INFO] = *bundlePackInfo_;
486     jsonObject[APP_INDEX] = appIndex_;
487     jsonObject[BUNDLE_IS_SANDBOX_APP] = isSandboxApp_;
488     jsonObject[BUNDLE_HQF_INFOS] = hqfInfos_;
489     jsonObject[OVERLAY_BUNDLE_INFO] = overlayBundleInfo_;
490     jsonObject[OVERLAY_TYPE] = overlayType_;
491     jsonObject[APPLY_QUICK_FIX_FREQUENCY] = applyQuickFixFrequency_;
492     jsonObject[DATA_GROUP_INFOS] = dataGroupInfos_;
493     jsonObject[DEVELOPER_ID] = developerId_;
494     jsonObject[ODID] = odid_;
495     jsonObject[UNINSTALL_STATE] = uninstallState_;
496 }
497 
from_json(const nlohmann::json & jsonObject,InnerModuleInfo & info)498 void from_json(const nlohmann::json &jsonObject, InnerModuleInfo &info)
499 {
500     // these are not required fields.
501     const auto &jsonObjectEnd = jsonObject.end();
502     int32_t parseResult = ERR_OK;
503     bool hwasanEnabled = static_cast<bool>(info.innerModuleInfoFlag &
504         InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
505     GetValueIfFindKey<std::string>(jsonObject,
506         jsonObjectEnd,
507         NAME,
508         info.name,
509         JsonType::STRING,
510         false,
511         parseResult,
512         ArrayType::NOT_ARRAY);
513     GetValueIfFindKey<std::string>(jsonObject,
514         jsonObjectEnd,
515         MODULE_PACKAGE,
516         info.modulePackage,
517         JsonType::STRING,
518         false,
519         parseResult,
520         ArrayType::NOT_ARRAY);
521     GetValueIfFindKey<std::string>(jsonObject,
522         jsonObjectEnd,
523         MODULE_NAME,
524         info.moduleName,
525         JsonType::STRING,
526         false,
527         parseResult,
528         ArrayType::NOT_ARRAY);
529     GetValueIfFindKey<std::string>(jsonObject,
530         jsonObjectEnd,
531         MODULE_PATH,
532         info.modulePath,
533         JsonType::STRING,
534         false,
535         parseResult,
536         ArrayType::NOT_ARRAY);
537     GetValueIfFindKey<std::string>(jsonObject,
538         jsonObjectEnd,
539         MODULE_DATA_DIR,
540         info.moduleDataDir,
541         JsonType::STRING,
542         false,
543         parseResult,
544         ArrayType::NOT_ARRAY);
545     GetValueIfFindKey<std::string>(jsonObject,
546         jsonObjectEnd,
547         MODULE_HAP_PATH,
548         info.hapPath,
549         JsonType::STRING,
550         false,
551         parseResult,
552         ArrayType::NOT_ARRAY);
553     GetValueIfFindKey<std::string>(jsonObject,
554         jsonObjectEnd,
555         MODULE_RES_PATH,
556         info.moduleResPath,
557         JsonType::STRING,
558         false,
559         parseResult,
560         ArrayType::NOT_ARRAY);
561     GetValueIfFindKey<bool>(jsonObject,
562         jsonObjectEnd,
563         MODULE_IS_ENTRY,
564         info.isEntry,
565         JsonType::BOOLEAN,
566         false,
567         parseResult,
568         ArrayType::NOT_ARRAY);
569     GetValueIfFindKey<MetaData>(jsonObject,
570         jsonObjectEnd,
571         MODULE_METADATA,
572         info.metaData,
573         JsonType::OBJECT,
574         false,
575         parseResult,
576         ArrayType::NOT_ARRAY);
577     GetValueIfFindKey<ModuleColorMode>(jsonObject,
578         jsonObjectEnd,
579         MODULE_COLOR_MODE,
580         info.colorMode,
581         JsonType::NUMBER,
582         false,
583         parseResult,
584         ArrayType::NOT_ARRAY);
585     GetValueIfFindKey<Distro>(jsonObject,
586         jsonObjectEnd,
587         MODULE_DISTRO,
588         info.distro,
589         JsonType::OBJECT,
590         false,
591         parseResult,
592         ArrayType::NOT_ARRAY);
593     GetValueIfFindKey<std::string>(jsonObject,
594         jsonObjectEnd,
595         MODULE_DESCRIPTION,
596         info.description,
597         JsonType::STRING,
598         false,
599         parseResult,
600         ArrayType::NOT_ARRAY);
601     GetValueIfFindKey<int32_t>(jsonObject,
602         jsonObjectEnd,
603         MODULE_DESCRIPTION_ID,
604         info.descriptionId,
605         JsonType::NUMBER,
606         false,
607         parseResult,
608         ArrayType::NOT_ARRAY);
609     GetValueIfFindKey<std::string>(jsonObject,
610         jsonObjectEnd,
611         MODULE_ICON,
612         info.icon,
613         JsonType::STRING,
614         false,
615         parseResult,
616         ArrayType::NOT_ARRAY);
617     GetValueIfFindKey<int32_t>(jsonObject,
618         jsonObjectEnd,
619         MODULE_ICON_ID,
620         info.iconId,
621         JsonType::NUMBER,
622         false,
623         parseResult,
624         ArrayType::NOT_ARRAY);
625     GetValueIfFindKey<std::string>(jsonObject,
626         jsonObjectEnd,
627         MODULE_LABEL,
628         info.label,
629         JsonType::STRING,
630         false,
631         parseResult,
632         ArrayType::NOT_ARRAY);
633     GetValueIfFindKey<int32_t>(jsonObject,
634         jsonObjectEnd,
635         MODULE_LABEL_ID,
636         info.labelId,
637         JsonType::NUMBER,
638         false,
639         parseResult,
640         ArrayType::NOT_ARRAY);
641     GetValueIfFindKey<std::string>(jsonObject,
642         jsonObjectEnd,
643         MODULE_MAIN_ABILITY,
644         info.mainAbility,
645         JsonType::STRING,
646         false,
647         parseResult,
648         ArrayType::NOT_ARRAY);
649     GetValueIfFindKey<std::string>(jsonObject,
650         jsonObjectEnd,
651         MODULE_ENTRY_ABILITY_KEY,
652         info.entryAbilityKey,
653         JsonType::STRING,
654         false,
655         parseResult,
656         ArrayType::NOT_ARRAY);
657     GetValueIfFindKey<std::string>(jsonObject,
658         jsonObjectEnd,
659         MODULE_SRC_PATH,
660         info.srcPath,
661         JsonType::STRING,
662         false,
663         parseResult,
664         ArrayType::NOT_ARRAY);
665     GetValueIfFindKey<std::string>(jsonObject,
666         jsonObjectEnd,
667         MODULE_HASH_VALUE,
668         info.hashValue,
669         JsonType::STRING,
670         false,
671         parseResult,
672         ArrayType::NOT_ARRAY);
673     GetValueIfFindKey<bool>(jsonObject,
674         jsonObjectEnd,
675         MODULE_DESCRIPTION_INSTALLATION_FREE,
676         info.installationFree,
677         JsonType::BOOLEAN,
678         false,
679         parseResult,
680         ArrayType::NOT_ARRAY);
681     GetValueIfFindKey<std::map<std::string, bool>>(jsonObject,
682         jsonObjectEnd,
683         MODULE_IS_REMOVABLE,
684         info.isRemovable,
685         JsonType::OBJECT,
686         false,
687         parseResult,
688         ArrayType::NOT_ARRAY);
689     GetValueIfFindKey<int32_t>(jsonObject,
690         jsonObjectEnd,
691         MODULE_UPGRADE_FLAG,
692         info.upgradeFlag,
693         JsonType::NUMBER,
694         false,
695         parseResult,
696         ArrayType::NOT_ARRAY);
697     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
698         jsonObjectEnd,
699         MODULE_REQ_CAPABILITIES,
700         info.reqCapabilities,
701         JsonType::ARRAY,
702         false,
703         parseResult,
704         ArrayType::STRING);
705     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
706         jsonObjectEnd,
707         MODULE_ABILITY_KEYS,
708         info.abilityKeys,
709         JsonType::ARRAY,
710         false,
711         parseResult,
712         ArrayType::STRING);
713     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
714         jsonObjectEnd,
715         MODULE_SKILL_KEYS,
716         info.skillKeys,
717         JsonType::ARRAY,
718         false,
719         parseResult,
720         ArrayType::STRING);
721     GetValueIfFindKey<std::string>(jsonObject,
722         jsonObjectEnd,
723         MODULE_PROCESS,
724         info.process,
725         JsonType::STRING,
726         false,
727         parseResult,
728         ArrayType::NOT_ARRAY);
729     GetValueIfFindKey<std::string>(jsonObject,
730         jsonObjectEnd,
731         MODULE_SRC_ENTRANCE,
732         info.srcEntrance,
733         JsonType::STRING,
734         false,
735         parseResult,
736         ArrayType::NOT_ARRAY);
737     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
738         jsonObjectEnd,
739         MODULE_DEVICE_TYPES,
740         info.deviceTypes,
741         JsonType::ARRAY,
742         false,
743         parseResult,
744         ArrayType::STRING);
745     GetValueIfFindKey<std::string>(jsonObject,
746         jsonObjectEnd,
747         MODULE_VIRTUAL_MACHINE,
748         info.virtualMachine,
749         JsonType::STRING,
750         false,
751         parseResult,
752         ArrayType::NOT_ARRAY);
753     GetValueIfFindKey<std::string>(jsonObject,
754         jsonObjectEnd,
755         MODULE_UI_SYNTAX,
756         info.uiSyntax,
757         JsonType::STRING,
758         false,
759         parseResult,
760         ArrayType::NOT_ARRAY);
761     GetValueIfFindKey<std::string>(jsonObject,
762         jsonObjectEnd,
763         MODULE_PAGES,
764         info.pages,
765         JsonType::STRING,
766         false,
767         parseResult,
768         ArrayType::NOT_ARRAY);
769     GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
770         jsonObjectEnd,
771         MODULE_META_DATA,
772         info.metadata,
773         JsonType::ARRAY,
774         false,
775         parseResult,
776         ArrayType::OBJECT);
777     GetValueIfFindKey<std::vector<HnpPackage>>(jsonObject,
778         jsonObjectEnd,
779         MODULE_HNP_PACKAGE,
780         info.hnpPackages,
781         JsonType::ARRAY,
782         false,
783         parseResult,
784         ArrayType::OBJECT);
785     GetValueIfFindKey<std::vector<RequestPermission>>(jsonObject,
786         jsonObjectEnd,
787         MODULE_REQUEST_PERMISSIONS,
788         info.requestPermissions,
789         JsonType::ARRAY,
790         false,
791         parseResult,
792         ArrayType::OBJECT);
793     GetValueIfFindKey<std::vector<DefinePermission>>(jsonObject,
794         jsonObjectEnd,
795         MODULE_DEFINE_PERMISSIONS,
796         info.definePermissions,
797         JsonType::ARRAY,
798         false,
799         parseResult,
800         ArrayType::OBJECT);
801     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
802         jsonObjectEnd,
803         MODULE_EXTENSION_KEYS,
804         info.extensionKeys,
805         JsonType::ARRAY,
806         false,
807         parseResult,
808         ArrayType::STRING);
809     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
810         jsonObjectEnd,
811         MODULE_EXTENSION_SKILL_KEYS,
812         info.extensionSkillKeys,
813         JsonType::ARRAY,
814         false,
815         parseResult,
816         ArrayType::STRING);
817     GetValueIfFindKey<bool>(jsonObject,
818         jsonObjectEnd,
819         MODULE_IS_MODULE_JSON,
820         info.isModuleJson,
821         JsonType::BOOLEAN,
822         false,
823         parseResult,
824         ArrayType::NOT_ARRAY);
825     GetValueIfFindKey<bool>(jsonObject,
826         jsonObjectEnd,
827         MODULE_IS_STAGE_BASED_MODEL,
828         info.isStageBasedModel,
829         JsonType::BOOLEAN,
830         false,
831         parseResult,
832         ArrayType::NOT_ARRAY);
833     GetValueIfFindKey<std::vector<Dependency>>(jsonObject,
834         jsonObjectEnd,
835         MODULE_DEPENDENCIES,
836         info.dependencies,
837         JsonType::ARRAY,
838         false,
839         parseResult,
840         ArrayType::OBJECT);
841     GetValueIfFindKey<std::string>(jsonObject,
842         jsonObjectEnd,
843         MODULE_COMPILE_MODE,
844         info.compileMode,
845         JsonType::STRING,
846         false,
847         parseResult,
848         ArrayType::NOT_ARRAY);
849     GetValueIfFindKey<bool>(jsonObject,
850         jsonObjectEnd,
851         MODULE_IS_LIB_ISOLATED,
852         info.isLibIsolated,
853         JsonType::BOOLEAN,
854         false,
855         parseResult,
856         ArrayType::NOT_ARRAY);
857     GetValueIfFindKey<std::string>(jsonObject,
858         jsonObjectEnd,
859         MODULE_NATIVE_LIBRARY_PATH,
860         info.nativeLibraryPath,
861         JsonType::STRING,
862         false,
863         parseResult,
864         ArrayType::NOT_ARRAY);
865     GetValueIfFindKey<std::string>(jsonObject,
866         jsonObjectEnd,
867         MODULE_CPU_ABI,
868         info.cpuAbi,
869         JsonType::STRING,
870         false,
871         parseResult,
872         ArrayType::NOT_ARRAY);
873     GetValueIfFindKey<std::string>(jsonObject,
874         jsonObjectEnd,
875         MODULE_TARGET_MODULE_NAME,
876         info.targetModuleName,
877         JsonType::STRING,
878         false,
879         parseResult,
880         ArrayType::NOT_ARRAY);
881     GetValueIfFindKey<int32_t>(jsonObject,
882         jsonObjectEnd,
883         MODULE_TARGET_PRIORITY,
884         info.targetPriority,
885         JsonType::NUMBER,
886         false,
887         parseResult,
888         ArrayType::NOT_ARRAY);
889     GetValueIfFindKey<std::vector<OverlayModuleInfo>>(jsonObject,
890         jsonObjectEnd,
891         MODULE_OVERLAY_MODULE_INFO,
892         info.overlayModuleInfo,
893         JsonType::ARRAY,
894         false,
895         parseResult,
896         ArrayType::OBJECT);
897     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
898         jsonObjectEnd,
899         MODULE_PRELOADS,
900         info.preloads,
901         JsonType::ARRAY,
902         false,
903         parseResult,
904         ArrayType::STRING);
905     GetValueIfFindKey<BundleType>(jsonObject,
906         jsonObjectEnd,
907         MODULE_BUNDLE_TYPE,
908         info.bundleType,
909         JsonType::NUMBER,
910         false,
911         parseResult,
912         ArrayType::NOT_ARRAY);
913     GetValueIfFindKey<uint32_t>(jsonObject,
914         jsonObjectEnd,
915         MODULE_VERSION_CODE,
916         info.versionCode,
917         JsonType::NUMBER,
918         false,
919         parseResult,
920         ArrayType::NOT_ARRAY);
921     GetValueIfFindKey<std::string>(jsonObject,
922         jsonObjectEnd,
923         MODULE_VERSION_NAME,
924         info.versionName,
925         JsonType::STRING,
926         false,
927         parseResult,
928         ArrayType::NOT_ARRAY);
929     GetValueIfFindKey<std::vector<ProxyData>>(jsonObject,
930         jsonObjectEnd,
931         MODULE_PROXY_DATAS,
932         info.proxyDatas,
933         JsonType::ARRAY,
934         false,
935         parseResult,
936         ArrayType::OBJECT);
937     GetValueIfFindKey<std::string>(jsonObject,
938         jsonObjectEnd,
939         MODULE_BUILD_HASH,
940         info.buildHash,
941         JsonType::STRING,
942         false,
943         parseResult,
944         ArrayType::NOT_ARRAY);
945     GetValueIfFindKey<std::string>(jsonObject,
946         jsonObjectEnd,
947         MODULE_ISOLATION_MODE,
948         info.isolationMode,
949         JsonType::STRING,
950         false,
951         parseResult,
952         ArrayType::NOT_ARRAY);
953     GetValueIfFindKey<bool>(jsonObject,
954         jsonObjectEnd,
955         MODULE_COMPRESS_NATIVE_LIBS,
956         info.compressNativeLibs,
957         JsonType::BOOLEAN,
958         false,
959         parseResult,
960         ArrayType::NOT_ARRAY);
961     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
962         jsonObjectEnd,
963         MODULE_NATIVE_LIBRARY_FILE_NAMES,
964         info.nativeLibraryFileNames,
965         JsonType::ARRAY,
966         false,
967         parseResult,
968         ArrayType::STRING);
969     GetValueIfFindKey<AOTCompileStatus>(jsonObject,
970         jsonObjectEnd,
971         MODULE_AOT_COMPILE_STATUS,
972         info.aotCompileStatus,
973         JsonType::NUMBER,
974         false,
975         parseResult,
976         ArrayType::NOT_ARRAY);
977     GetValueIfFindKey<std::string>(jsonObject,
978         jsonObjectEnd,
979         MODULE_FILE_CONTEXT_MENU,
980         info.fileContextMenu,
981         JsonType::STRING,
982         false,
983         parseResult,
984         ArrayType::NOT_ARRAY);
985     GetValueIfFindKey<bool>(jsonObject,
986         jsonObjectEnd,
987         MODULE_IS_ENCRYPTED,
988         info.isEncrypted,
989         JsonType::BOOLEAN,
990         false,
991         parseResult,
992         ArrayType::NOT_ARRAY);
993     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
994         jsonObjectEnd,
995         MODULE_QUERY_SCHEMES,
996         info.querySchemes,
997         JsonType::ARRAY,
998         false,
999         parseResult,
1000         ArrayType::STRING);
1001     GetValueIfFindKey<std::string>(jsonObject,
1002         jsonObjectEnd,
1003         MODULE_ROUTER_MAP,
1004         info.routerMap,
1005         JsonType::STRING,
1006         false,
1007         parseResult,
1008         ArrayType::NOT_ARRAY);
1009     GetValueIfFindKey<std::vector<AppEnvironment>>(jsonObject,
1010         jsonObjectEnd,
1011         MODULE_APP_ENVIRONMENTS,
1012         info.appEnvironments,
1013         JsonType::ARRAY,
1014         false,
1015         parseResult,
1016         ArrayType::OBJECT);
1017     GetValueIfFindKey<bool>(jsonObject,
1018         jsonObjectEnd,
1019         MODULE_ASAN_ENABLED,
1020         info.asanEnabled,
1021         JsonType::BOOLEAN,
1022         false,
1023         parseResult,
1024         ArrayType::NOT_ARRAY);
1025     GetValueIfFindKey<bool>(jsonObject,
1026         jsonObjectEnd,
1027         MODULE_GWP_ASAN_ENABLED,
1028         info.gwpAsanEnabled,
1029         JsonType::BOOLEAN,
1030         false,
1031         parseResult,
1032         ArrayType::NOT_ARRAY);
1033     GetValueIfFindKey<bool>(jsonObject,
1034         jsonObjectEnd,
1035         MODULE_TSAN_ENABLED,
1036         info.tsanEnabled,
1037         JsonType::BOOLEAN,
1038         false,
1039         parseResult,
1040         ArrayType::NOT_ARRAY);
1041     GetValueIfFindKey<std::string>(jsonObject,
1042         jsonObjectEnd,
1043         MODULE_PACKAGE_NAME,
1044         info.packageName,
1045         JsonType::STRING,
1046         false,
1047         parseResult,
1048         ArrayType::NOT_ARRAY);
1049     GetValueIfFindKey<std::string>(jsonObject,
1050         jsonObjectEnd,
1051         MODULE_APP_STARTUP,
1052         info.appStartup,
1053         JsonType::STRING,
1054         false,
1055         parseResult,
1056         ArrayType::NOT_ARRAY);
1057     GetValueIfFindKey<bool>(jsonObject,
1058         jsonObjectEnd,
1059         MODULE_HWASAN_ENABLED,
1060         hwasanEnabled,
1061         JsonType::BOOLEAN,
1062         false,
1063         parseResult,
1064         ArrayType::NOT_ARRAY);
1065     if (parseResult != ERR_OK) {
1066         APP_LOGE("read InnerModuleInfo from database error code : %{public}d", parseResult);
1067     } else {
1068         info.innerModuleInfoFlag = hwasanEnabled ? info.innerModuleInfoFlag | InnerBundleInfo::GetSanitizerFlag(
1069             GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED) : info.innerModuleInfoFlag &
1070             (~InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
1071     }
1072 }
1073 
from_json(const nlohmann::json & jsonObject,Distro & distro)1074 void from_json(const nlohmann::json &jsonObject, Distro &distro)
1075 {
1076     const auto &jsonObjectEnd = jsonObject.end();
1077     int32_t parseResult = ERR_OK;
1078     GetValueIfFindKey<bool>(jsonObject,
1079         jsonObjectEnd,
1080         ProfileReader::BUNDLE_MODULE_PROFILE_KEY_DELIVERY_WITH_INSTALL,
1081         distro.deliveryWithInstall,
1082         JsonType::BOOLEAN,
1083         true,
1084         parseResult,
1085         ArrayType::NOT_ARRAY);
1086     GetValueIfFindKey<std::string>(jsonObject,
1087         jsonObjectEnd,
1088         ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_NAME,
1089         distro.moduleName,
1090         JsonType::STRING,
1091         true,
1092         parseResult,
1093         ArrayType::NOT_ARRAY);
1094     GetValueIfFindKey<std::string>(jsonObject,
1095         jsonObjectEnd,
1096         ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_TYPE,
1097         distro.moduleType,
1098         JsonType::STRING,
1099         true,
1100         parseResult,
1101         ArrayType::NOT_ARRAY);
1102     // mustFlag decide by distro.moduleType
1103     GetValueIfFindKey<bool>(jsonObject,
1104         jsonObjectEnd,
1105         ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_INSTALLATION_FREE,
1106         distro.installationFree,
1107         JsonType::BOOLEAN,
1108         false,
1109         parseResult,
1110         ArrayType::NOT_ARRAY);
1111     if (parseResult != ERR_OK) {
1112         APP_LOGE("Distro from_json error, error code : %{public}d", parseResult);
1113     }
1114 }
1115 
from_json(const nlohmann::json & jsonObject,InstallMark & installMark)1116 void from_json(const nlohmann::json &jsonObject, InstallMark &installMark)
1117 {
1118     const auto &jsonObjectEnd = jsonObject.end();
1119     int32_t parseResult = ERR_OK;
1120     GetValueIfFindKey<std::string>(jsonObject,
1121         jsonObjectEnd,
1122         ProfileReader::BUNDLE_INSTALL_MARK_BUNDLE,
1123         installMark.bundleName,
1124         JsonType::STRING,
1125         false,
1126         parseResult,
1127         ArrayType::NOT_ARRAY);
1128     GetValueIfFindKey<std::string>(jsonObject,
1129         jsonObjectEnd,
1130         ProfileReader::BUNDLE_INSTALL_MARK_PACKAGE,
1131         installMark.packageName,
1132         JsonType::STRING,
1133         false,
1134         parseResult,
1135         ArrayType::NOT_ARRAY);
1136     GetValueIfFindKey<int32_t>(jsonObject,
1137         jsonObjectEnd,
1138         ProfileReader::BUNDLE_INSTALL_MARK_STATUS,
1139         installMark.status,
1140         JsonType::NUMBER,
1141         false,
1142         parseResult,
1143         ArrayType::NOT_ARRAY);
1144     if (parseResult != ERR_OK) {
1145         APP_LOGE("InstallMark from_json error, error code : %{public}d", parseResult);
1146     }
1147 }
1148 
from_json(const nlohmann::json & jsonObject,DefinePermission & definePermission)1149 void from_json(const nlohmann::json &jsonObject, DefinePermission &definePermission)
1150 {
1151     const auto &jsonObjectEnd = jsonObject.end();
1152     int32_t parseResult = ERR_OK;
1153     GetValueIfFindKey<std::string>(jsonObject,
1154         jsonObjectEnd,
1155         Profile::DEFINEPERMISSION_NAME,
1156         definePermission.name,
1157         JsonType::STRING,
1158         false,
1159         parseResult,
1160         ArrayType::NOT_ARRAY);
1161     GetValueIfFindKey<std::string>(jsonObject,
1162         jsonObjectEnd,
1163         Profile::DEFINEPERMISSION_GRANT_MODE,
1164         definePermission.grantMode,
1165         JsonType::STRING,
1166         false,
1167         parseResult,
1168         ArrayType::NOT_ARRAY);
1169     GetValueIfFindKey<std::string>(jsonObject,
1170         jsonObjectEnd,
1171         Profile::DEFINEPERMISSION_AVAILABLE_LEVEL,
1172         definePermission.availableLevel,
1173         JsonType::STRING,
1174         false,
1175         parseResult,
1176         ArrayType::NOT_ARRAY);
1177     GetValueIfFindKey<bool>(jsonObject,
1178         jsonObjectEnd,
1179         Profile::DEFINEPERMISSION_PROVISION_ENABLE,
1180         definePermission.provisionEnable,
1181         JsonType::BOOLEAN,
1182         false,
1183         parseResult,
1184         ArrayType::NOT_ARRAY);
1185     GetValueIfFindKey<bool>(jsonObject,
1186         jsonObjectEnd,
1187         Profile::DEFINEPERMISSION_DISTRIBUTED_SCENE_ENABLE,
1188         definePermission.distributedSceneEnable,
1189         JsonType::BOOLEAN,
1190         false,
1191         parseResult,
1192         ArrayType::NOT_ARRAY);
1193     GetValueIfFindKey<std::string>(jsonObject,
1194         jsonObjectEnd,
1195         Profile::LABEL,
1196         definePermission.label,
1197         JsonType::STRING,
1198         false,
1199         parseResult,
1200         ArrayType::NOT_ARRAY);
1201     GetValueIfFindKey<int32_t>(jsonObject,
1202         jsonObjectEnd,
1203         Profile::LABEL_ID,
1204         definePermission.labelId,
1205         JsonType::NUMBER,
1206         false,
1207         parseResult,
1208         ArrayType::NOT_ARRAY);
1209     GetValueIfFindKey<std::string>(jsonObject,
1210         jsonObjectEnd,
1211         Profile::DESCRIPTION,
1212         definePermission.description,
1213         JsonType::STRING,
1214         false,
1215         parseResult,
1216         ArrayType::NOT_ARRAY);
1217     GetValueIfFindKey<int32_t>(jsonObject,
1218         jsonObjectEnd,
1219         Profile::DESCRIPTION_ID,
1220         definePermission.descriptionId,
1221         JsonType::NUMBER,
1222         false,
1223         parseResult,
1224         ArrayType::NOT_ARRAY);
1225     GetValueIfFindKey<std::string>(jsonObject,
1226         jsonObjectEnd,
1227         Profile::DEFINEPERMISSION_AVAILABLE_TYPE,
1228         definePermission.availableType,
1229         JsonType::STRING,
1230         false,
1231         parseResult,
1232         ArrayType::NOT_ARRAY);
1233     if (parseResult != ERR_OK) {
1234         APP_LOGE("DefinePermission from_json error, error code : %{public}d", parseResult);
1235     }
1236 }
1237 
from_json(const nlohmann::json & jsonObject,Dependency & dependency)1238 void from_json(const nlohmann::json &jsonObject, Dependency &dependency)
1239 {
1240     const auto &jsonObjectEnd = jsonObject.end();
1241     int32_t parseResult = ERR_OK;
1242     GetValueIfFindKey<std::string>(jsonObject,
1243         jsonObjectEnd,
1244         Profile::DEPENDENCIES_MODULE_NAME,
1245         dependency.moduleName,
1246         JsonType::STRING,
1247         false,
1248         parseResult,
1249         ArrayType::NOT_ARRAY);
1250     GetValueIfFindKey<std::string>(jsonObject,
1251         jsonObjectEnd,
1252         Profile::DEPENDENCIES_BUNDLE_NAME,
1253         dependency.bundleName,
1254         JsonType::STRING,
1255         false,
1256         parseResult,
1257         ArrayType::NOT_ARRAY);
1258     GetValueIfFindKey<int>(jsonObject,
1259         jsonObjectEnd,
1260         Profile::APP_VERSION_CODE,
1261         dependency.versionCode,
1262         JsonType::NUMBER,
1263         false,
1264         parseResult,
1265         ArrayType::NOT_ARRAY);
1266     if (parseResult != ERR_OK) {
1267         APP_LOGE("Dependency from_json error, error code : %{public}d", parseResult);
1268     }
1269 }
1270 
FromJson(const nlohmann::json & jsonObject)1271 int32_t InnerBundleInfo::FromJson(const nlohmann::json &jsonObject)
1272 {
1273     const auto &jsonObjectEnd = jsonObject.end();
1274     int32_t parseResult = ERR_OK;
1275     GetValueIfFindKey<Constants::AppType>(jsonObject,
1276         jsonObjectEnd,
1277         APP_TYPE,
1278         appType_,
1279         JsonType::NUMBER,
1280         true,
1281         parseResult,
1282         ArrayType::NOT_ARRAY);
1283     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1284         jsonObjectEnd,
1285         ALLOWED_ACLS,
1286         allowedAcls_,
1287         JsonType::ARRAY,
1288         false,
1289         parseResult,
1290         ArrayType::STRING);
1291     GetValueIfFindKey<BundleStatus>(jsonObject,
1292         jsonObjectEnd,
1293         BUNDLE_STATUS,
1294         bundleStatus_,
1295         JsonType::NUMBER,
1296         true,
1297         parseResult,
1298         ArrayType::NOT_ARRAY);
1299     GetValueIfFindKey<BundleInfo>(jsonObject,
1300         jsonObjectEnd,
1301         BASE_BUNDLE_INFO,
1302         *baseBundleInfo_,
1303         JsonType::OBJECT,
1304         true,
1305         parseResult,
1306         ArrayType::NOT_ARRAY);
1307     GetValueIfFindKey<ApplicationInfo>(jsonObject,
1308         jsonObjectEnd,
1309         BASE_APPLICATION_INFO,
1310         *baseApplicationInfo_,
1311         JsonType::OBJECT,
1312         true,
1313         parseResult,
1314         ArrayType::NOT_ARRAY);
1315     GetValueIfFindKey<std::map<std::string, AbilityInfo>>(jsonObject,
1316         jsonObjectEnd,
1317         BASE_ABILITY_INFO,
1318         baseAbilityInfos_,
1319         JsonType::OBJECT,
1320         true,
1321         parseResult,
1322         ArrayType::NOT_ARRAY);
1323     GetValueIfFindKey<std::map<std::string, InnerModuleInfo>>(jsonObject,
1324         jsonObjectEnd,
1325         INNER_MODULE_INFO,
1326         innerModuleInfos_,
1327         JsonType::OBJECT,
1328         true,
1329         parseResult,
1330         ArrayType::NOT_ARRAY);
1331     GetValueIfFindKey<std::map<std::string, std::vector<InnerModuleInfo>>>(jsonObject,
1332         jsonObjectEnd,
1333         INNER_SHARED_MODULE_INFO,
1334         innerSharedModuleInfos_,
1335         JsonType::OBJECT,
1336         false,
1337         parseResult,
1338         ArrayType::NOT_ARRAY);
1339     GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
1340         jsonObjectEnd,
1341         SKILL_INFOS,
1342         skillInfos_,
1343         JsonType::OBJECT,
1344         true,
1345         parseResult,
1346         ArrayType::NOT_ARRAY);
1347     GetValueIfFindKey<int>(jsonObject,
1348         jsonObjectEnd,
1349         USER_ID,
1350         userId_,
1351         JsonType::NUMBER,
1352         true,
1353         parseResult,
1354         ArrayType::NOT_ARRAY);
1355     GetValueIfFindKey<std::string>(jsonObject,
1356         jsonObjectEnd,
1357         APP_FEATURE,
1358         appFeature_,
1359         JsonType::STRING,
1360         true,
1361         parseResult,
1362         ArrayType::NOT_ARRAY);
1363     GetValueIfFindKey<std::map<std::string, std::vector<FormInfo>>>(jsonObject,
1364         jsonObjectEnd,
1365         MODULE_FORMS,
1366         formInfos_,
1367         JsonType::OBJECT,
1368         true,
1369         parseResult,
1370         ArrayType::NOT_ARRAY);
1371     GetValueIfFindKey<std::map<std::string, ShortcutInfo>>(jsonObject,
1372         jsonObjectEnd,
1373         MODULE_SHORTCUT,
1374         shortcutInfos_,
1375         JsonType::OBJECT,
1376         true,
1377         parseResult,
1378         ArrayType::NOT_ARRAY);
1379     GetValueIfFindKey<std::map<std::string, CommonEventInfo>>(jsonObject,
1380         jsonObjectEnd,
1381         MODULE_COMMON_EVENT,
1382         commonEvents_,
1383         JsonType::OBJECT,
1384         true,
1385         parseResult,
1386         ArrayType::NOT_ARRAY);
1387     GetValueIfFindKey<InstallMark>(jsonObject,
1388         jsonObjectEnd,
1389         INSTALL_MARK,
1390         mark_,
1391         JsonType::OBJECT,
1392         false,
1393         parseResult,
1394         ArrayType::NOT_ARRAY);
1395     int32_t isOldVersion = ERR_OK;
1396     GetValueIfFindKey<std::map<std::string, InnerBundleUserInfo>>(jsonObject,
1397         jsonObjectEnd,
1398         INNER_BUNDLE_USER_INFOS,
1399         innerBundleUserInfos_,
1400         JsonType::OBJECT,
1401         true,
1402         isOldVersion,
1403         ArrayType::NOT_ARRAY);
1404     if (parseResult == ERR_OK && isOldVersion == ERR_APPEXECFWK_PARSE_PROFILE_MISSING_PROP) {
1405         // To be compatible with the old database,
1406         // if the old data does not have bundleUserInfos,
1407         // the default user information needs to be constructed.
1408         BuildDefaultUserInfo();
1409     }
1410     GetValueIfFindKey<bool>(jsonObject,
1411         jsonObjectEnd,
1412         BUNDLE_IS_NEW_VERSION,
1413         isNewVersion_,
1414         JsonType::BOOLEAN,
1415         false,
1416         parseResult,
1417         ArrayType::NOT_ARRAY);
1418     GetValueIfFindKey<std::map<std::string, ExtensionAbilityInfo>>(jsonObject,
1419         jsonObjectEnd,
1420         BUNDLE_BASE_EXTENSION_INFOS,
1421         baseExtensionInfos_,
1422         JsonType::OBJECT,
1423         false,
1424         parseResult,
1425         ArrayType::NOT_ARRAY);
1426     GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
1427         jsonObjectEnd,
1428         BUNDLE_EXTENSION_SKILL_INFOS,
1429         extensionSkillInfos_,
1430         JsonType::OBJECT,
1431         false,
1432         parseResult,
1433         ArrayType::NOT_ARRAY);
1434     GetValueIfFindKey<std::map<std::string, ExtendResourceInfo>>(jsonObject,
1435         jsonObjectEnd,
1436         BUNDLE_EXTEND_RESOURCES,
1437         extendResourceInfos_,
1438         JsonType::OBJECT,
1439         false,
1440         parseResult,
1441         ArrayType::NOT_ARRAY);
1442     GetValueIfFindKey<std::string>(jsonObject,
1443         jsonObjectEnd,
1444         CUR_DYNAMIC_ICON_MODULE,
1445         curDynamicIconModule_,
1446         JsonType::STRING,
1447         false,
1448         parseResult,
1449         ArrayType::NOT_ARRAY);
1450     GetValueIfFindKey<BundlePackInfo>(jsonObject,
1451         jsonObjectEnd,
1452         BUNDLE_PACK_INFO,
1453         *bundlePackInfo_,
1454         JsonType::OBJECT,
1455         false,
1456         parseResult,
1457         ArrayType::NOT_ARRAY);
1458     GetValueIfFindKey<int>(jsonObject,
1459         jsonObjectEnd,
1460         APP_INDEX,
1461         appIndex_,
1462         JsonType::NUMBER,
1463         false,
1464         parseResult,
1465         ArrayType::NOT_ARRAY);
1466     GetValueIfFindKey<bool>(jsonObject,
1467         jsonObjectEnd,
1468         BUNDLE_IS_SANDBOX_APP,
1469         isSandboxApp_,
1470         JsonType::BOOLEAN,
1471         false,
1472         parseResult,
1473         ArrayType::NOT_ARRAY);
1474     GetValueIfFindKey<std::vector<HqfInfo>>(jsonObject,
1475         jsonObjectEnd,
1476         BUNDLE_HQF_INFOS,
1477         hqfInfos_,
1478         JsonType::ARRAY,
1479         false,
1480         parseResult,
1481         ArrayType::OBJECT);
1482     GetValueIfFindKey<std::vector<OverlayBundleInfo>>(jsonObject,
1483         jsonObjectEnd,
1484         OVERLAY_BUNDLE_INFO,
1485         overlayBundleInfo_,
1486         JsonType::ARRAY,
1487         false,
1488         parseResult,
1489         ArrayType::OBJECT);
1490     GetValueIfFindKey<int32_t>(jsonObject,
1491         jsonObjectEnd,
1492         OVERLAY_TYPE,
1493         overlayType_,
1494         JsonType::NUMBER,
1495         false,
1496         parseResult,
1497         ArrayType::NOT_ARRAY);
1498     GetValueIfFindKey<int32_t>(jsonObject,
1499         jsonObjectEnd,
1500         APPLY_QUICK_FIX_FREQUENCY,
1501         applyQuickFixFrequency_,
1502         JsonType::NUMBER,
1503         false,
1504         parseResult,
1505         ArrayType::NOT_ARRAY);
1506     GetValueIfFindKey<std::unordered_map<std::string, std::vector<DataGroupInfo>>>(jsonObject,
1507         jsonObjectEnd,
1508         DATA_GROUP_INFOS,
1509         dataGroupInfos_,
1510         JsonType::OBJECT,
1511         false,
1512         parseResult,
1513         ArrayType::NOT_ARRAY);
1514     GetValueIfFindKey<std::string>(jsonObject,
1515         jsonObjectEnd,
1516         DEVELOPER_ID,
1517         developerId_,
1518         JsonType::STRING,
1519         false,
1520         parseResult,
1521         ArrayType::NOT_ARRAY);
1522     GetValueIfFindKey<std::string>(jsonObject,
1523         jsonObjectEnd,
1524         ODID,
1525         odid_,
1526         JsonType::STRING,
1527         false,
1528         parseResult,
1529         ArrayType::NOT_ARRAY);
1530     GetValueIfFindKey<bool>(jsonObject,
1531         jsonObjectEnd,
1532         UNINSTALL_STATE,
1533         uninstallState_,
1534         JsonType::BOOLEAN,
1535         false,
1536         parseResult,
1537         ArrayType::NOT_ARRAY);
1538     if (parseResult != ERR_OK) {
1539         APP_LOGE("read InnerBundleInfo from database error code : %{public}d", parseResult);
1540     }
1541     return parseResult;
1542 }
1543 
BuildDefaultUserInfo()1544 void InnerBundleInfo::BuildDefaultUserInfo()
1545 {
1546     APP_LOGD("BuildDefaultUserInfo: bundleName: %{public}s",
1547         baseApplicationInfo_->bundleName.c_str());
1548     InnerBundleUserInfo defaultInnerBundleUserInfo;
1549     defaultInnerBundleUserInfo.bundleUserInfo.userId = GetUserId();
1550     defaultInnerBundleUserInfo.uid = uid_;
1551     defaultInnerBundleUserInfo.gids.emplace_back(gid_);
1552     defaultInnerBundleUserInfo.installTime = baseBundleInfo_->installTime;
1553     defaultInnerBundleUserInfo.updateTime = baseBundleInfo_->updateTime;
1554     defaultInnerBundleUserInfo.bundleName = baseApplicationInfo_->bundleName;
1555     defaultInnerBundleUserInfo.bundleUserInfo.enabled = baseApplicationInfo_->enabled;
1556     AddInnerBundleUserInfo(defaultInnerBundleUserInfo);
1557 }
1558 
FindHapModuleInfo(const std::string & modulePackage,int32_t userId,int32_t appIndex) const1559 std::optional<HapModuleInfo> InnerBundleInfo::FindHapModuleInfo(
1560     const std::string &modulePackage, int32_t userId, int32_t appIndex) const
1561 {
1562     auto it = innerModuleInfos_.find(modulePackage);
1563     if (it == innerModuleInfos_.end()) {
1564         APP_LOGE("not find module %{public}s", modulePackage.c_str());
1565         return std::nullopt;
1566     }
1567     HapModuleInfo hapInfo;
1568     hapInfo.name = it->second.name;
1569     hapInfo.package = it->second.modulePackage;
1570     hapInfo.moduleName = it->second.moduleName;
1571     hapInfo.description = it->second.description;
1572     hapInfo.descriptionId = it->second.descriptionId;
1573     hapInfo.label = it->second.label;
1574     hapInfo.labelId = it->second.labelId;
1575     hapInfo.iconPath = it->second.icon;
1576     hapInfo.iconId = it->second.iconId;
1577     hapInfo.mainAbility = it->second.mainAbility;
1578     hapInfo.srcPath = it->second.srcPath;
1579     hapInfo.hapPath = it->second.hapPath;
1580     hapInfo.supportedModes = baseApplicationInfo_->supportedModes;
1581     hapInfo.reqCapabilities = it->second.reqCapabilities;
1582     hapInfo.colorMode = it->second.colorMode;
1583     hapInfo.isRemovable = it->second.isRemovable;
1584     hapInfo.upgradeFlag = it->second.upgradeFlag;
1585     hapInfo.isLibIsolated = it->second.isLibIsolated;
1586     hapInfo.nativeLibraryPath = it->second.nativeLibraryPath;
1587     hapInfo.cpuAbi = it->second.cpuAbi;
1588 
1589     hapInfo.bundleName = baseApplicationInfo_->bundleName;
1590     hapInfo.mainElementName = it->second.mainAbility;
1591     hapInfo.pages = it->second.pages;
1592     hapInfo.process = it->second.process;
1593     hapInfo.resourcePath = it->second.moduleResPath;
1594     hapInfo.srcEntrance = it->second.srcEntrance;
1595     hapInfo.uiSyntax = it->second.uiSyntax;
1596     hapInfo.virtualMachine = it->second.virtualMachine;
1597     hapInfo.deliveryWithInstall = it->second.distro.deliveryWithInstall;
1598     hapInfo.installationFree = it->second.distro.installationFree;
1599     hapInfo.isModuleJson = it->second.isModuleJson;
1600     hapInfo.isStageBasedModel = it->second.isStageBasedModel;
1601     hapInfo.deviceTypes = it->second.deviceTypes;
1602     hapInfo.appStartup = it->second.appStartup;
1603     std::string moduleType = it->second.distro.moduleType;
1604     if (moduleType == Profile::MODULE_TYPE_ENTRY) {
1605         hapInfo.moduleType = ModuleType::ENTRY;
1606     } else if (moduleType == Profile::MODULE_TYPE_FEATURE) {
1607         hapInfo.moduleType = ModuleType::FEATURE;
1608     } else if (moduleType == Profile::MODULE_TYPE_SHARED) {
1609         hapInfo.moduleType = ModuleType::SHARED;
1610     } else {
1611         hapInfo.moduleType = ModuleType::UNKNOWN;
1612     }
1613     std::string key;
1614     key.append(".").append(modulePackage).append(".");
1615     for (const auto &extension : baseExtensionInfos_) {
1616         if ((extension.first.find(key) != std::string::npos) && (extension.second.moduleName == hapInfo.moduleName)) {
1617             hapInfo.extensionInfos.emplace_back(extension.second);
1618         }
1619     }
1620     hapInfo.metadata = it->second.metadata;
1621     for (auto &ability : baseAbilityInfos_) {
1622         if (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1623             continue;
1624         }
1625         if ((ability.first.find(key) != std::string::npos) && (ability.second.moduleName == hapInfo.moduleName)) {
1626             auto &abilityInfo = hapInfo.abilityInfos.emplace_back(ability.second);
1627             GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1628                 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1629                 abilityInfo.applicationInfo, appIndex);
1630         }
1631     }
1632     hapInfo.dependencies = it->second.dependencies;
1633     hapInfo.compileMode = ConvertCompileMode(it->second.compileMode);
1634     for (const auto &hqf : hqfInfos_) {
1635         if (hqf.moduleName == it->second.moduleName) {
1636             hapInfo.hqfInfo = hqf;
1637             break;
1638         }
1639     }
1640     for (const auto &item : it->second.preloads) {
1641         PreloadItem preload(item);
1642         hapInfo.preloads.emplace_back(preload);
1643     }
1644     for (const auto &item : it->second.proxyDatas) {
1645         ProxyData proxyData(item);
1646         hapInfo.proxyDatas.emplace_back(proxyData);
1647     }
1648     hapInfo.buildHash = it->second.buildHash;
1649     hapInfo.isolationMode = GetIsolationMode(it->second.isolationMode);
1650     hapInfo.compressNativeLibs = it->second.compressNativeLibs;
1651     hapInfo.nativeLibraryFileNames = it->second.nativeLibraryFileNames;
1652     hapInfo.aotCompileStatus = it->second.aotCompileStatus;
1653     hapInfo.fileContextMenu = it->second.fileContextMenu;
1654     hapInfo.routerMap = it->second.routerMap;
1655     hapInfo.appEnvironments = it->second.appEnvironments;
1656     hapInfo.packageName = it->second.packageName;
1657     return hapInfo;
1658 }
1659 
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,int32_t userId) const1660 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfo(
1661     const std::string &moduleName,
1662     const std::string &abilityName,
1663     int32_t userId) const
1664 {
1665     for (const auto &ability : baseAbilityInfos_) {
1666         auto abilityInfo = ability.second;
1667         if ((abilityInfo.name == abilityName) &&
1668             (moduleName.empty() || (abilityInfo.moduleName == moduleName))) {
1669             GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1670                 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1671                 abilityInfo.applicationInfo);
1672             return abilityInfo;
1673         }
1674     }
1675 
1676     return std::nullopt;
1677 }
1678 
FindAbilityInfoV9(const std::string & moduleName,const std::string & abilityName) const1679 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfoV9(
1680     const std::string &moduleName, const std::string &abilityName) const
1681 {
1682     for (const auto &ability : baseAbilityInfos_) {
1683         auto abilityInfo = ability.second;
1684         if ((abilityInfo.name == abilityName) &&
1685             (moduleName.empty() || (abilityInfo.moduleName == moduleName))) {
1686             return abilityInfo;
1687         }
1688     }
1689     APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s",
1690         GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str());
1691     return std::nullopt;
1692 }
1693 
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,AbilityInfo & info) const1694 ErrCode InnerBundleInfo::FindAbilityInfo(
1695     const std::string &moduleName, const std::string &abilityName, AbilityInfo &info) const
1696 {
1697     bool isModuleFind = false;
1698     for (const auto &ability : baseAbilityInfos_) {
1699         auto abilityInfo = ability.second;
1700         if ((abilityInfo.moduleName == moduleName)) {
1701             isModuleFind = true;
1702             if (abilityInfo.name == abilityName) {
1703                 info = abilityInfo;
1704                 return ERR_OK;
1705             }
1706         }
1707     }
1708     APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s, isModuleFind:%{public}d",
1709         GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str(), isModuleFind);
1710     if (isModuleFind) {
1711         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
1712     } else {
1713         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
1714     }
1715 }
1716 
FindAbilityInfos(int32_t userId) const1717 std::optional<std::vector<AbilityInfo>> InnerBundleInfo::FindAbilityInfos(int32_t userId) const
1718 {
1719     if (!HasInnerBundleUserInfo(userId)) {
1720         return std::nullopt;
1721     }
1722 
1723     std::vector<AbilityInfo> abilitys;
1724     for (const auto &ability : baseAbilityInfos_) {
1725         if (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1726             continue;
1727         }
1728         auto abilityInfo = ability.second;
1729         GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1730             ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1731             abilityInfo.applicationInfo);
1732         abilitys.emplace_back(abilityInfo);
1733     }
1734 
1735     if (abilitys.empty()) {
1736         return std::nullopt;
1737     }
1738     return abilitys;
1739 }
1740 
FindAbilityInfo(const std::string continueType,int32_t userId) const1741 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfo(const std::string continueType, int32_t userId) const
1742 {
1743     for (const auto &ability : baseAbilityInfos_) {
1744         AbilityInfo abilityInfo = ability.second;
1745         std::vector<std::string> continueTypes = abilityInfo.continueType;
1746         auto item = std::find(continueTypes.begin(), continueTypes.end(), continueType);
1747         if (item != continueTypes.end()) {
1748             GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1749                 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1750                 abilityInfo.applicationInfo);
1751             return abilityInfo;
1752         }
1753     }
1754     return std::nullopt;
1755 }
1756 
FindExtensionInfo(const std::string & moduleName,const std::string & extensionName) const1757 std::optional<ExtensionAbilityInfo> InnerBundleInfo::FindExtensionInfo(
1758     const std::string &moduleName, const std::string &extensionName) const
1759 {
1760     for (const auto &extension : baseExtensionInfos_) {
1761         if ((extension.second.name == extensionName) &&
1762             (moduleName.empty() || (extension.second.moduleName == moduleName))) {
1763             return extension.second;
1764         }
1765     }
1766 
1767     return std::nullopt;
1768 }
1769 
FindExtensionInfos() const1770 std::optional<std::vector<ExtensionAbilityInfo>> InnerBundleInfo::FindExtensionInfos() const
1771 {
1772     std::vector<ExtensionAbilityInfo> extensions;
1773     for (const auto &extension : baseExtensionInfos_) {
1774         extensions.emplace_back(extension.second);
1775     }
1776 
1777     if (extensions.empty()) {
1778         return std::nullopt;
1779     }
1780 
1781     return extensions;
1782 }
1783 
AddModuleInfo(const InnerBundleInfo & newInfo)1784 bool InnerBundleInfo::AddModuleInfo(const InnerBundleInfo &newInfo)
1785 {
1786     if (newInfo.currentPackage_.empty()) {
1787         APP_LOGE("current package is empty");
1788         return false;
1789     }
1790     if (FindModule(newInfo.currentPackage_)) {
1791         APP_LOGE("current package %{public}s exist", currentPackage_.c_str());
1792         return false;
1793     }
1794     AddInnerModuleInfo(newInfo.innerModuleInfos_);
1795     AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
1796     AddModuleSkillInfo(newInfo.skillInfos_);
1797     AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
1798     AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
1799     AddModuleFormInfo(newInfo.formInfos_);
1800     AddModuleShortcutInfo(newInfo.shortcutInfos_);
1801     AddModuleCommonEvent(newInfo.commonEvents_);
1802     UpdateIsCompressNativeLibs();
1803     return true;
1804 }
1805 
UpdateBaseBundleInfo(const BundleInfo & bundleInfo,bool isEntry)1806 void InnerBundleInfo::UpdateBaseBundleInfo(const BundleInfo &bundleInfo, bool isEntry)
1807 {
1808     baseBundleInfo_->name = bundleInfo.name;
1809 
1810     baseBundleInfo_->versionCode = bundleInfo.versionCode;
1811     baseBundleInfo_->versionName = bundleInfo.versionName;
1812     baseBundleInfo_->minCompatibleVersionCode = bundleInfo.minCompatibleVersionCode;
1813 
1814     baseBundleInfo_->compatibleVersion = bundleInfo.compatibleVersion;
1815     baseBundleInfo_->targetVersion = bundleInfo.targetVersion;
1816 
1817     baseBundleInfo_->isKeepAlive = bundleInfo.isKeepAlive;
1818     baseBundleInfo_->singleton = bundleInfo.singleton;
1819     if (!baseBundleInfo_->isPreInstallApp) {
1820         baseBundleInfo_->isPreInstallApp = bundleInfo.isPreInstallApp;
1821     }
1822 
1823     baseBundleInfo_->vendor = bundleInfo.vendor;
1824     if (!baseBundleInfo_->isNativeApp) {
1825         baseBundleInfo_->isNativeApp = bundleInfo.isNativeApp;
1826     }
1827 
1828     if (isEntry) {
1829         baseBundleInfo_->mainEntry = bundleInfo.mainEntry;
1830         baseBundleInfo_->entryModuleName = bundleInfo.entryModuleName;
1831     }
1832 }
1833 
UpdateBaseApplicationInfo(const ApplicationInfo & applicationInfo,bool isEntry)1834 void InnerBundleInfo::UpdateBaseApplicationInfo(
1835     const ApplicationInfo &applicationInfo, bool isEntry)
1836 {
1837     baseApplicationInfo_->name = applicationInfo.name;
1838     baseApplicationInfo_->bundleName = applicationInfo.bundleName;
1839 
1840     baseApplicationInfo_->versionCode = applicationInfo.versionCode;
1841     baseApplicationInfo_->versionName = applicationInfo.versionName;
1842     baseApplicationInfo_->minCompatibleVersionCode = applicationInfo.minCompatibleVersionCode;
1843 
1844     baseApplicationInfo_->apiCompatibleVersion = applicationInfo.apiCompatibleVersion;
1845     baseApplicationInfo_->apiTargetVersion = applicationInfo.apiTargetVersion;
1846 
1847     baseApplicationInfo_->iconPath = applicationInfo.iconPath;
1848     baseApplicationInfo_->iconId = applicationInfo.iconId;
1849     baseApplicationInfo_->label = applicationInfo.label;
1850     baseApplicationInfo_->labelId = applicationInfo.labelId;
1851     baseApplicationInfo_->description = applicationInfo.description;
1852     baseApplicationInfo_->descriptionId = applicationInfo.descriptionId;
1853     baseApplicationInfo_->iconResource = applicationInfo.iconResource;
1854     baseApplicationInfo_->labelResource = applicationInfo.labelResource;
1855     baseApplicationInfo_->descriptionResource = applicationInfo.descriptionResource;
1856     baseApplicationInfo_->singleton = applicationInfo.singleton;
1857     baseApplicationInfo_->userDataClearable = applicationInfo.userDataClearable;
1858     baseApplicationInfo_->accessible = applicationInfo.accessible;
1859     baseApplicationInfo_->cloudFileSyncEnabled = applicationInfo.cloudFileSyncEnabled;
1860 
1861     if (!baseApplicationInfo_->isSystemApp) {
1862         baseApplicationInfo_->isSystemApp = applicationInfo.isSystemApp;
1863     }
1864     if (!baseApplicationInfo_->isLauncherApp) {
1865         baseApplicationInfo_->isLauncherApp = applicationInfo.isLauncherApp;
1866     }
1867 
1868     baseApplicationInfo_->deviceId = applicationInfo.deviceId;
1869     baseApplicationInfo_->distributedNotificationEnabled = applicationInfo.distributedNotificationEnabled;
1870     baseApplicationInfo_->entityType = applicationInfo.entityType;
1871     baseApplicationInfo_->process = applicationInfo.process;
1872     baseApplicationInfo_->supportedModes = applicationInfo.supportedModes;
1873     baseApplicationInfo_->vendor = applicationInfo.vendor;
1874     baseApplicationInfo_->appDistributionType = applicationInfo.appDistributionType;
1875     baseApplicationInfo_->appProvisionType = applicationInfo.appProvisionType;
1876     baseApplicationInfo_->formVisibleNotify = applicationInfo.formVisibleNotify;
1877     baseApplicationInfo_->needAppDetail = applicationInfo.needAppDetail;
1878     baseApplicationInfo_->appDetailAbilityLibraryPath = applicationInfo.appDetailAbilityLibraryPath;
1879     baseApplicationInfo_->bundleType = applicationInfo.bundleType;
1880     UpdatePrivilegeCapability(applicationInfo);
1881     SetHideDesktopIcon(applicationInfo.hideDesktopIcon);
1882 #ifdef BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION
1883     baseApplicationInfo_->targetBundleName = applicationInfo.targetBundleName;
1884     baseApplicationInfo_->targetPriority = applicationInfo.targetPriority;
1885 #endif
1886     UpdateDebug(applicationInfo.debug, isEntry);
1887     baseApplicationInfo_->organization = applicationInfo.organization;
1888     baseApplicationInfo_->multiProjects = applicationInfo.multiProjects;
1889     baseApplicationInfo_->appEnvironments = applicationInfo.appEnvironments;
1890     baseApplicationInfo_->maxChildProcess = applicationInfo.maxChildProcess;
1891     baseApplicationInfo_->installSource = applicationInfo.installSource;
1892     baseApplicationInfo_->configuration = applicationInfo.configuration;
1893 }
1894 
GetApplicationEnabledV9(int32_t userId,bool & isEnabled,int32_t appIndex) const1895 ErrCode InnerBundleInfo::GetApplicationEnabledV9(int32_t userId, bool &isEnabled, int32_t appIndex) const
1896 {
1897     InnerBundleUserInfo innerBundleUserInfo;
1898     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1899         APP_LOGD("can not find bundleUserInfo in userId: %{public}d when GetApplicationEnabled", userId);
1900         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1901     }
1902     if (appIndex == 0) {
1903         isEnabled = innerBundleUserInfo.bundleUserInfo.enabled;
1904         PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1905             innerBundleUserInfo.bundleUserInfo.setEnabledCaller);
1906         return ERR_OK;
1907     } else if (appIndex > 0 && appIndex <= Constants::INITIAL_SANDBOX_APP_INDEX) {
1908         const std::map<std::string, InnerBundleCloneInfo> mpCloneInfos = innerBundleUserInfo.cloneInfos;
1909         std::string key = InnerBundleUserInfo::AppIndexToKey(appIndex);
1910         if (mpCloneInfos.find(key) == mpCloneInfos.end()) {
1911             return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
1912         }
1913         isEnabled = mpCloneInfos.at(key).enabled;
1914         PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1915             mpCloneInfos.at(key).setEnabledCaller);
1916         return ERR_OK;
1917     } else {
1918         return ERR_APPEXECFWK_APP_INDEX_OUT_OF_RANGE;
1919     }
1920 }
1921 
UpdateAppDetailAbilityAttrs()1922 void InnerBundleInfo::UpdateAppDetailAbilityAttrs()
1923 {
1924     if (IsExistLauncherAbility()) {
1925         baseApplicationInfo_->needAppDetail = false;
1926         baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
1927     }
1928     for (auto iter = baseAbilityInfos_.begin(); iter != baseAbilityInfos_.end(); ++iter) {
1929         if (iter->second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1930             baseAbilityInfos_.erase(iter);
1931             return;
1932         }
1933     }
1934 }
1935 
IsHideDesktopIcon() const1936 bool InnerBundleInfo::IsHideDesktopIcon() const
1937 {
1938     return baseApplicationInfo_->hideDesktopIcon ? true : !IsExistLauncherAbility();
1939 }
1940 
IsExistLauncherAbility() const1941 bool InnerBundleInfo::IsExistLauncherAbility() const
1942 {
1943     bool isExistLauncherAbility = false;
1944     OHOS::AAFwk::Want want;
1945     want.SetAction(OHOS::AAFwk::Want::ACTION_HOME);
1946     want.AddEntity(OHOS::AAFwk::Want::ENTITY_HOME);
1947     for (const auto& abilityInfoPair : baseAbilityInfos_) {
1948         auto skillsPair = skillInfos_.find(abilityInfoPair.first);
1949         if (skillsPair == skillInfos_.end()) {
1950             continue;
1951         }
1952         for (const Skill& skill : skillsPair->second) {
1953             if (skill.MatchLauncher(want) && (abilityInfoPair.second.type == AbilityType::PAGE)) {
1954                 isExistLauncherAbility = true;
1955                 break;
1956             }
1957         }
1958     }
1959     return isExistLauncherAbility;
1960 }
1961 
UpdateNativeLibAttrs(const ApplicationInfo & applicationInfo)1962 void InnerBundleInfo::UpdateNativeLibAttrs(const ApplicationInfo &applicationInfo)
1963 {
1964     baseApplicationInfo_->cpuAbi = applicationInfo.cpuAbi;
1965     baseApplicationInfo_->nativeLibraryPath = applicationInfo.nativeLibraryPath;
1966 }
1967 
UpdateArkNativeAttrs(const ApplicationInfo & applicationInfo)1968 void InnerBundleInfo::UpdateArkNativeAttrs(const ApplicationInfo &applicationInfo)
1969 {
1970     baseApplicationInfo_->arkNativeFileAbi = applicationInfo.arkNativeFileAbi;
1971     baseApplicationInfo_->arkNativeFilePath = applicationInfo.arkNativeFilePath;
1972 }
1973 
UpdatePrivilegeCapability(const ApplicationInfo & applicationInfo)1974 void InnerBundleInfo::UpdatePrivilegeCapability(const ApplicationInfo &applicationInfo)
1975 {
1976     SetKeepAlive(applicationInfo.keepAlive);
1977     baseApplicationInfo_->runningResourcesApply = applicationInfo.runningResourcesApply;
1978     baseApplicationInfo_->associatedWakeUp = applicationInfo.associatedWakeUp;
1979     SetAllowCommonEvent(applicationInfo.allowCommonEvent);
1980     SetAllowAppRunWhenDeviceFirstLocked(applicationInfo.allowAppRunWhenDeviceFirstLocked);
1981     baseApplicationInfo_->resourcesApply = applicationInfo.resourcesApply;
1982     baseApplicationInfo_->allowEnableNotification = applicationInfo.allowEnableNotification;
1983     if (applicationInfo.hideDesktopIcon) {
1984         SetHideDesktopIcon(true);
1985     }
1986 }
1987 
UpdateRemovable(bool isPreInstall,bool removable)1988 void InnerBundleInfo::UpdateRemovable(bool isPreInstall, bool removable)
1989 {
1990 #ifdef USE_PRE_BUNDLE_PROFILE
1991     if (!isPreInstall) {
1992         return;
1993     }
1994 #endif
1995 
1996     baseApplicationInfo_->removable = removable;
1997 }
1998 
UpdateModuleInfo(const InnerBundleInfo & newInfo)1999 void InnerBundleInfo::UpdateModuleInfo(const InnerBundleInfo &newInfo)
2000 {
2001     if (newInfo.currentPackage_.empty()) {
2002         APP_LOGE("no package in new info");
2003         return;
2004     }
2005 
2006     RemoveModuleInfo(newInfo.currentPackage_);
2007     AddInnerModuleInfo(newInfo.innerModuleInfos_);
2008     AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
2009     AddModuleSkillInfo(newInfo.skillInfos_);
2010     AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
2011     AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
2012     AddModuleFormInfo(newInfo.formInfos_);
2013     AddModuleShortcutInfo(newInfo.shortcutInfos_);
2014     AddModuleCommonEvent(newInfo.commonEvents_);
2015     UpdateIsCompressNativeLibs();
2016 }
2017 
GetMaxVerBaseSharedBundleInfo(const std::string & moduleName,BaseSharedBundleInfo & baseSharedBundleInfo) const2018 bool InnerBundleInfo::GetMaxVerBaseSharedBundleInfo(const std::string &moduleName,
2019     BaseSharedBundleInfo &baseSharedBundleInfo) const
2020 {
2021     auto it = innerSharedModuleInfos_.find(moduleName);
2022     if (it == innerSharedModuleInfos_.end()) {
2023         APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2024         return false;
2025     }
2026     auto sharedModuleInfoVector = it->second;
2027     if (sharedModuleInfoVector.empty()) {
2028         APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2029         return false;
2030     }
2031     InnerModuleInfo innerModuleInfo = sharedModuleInfoVector.front();
2032     if (innerModuleInfo.bundleType != BundleType::SHARED) {
2033         APP_LOGE("GetMaxVerBaseSharedBundleInfo failed, bundleType is invalid");
2034         return false;
2035     }
2036     baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2037     baseSharedBundleInfo.moduleName = innerModuleInfo.moduleName;
2038     baseSharedBundleInfo.versionCode = innerModuleInfo.versionCode;
2039     baseSharedBundleInfo.nativeLibraryPath = innerModuleInfo.nativeLibraryPath;
2040     baseSharedBundleInfo.hapPath = innerModuleInfo.hapPath;
2041     baseSharedBundleInfo.compressNativeLibs = innerModuleInfo.compressNativeLibs;
2042     baseSharedBundleInfo.nativeLibraryFileNames = innerModuleInfo.nativeLibraryFileNames;
2043     return true;
2044 }
2045 
GetBaseSharedBundleInfo(const std::string & moduleName,uint32_t versionCode,BaseSharedBundleInfo & baseSharedBundleInfo) const2046 bool InnerBundleInfo::GetBaseSharedBundleInfo(const std::string &moduleName, uint32_t versionCode,
2047     BaseSharedBundleInfo &baseSharedBundleInfo) const
2048 {
2049     auto it = innerSharedModuleInfos_.find(moduleName);
2050     if (it == innerSharedModuleInfos_.end()) {
2051         APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2052         return false;
2053     }
2054     auto sharedModuleInfoVector = it->second;
2055     if (sharedModuleInfoVector.empty()) {
2056         APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2057         return false;
2058     }
2059     for (const auto &item : sharedModuleInfoVector) {
2060         if (item.bundleType != BundleType::SHARED) {
2061             APP_LOGE("GetBaseSharedBundleInfo failed, bundleType is invalid");
2062             return false;
2063         }
2064         if (item.versionCode == versionCode) {
2065             baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2066             baseSharedBundleInfo.moduleName = item.moduleName;
2067             baseSharedBundleInfo.versionCode = item.versionCode;
2068             baseSharedBundleInfo.nativeLibraryPath = item.nativeLibraryPath;
2069             baseSharedBundleInfo.hapPath = item.hapPath;
2070             baseSharedBundleInfo.compressNativeLibs = item.compressNativeLibs;
2071             baseSharedBundleInfo.nativeLibraryFileNames = item.nativeLibraryFileNames;
2072             return true;
2073         }
2074     }
2075     APP_LOGE("GetBaseSharedBundleInfo failed, the version(%{public}d) not exists for this module(%{public}s)",
2076         versionCode, moduleName.c_str());
2077     return false;
2078 }
2079 
InsertInnerSharedModuleInfo(const std::string & moduleName,const InnerModuleInfo & innerModuleInfo)2080 void InnerBundleInfo::InsertInnerSharedModuleInfo(const std::string &moduleName,
2081     const InnerModuleInfo &innerModuleInfo)
2082 {
2083     auto iterator = innerSharedModuleInfos_.find(moduleName);
2084     if (iterator != innerSharedModuleInfos_.end()) {
2085         auto innerModuleInfoVector = iterator->second;
2086         bool insertFlag = false;
2087         for (unsigned long i = 0; i < innerModuleInfoVector.size(); i++) {
2088             if (innerModuleInfo.versionCode == innerModuleInfoVector.at(i).versionCode) {
2089                 // if the inserted versionCode same as the existing one, replace old innerModuleInfo.
2090                 innerModuleInfoVector.at(i) = innerModuleInfo;
2091                 insertFlag = true;
2092                 break;
2093             } else if (innerModuleInfo.versionCode > innerModuleInfoVector.at(i).versionCode) {
2094                 // if the inserted versionCode bigger then the existing one, insert the specified location.
2095                 innerModuleInfoVector.emplace(innerModuleInfoVector.begin() + i, innerModuleInfo);
2096                 insertFlag = true;
2097                 break;
2098             } else {
2099                 continue;
2100             }
2101         }
2102         if (!insertFlag) {
2103             // insert innerModuleInfo in last location.
2104             innerModuleInfoVector.emplace(innerModuleInfoVector.end(), innerModuleInfo);
2105         }
2106         innerSharedModuleInfos_[moduleName] = innerModuleInfoVector;
2107     } else {
2108         std::vector<InnerModuleInfo> newInnerModuleInfoVector;
2109         newInnerModuleInfoVector.emplace_back(innerModuleInfo);
2110         innerSharedModuleInfos_.try_emplace(moduleName, newInnerModuleInfoVector);
2111     }
2112 }
2113 
SetSharedModuleNativeLibraryPath(const std::string & nativeLibraryPath)2114 void InnerBundleInfo::SetSharedModuleNativeLibraryPath(const std::string &nativeLibraryPath)
2115 {
2116     auto sharedModuleInfoIterator = innerSharedModuleInfos_.find(currentPackage_);
2117     auto moduleInfoIterator = innerModuleInfos_.find(currentPackage_);
2118     if ((sharedModuleInfoIterator == innerSharedModuleInfos_.end()) ||
2119         (moduleInfoIterator == innerModuleInfos_.end())) {
2120         APP_LOGE("The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
2121         return;
2122     }
2123     auto &innerModuleInfoVector = sharedModuleInfoIterator->second;
2124     for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
2125         if (iter->versionCode == moduleInfoIterator->second.versionCode) {
2126             iter->nativeLibraryPath = nativeLibraryPath;
2127             return;
2128         }
2129     }
2130 }
2131 
GetSharedBundleInfo(SharedBundleInfo & sharedBundleInfo) const2132 bool InnerBundleInfo::GetSharedBundleInfo(SharedBundleInfo &sharedBundleInfo) const
2133 {
2134     sharedBundleInfo.name = GetBundleName();
2135     sharedBundleInfo.compatiblePolicy = CompatiblePolicy::BACKWARD_COMPATIBILITY;
2136     std::vector<SharedModuleInfo> sharedModuleInfos;
2137     for (const auto &infoVector : innerSharedModuleInfos_) {
2138         for (const auto &info : infoVector.second) {
2139             SharedModuleInfo sharedModuleInfo;
2140             sharedModuleInfo.name = info.name;
2141             sharedModuleInfo.versionCode = info.versionCode;
2142             sharedModuleInfo.versionName = info.versionName;
2143             sharedModuleInfo.description = info.description;
2144             sharedModuleInfo.descriptionId = info.descriptionId;
2145             sharedModuleInfo.compressNativeLibs = info.compressNativeLibs;
2146             sharedModuleInfo.hapPath = info.hapPath;
2147             sharedModuleInfo.cpuAbi = info.cpuAbi;
2148             sharedModuleInfo.nativeLibraryPath = info.nativeLibraryPath;
2149             sharedModuleInfo.nativeLibraryFileNames = info.nativeLibraryFileNames;
2150             sharedModuleInfos.emplace_back(sharedModuleInfo);
2151         }
2152     }
2153     sharedBundleInfo.sharedModuleInfos = sharedModuleInfos;
2154     return true;
2155 }
2156 
GetSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2157 bool InnerBundleInfo::GetSharedDependencies(const std::string &moduleName,
2158     std::vector<Dependency> &dependencies) const
2159 {
2160     if (innerModuleInfos_.find(moduleName) != innerModuleInfos_.end()) {
2161         dependencies = innerModuleInfos_.at(moduleName).dependencies;
2162         return true;
2163     }
2164     APP_LOGE("GetSharedDependencies not find module %{public}s", moduleName.c_str());
2165     return false;
2166 }
2167 
GetAllSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2168 bool InnerBundleInfo::GetAllSharedDependencies(const std::string &moduleName,
2169     std::vector<Dependency> &dependencies) const
2170 {
2171     if (!GetSharedDependencies(moduleName, dependencies)) {
2172         return false;
2173     }
2174     std::deque<Dependency> dependenciesDeque;
2175     std::copy(dependencies.begin(), dependencies.end(), std::back_inserter(dependenciesDeque));
2176     dependencies.clear();
2177     while (!dependenciesDeque.empty()) {
2178         bool isAdd = true;
2179         Dependency itemDependency = dependenciesDeque.front();
2180         dependenciesDeque.pop_front();
2181         for (const auto &item : dependencies) {
2182             if (item.bundleName == itemDependency.bundleName && item.moduleName == itemDependency.moduleName &&
2183                 item.versionCode == itemDependency.versionCode) {
2184                 isAdd = false;
2185                 break;
2186             }
2187         }
2188         if (isAdd) {
2189             dependencies.push_back(itemDependency);
2190             std::vector<Dependency> tempDependencies;
2191             if (GetSharedDependencies(itemDependency.moduleName, tempDependencies)) {
2192                 std::copy(tempDependencies.begin(), tempDependencies.end(), std::back_inserter(dependenciesDeque));
2193             }
2194         }
2195     }
2196     return true;
2197 }
2198 
RemoveModuleInfo(const std::string & modulePackage)2199 void InnerBundleInfo::RemoveModuleInfo(const std::string &modulePackage)
2200 {
2201     auto it = innerModuleInfos_.find(modulePackage);
2202     if (it == innerModuleInfos_.end()) {
2203         APP_LOGE("The module(%{public}s) infomation not exist", modulePackage.c_str());
2204         return;
2205     }
2206 
2207     auto oldModuleInfo = it->second;
2208     if (oldModuleInfo.isEntry) {
2209         baseBundleInfo_->mainEntry.clear();
2210         baseBundleInfo_->entryModuleName.clear();
2211     }
2212     innerModuleInfos_.erase(it);
2213     std::string key;
2214     key.append(".").append(modulePackage).append(".");
2215     for (auto iter = shortcutInfos_.begin(); iter != shortcutInfos_.end();) {
2216         if (iter->first.find(key) != std::string::npos) {
2217             shortcutInfos_.erase(iter++);
2218         } else {
2219             ++iter;
2220         }
2221     }
2222 
2223     for (auto iter = commonEvents_.begin(); iter != commonEvents_.end();) {
2224         if (iter->first.find(key) != std::string::npos) {
2225             commonEvents_.erase(iter++);
2226         } else {
2227             ++iter;
2228         }
2229     }
2230 
2231     // delete old abilityInfos
2232     for (auto abilityKey : oldModuleInfo.abilityKeys) {
2233         auto abilityItem = baseAbilityInfos_.find(abilityKey);
2234         if (abilityItem == baseAbilityInfos_.end()) {
2235             continue;
2236         }
2237 
2238         baseAbilityInfos_.erase(abilityItem);
2239         formInfos_.erase(abilityKey);
2240     }
2241 
2242     // delete old skillInfos
2243     for (auto skillKey : oldModuleInfo.skillKeys) {
2244         auto skillItem = skillInfos_.find(skillKey);
2245         if (skillItem == skillInfos_.end()) {
2246             continue;
2247         }
2248 
2249         skillInfos_.erase(skillItem);
2250     }
2251 
2252     // delete old extensionInfos
2253     for (auto extensionKey : oldModuleInfo.extensionKeys) {
2254         auto extensionItem = baseExtensionInfos_.find(extensionKey);
2255         if (extensionItem == baseExtensionInfos_.end()) {
2256             continue;
2257         }
2258 
2259         baseExtensionInfos_.erase(extensionItem);
2260     }
2261 
2262     // delete old extensionSkillInfos
2263     for (auto extensionSkillKey : oldModuleInfo.extensionSkillKeys) {
2264         auto extensionSkillItem = extensionSkillInfos_.find(extensionSkillKey);
2265         if (extensionSkillItem == extensionSkillInfos_.end()) {
2266             continue;
2267         }
2268 
2269         extensionSkillInfos_.erase(extensionSkillItem);
2270     }
2271 }
2272 
ToString() const2273 std::string InnerBundleInfo::ToString() const
2274 {
2275     nlohmann::json j;
2276     ToJson(j);
2277     return j.dump();
2278 }
2279 
GetApplicationInfo(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2280 void InnerBundleInfo::GetApplicationInfo(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2281     int32_t appIndex) const
2282 {
2283     InnerBundleUserInfo innerBundleUserInfo;
2284     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2285         LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2286         return;
2287     }
2288 
2289     if (baseApplicationInfo_ == nullptr) {
2290         LOG_E(BMS_TAG_QUERY, "baseApplicationInfo_ is nullptr");
2291         return;
2292     }
2293     appInfo = *baseApplicationInfo_;
2294     if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2295         return;
2296     }
2297 
2298     for (const auto &info : innerModuleInfos_) {
2299         bool deCompress = info.second.hapPath.empty();
2300         ModuleInfo moduleInfo;
2301         moduleInfo.moduleName = info.second.moduleName;
2302         if (deCompress) {
2303             moduleInfo.moduleSourceDir = info.second.modulePath;
2304             appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2305         }
2306         if (info.second.hnpPackages.size() > 0) {
2307             appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2308         }
2309         moduleInfo.preloads = info.second.preloads;
2310         appInfo.moduleInfos.emplace_back(moduleInfo);
2311         if (deCompress && info.second.isEntry) {
2312             appInfo.entryDir = info.second.modulePath;
2313         }
2314         if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_PERMISSION) ==
2315             GET_APPLICATION_INFO_WITH_PERMISSION) {
2316             for (const auto &item : info.second.requestPermissions) {
2317                 appInfo.permissions.push_back(item.name);
2318             }
2319         }
2320         if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_METADATA) == GET_APPLICATION_INFO_WITH_METADATA) {
2321             bool isModuleJson = info.second.isModuleJson;
2322             if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2323                 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2324             }
2325             if (isModuleJson && info.second.metadata.size() > 0) {
2326                 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2327             }
2328         }
2329         if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) !=
2330             GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) {
2331             appInfo.fingerprint.clear();
2332         }
2333     }
2334     if (!appInfo.permissions.empty()) {
2335         RemoveDuplicateName(appInfo.permissions);
2336     }
2337     appInfo.appIndex = appIndex;
2338     // The label and icon are first used under main ability
2339     AdaptMainLauncherResourceInfo(appInfo);
2340 }
2341 
GetApplicationInfoV9(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2342 ErrCode InnerBundleInfo::GetApplicationInfoV9(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2343     int32_t appIndex) const
2344 {
2345     InnerBundleUserInfo innerBundleUserInfo;
2346     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2347         LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2348         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2349     }
2350 
2351     appInfo = *baseApplicationInfo_;
2352     if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2353         return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
2354     }
2355 
2356     for (const auto &info : innerModuleInfos_) {
2357         bool deCompress = info.second.hapPath.empty();
2358         ModuleInfo moduleInfo;
2359         moduleInfo.moduleName = info.second.moduleName;
2360         if (deCompress) {
2361             moduleInfo.moduleSourceDir = info.second.modulePath;
2362             appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2363         }
2364         if (info.second.hnpPackages.size() > 0) {
2365             appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2366         }
2367         moduleInfo.preloads = info.second.preloads;
2368         appInfo.moduleInfos.emplace_back(moduleInfo);
2369         if (deCompress && info.second.isEntry) {
2370             appInfo.entryDir = info.second.modulePath;
2371         }
2372         if ((static_cast<uint32_t>(flags) &
2373             static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) ==
2374             static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) {
2375             for (const auto &item : info.second.requestPermissions) {
2376                 appInfo.permissions.push_back(item.name);
2377             }
2378         }
2379         if ((static_cast<uint32_t>(flags) &
2380             static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) ==
2381             static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) {
2382             bool isModuleJson = info.second.isModuleJson;
2383             if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2384                 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2385             }
2386             if (isModuleJson && info.second.metadata.size() > 0) {
2387                 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2388             }
2389         }
2390     }
2391     if (!appInfo.permissions.empty()) {
2392         RemoveDuplicateName(appInfo.permissions);
2393     }
2394     // The label and icon are first used under main ability
2395     AdaptMainLauncherResourceInfo(appInfo);
2396     return ERR_OK;
2397 }
2398 
GetBundleInfo(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2399 bool InnerBundleInfo::GetBundleInfo(int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2400 {
2401     InnerBundleUserInfo innerBundleUserInfo;
2402     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2403         LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo bundleName:%{public}s",
2404             userId, GetBundleName().c_str());
2405         return false;
2406     }
2407 
2408     bundleInfo = *baseBundleInfo_;
2409     if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2410         LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2411         return false;
2412     }
2413     bundleInfo.overlayType = overlayType_;
2414     bundleInfo.isNewVersion = isNewVersion_;
2415 
2416     GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
2417         bundleInfo.applicationInfo, appIndex);
2418     for (const auto &info : innerModuleInfos_) {
2419         if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2420             == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2421             for (const auto &item : info.second.requestPermissions) {
2422                 bundleInfo.reqPermissions.push_back(item.name);
2423             }
2424             for (const auto &item : info.second.definePermissions) {
2425                 bundleInfo.defPermissions.push_back(item.name);
2426             }
2427         }
2428         bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2429         auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
2430         if (hapmoduleinfo) {
2431             GetModuleWithHashValue(flags, info.second.modulePackage, *hapmoduleinfo);
2432             bundleInfo.hapModuleInfos.emplace_back(*hapmoduleinfo);
2433             bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2434             bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2435             bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2436             bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2437         } else {
2438             LOG_E(BMS_TAG_QUERY, "can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
2439         }
2440     }
2441     if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2442         == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2443         if (!bundleInfo.reqPermissions.empty()) {
2444             RemoveDuplicateName(bundleInfo.reqPermissions);
2445         }
2446         if (!bundleInfo.defPermissions.empty()) {
2447             RemoveDuplicateName(bundleInfo.defPermissions);
2448         }
2449         if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo,
2450             bundleInfo.applicationInfo.accessTokenId, bundleInfo.applicationInfo.deviceId)) {
2451             LOG_E(BMS_TAG_QUERY, "get request permission state failed");
2452         }
2453         bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2454     }
2455     GetBundleWithAbilities(flags, bundleInfo, appIndex, userId);
2456     GetBundleWithExtension(flags, bundleInfo, appIndex, userId);
2457     return true;
2458 }
2459 
GetBundleInfoV9(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2460 ErrCode InnerBundleInfo::GetBundleInfoV9(int32_t flags, BundleInfo &bundleInfo, int32_t userId,
2461     int32_t appIndex) const
2462 {
2463     InnerBundleUserInfo innerBundleUserInfo;
2464     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2465         LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo", userId);
2466         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2467     }
2468 
2469     bundleInfo = *baseBundleInfo_;
2470     if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2471         LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2472         return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2473     }
2474     bundleInfo.overlayType = overlayType_;
2475     bundleInfo.isNewVersion = isNewVersion_;
2476 
2477     for (const auto &info : innerModuleInfos_) {
2478         bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2479         auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId, appIndex);
2480         if (hapmoduleinfo) {
2481             bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2482             bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2483             bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2484             bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2485         } else {
2486             LOG_E(BMS_TAG_QUERY, "can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
2487         }
2488     }
2489     ProcessBundleFlags(flags, userId, bundleInfo, appIndex);
2490     return ERR_OK;
2491 }
2492 
GetSharedBundleInfo(int32_t flags,BundleInfo & bundleInfo) const2493 bool InnerBundleInfo::GetSharedBundleInfo(int32_t flags, BundleInfo &bundleInfo) const
2494 {
2495     bundleInfo = *baseBundleInfo_;
2496     ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, Constants::ALL_USERID);
2497     bundleInfo.applicationInfo = *baseApplicationInfo_;
2498     return true;
2499 }
2500 
ProcessBundleFlags(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2501 void InnerBundleInfo::ProcessBundleFlags(
2502     int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2503 {
2504     if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
2505         == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
2506         if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2507             == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2508             GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), userId,
2509                 bundleInfo.applicationInfo, appIndex);
2510         } else {
2511             GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_DEFAULT), userId,
2512                 bundleInfo.applicationInfo, appIndex);
2513         }
2514     }
2515     bundleInfo.applicationInfo.appIndex = appIndex;
2516     GetBundleWithReqPermissionsV9(flags, userId, bundleInfo, appIndex);
2517     ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, userId, appIndex);
2518     if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
2519         == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
2520         bundleInfo.signatureInfo.appId = baseBundleInfo_->appId;
2521         bundleInfo.signatureInfo.fingerprint = baseApplicationInfo_->fingerprint;
2522         bundleInfo.signatureInfo.certificate = baseBundleInfo_->signatureInfo.certificate;
2523     }
2524 }
2525 
GetBundleWithReqPermissionsV9(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2526 void InnerBundleInfo::GetBundleWithReqPermissionsV9(
2527     int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2528 {
2529     if ((static_cast<uint32_t>(flags) &
2530         static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION))
2531         != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION)) {
2532         return;
2533     }
2534     for (const auto &info : innerModuleInfos_) {
2535         for (const auto &item : info.second.requestPermissions) {
2536             bundleInfo.reqPermissions.push_back(item.name);
2537         }
2538         for (const auto &item : info.second.definePermissions) {
2539             bundleInfo.defPermissions.push_back(item.name);
2540         }
2541     }
2542     if (!bundleInfo.reqPermissions.empty()) {
2543         RemoveDuplicateName(bundleInfo.reqPermissions);
2544     }
2545     if (!bundleInfo.defPermissions.empty()) {
2546         RemoveDuplicateName(bundleInfo.defPermissions);
2547     }
2548     InnerBundleUserInfo innerBundleUserInfo;
2549     if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2550         APP_LOGE("not find userId %{public}d when get applicationInfo", userId);
2551         return;
2552     }
2553     uint32_t tokenId = innerBundleUserInfo.accessTokenId;
2554     std::string deviceId = baseApplicationInfo_->deviceId;
2555     if (appIndex != 0) {
2556         // clone app
2557         const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = innerBundleUserInfo.cloneInfos;
2558         std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
2559         if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
2560             LOG_E(BMS_TAG_QUERY,
2561                 "can not find userId %{public}d, appIndex %{public}d when get applicationInfo", userId, appIndex);
2562             return;
2563         }
2564         const InnerBundleCloneInfo &cloneInfo = mpCloneInfos.at(appIndexKey);
2565         tokenId = cloneInfo.accessTokenId;
2566     }
2567     if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo, tokenId, deviceId)) {
2568         APP_LOGE("get request permission state failed");
2569     }
2570     bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2571 }
2572 
GetModuleWithHashValue(int32_t flags,const std::string & modulePackage,HapModuleInfo & hapModuleInfo) const2573 void InnerBundleInfo::GetModuleWithHashValue(
2574     int32_t flags, const std::string &modulePackage, HapModuleInfo &hapModuleInfo) const
2575 {
2576     if (!(static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_HASH_VALUE)) {
2577         return;
2578     }
2579 
2580     auto it = innerModuleInfos_.find(modulePackage);
2581     if (it == innerModuleInfos_.end()) {
2582         APP_LOGE("not find module %{public}s", modulePackage.c_str());
2583         return;
2584     }
2585 
2586     hapModuleInfo.hashValue = it->second.hashValue;
2587 }
2588 
ProcessBundleWithHapModuleInfoFlag(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2589 void InnerBundleInfo::ProcessBundleWithHapModuleInfoFlag(
2590     int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2591 {
2592     if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE))
2593         != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE)) {
2594         bundleInfo.hapModuleInfos.clear();
2595         return;
2596     }
2597     for (const auto &info : innerModuleInfos_) {
2598         auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId, appIndex);
2599         if (hapmoduleinfo) {
2600             HapModuleInfo hapModuleInfo = *hapmoduleinfo;
2601             auto it = innerModuleInfos_.find(info.second.modulePackage);
2602             if (it == innerModuleInfos_.end()) {
2603                 APP_LOGE("not find module %{public}s", info.second.modulePackage.c_str());
2604             } else {
2605                 hapModuleInfo.hashValue = it->second.hashValue;
2606             }
2607             if (hapModuleInfo.hapPath.empty()) {
2608                 hapModuleInfo.moduleSourceDir = info.second.modulePath;
2609             }
2610             if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2611                 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2612                 hapModuleInfo.metadata.clear();
2613             }
2614 
2615             GetBundleWithAbilitiesV9(flags, hapModuleInfo, userId, appIndex);
2616             GetBundleWithExtensionAbilitiesV9(flags, hapModuleInfo, appIndex);
2617             bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
2618         }
2619     }
2620 }
2621 
GetBundleWithAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t userId,int32_t appIndex) const2622 void InnerBundleInfo::GetBundleWithAbilitiesV9(
2623     int32_t flags, HapModuleInfo &hapModuleInfo, int32_t userId, int32_t appIndex) const
2624 {
2625     hapModuleInfo.abilityInfos.clear();
2626     if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY))
2627         != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY)) {
2628         return;
2629     }
2630     APP_LOGD("Get bundleInfo with abilities");
2631     for (auto &ability : baseAbilityInfos_) {
2632         if ((ability.second.moduleName != hapModuleInfo.moduleName) ||
2633             (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY)) {
2634             continue;
2635         }
2636         bool isEnabled = IsAbilityEnabled(ability.second, userId, appIndex);
2637         if (!(static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE))
2638             && !isEnabled) {
2639             APP_LOGW_NOFUNC("ability:%{public}s disabled,", ability.second.name.c_str());
2640             continue;
2641         }
2642         AbilityInfo abilityInfo = ability.second;
2643         abilityInfo.enabled = isEnabled;
2644         abilityInfo.appIndex = appIndex;
2645 
2646         if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2647             != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2648             abilityInfo.metaData.customizeData.clear();
2649             abilityInfo.metadata.clear();
2650         }
2651         if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2652             != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2653             abilityInfo.skills.clear();
2654         }
2655 
2656         hapModuleInfo.abilityInfos.emplace_back(abilityInfo);
2657     }
2658 }
2659 
GetBundleWithExtensionAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t appIndex) const2660 void InnerBundleInfo::GetBundleWithExtensionAbilitiesV9(
2661     int32_t flags, HapModuleInfo &hapModuleInfo, int32_t appIndex) const
2662 {
2663     hapModuleInfo.extensionInfos.clear();
2664     if ((static_cast<uint32_t>(flags) &
2665         static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY))
2666         != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY)) {
2667         return;
2668     }
2669     APP_LOGD("Get bundleInfo with extensionAbilities");
2670     for (const auto &extensionInfo : baseExtensionInfos_) {
2671         if (extensionInfo.second.moduleName != hapModuleInfo.moduleName || !extensionInfo.second.enabled) {
2672             continue;
2673         }
2674         ExtensionAbilityInfo info = extensionInfo.second;
2675         info.appIndex = appIndex;
2676 
2677         if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2678             != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2679             info.metadata.clear();
2680         }
2681         if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2682             != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2683             info.skills.clear();
2684         }
2685         hapModuleInfo.extensionInfos.emplace_back(info);
2686     }
2687 }
2688 
GetBundleWithAbilities(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2689 void InnerBundleInfo::GetBundleWithAbilities(
2690     int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2691 {
2692     APP_LOGD("bundleName:%{public}s userid:%{public}d", bundleInfo.name.c_str(), userId);
2693     if (static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_ABILITIES) {
2694         for (auto &ability : baseAbilityInfos_) {
2695             if (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY) {
2696                 continue;
2697             }
2698             bool isEnabled = IsAbilityEnabled(ability.second, userId);
2699             if (!(static_cast<uint32_t>(flags) & GET_ABILITY_INFO_WITH_DISABLE)
2700                 && !isEnabled) {
2701                 APP_LOGW_NOFUNC("ability:%{public}s disabled,", ability.second.name.c_str());
2702                 continue;
2703             }
2704             AbilityInfo abilityInfo = ability.second;
2705             abilityInfo.enabled = isEnabled;
2706             if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2707                 abilityInfo.skills.clear();
2708             }
2709             abilityInfo.appIndex = appIndex;
2710             bundleInfo.abilityInfos.emplace_back(abilityInfo);
2711         }
2712     }
2713 }
2714 
GetBundleWithExtension(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2715 void InnerBundleInfo::GetBundleWithExtension(
2716     int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2717 {
2718     APP_LOGD("get bundleInfo with extensionInfo begin");
2719     if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_EXTENSION_INFO) == GET_BUNDLE_WITH_EXTENSION_INFO) {
2720         for (const auto &extensionInfo : baseExtensionInfos_) {
2721             if (!extensionInfo.second.enabled) {
2722                 continue;
2723             }
2724             ExtensionAbilityInfo info = extensionInfo.second;
2725             if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2726                 info.skills.clear();
2727             }
2728             info.appIndex = appIndex;
2729             bundleInfo.extensionInfos.emplace_back(info);
2730         }
2731     }
2732     APP_LOGD("get bundleInfo with extensionInfo end");
2733 }
2734 
CheckSpecialMetaData(const std::string & metaData) const2735 bool InnerBundleInfo::CheckSpecialMetaData(const std::string &metaData) const
2736 {
2737     if (isNewVersion_) {
2738         for (const auto &moduleInfo : innerModuleInfos_) {
2739             for (const auto &data : moduleInfo.second.metadata) {
2740                 if (metaData == data.name) {
2741                     return true;
2742                 }
2743             }
2744         }
2745         return false;
2746     }
2747     // old version
2748     for (const auto &moduleInfo : innerModuleInfos_) {
2749         for (const auto &data : moduleInfo.second.metaData.customizeData) {
2750             if (metaData == data.name) {
2751                 return true;
2752             }
2753         }
2754     }
2755     return false;
2756 }
2757 
GetFormsInfoByModule(const std::string & moduleName,std::vector<FormInfo> & formInfos) const2758 void InnerBundleInfo::GetFormsInfoByModule(const std::string &moduleName, std::vector<FormInfo> &formInfos) const
2759 {
2760     for (const auto &data : formInfos_) {
2761         for (auto &form : data.second) {
2762             if (form.moduleName == moduleName) {
2763                 formInfos.emplace_back(form);
2764             }
2765         }
2766     }
2767 }
2768 
GetFormsInfoByApp(std::vector<FormInfo> & formInfos) const2769 void InnerBundleInfo::GetFormsInfoByApp(std::vector<FormInfo> &formInfos) const
2770 {
2771     for (const auto &data : formInfos_) {
2772         std::copy(data.second.begin(), data.second.end(), std::back_inserter(formInfos));
2773     }
2774 }
2775 
GetShortcutInfos(std::vector<ShortcutInfo> & shortcutInfos) const2776 void InnerBundleInfo::GetShortcutInfos(std::vector<ShortcutInfo> &shortcutInfos) const
2777 {
2778     for (const auto &shortcut : shortcutInfos_) {
2779         shortcutInfos.emplace_back(shortcut.second);
2780     }
2781 }
2782 
GetCommonEvents(const std::string & eventKey,std::vector<CommonEventInfo> & commonEvents) const2783 void InnerBundleInfo::GetCommonEvents(const std::string &eventKey, std::vector<CommonEventInfo> &commonEvents) const
2784 {
2785     CommonEventInfo item;
2786     for (const auto &commonEvent : commonEvents_) {
2787         for (const auto &event : commonEvent.second.events) {
2788             if (event == eventKey) {
2789                 item = commonEvent.second;
2790                 item.uid = GetUid(GetUserId());
2791                 commonEvents.emplace_back(item);
2792                 break;
2793             }
2794         }
2795     }
2796 }
2797 
GetInnerModuleInfoByModuleName(const std::string & moduleName) const2798 std::optional<InnerModuleInfo> InnerBundleInfo::GetInnerModuleInfoByModuleName(const std::string &moduleName) const
2799 {
2800     for (const auto &innerModuleInfo : innerModuleInfos_) {
2801         APP_LOGD("info.moduleName = %{public}s, moduleName= %{public}s",
2802             innerModuleInfo.second.moduleName.c_str(), moduleName.c_str());
2803         if (innerModuleInfo.second.moduleName == moduleName) {
2804             return innerModuleInfo.second;
2805         }
2806     }
2807     return std::nullopt;
2808 }
2809 
GetInnerModuleInfoHnpInfo(const std::string & moduleName) const2810 std::optional<std::vector<HnpPackage>> InnerBundleInfo::GetInnerModuleInfoHnpInfo(const std::string &moduleName) const
2811 {
2812     for (const auto &innerModuleInfo : innerModuleInfos_) {
2813         if (!(innerModuleInfo.second.hnpPackages.empty())) {
2814             if (innerModuleInfo.second.moduleName == moduleName) {
2815                 return innerModuleInfo.second.hnpPackages;
2816             }
2817         }
2818     }
2819     return std::nullopt;
2820 }
2821 
GetInnerModuleInfoHnpPath(const std::string & moduleName) const2822 std::string InnerBundleInfo::GetInnerModuleInfoHnpPath(const std::string &moduleName) const
2823 {
2824     for (const auto &innerModuleInfo : innerModuleInfos_) {
2825         if (!(innerModuleInfo.second.hnpPackages.empty())) {
2826             if (innerModuleInfo.second.moduleName == moduleName) {
2827                 return innerModuleInfo.second.moduleHnpsPath;
2828             }
2829         }
2830     }
2831     return "";
2832 }
2833 
GetModuleNames(std::vector<std::string> & moduleNames) const2834 void InnerBundleInfo::GetModuleNames(std::vector<std::string> &moduleNames) const
2835 {
2836     for (const auto &innerModuleInfo : innerModuleInfos_) {
2837         moduleNames.emplace_back(innerModuleInfo.second.moduleName);
2838     }
2839 }
2840 
ResetBundleState(int32_t userId)2841 void InnerBundleInfo::ResetBundleState(int32_t userId)
2842 {
2843     if (userId == Constants::ALL_USERID) {
2844         for (auto& innerBundleUserInfo : innerBundleUserInfos_) {
2845             innerBundleUserInfo.second.bundleUserInfo.Reset();
2846         }
2847 
2848         return;
2849     }
2850 
2851     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2852     if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
2853         APP_LOGD("no this user %{public}s", key.c_str());
2854         return;
2855     }
2856 
2857     innerBundleUserInfos_.at(key).bundleUserInfo.Reset();
2858 }
2859 
RemoveInnerBundleUserInfo(int32_t userId)2860 void InnerBundleInfo::RemoveInnerBundleUserInfo(int32_t userId)
2861 {
2862     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2863     auto infoItem = innerBundleUserInfos_.find(key);
2864     if (infoItem == innerBundleUserInfos_.end()) {
2865         return;
2866     }
2867 
2868     auto result = innerBundleUserInfos_.erase(key);
2869     if (result == 0) {
2870         APP_LOGE("remove userId:%{public}d key:%{public}s info failed", userId, key.c_str());
2871     }
2872     for (auto &innerModuleInfo : innerModuleInfos_) {
2873         DeleteModuleRemovable(innerModuleInfo.second.moduleName, userId);
2874     }
2875 }
2876 
AddInnerBundleUserInfo(const InnerBundleUserInfo & innerBundleUserInfo)2877 void InnerBundleInfo::AddInnerBundleUserInfo(
2878     const InnerBundleUserInfo& innerBundleUserInfo)
2879 {
2880     auto& key = NameAndUserIdToKey(
2881         GetBundleName(), innerBundleUserInfo.bundleUserInfo.userId);
2882     auto infoItem = innerBundleUserInfos_.find(key);
2883     if (infoItem == innerBundleUserInfos_.end()) {
2884         innerBundleUserInfos_.emplace(key, innerBundleUserInfo);
2885         return;
2886     }
2887 
2888     innerBundleUserInfos_[key] = innerBundleUserInfo;
2889 }
2890 
GetInnerBundleUserInfo(int32_t userId,InnerBundleUserInfo & innerBundleUserInfo) const2891 bool InnerBundleInfo::GetInnerBundleUserInfo(
2892     int32_t userId, InnerBundleUserInfo& innerBundleUserInfo) const
2893 {
2894     if (userId == ServiceConstants::NOT_EXIST_USERID) {
2895         return true;
2896     }
2897 
2898     if (userId == Constants::ALL_USERID) {
2899         if (innerBundleUserInfos_.empty()) {
2900             return false;
2901         }
2902 
2903         innerBundleUserInfo = innerBundleUserInfos_.begin()->second;
2904         return true;
2905     }
2906 
2907     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2908     auto infoItem = innerBundleUserInfos_.find(key);
2909     if (infoItem == innerBundleUserInfos_.end()) {
2910         return false;
2911     }
2912 
2913     innerBundleUserInfo = infoItem->second;
2914     return true;
2915 }
2916 
HasInnerBundleUserInfo(int32_t userId) const2917 bool InnerBundleInfo::HasInnerBundleUserInfo(int32_t userId) const
2918 {
2919     if (userId == Constants::ALL_USERID || userId == Constants::ANY_USERID) {
2920         return !innerBundleUserInfos_.empty();
2921     }
2922 
2923     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2924     auto infoItem = innerBundleUserInfos_.find(key);
2925     return infoItem != innerBundleUserInfos_.end();
2926 }
2927 
SetBundleInstallTime(const int64_t time,int32_t userId)2928 void InnerBundleInfo::SetBundleInstallTime(const int64_t time, int32_t userId)
2929 {
2930     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2931     auto infoItem = innerBundleUserInfos_.find(key);
2932     if (infoItem == innerBundleUserInfos_.end()) {
2933         return;
2934     }
2935 
2936     infoItem->second.installTime = time;
2937     infoItem->second.updateTime = time;
2938 }
2939 
SetAccessTokenId(uint32_t accessToken,const int32_t userId)2940 void InnerBundleInfo::SetAccessTokenId(uint32_t accessToken, const int32_t userId)
2941 {
2942     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2943     auto infoItem = innerBundleUserInfos_.find(key);
2944     if (infoItem == innerBundleUserInfos_.end()) {
2945         return;
2946     }
2947 
2948     infoItem->second.accessTokenId = accessToken;
2949 }
2950 
SetAccessTokenIdEx(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId)2951 void InnerBundleInfo::SetAccessTokenIdEx(
2952     const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
2953     const int32_t userId)
2954 {
2955     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2956     auto infoItem = innerBundleUserInfos_.find(key);
2957     if (infoItem == innerBundleUserInfos_.end()) {
2958         return;
2959     }
2960 
2961     infoItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
2962     infoItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
2963 }
2964 
SetAccessTokenIdExWithAppIndex(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId,const int32_t appIndex)2965 void InnerBundleInfo::SetAccessTokenIdExWithAppIndex(
2966     const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
2967     const int32_t userId, const int32_t appIndex)
2968 {
2969     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2970     auto infoItem = innerBundleUserInfos_.find(key);
2971     if (infoItem == innerBundleUserInfos_.end()) {
2972         return;
2973     }
2974 
2975     auto& userInfo = infoItem->second;
2976     std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
2977 
2978     auto cloneKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
2979     auto cloneItem = cloneInfos.find(cloneKey);
2980     if (cloneItem == cloneInfos.end()) {
2981         return;
2982     }
2983     cloneItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
2984     cloneItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
2985 }
2986 
SetkeyId(const int32_t userId,const std::string & keyId)2987 void InnerBundleInfo::SetkeyId(const int32_t userId, const std::string &keyId)
2988 {
2989     if (keyId.empty()) {
2990         APP_LOGE("SetkeyId failed, keyId is empty");
2991         return;
2992     }
2993     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2994     auto infoItem = innerBundleUserInfos_.find(key);
2995     if (infoItem == innerBundleUserInfos_.end()) {
2996         APP_LOGE("SetkeyId failed, not find userInfo for userId %{public}d", userId);
2997         return;
2998     }
2999     infoItem->second.keyId = keyId;
3000 }
3001 
SetBundleUpdateTime(const int64_t time,int32_t userId)3002 void InnerBundleInfo::SetBundleUpdateTime(const int64_t time, int32_t userId)
3003 {
3004     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3005     auto infoItem = innerBundleUserInfos_.find(key);
3006     if (infoItem == innerBundleUserInfos_.end()) {
3007         return;
3008     }
3009 
3010     infoItem->second.updateTime = time;
3011 }
3012 
IsAbilityEnabled(const AbilityInfo & abilityInfo,int32_t userId,int32_t appIndex) const3013 bool InnerBundleInfo::IsAbilityEnabled(const AbilityInfo &abilityInfo, int32_t userId, int32_t appIndex) const
3014 {
3015     APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3016     if (userId == ServiceConstants::NOT_EXIST_USERID) {
3017         return true;
3018     }
3019     auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3020     auto infoItem = innerBundleUserInfos_.find(key);
3021     if (infoItem == innerBundleUserInfos_.end()) {
3022         APP_LOGD("innerBundleUserInfos find key:%{public}s, error", key.c_str());
3023         return false;
3024     }
3025 
3026     if (appIndex == 0) {
3027         auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3028         if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3029             != disabledAbilities.end()) {
3030             return false;
3031         } else {
3032             return true;
3033         }
3034     }
3035 
3036     const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3037     std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3038     if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3039         return false;
3040     }
3041     auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3042     if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3043         != disabledAbilities.end()) {
3044         return false;
3045     } else {
3046         return true;
3047     }
3048 }
3049 
SetOverlayModuleState(const std::string & moduleName,int32_t state,int32_t userId)3050 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state, int32_t userId)
3051 {
3052     APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3053     if (overlayType_ == NON_OVERLAY_TYPE) {
3054         APP_LOGW("no overlay module");
3055         return;
3056     }
3057     for (auto &innerUserInfo : innerBundleUserInfos_) {
3058         if (innerUserInfo.second.bundleUserInfo.userId != userId) {
3059             continue;
3060         }
3061 
3062         auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3063         bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3064             if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3065                 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3066                 return true;
3067             }
3068             return false;
3069         });
3070         if (!isSetSucc) {
3071             APP_LOGD("no overlay module state info under user %{public}d", userId);
3072             overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3073         }
3074     }
3075 }
3076 
SetOverlayModuleState(const std::string & moduleName,int32_t state)3077 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state)
3078 {
3079     APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3080     if (overlayType_ == NON_OVERLAY_TYPE) {
3081         APP_LOGW("no overlay module");
3082         return;
3083     }
3084     for (auto &innerUserInfo : innerBundleUserInfos_) {
3085         auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3086         bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3087             if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3088                 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3089                 return true;
3090             }
3091             return false;
3092         });
3093         if (!isSetSucc) {
3094             overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3095         }
3096     }
3097 }
3098 
GetOverlayModuleState(const std::string & moduleName,int32_t userId,int32_t & state) const3099 bool InnerBundleInfo::GetOverlayModuleState(const std::string &moduleName, int32_t userId, int32_t &state) const
3100 {
3101     APP_LOGD("start to get overlay state of moduleName:%{public}s, userId:%{public}d", moduleName.c_str(), userId);
3102     if (userId == ServiceConstants::NOT_EXIST_USERID) {
3103         APP_LOGE("invalid userId %{public}d", userId);
3104         return false;
3105     }
3106     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3107     auto infoItem = innerBundleUserInfos_.find(key);
3108     if (infoItem == innerBundleUserInfos_.end()) {
3109         APP_LOGE("no userInfo under userId %{public}d", userId);
3110         return false;
3111     }
3112 
3113     auto overlayModulesState = infoItem->second.bundleUserInfo.overlayModulesState;
3114     if (overlayModulesState.empty()) {
3115         APP_LOGE("no overlay module installed under userId %{public}d", userId);
3116         return false;
3117     }
3118     for (const auto &item : overlayModulesState) {
3119         auto pos = item.find(moduleName + Constants::FILE_UNDERLINE);
3120         if (pos == std::string::npos) {
3121             continue;
3122         }
3123         return OHOS::StrToInt(item.substr(moduleName.length() + 1), state);
3124     }
3125     APP_LOGE("no overlay module installed under userId %{public}d", userId);
3126     return false;
3127 }
3128 
ClearOverlayModuleStates(const std::string & moduleName)3129 void InnerBundleInfo::ClearOverlayModuleStates(const std::string &moduleName)
3130 {
3131     // delete overlay module state
3132     for (auto &innerUserInfo : innerBundleUserInfos_) {
3133         auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3134         auto iter = std::find_if(overlayStates.begin(), overlayStates.end(), [&moduleName](const auto &item) {
3135             if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3136                 return true;
3137             }
3138             return false;
3139         });
3140         if (iter != overlayStates.end()) {
3141             overlayStates.erase(iter);
3142         }
3143     }
3144 }
3145 
IsAbilityEnabledV9(const AbilityInfo & abilityInfo,int32_t userId,bool & isEnable,int32_t appIndex) const3146 ErrCode InnerBundleInfo::IsAbilityEnabledV9(const AbilityInfo &abilityInfo,
3147     int32_t userId, bool &isEnable, int32_t appIndex) const
3148 {
3149     APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3150     if (userId == ServiceConstants::NOT_EXIST_USERID) {
3151         isEnable = true;
3152         return ERR_OK;
3153     }
3154     auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3155     auto infoItem = innerBundleUserInfos_.find(key);
3156     if (infoItem == innerBundleUserInfos_.end()) {
3157         APP_LOGE("innerBundleUserInfos find key:%{public}s, error", key.c_str());
3158         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3159     }
3160     if (appIndex == 0) {
3161         auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3162         if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3163             != disabledAbilities.end()) {
3164             isEnable = false;
3165         } else {
3166             isEnable = true;
3167         }
3168         return ERR_OK;
3169     }
3170     const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3171     std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3172     if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3173         return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
3174     }
3175     auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3176     if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3177         != disabledAbilities.end()) {
3178         isEnable = false;
3179     } else {
3180         isEnable = true;
3181     }
3182     return ERR_OK;
3183 }
3184 
SetAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId)3185 ErrCode InnerBundleInfo::SetAbilityEnabled(
3186     const std::string &moduleName, const std::string &abilityName, bool isEnabled, int32_t userId)
3187 {
3188     APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d",
3189         moduleName.c_str(), abilityName.c_str(), userId);
3190     for (const auto &ability : baseAbilityInfos_) {
3191         if ((ability.second.name == abilityName) &&
3192             (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3193             auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3194             auto infoItem = innerBundleUserInfos_.find(key);
3195             if (infoItem == innerBundleUserInfos_.end()) {
3196                 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3197                 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3198             }
3199 
3200             auto iter = std::find(infoItem->second.bundleUserInfo.disabledAbilities.begin(),
3201                                   infoItem->second.bundleUserInfo.disabledAbilities.end(),
3202                                   abilityName);
3203             if (iter != infoItem->second.bundleUserInfo.disabledAbilities.end()) {
3204                 if (isEnabled) {
3205                     infoItem->second.bundleUserInfo.disabledAbilities.erase(iter);
3206                 }
3207             } else {
3208                 if (!isEnabled) {
3209                     infoItem->second.bundleUserInfo.disabledAbilities.push_back(abilityName);
3210                 }
3211             }
3212             return ERR_OK;
3213         }
3214     }
3215     APP_LOGE("SetAbilityEnabled find abilityInfo failed");
3216     return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3217 }
3218 
SetCloneAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId,int32_t appIndex)3219 ErrCode InnerBundleInfo::SetCloneAbilityEnabled(const std::string &moduleName, const std::string &abilityName,
3220     bool isEnabled, int32_t userId, int32_t appIndex)
3221 {
3222     APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d for appIndex %{public}d",
3223         moduleName.c_str(), abilityName.c_str(), userId, appIndex);
3224     for (const auto &ability : baseAbilityInfos_) {
3225         if ((ability.second.name == abilityName) &&
3226             (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3227             auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3228             auto infoItem = innerBundleUserInfos_.find(key);
3229             if (infoItem == innerBundleUserInfos_.end()) {
3230                 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3231                 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
3232             }
3233 
3234             auto cloneIter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3235             if (cloneIter == infoItem->second.cloneInfos.end()) {
3236                 APP_LOGW("appIndex %{public}d invalid", appIndex);
3237                 return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3238             }
3239 
3240             auto iter = std::find(cloneIter->second.disabledAbilities.begin(),
3241                                   cloneIter->second.disabledAbilities.end(),
3242                                   abilityName);
3243             if (iter != cloneIter->second.disabledAbilities.end() && isEnabled) {
3244                 cloneIter->second.disabledAbilities.erase(iter);
3245             }
3246             if (iter == cloneIter->second.disabledAbilities.end() && !isEnabled) {
3247                 cloneIter->second.disabledAbilities.push_back(abilityName);
3248             }
3249             return ERR_OK;
3250         }
3251     }
3252     APP_LOGW("SetCloneAbilityEnabled find abilityInfo failed");
3253     return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3254 }
3255 
RemoveDuplicateName(std::vector<std::string> & name) const3256 void InnerBundleInfo::RemoveDuplicateName(std::vector<std::string> &name) const
3257 {
3258     std::sort(name.begin(), name.end());
3259     auto iter = std::unique(name.begin(), name.end());
3260     name.erase(iter, name.end());
3261 }
3262 
SetInnerModuleNeedDelete(const std::string & moduleName,const bool needDelete)3263 void InnerBundleInfo::SetInnerModuleNeedDelete(const std::string &moduleName, const bool needDelete)
3264 {
3265     if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3266         APP_LOGE("innerBundleInfo does not contain the module module %{public}s", moduleName.c_str());
3267         return;
3268     }
3269     innerModuleInfos_.at(moduleName).needDelete = needDelete;
3270 }
3271 
GetInnerModuleNeedDelete(const std::string & moduleName)3272 bool InnerBundleInfo::GetInnerModuleNeedDelete(const std::string &moduleName)
3273 {
3274     if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3275         APP_LOGE("innerBundleInfo does not contain the module %{public}s", moduleName.c_str());
3276         return true;
3277     }
3278     return innerModuleInfos_.at(moduleName).needDelete;
3279 }
3280 
GetAllDefinePermissions() const3281 std::vector<DefinePermission> InnerBundleInfo::GetAllDefinePermissions() const
3282 {
3283     std::vector<DefinePermission> definePermissions;
3284     for (const auto &info : innerModuleInfos_) {
3285         if (info.second.needDelete) {
3286             continue;
3287         }
3288         std::transform(info.second.definePermissions.begin(),
3289             info.second.definePermissions.end(),
3290             std::back_inserter(definePermissions),
3291             [](const auto &p) { return p; });
3292     }
3293     if (!definePermissions.empty()) {
3294         std::sort(definePermissions.begin(), definePermissions.end(),
3295             [](DefinePermission defPermA, DefinePermission defPermB) {
3296                 return defPermA.name < defPermB.name;
3297             });
3298         auto iter = std::unique(definePermissions.begin(), definePermissions.end(),
3299             [](DefinePermission defPermA, DefinePermission defPermB) {
3300                 return defPermA.name == defPermB.name;
3301             });
3302         definePermissions.erase(iter, definePermissions.end());
3303     }
3304     return definePermissions;
3305 }
3306 
GetAllRequestPermissions() const3307 std::vector<RequestPermission> InnerBundleInfo::GetAllRequestPermissions() const
3308 {
3309     std::unordered_map<std::string, std::string> moduleNameMap;
3310     std::vector<RequestPermission> requestPermissions;
3311     for (const auto &info : innerModuleInfos_) {
3312         if (info.second.needDelete) {
3313             continue;
3314         }
3315         for (auto item : info.second.requestPermissions) {
3316             item.moduleName = info.second.moduleName;
3317             requestPermissions.push_back(item);
3318             if (moduleNameMap.find(item.moduleName) == moduleNameMap.end()) {
3319                 moduleNameMap[item.moduleName] = info.second.distro.moduleType;
3320             }
3321         }
3322     }
3323     if (!requestPermissions.empty()) {
3324         InnerProcessRequestPermissions(moduleNameMap, requestPermissions);
3325     }
3326     return requestPermissions;
3327 }
3328 
InnerProcessRequestPermissions(const std::unordered_map<std::string,std::string> & moduleNameMap,std::vector<RequestPermission> & requestPermissions) const3329 void InnerBundleInfo::InnerProcessRequestPermissions(
3330     const std::unordered_map<std::string, std::string> &moduleNameMap,
3331     std::vector<RequestPermission> &requestPermissions) const
3332 {
3333     std::sort(requestPermissions.begin(), requestPermissions.end(),
3334         [&moduleNameMap](RequestPermission reqPermA, RequestPermission reqPermB) {
3335             if (reqPermA.name == reqPermB.name) {
3336                 if ((reqPermA.reasonId == 0) || (reqPermB.reasonId == 0)) {
3337                     return reqPermA.reasonId > reqPermB.reasonId;
3338                 }
3339                 auto moduleTypeA = moduleNameMap.find(reqPermA.moduleName);
3340                 if (moduleTypeA == moduleNameMap.end()) {
3341                     return reqPermA.reasonId > reqPermB.reasonId;
3342                 }
3343                 auto moduleTypeB = moduleNameMap.find(reqPermB.moduleName);
3344                 if (moduleTypeB == moduleNameMap.end()) {
3345                     return reqPermA.reasonId > reqPermB.reasonId;
3346                 }
3347                 if ((moduleTypeA->second == Profile::MODULE_TYPE_ENTRY) &&
3348                     ((moduleTypeB->second == Profile::MODULE_TYPE_ENTRY))) {
3349                     return reqPermA.reasonId > reqPermB.reasonId;
3350                 } else if (moduleTypeA->second == Profile::MODULE_TYPE_ENTRY) {
3351                     return true;
3352                 } else if (moduleTypeB->second == Profile::MODULE_TYPE_ENTRY) {
3353                     return false;
3354                 }
3355                 if ((moduleTypeA->second == Profile::MODULE_TYPE_FEATURE) &&
3356                     ((moduleTypeB->second == Profile::MODULE_TYPE_FEATURE))) {
3357                     return reqPermA.reasonId > reqPermB.reasonId;
3358                 } else if (moduleTypeA->second == Profile::MODULE_TYPE_FEATURE) {
3359                     return true;
3360                 } else if (moduleTypeB->second == Profile::MODULE_TYPE_FEATURE) {
3361                     return false;
3362                 }
3363                 return reqPermA.reasonId > reqPermB.reasonId;
3364             }
3365             return reqPermA.name < reqPermB.name;
3366         });
3367     auto iter = std::unique(requestPermissions.begin(), requestPermissions.end(),
3368         [](RequestPermission reqPermA, RequestPermission reqPermB) {
3369             return reqPermA.name == reqPermB.name;
3370         });
3371     requestPermissions.erase(iter, requestPermissions.end());
3372 }
3373 
SetApplicationEnabled(bool enabled,const std::string & caller,int32_t userId)3374 ErrCode InnerBundleInfo::SetApplicationEnabled(bool enabled, const std::string &caller, int32_t userId)
3375 {
3376     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3377     auto infoItem = innerBundleUserInfos_.find(key);
3378     if (infoItem == innerBundleUserInfos_.end()) {
3379         APP_LOGE("SetApplicationEnabled not find:%{public}s bundleUserInfo in userId: %{public}d",
3380             GetBundleName().c_str(), userId);
3381         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3382     }
3383 
3384     infoItem->second.bundleUserInfo.enabled = enabled;
3385     if (!caller.empty()) {
3386         infoItem->second.bundleUserInfo.setEnabledCaller = caller;
3387     }
3388     return ERR_OK;
3389 }
3390 
SetCloneApplicationEnabled(bool enabled,int32_t appIndex,const std::string & caller,int32_t userId)3391 ErrCode InnerBundleInfo::SetCloneApplicationEnabled(bool enabled, int32_t appIndex, const std::string &caller,
3392     int32_t userId)
3393 {
3394     auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3395     auto infoItem = innerBundleUserInfos_.find(key);
3396     if (infoItem == innerBundleUserInfos_.end()) {
3397         APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}s bundleUserInfo in userId:%{public}d",
3398             GetBundleName().c_str(), userId);
3399         return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
3400     }
3401 
3402     auto iter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3403     if (iter == infoItem->second.cloneInfos.end()) {
3404         APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}d appIndex in userId:%{public}d",
3405             appIndex, userId);
3406         return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3407     }
3408     iter->second.enabled = enabled;
3409     iter->second.setEnabledCaller = caller;
3410     return ERR_OK;
3411 }
3412 
GetCurModuleName() const3413 const std::string InnerBundleInfo::GetCurModuleName() const
3414 {
3415     if (innerModuleInfos_.find(currentPackage_) != innerModuleInfos_.end()) {
3416         return innerModuleInfos_.at(currentPackage_).moduleName;
3417     }
3418 
3419     return Constants::EMPTY_STRING;
3420 }
3421 
IsBundleRemovable() const3422 bool InnerBundleInfo::IsBundleRemovable() const
3423 {
3424     if (IsPreInstallApp()) {
3425         APP_LOGE("PreInstallApp should not be cleaned");
3426         return false;
3427     }
3428 
3429     for (const auto &innerModuleInfo : innerModuleInfos_) {
3430         if (!innerModuleInfo.second.installationFree) {
3431             return false;
3432         }
3433 
3434         for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3435             if (!stateIter.second) {
3436                 return false;
3437             }
3438         }
3439     }
3440 
3441     return true;
3442 }
3443 
GetLastInstallationTime() const3444 int64_t InnerBundleInfo::GetLastInstallationTime() const
3445 {
3446     int64_t installTime = 0;
3447     for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3448         installTime = innerBundleUserInfo.second.updateTime > installTime ?
3449             innerBundleUserInfo.second.updateTime : installTime;
3450     }
3451 
3452     return installTime;
3453 }
3454 
GetRemovableModules(std::vector<std::string> & moduleToDelete) const3455 bool InnerBundleInfo::GetRemovableModules(std::vector<std::string> &moduleToDelete) const
3456 {
3457     for (const auto &innerModuleInfo : innerModuleInfos_) {
3458         if (!innerModuleInfo.second.installationFree) {
3459             continue;
3460         }
3461 
3462         bool canDelete = true;
3463         for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3464             if (!stateIter.second) {
3465                 canDelete = false;
3466                 break;
3467             }
3468         }
3469 
3470         if (canDelete) {
3471             moduleToDelete.emplace_back(innerModuleInfo.second.moduleName);
3472         }
3473     }
3474 
3475     return !moduleToDelete.empty();
3476 }
3477 
GetFreeInstallModules(std::vector<std::string> & freeInstallModule) const3478 bool InnerBundleInfo::GetFreeInstallModules(std::vector<std::string> &freeInstallModule) const
3479 {
3480     for (const auto &innerModuleInfo : innerModuleInfos_) {
3481         if (!innerModuleInfo.second.installationFree) {
3482             continue;
3483         }
3484 
3485         freeInstallModule.emplace_back(innerModuleInfo.second.moduleName);
3486     }
3487 
3488     return !freeInstallModule.empty();
3489 }
3490 
IsUserExistModule(const std::string & moduleName,int32_t userId) const3491 bool InnerBundleInfo::IsUserExistModule(const std::string &moduleName, int32_t userId) const
3492 {
3493     APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3494     auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3495     if (!modInfoItem) {
3496         APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3497         return false;
3498     }
3499 
3500     auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3501     if (item == modInfoItem->isRemovable.end()) {
3502         APP_LOGE("userId:%{public}d not moduleName:%{public}s", userId, moduleName.c_str());
3503         return false;
3504     }
3505 
3506     APP_LOGD("userId:%{public}d exist moduleName:%{public}s", userId, moduleName.c_str());
3507     return true;
3508 }
3509 
IsModuleRemovable(const std::string & moduleName,int32_t userId,bool & isRemovable) const3510 ErrCode InnerBundleInfo::IsModuleRemovable(
3511     const std::string &moduleName, int32_t userId, bool &isRemovable) const
3512 {
3513     APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3514     auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3515     if (!modInfoItem) {
3516         APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3517         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3518     }
3519 
3520     auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3521     if (item == modInfoItem->isRemovable.end()) {
3522         APP_LOGW("userId:%{public}d not moduleName:%{public}s", userId, moduleName.c_str());
3523         isRemovable = false;
3524         return ERR_OK;
3525     }
3526 
3527     isRemovable = item->second;
3528     APP_LOGD("userId:%{public}d, moduleName:%{public}s, isRemovable:%{public}d,",
3529         userId, moduleName.c_str(), isRemovable);
3530     return ERR_OK;
3531 }
3532 
AddModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId,bool isEnable) const3533 bool InnerBundleInfo::AddModuleRemovableInfo(
3534     InnerModuleInfo &info, const std::string &stringUserId, bool isEnable) const
3535 {
3536     auto item = info.isRemovable.find(stringUserId);
3537     if (item == info.isRemovable.end()) {
3538         auto result = info.isRemovable.try_emplace(stringUserId, isEnable);
3539         if (!result.second) {
3540             APP_LOGE("add userId:%{public}s isRemovable:%{public}d failed", stringUserId.c_str(), isEnable);
3541             return false;
3542         }
3543 
3544         APP_LOGD("add userId:%{public}s isRemovable:%{public}d into map", stringUserId.c_str(), isEnable);
3545         return true;
3546     }
3547 
3548     item->second = isEnable;
3549     APP_LOGD("set userId:%{public}s isEnable:%{public}d ok", stringUserId.c_str(), isEnable);
3550     return true;
3551 }
3552 
SetModuleRemovable(const std::string & moduleName,bool isEnable,int32_t userId)3553 bool InnerBundleInfo::SetModuleRemovable(const std::string &moduleName, bool isEnable, int32_t userId)
3554 {
3555     std::string stringUserId = std::to_string(userId);
3556     APP_LOGD("userId:%{public}d moduleName:%{public}s isEnable:%{public}d", userId, moduleName.c_str(), isEnable);
3557     for (auto &innerModuleInfo : innerModuleInfos_) {
3558         if (innerModuleInfo.second.moduleName == moduleName) {
3559             return AddModuleRemovableInfo(innerModuleInfo.second, stringUserId, isEnable);
3560         }
3561     }
3562 
3563     return false;
3564 }
3565 
DeleteModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId)3566 void InnerBundleInfo::DeleteModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId)
3567 {
3568     auto item = info.isRemovable.find(stringUserId);
3569     if (item == info.isRemovable.end()) {
3570         return;
3571     }
3572 
3573     info.isRemovable.erase(stringUserId);
3574 }
3575 
DeleteModuleRemovable(const std::string & moduleName,int32_t userId)3576 void InnerBundleInfo::DeleteModuleRemovable(const std::string &moduleName, int32_t userId)
3577 {
3578     std::string stringUserId = std::to_string(userId);
3579     APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3580     for (auto &innerModuleInfo : innerModuleInfos_) {
3581         if (innerModuleInfo.second.moduleName == moduleName) {
3582             DeleteModuleRemovableInfo(innerModuleInfo.second, stringUserId);
3583             return;
3584         }
3585     }
3586 }
3587 
SetModuleUpgradeFlag(std::string moduleName,int32_t upgradeFlag)3588 ErrCode InnerBundleInfo::SetModuleUpgradeFlag(std::string moduleName, int32_t upgradeFlag)
3589 {
3590     APP_LOGD("moduleName= %{public}s, upgradeFlag = %{public}d", moduleName.c_str(), upgradeFlag);
3591     for (auto &innerModuleInfo : innerModuleInfos_) {
3592         if (innerModuleInfo.second.moduleName == moduleName) {
3593             innerModuleInfo.second.upgradeFlag = upgradeFlag;
3594             return ERR_OK;
3595         }
3596     }
3597     return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3598 }
3599 
GetModuleUpgradeFlag(std::string moduleName) const3600 int32_t InnerBundleInfo::GetModuleUpgradeFlag(std::string moduleName) const
3601 {
3602     auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3603     if (!moduleInfo) {
3604         APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3605         return UpgradeFlag::NOT_UPGRADE;
3606     }
3607     APP_LOGD("innerModuleInfo.upgradeFlag : %{public}d", moduleInfo->upgradeFlag);
3608     return moduleInfo->upgradeFlag;
3609 }
3610 
GetResponseUserId(int32_t requestUserId) const3611 int32_t InnerBundleInfo::GetResponseUserId(int32_t requestUserId) const
3612 {
3613     if (innerBundleUserInfos_.empty()) {
3614         APP_LOGD("user map is empty");
3615         return Constants::INVALID_USERID;
3616     }
3617 
3618     if (requestUserId == Constants::ANY_USERID) {
3619         return innerBundleUserInfos_.begin()->second.bundleUserInfo.userId;
3620     }
3621 
3622     if (HasInnerBundleUserInfo(requestUserId)) {
3623         return requestUserId;
3624     }
3625 
3626     if (requestUserId < Constants::START_USERID) {
3627         APP_LOGD("requestUserId(%{public}d) less than start userId", requestUserId);
3628         return Constants::INVALID_USERID;
3629     }
3630 
3631     int32_t responseUserId = Constants::INVALID_USERID;
3632     for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3633         if (innerBundleUserInfo.second.bundleUserInfo.userId < Constants::START_USERID) {
3634             responseUserId = innerBundleUserInfo.second.bundleUserInfo.userId;
3635             break;
3636         }
3637     }
3638 
3639     APP_LOGD("requestUserId(%{public}d) and responseUserId(%{public}d)", requestUserId, responseUserId);
3640     return responseUserId;
3641 }
3642 
GetDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3643 bool InnerBundleInfo::GetDependentModuleNames(const std::string &moduleName,
3644     std::vector<std::string> &dependentModuleNames) const
3645 {
3646     for (auto iter = innerModuleInfos_.begin(); iter != innerModuleInfos_.end(); ++iter) {
3647         if (iter->second.moduleName == moduleName) {
3648             for (const auto &dependency : iter->second.dependencies) {
3649                 dependentModuleNames.push_back(dependency.moduleName);
3650             }
3651             return true;
3652         }
3653     }
3654     APP_LOGE("GetDependentModuleNames not find module %{public}s", moduleName.c_str());
3655     return false;
3656 }
3657 
GetAllDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3658 bool InnerBundleInfo::GetAllDependentModuleNames(const std::string &moduleName,
3659     std::vector<std::string> &dependentModuleNames) const
3660 {
3661     if (!GetDependentModuleNames(moduleName, dependentModuleNames)) {
3662         return false;
3663     }
3664     std::deque<std::string> moduleDeque;
3665     std::copy(dependentModuleNames.begin(), dependentModuleNames.end(), std::back_inserter(moduleDeque));
3666     dependentModuleNames.clear();
3667     while (!moduleDeque.empty()) {
3668         std::string name = moduleDeque.front();
3669         moduleDeque.pop_front();
3670         if (std::find(dependentModuleNames.begin(), dependentModuleNames.end(), name) == dependentModuleNames.end()) {
3671             dependentModuleNames.push_back(name);
3672             std::vector<std::string> tempModuleNames;
3673             if (GetDependentModuleNames(name, tempModuleNames)) {
3674                 std::copy(tempModuleNames.begin(), tempModuleNames.end(), std::back_inserter(moduleDeque));
3675             }
3676         }
3677     }
3678     return true;
3679 }
3680 
GetMainAbility() const3681 std::string InnerBundleInfo::GetMainAbility() const
3682 {
3683     AbilityInfo abilityInfo;
3684     GetMainAbilityInfo(abilityInfo);
3685     return abilityInfo.name;
3686 }
3687 
GetMainAbilityInfo(AbilityInfo & abilityInfo) const3688 void InnerBundleInfo::GetMainAbilityInfo(AbilityInfo &abilityInfo) const
3689 {
3690     for (const auto& item : innerModuleInfos_) {
3691         const std::string& key = item.second.entryAbilityKey;
3692         if (!key.empty() && (baseAbilityInfos_.count(key) != 0)) {
3693             abilityInfo = baseAbilityInfos_.at(key);
3694             if (item.second.isEntry) {
3695                 return;
3696             }
3697         }
3698     }
3699 }
3700 
HasEntry() const3701 bool InnerBundleInfo::HasEntry() const
3702 {
3703     return std::any_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3704             return item.second.isEntry;
3705         });
3706 }
3707 
IsHsp() const3708 bool InnerBundleInfo::IsHsp() const
3709 {
3710     if (!innerModuleInfos_.empty()) {
3711         return std::all_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3712             return item.second.distro.moduleType == Profile::MODULE_TYPE_SHARED;
3713         });
3714     }
3715     return false;
3716 }
3717 
SetAppDistributionType(const std::string & appDistributionType)3718 void InnerBundleInfo::SetAppDistributionType(const std::string &appDistributionType)
3719 {
3720     baseApplicationInfo_->appDistributionType = appDistributionType;
3721 }
3722 
GetAppDistributionType() const3723 std::string InnerBundleInfo::GetAppDistributionType() const
3724 {
3725     return baseApplicationInfo_->appDistributionType;
3726 }
3727 
SetAppProvisionType(const std::string & appProvisionType)3728 void InnerBundleInfo::SetAppProvisionType(const std::string &appProvisionType)
3729 {
3730     baseApplicationInfo_->appProvisionType = appProvisionType;
3731 }
3732 
GetAppProvisionType() const3733 std::string InnerBundleInfo::GetAppProvisionType() const
3734 {
3735     return baseApplicationInfo_->appProvisionType;
3736 }
3737 
SetAppCrowdtestDeadline(int64_t crowdtestDeadline)3738 void InnerBundleInfo::SetAppCrowdtestDeadline(int64_t crowdtestDeadline)
3739 {
3740     baseApplicationInfo_->crowdtestDeadline = crowdtestDeadline;
3741 }
3742 
GetAppCrowdtestDeadline() const3743 int64_t InnerBundleInfo::GetAppCrowdtestDeadline() const
3744 {
3745     return baseApplicationInfo_->crowdtestDeadline;
3746 }
3747 
GetDistroModuleName() const3748 std::vector<std::string> InnerBundleInfo::GetDistroModuleName() const
3749 {
3750     std::vector<std::string> moduleVec;
3751     for (const auto &item : innerModuleInfos_) {
3752         moduleVec.push_back(item.second.moduleName);
3753     }
3754     return moduleVec;
3755 }
3756 
GetModuleNameByPackage(const std::string & packageName) const3757 std::string InnerBundleInfo::GetModuleNameByPackage(const std::string &packageName) const
3758 {
3759     auto it = innerModuleInfos_.find(packageName);
3760     if (it == innerModuleInfos_.end()) {
3761         return Constants::EMPTY_STRING;
3762     }
3763     return it->second.moduleName;
3764 }
3765 
GetModuleTypeByPackage(const std::string & packageName) const3766 std::string InnerBundleInfo::GetModuleTypeByPackage(const std::string &packageName) const
3767 {
3768     auto it = innerModuleInfos_.find(packageName);
3769     if (it == innerModuleInfos_.end()) {
3770         return Constants::EMPTY_STRING;
3771     }
3772     return it->second.distro.moduleType;
3773 }
3774 
GetAppQuickFix() const3775 AppQuickFix InnerBundleInfo::GetAppQuickFix() const
3776 {
3777     return baseApplicationInfo_->appQuickFix;
3778 }
3779 
SetAppQuickFix(const AppQuickFix & appQuickFix)3780 void InnerBundleInfo::SetAppQuickFix(const AppQuickFix &appQuickFix)
3781 {
3782     baseApplicationInfo_->appQuickFix = appQuickFix;
3783     if (appQuickFix.deployedAppqfInfo.hqfInfos.empty() && appQuickFix.deployingAppqfInfo.hqfInfos.empty()) {
3784         baseApplicationInfo_->appQuickFix.bundleName = Constants::EMPTY_STRING;
3785         baseApplicationInfo_->appQuickFix.versionCode = 0;
3786         baseApplicationInfo_->appQuickFix.versionName = Constants::EMPTY_STRING;
3787     }
3788     SetQuickFixHqfInfos(appQuickFix.deployedAppqfInfo.hqfInfos);
3789 }
3790 
GetQuickFixHqfInfos() const3791 std::vector<HqfInfo> InnerBundleInfo::GetQuickFixHqfInfos() const
3792 {
3793     return hqfInfos_;
3794 }
3795 
SetQuickFixHqfInfos(const std::vector<HqfInfo> & hqfInfos)3796 void InnerBundleInfo::SetQuickFixHqfInfos(const std::vector<HqfInfo> &hqfInfos)
3797 {
3798     hqfInfos_ = hqfInfos;
3799 }
3800 
FetchNativeSoAttrs(const std::string & requestPackage,std::string & cpuAbi,std::string & nativeLibraryPath) const3801 bool InnerBundleInfo::FetchNativeSoAttrs(
3802     const std::string &requestPackage, std::string &cpuAbi, std::string &nativeLibraryPath) const
3803 {
3804     auto moduleIter = innerModuleInfos_.find(requestPackage);
3805     if (moduleIter == innerModuleInfos_.end()) {
3806         APP_LOGE("requestPackage(%{public}s) not exist", requestPackage.c_str());
3807         return false;
3808     }
3809 
3810     auto &moduleInfo = moduleIter->second;
3811     if (!moduleInfo.compressNativeLibs) {
3812         cpuAbi = moduleInfo.cpuAbi;
3813         nativeLibraryPath = moduleInfo.nativeLibraryPath;
3814         return !nativeLibraryPath.empty();
3815     }
3816 
3817     if (moduleInfo.isLibIsolated) {
3818         cpuAbi = moduleInfo.cpuAbi;
3819         nativeLibraryPath = moduleInfo.nativeLibraryPath;
3820     } else {
3821         cpuAbi = baseApplicationInfo_->cpuAbi;
3822         nativeLibraryPath = baseApplicationInfo_->nativeLibraryPath;
3823     }
3824 
3825     return !nativeLibraryPath.empty();
3826 }
3827 
IsLibIsolated(const std::string & moduleName) const3828 bool InnerBundleInfo::IsLibIsolated(const std::string &moduleName) const
3829 {
3830     auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3831     if (!moduleInfo) {
3832         APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
3833         return false;
3834     }
3835 
3836     return moduleInfo->isLibIsolated;
3837 }
3838 
GetDeviceType(const std::string & packageName) const3839 std::vector<std::string> InnerBundleInfo::GetDeviceType(const std::string &packageName) const
3840 {
3841     auto it = innerModuleInfos_.find(packageName);
3842     if (it == innerModuleInfos_.end()) {
3843         APP_LOGW("%{public}s not existed", packageName.c_str());
3844         return std::vector<std::string>();
3845     }
3846     return innerModuleInfos_.at(packageName).deviceTypes;
3847 }
3848 
AddApplyQuickFixFrequency()3849 void InnerBundleInfo::AddApplyQuickFixFrequency()
3850 {
3851     ++applyQuickFixFrequency_;
3852 }
3853 
GetApplyQuickFixFrequency() const3854 int32_t InnerBundleInfo::GetApplyQuickFixFrequency() const
3855 {
3856     return applyQuickFixFrequency_;
3857 }
3858 
ResetApplyQuickFixFrequency()3859 void InnerBundleInfo::ResetApplyQuickFixFrequency()
3860 {
3861     applyQuickFixFrequency_ = 0;
3862 }
3863 
GetAllHspVersion() const3864 std::vector<uint32_t> InnerBundleInfo::GetAllHspVersion() const
3865 {
3866     std::vector<uint32_t> versionCodes;
3867     for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
3868         for (const auto &module : modules) {
3869             if (std::find(versionCodes.begin(), versionCodes.end(), module.versionCode) == versionCodes.end()) {
3870                 versionCodes.emplace_back(module.versionCode);
3871             }
3872         }
3873     }
3874     return versionCodes;
3875 }
3876 
DeleteHspModuleByVersion(int32_t versionCode)3877 void InnerBundleInfo::DeleteHspModuleByVersion(int32_t versionCode)
3878 {
3879     for (auto modulesIt = innerSharedModuleInfos_.begin(); modulesIt != innerSharedModuleInfos_.end();) {
3880         if (modulesIt->second.size() == SINGLE_HSP_VERSION &&
3881             modulesIt->second.front().versionCode == static_cast<uint32_t>(versionCode)) {
3882             modulesIt = innerSharedModuleInfos_.erase(modulesIt);
3883         } else {
3884             modulesIt->second.erase(
3885                 std::remove_if(modulesIt->second.begin(), modulesIt->second.end(),
3886                     [versionCode] (InnerModuleInfo &module) {
3887                         return module.versionCode == static_cast<uint32_t>(versionCode);
3888                     }));
3889             ++modulesIt;
3890         }
3891     }
3892 }
3893 
GetProxyDataInfos(const std::string & moduleName,std::vector<ProxyData> & proxyDatas) const3894 ErrCode InnerBundleInfo::GetProxyDataInfos(
3895     const std::string &moduleName, std::vector<ProxyData> &proxyDatas) const
3896 {
3897     if (moduleName == Constants::EMPTY_STRING) {
3898         GetAllProxyDataInfos(proxyDatas);
3899         return ERR_OK;
3900     }
3901     auto moduleIt = std::find_if(innerModuleInfos_.begin(), innerModuleInfos_.end(), [&moduleName](const auto &info) {
3902         return info.second.moduleName == moduleName;
3903     });
3904     if (moduleIt != innerModuleInfos_.end()) {
3905         proxyDatas.insert(
3906             proxyDatas.end(), moduleIt->second.proxyDatas.begin(), moduleIt->second.proxyDatas.end());
3907     } else {
3908         APP_LOGE("moduleName %{public}s not found", moduleName.c_str());
3909         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3910     }
3911     if (proxyDatas.empty()) {
3912         APP_LOGW("proxyDatas is empty");
3913     }
3914     return ERR_OK;
3915 }
3916 
GetAllProxyDataInfos(std::vector<ProxyData> & proxyDatas) const3917 void InnerBundleInfo::GetAllProxyDataInfos(std::vector<ProxyData> &proxyDatas) const
3918 {
3919     for (const auto &innerModuleInfo : innerModuleInfos_) {
3920         proxyDatas.insert(
3921             proxyDatas.end(), innerModuleInfo.second.proxyDatas.begin(), innerModuleInfo.second.proxyDatas.end());
3922     }
3923 }
3924 
GetIsolationMode(const std::string & isolationMode) const3925 IsolationMode InnerBundleInfo::GetIsolationMode(const std::string &isolationMode) const
3926 {
3927     auto isolationModeRes = ISOLATION_MODE_MAP.find(isolationMode);
3928     if (isolationModeRes != ISOLATION_MODE_MAP.end()) {
3929         return isolationModeRes->second;
3930     } else {
3931         return IsolationMode::NONISOLATION_FIRST;
3932     }
3933 }
3934 
SetModuleHapPath(const std::string & hapPath)3935 void InnerBundleInfo::SetModuleHapPath(const std::string &hapPath)
3936 {
3937     if (innerModuleInfos_.count(currentPackage_) == 1) {
3938         innerModuleInfos_.at(currentPackage_).hapPath = hapPath;
3939         for (auto &abilityInfo : baseAbilityInfos_) {
3940             abilityInfo.second.hapPath = hapPath;
3941         }
3942         for (auto &extensionInfo : baseExtensionInfos_) {
3943             extensionInfo.second.hapPath = hapPath;
3944         }
3945         if (!innerModuleInfos_.at(currentPackage_).compressNativeLibs &&
3946             !innerModuleInfos_.at(currentPackage_).nativeLibraryPath.empty()) {
3947             auto pos = hapPath.rfind(ServiceConstants::PATH_SEPARATOR);
3948             if (pos != std::string::npos) {
3949                 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
3950                     hapPath.substr(pos + 1, hapPath.length() - pos - 1) + NATIVE_LIBRARY_PATH_SYMBOL +
3951                     innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
3952                 return;
3953             }
3954             innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
3955                 hapPath + NATIVE_LIBRARY_PATH_SYMBOL + innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
3956         }
3957     }
3958 }
3959 
IsCompressNativeLibs(const std::string & moduleName) const3960 bool InnerBundleInfo::IsCompressNativeLibs(const std::string &moduleName) const
3961 {
3962     auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3963     if (!moduleInfo) {
3964         APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
3965         return true; // compressNativeLibs default true
3966     }
3967 
3968     return moduleInfo->compressNativeLibs;
3969 }
3970 
SetNativeLibraryFileNames(const std::string & moduleName,const std::vector<std::string> & fileNames)3971 void InnerBundleInfo::SetNativeLibraryFileNames(const std::string &moduleName,
3972     const std::vector<std::string> &fileNames)
3973 {
3974     if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3975         APP_LOGE("innerBundleInfo not contain the module: %{public}s", moduleName.c_str());
3976         return;
3977     }
3978     innerModuleInfos_.at(moduleName).nativeLibraryFileNames = fileNames;
3979 }
3980 
UpdateSharedModuleInfo()3981 void InnerBundleInfo::UpdateSharedModuleInfo()
3982 {
3983     auto sharedModuleInfoIter = innerSharedModuleInfos_.find(currentPackage_);
3984     auto moduleInfoIter = innerModuleInfos_.find(currentPackage_);
3985     if ((sharedModuleInfoIter == innerSharedModuleInfos_.end()) ||
3986         (moduleInfoIter == innerModuleInfos_.end())) {
3987         APP_LOGE("The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
3988         return;
3989     }
3990     auto &innerModuleInfoVector = sharedModuleInfoIter->second;
3991     for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
3992         if (iter->versionCode == moduleInfoIter->second.versionCode) {
3993             iter->hapPath = moduleInfoIter->second.hapPath;
3994             iter->compressNativeLibs = moduleInfoIter->second.compressNativeLibs;
3995             iter->cpuAbi = moduleInfoIter->second.cpuAbi;
3996             iter->nativeLibraryPath = moduleInfoIter->second.nativeLibraryPath;
3997             iter->nativeLibraryFileNames = moduleInfoIter->second.nativeLibraryFileNames;
3998             return;
3999         }
4000     }
4001 }
4002 
SetExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4003 ErrCode InnerBundleInfo::SetExtName(
4004     const std::string &moduleName, const std::string &abilityName, const std::string extName)
4005 {
4006     auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4007     if (abilityInfoPair == baseAbilityInfos_.end()) {
4008         APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4009         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4010     }
4011     if (moduleName != abilityInfoPair->second.moduleName) {
4012         APP_LOGE("module %{public}s not exists", moduleName.c_str());
4013         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4014     }
4015     auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4016     bool duplicated = std::any_of(supportExtNames.begin(), supportExtNames.end(), [&extName](const auto &name) {
4017             return extName == name;
4018     });
4019     if (duplicated) {
4020         APP_LOGW("extName %{public}s already exist in ability %{public}s", extName.c_str(), abilityName.c_str());
4021         return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4022     }
4023     supportExtNames.emplace_back(extName);
4024     return ERR_OK;
4025 }
4026 
SetMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4027 ErrCode InnerBundleInfo::SetMimeType(
4028     const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4029 {
4030     auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4031     if (abilityInfoPair == baseAbilityInfos_.end()) {
4032         APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4033         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4034     }
4035     if (moduleName != abilityInfoPair->second.moduleName) {
4036         APP_LOGE("module %{public}s not exists", moduleName.c_str());
4037         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4038     }
4039     auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4040     bool duplicated = std::any_of(supportMimeTypes.begin(), supportMimeTypes.end(), [&mimeType](const auto &type) {
4041             return mimeType == type;
4042     });
4043     if (duplicated) {
4044         APP_LOGW("MIME type %{public}s already exist in ability %{public}s", mimeType.c_str(), abilityName.c_str());
4045         return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4046     }
4047     abilityInfoPair->second.supportMimeTypes.emplace_back(mimeType);
4048     return ERR_OK;
4049 }
4050 
DelExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4051 ErrCode InnerBundleInfo::DelExtName(
4052     const std::string &moduleName, const std::string &abilityName, const std::string extName)
4053 {
4054     auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4055     if (abilityInfoPair == baseAbilityInfos_.end()) {
4056         APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4057         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4058     }
4059     if (moduleName != abilityInfoPair->second.moduleName) {
4060         APP_LOGE("module %{public}s not exists", moduleName.c_str());
4061         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4062     }
4063     auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4064     supportExtNames.erase(std::remove(supportExtNames.begin(), supportExtNames.end(), extName), supportExtNames.end());
4065     return ERR_OK;
4066 }
4067 
DelMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4068 ErrCode InnerBundleInfo::DelMimeType(
4069     const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4070 {
4071     auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4072     if (abilityInfoPair == baseAbilityInfos_.end()) {
4073         APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4074         return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4075     }
4076     if (moduleName != abilityInfoPair->second.moduleName) {
4077         APP_LOGE("module %{public}s not exists", moduleName.c_str());
4078         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4079     }
4080     auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4081     supportMimeTypes.erase(
4082         std::remove(supportMimeTypes.begin(), supportMimeTypes.end(), mimeType), supportMimeTypes.end());
4083     return ERR_OK;
4084 }
4085 
GetAppServiceHspInfo(BundleInfo & bundleInfo) const4086 ErrCode InnerBundleInfo::GetAppServiceHspInfo(BundleInfo &bundleInfo) const
4087 {
4088     if (baseApplicationInfo_->bundleType != BundleType::APP_SERVICE_FWK) {
4089         APP_LOGW("%{public}s is not app service", GetBundleName().c_str());
4090         return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
4091     }
4092     bundleInfo = *baseBundleInfo_;
4093     bundleInfo.applicationInfo = *baseApplicationInfo_;
4094     for (const auto &info : innerModuleInfos_) {
4095         if (info.second.distro.moduleType == Profile::MODULE_TYPE_SHARED) {
4096             auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, Constants::ALL_USERID);
4097             if (hapmoduleinfo) {
4098                 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
4099                 hapModuleInfo.moduleSourceDir = hapModuleInfo.hapPath.empty() ?
4100                     info.second.modulePath : hapModuleInfo.moduleSourceDir;
4101                 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
4102             }
4103         }
4104     }
4105     if (bundleInfo.hapModuleInfos.empty()) {
4106         APP_LOGE("bundleName:%{public}s no hsp module info", baseApplicationInfo_->bundleName.c_str());
4107         return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4108     }
4109     return ERR_OK;
4110 }
4111 
UpdateIsCompressNativeLibs()4112 void InnerBundleInfo::UpdateIsCompressNativeLibs()
4113 {
4114     if (innerModuleInfos_.empty()) {
4115         baseApplicationInfo_->isCompressNativeLibs = true;
4116         return;
4117     }
4118     baseApplicationInfo_->isCompressNativeLibs = false;
4119     for (const auto &info : innerModuleInfos_) {
4120         baseApplicationInfo_->isCompressNativeLibs =
4121             (baseApplicationInfo_->isCompressNativeLibs || info.second.compressNativeLibs) ? true : false;
4122     }
4123 }
4124 
SetResourcesApply(const std::vector<int32_t> & resourcesApply)4125 void InnerBundleInfo::SetResourcesApply(const std::vector<int32_t> &resourcesApply)
4126 {
4127     baseApplicationInfo_->resourcesApply = resourcesApply;
4128 }
4129 
InnerProcessShortcut(const Shortcut & oldShortcut,ShortcutInfo & shortcutInfo) const4130 void InnerBundleInfo::InnerProcessShortcut(const Shortcut &oldShortcut, ShortcutInfo &shortcutInfo) const
4131 {
4132     shortcutInfo.id = oldShortcut.shortcutId;
4133     shortcutInfo.icon = oldShortcut.icon;
4134     shortcutInfo.label = oldShortcut.label;
4135     shortcutInfo.iconId = oldShortcut.iconId;
4136     if (shortcutInfo.iconId == 0) {
4137         auto iter = oldShortcut.icon.find(PORT_SEPARATOR);
4138         if (iter != std::string::npos) {
4139             shortcutInfo.iconId = static_cast<uint32_t>(atoi(oldShortcut.icon.substr(iter + 1).c_str()));
4140         }
4141     }
4142     shortcutInfo.labelId = oldShortcut.labelId;
4143     if (shortcutInfo.labelId == 0) {
4144         auto iter = oldShortcut.label.find(PORT_SEPARATOR);
4145         if (iter != std::string::npos) {
4146             shortcutInfo.labelId = static_cast<uint32_t>(atoi(oldShortcut.label.substr(iter + 1).c_str()));
4147         }
4148     }
4149     for (const ShortcutWant &shortcutWant : oldShortcut.wants) {
4150         ShortcutIntent shortcutIntent;
4151         shortcutIntent.targetBundle = shortcutWant.bundleName;
4152         shortcutIntent.targetModule = shortcutWant.moduleName;
4153         shortcutIntent.targetClass = shortcutWant.abilityName;
4154         shortcutIntent.parameters = shortcutWant.parameters;
4155         shortcutInfo.intents.emplace_back(shortcutIntent);
4156     }
4157 }
4158 
GetEntryModuleName() const4159 std::string InnerBundleInfo::GetEntryModuleName() const
4160 {
4161     for (const auto &item : innerModuleInfos_) {
4162         if (item.second.isEntry) {
4163             return item.second.modulePackage;
4164         }
4165     }
4166     return Constants::EMPTY_STRING;
4167 }
4168 
SetMoudleIsEncrpted(const std::string & packageName,bool isEncrypted)4169 void InnerBundleInfo::SetMoudleIsEncrpted(const std::string &packageName, bool isEncrypted)
4170 {
4171     auto it = innerModuleInfos_.find(packageName);
4172     if (it == innerModuleInfos_.end()) {
4173         return;
4174     }
4175     it->second.isEncrypted = isEncrypted;
4176 }
4177 
IsEncryptedMoudle(const std::string & packageName) const4178 bool InnerBundleInfo::IsEncryptedMoudle(const std::string &packageName) const
4179 {
4180     auto it = innerModuleInfos_.find(packageName);
4181     if (it == innerModuleInfos_.end()) {
4182         return false;
4183     }
4184     return it->second.isEncrypted;
4185 }
4186 
GetAllEncryptedModuleNames(std::vector<std::string> & moduleNames) const4187 void InnerBundleInfo::GetAllEncryptedModuleNames(std::vector<std::string> &moduleNames) const
4188 {
4189     for (const auto &info : innerModuleInfos_) {
4190         if (info.second.isEncrypted) {
4191             moduleNames.emplace_back(info.second.moduleName);
4192         }
4193     }
4194 }
4195 
IsContainEncryptedModule() const4196 bool InnerBundleInfo::IsContainEncryptedModule() const
4197 {
4198     for (const auto &info : innerModuleInfos_) {
4199         if (info.second.isEncrypted) {
4200             return true;
4201         }
4202     }
4203     return false;
4204 }
4205 
GetAppIdentifier() const4206 std::string InnerBundleInfo::GetAppIdentifier() const
4207 {
4208     return baseBundleInfo_->signatureInfo.appIdentifier;
4209 }
4210 
SetAppIdentifier(const std::string & appIdentifier)4211 void InnerBundleInfo::SetAppIdentifier(const std::string &appIdentifier)
4212 {
4213     baseBundleInfo_->signatureInfo.appIdentifier = appIdentifier;
4214 }
4215 
SetCertificate(const std::string & certificate)4216 void InnerBundleInfo::SetCertificate(const std::string &certificate)
4217 {
4218     baseBundleInfo_->signatureInfo.certificate = certificate;
4219 }
4220 
GetCertificate() const4221 std::string InnerBundleInfo::GetCertificate() const
4222 {
4223     return baseBundleInfo_->signatureInfo.certificate;
4224 }
4225 
UpdateDebug(bool debug,bool isEntry)4226 void InnerBundleInfo::UpdateDebug(bool debug, bool isEntry)
4227 {
4228     if (isEntry) {
4229         baseApplicationInfo_->debug = debug;
4230     } else if (!HasEntry() && debug) {
4231         baseApplicationInfo_->debug = debug;
4232     }
4233 }
4234 
AddOldAppId(const std::string & appId)4235 void InnerBundleInfo::AddOldAppId(const std::string &appId)
4236 {
4237     auto appIds = baseBundleInfo_->oldAppIds;
4238     if (std::find(appIds.begin(), appIds.end(), appId) == appIds.end()) {
4239         baseBundleInfo_->oldAppIds.emplace_back(appId);
4240     }
4241 }
4242 
GetOldAppIds() const4243 std::vector<std::string> InnerBundleInfo::GetOldAppIds() const
4244 {
4245     return baseBundleInfo_->oldAppIds;
4246 }
4247 
GetQuerySchemes() const4248 std::vector<std::string> InnerBundleInfo::GetQuerySchemes() const
4249 {
4250     std::string entryModuleName = GetEntryModuleName();
4251     auto it = innerModuleInfos_.find(entryModuleName);
4252     if (it == innerModuleInfos_.end()) {
4253         return std::vector<std::string>();
4254     }
4255     std::vector<std::string> querySchemes = innerModuleInfos_.at(entryModuleName).querySchemes;
4256     for (size_t i = 0; i < querySchemes.size(); i++) {
4257         transform(querySchemes[i].begin(), querySchemes[i].end(), querySchemes[i].begin(), ::tolower);
4258     }
4259     return querySchemes;
4260 }
4261 
UpdateOdid(const std::string & developerId,const std::string & odid)4262 void InnerBundleInfo::UpdateOdid(const std::string &developerId, const std::string &odid)
4263 {
4264     developerId_ = developerId;
4265     odid_ = odid;
4266 }
4267 
UpdateOdidByBundleInfo(const InnerBundleInfo & info)4268 void InnerBundleInfo::UpdateOdidByBundleInfo(const InnerBundleInfo &info)
4269 {
4270     std::string developerId;
4271     std::string odid;
4272     info.GetDeveloperidAndOdid(developerId, odid);
4273     developerId_ = developerId;
4274     odid_ = odid;
4275 }
4276 
GetDeveloperidAndOdid(std::string & developerId,std::string & odid) const4277 void InnerBundleInfo::GetDeveloperidAndOdid(std::string &developerId, std::string &odid) const
4278 {
4279     developerId = developerId_;
4280     odid = odid_;
4281 }
4282 
GetOdid(std::string & odid) const4283 void InnerBundleInfo::GetOdid(std::string &odid) const
4284 {
4285     odid = odid_;
4286 }
4287 
AddAllowedAcls(const std::vector<std::string> & allowedAcls)4288 void InnerBundleInfo::AddAllowedAcls(const std::vector<std::string> &allowedAcls)
4289 {
4290     for (const auto &acl : allowedAcls) {
4291         if (!acl.empty() && (std::find(allowedAcls_.begin(), allowedAcls_.end(), acl) == allowedAcls_.end())) {
4292             allowedAcls_.emplace_back(acl);
4293         }
4294     }
4295 }
4296 
IsAsanEnabled() const4297 bool InnerBundleInfo::IsAsanEnabled() const
4298 {
4299     for (const auto &item : innerModuleInfos_) {
4300         if (item.second.asanEnabled) {
4301             return true;
4302         }
4303     }
4304     for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4305         for (const auto &module : modules) {
4306             if (module.asanEnabled) {
4307                 return true;
4308             }
4309         }
4310     }
4311     return false;
4312 }
4313 
IsGwpAsanEnabled() const4314 bool InnerBundleInfo::IsGwpAsanEnabled() const
4315 {
4316     for (const auto &item : innerModuleInfos_) {
4317         if (item.second.gwpAsanEnabled) {
4318             return true;
4319         }
4320     }
4321     for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4322         for (const auto &module : modules) {
4323             if (module.gwpAsanEnabled) {
4324                 return true;
4325             }
4326         }
4327     }
4328     return false;
4329 }
4330 
IsTsanEnabled() const4331 bool InnerBundleInfo::IsTsanEnabled() const
4332 {
4333     for (const auto &item : innerModuleInfos_) {
4334         if (item.second.tsanEnabled) {
4335             return true;
4336         }
4337     }
4338     for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4339         for (const auto &module : modules) {
4340             if (module.tsanEnabled) {
4341                 return true;
4342             }
4343         }
4344     }
4345     return false;
4346 }
4347 
IsHwasanEnabled() const4348 bool InnerBundleInfo::IsHwasanEnabled() const
4349 {
4350     bool hwasanEnabled = false;
4351     for (const auto &item : innerModuleInfos_) {
4352         hwasanEnabled = static_cast<bool>(item.second.innerModuleInfoFlag &
4353             GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4354         if (hwasanEnabled) {
4355             return true;
4356         }
4357     }
4358     for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4359         for (const auto &module : modules) {
4360             hwasanEnabled = static_cast<bool>(module.innerModuleInfoFlag &
4361                 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4362             if (hwasanEnabled) {
4363                 return true;
4364             }
4365         }
4366     }
4367     return false;
4368 }
4369 
GetUninstallState() const4370 bool InnerBundleInfo::GetUninstallState() const
4371 {
4372     return uninstallState_;
4373 }
4374 
SetUninstallState(const bool & uninstallState)4375 void InnerBundleInfo::SetUninstallState(const bool &uninstallState)
4376 {
4377     uninstallState_ = uninstallState;
4378 }
4379 
IsNeedSendNotify() const4380 bool InnerBundleInfo::IsNeedSendNotify() const
4381 {
4382     return isNeedSendNotify_;
4383 }
4384 
SetNeedSendNotify(const bool needStatus)4385 void InnerBundleInfo::SetNeedSendNotify(const bool needStatus)
4386 {
4387     isNeedSendNotify_ = needStatus;
4388 }
4389 
GetAllExtensionDirsInSpecifiedModule(const std::string & moduleName) const4390 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirsInSpecifiedModule(const std::string &moduleName) const
4391 {
4392     std::vector<std::string> dirVec;
4393     auto extensionInfoMap = GetInnerExtensionInfos();
4394     for (auto item : extensionInfoMap) {
4395         if (item.second.moduleName != moduleName || !item.second.needCreateSandbox) {
4396             continue;
4397         }
4398         std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4399             ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4400             ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4401         dirVec.emplace_back(dir);
4402     }
4403     return dirVec;
4404 }
4405 
GetAllExtensionDirs() const4406 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirs() const
4407 {
4408     std::vector<std::string> dirVec;
4409     auto extensionInfoMap = GetInnerExtensionInfos();
4410     for (auto item : extensionInfoMap) {
4411         if (!item.second.needCreateSandbox) {
4412             continue;
4413         }
4414         // eg: +extension-entry-inputMethodExtAbility+com.example.myapplication
4415         std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4416             ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4417             ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4418         dirVec.emplace_back(dir);
4419     }
4420     return dirVec;
4421 }
4422 
SetApplicationFlags(ApplicationInfoFlag flag)4423 void InnerBundleInfo::SetApplicationFlags(ApplicationInfoFlag flag)
4424 {
4425     uint32_t applicationFlags = static_cast<uint32_t>(baseApplicationInfo_->applicationFlags);
4426     uint32_t installSourceFlag = static_cast<uint32_t>(flag);
4427     baseApplicationInfo_->applicationFlags =
4428         static_cast<int32_t>((applicationFlags & PREINSTALL_SOURCE_CLEAN_MASK) | installSourceFlag);
4429 }
4430 
UpdateExtensionSandboxInfo(const std::vector<std::string> & typeList)4431 void InnerBundleInfo::UpdateExtensionSandboxInfo(const std::vector<std::string> &typeList)
4432 {
4433     for (auto &extensionItem : baseExtensionInfos_) {
4434         extensionItem.second.needCreateSandbox = false;
4435         std::string typeName = extensionItem.second.extensionTypeName;
4436         auto it = std::find(typeList.begin(), typeList.end(), typeName);
4437         if (it != typeList.end()) {
4438             extensionItem.second.needCreateSandbox = true;
4439         }
4440     }
4441 }
4442 
UpdateExtensionDataGroupInfo(const std::string & key,const std::vector<std::string> & dataGroupIds)4443 void InnerBundleInfo::UpdateExtensionDataGroupInfo(
4444     const std::string &key, const std::vector<std::string>& dataGroupIds)
4445 {
4446     auto it = baseExtensionInfos_.find(key);
4447     if (it == baseExtensionInfos_.end()) {
4448         APP_LOGW("UpdateExtensionDataGroupInfo not find key: %{public}s", key.c_str());
4449         return;
4450     }
4451     it->second.validDataGroupIds = dataGroupIds;
4452 }
4453 
AddDataGroupInfo(const std::string & dataGroupId,const DataGroupInfo & info)4454 void InnerBundleInfo::AddDataGroupInfo(const std::string &dataGroupId, const DataGroupInfo &info)
4455 {
4456     APP_LOGD("AddDataGroupInfo, dataGroupId: %{public}s, dataGroupInfo: %{public}s",
4457         dataGroupId.c_str(), info.ToString().c_str());
4458     auto dataGroupInfosItem = dataGroupInfos_.find(dataGroupId);
4459     if (dataGroupInfosItem == dataGroupInfos_.end()) {
4460         APP_LOGD("AddDataGroupInfo add new dataGroupInfo for dataGroupId: %{public}s", dataGroupId.c_str());
4461         dataGroupInfos_[dataGroupId] = std::vector<DataGroupInfo> { info };
4462         return;
4463     }
4464     int32_t userId = info.userId;
4465     auto iter = std::find_if(std::begin(dataGroupInfos_[dataGroupId]), std::end(dataGroupInfos_[dataGroupId]),
4466         [userId](const DataGroupInfo &dataGroupinfo) { return dataGroupinfo.userId == userId; });
4467     if (iter != std::end(dataGroupInfos_[dataGroupId])) {
4468         if ((iter->uid == info.uid) && (iter->uuid == info.uuid)) {
4469             return;
4470         }
4471         APP_LOGW("uid or uuid not same, dataGroupId: %{public}s", dataGroupId.c_str());
4472         dataGroupInfos_[dataGroupId].erase(iter);
4473     }
4474     APP_LOGD("AddDataGroupInfo add new dataGroupInfo for user: %{public}d", info.userId);
4475     dataGroupInfos_[dataGroupId].emplace_back(info);
4476 }
4477 
AddCloneBundle(const InnerBundleCloneInfo & attr)4478 ErrCode InnerBundleInfo::AddCloneBundle(const InnerBundleCloneInfo &attr)
4479 {
4480     int32_t userId = attr.userId;
4481     int32_t appIndex = attr.appIndex;
4482     const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4483     if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4484         APP_LOGE("Add Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4485             userId, GetBundleName().c_str());
4486         return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4487     }
4488     InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4489     std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4490 
4491     if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4492         APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4493         return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4494     }
4495     std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4496     if (cloneInfos.find(appIndexKey) != cloneInfos.end()) {
4497         APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d existed", appIndex);
4498         return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
4499     }
4500 
4501     InnerBundleCloneInfo cloneInfo;
4502     cloneInfo.userId = userId;
4503     cloneInfo.appIndex = appIndex;
4504     // copy from user
4505     cloneInfo.enabled = userInfo.bundleUserInfo.enabled;
4506     cloneInfo.disabledAbilities = userInfo.bundleUserInfo.disabledAbilities;
4507     cloneInfo.accessTokenId = attr.accessTokenId;
4508     cloneInfo.accessTokenIdEx = attr.accessTokenIdEx;
4509     cloneInfo.uid = attr.uid;
4510     cloneInfo.gids = attr.gids;
4511     int64_t now = BundleUtil::GetCurrentTime();
4512     cloneInfo.installTime = now;
4513 
4514     cloneInfos[appIndexKey] = cloneInfo;
4515     APP_LOGD("Add clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4516         userId, appIndex, GetBundleName().c_str());
4517     return ERR_OK;
4518 }
4519 
RemoveCloneBundle(const int32_t userId,const int32_t appIndex)4520 ErrCode InnerBundleInfo::RemoveCloneBundle(const int32_t userId, const int32_t appIndex)
4521 {
4522     const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4523     if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4524         APP_LOGE("Remove Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4525             userId, GetBundleName().c_str());
4526         return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4527     }
4528     InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4529     std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4530 
4531     if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4532         APP_LOGE("Remove Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4533         return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4534     }
4535     std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4536     if (cloneInfos.find(appIndexKey) == cloneInfos.end()) {
4537         APP_LOGD("appIndex: %{public}d not found", appIndex);
4538         return ERR_OK;
4539     }
4540     cloneInfos.erase(appIndexKey);
4541     APP_LOGD("Remove clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4542         userId, appIndex, GetBundleName().c_str());
4543     return ERR_OK;
4544 }
4545 
GetAvailableCloneAppIndex(const int32_t userId,int32_t & appIndex)4546 ErrCode InnerBundleInfo::GetAvailableCloneAppIndex(const int32_t userId, int32_t &appIndex)
4547 {
4548     const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4549     if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4550         return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4551     }
4552     InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4553     std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4554 
4555     int32_t candidateAppIndex = 1;
4556     while (cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(candidateAppIndex)) != cloneInfos.end()) {
4557         candidateAppIndex++;
4558     }
4559     appIndex = candidateAppIndex;
4560     return ERR_OK;
4561 }
4562 
IsCloneAppIndexExisted(const int32_t userId,const int32_t appIndex,bool & res)4563 ErrCode InnerBundleInfo::IsCloneAppIndexExisted(const int32_t userId, const int32_t appIndex, bool &res)
4564 {
4565     const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4566     if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4567         return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4568     }
4569     InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4570     std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4571 
4572     res = cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(appIndex)) != cloneInfos.end();
4573     return ERR_OK;
4574 }
4575 
GetApplicationInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,ApplicationInfo & appInfo) const4576 bool InnerBundleInfo::GetApplicationInfoAdaptBundleClone(
4577     const InnerBundleUserInfo &innerBundleUserInfo,
4578     int32_t appIndex,
4579     ApplicationInfo &appInfo) const
4580 {
4581     if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4582         if (appInfo.removable && !innerBundleUserInfo.isRemovable) {
4583             appInfo.removable = false;
4584         }
4585 
4586         appInfo.accessTokenId = innerBundleUserInfo.accessTokenId;
4587         appInfo.accessTokenIdEx = innerBundleUserInfo.accessTokenIdEx;
4588         appInfo.enabled = innerBundleUserInfo.bundleUserInfo.enabled;
4589         appInfo.uid = innerBundleUserInfo.uid;
4590         return true;
4591     }
4592     APP_LOGD("start appIndex: %{public}d", appIndex);
4593     auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4594     if (iter == innerBundleUserInfo.cloneInfos.end()) {
4595         APP_LOGE("appIndex %{public}d not exist", appIndex);
4596         return false;
4597     }
4598     appInfo.accessTokenId = iter->second.accessTokenId;
4599     appInfo.accessTokenIdEx = iter->second.accessTokenIdEx;
4600     appInfo.enabled = iter->second.enabled;
4601     appInfo.uid = iter->second.uid;
4602     appInfo.appIndex = iter->second.appIndex;
4603     return true;
4604 }
4605 
GetBundleInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,BundleInfo & bundleInfo) const4606 bool InnerBundleInfo::GetBundleInfoAdaptBundleClone(
4607     const InnerBundleUserInfo &innerBundleUserInfo,
4608     int32_t appIndex,
4609     BundleInfo &bundleInfo) const
4610 {
4611     if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4612         bundleInfo.uid = innerBundleUserInfo.uid;
4613         if (!innerBundleUserInfo.gids.empty()) {
4614             bundleInfo.gid = innerBundleUserInfo.gids[0];
4615         }
4616         bundleInfo.installTime = innerBundleUserInfo.installTime;
4617         bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4618         bundleInfo.appIndex = appIndex_;
4619         return true;
4620     }
4621     APP_LOGD("start appIndex: %{public}d", appIndex);
4622     auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4623     if (iter == innerBundleUserInfo.cloneInfos.end()) {
4624         APP_LOGE("appIndex %{public}d not exist", appIndex);
4625         return false;
4626     }
4627     bundleInfo.uid = iter->second.uid;
4628     bundleInfo.gid = iter->second.uid; // no gids, need add
4629     bundleInfo.installTime = iter->second.installTime;
4630     bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4631     bundleInfo.appIndex = appIndex;
4632     return true;
4633 }
4634 
VerifyAndAckCloneAppIndex(int32_t userId,int32_t & appIndex)4635 ErrCode InnerBundleInfo::VerifyAndAckCloneAppIndex(int32_t userId, int32_t &appIndex)
4636 {
4637     auto multiAppModeData = this->baseApplicationInfo_->multiAppMode;
4638     if (multiAppModeData.multiAppModeType != MultiAppModeType::APP_CLONE) {
4639         APP_LOGE("bundleName:%{public}s is not clone app", GetBundleName().c_str());
4640         return ERR_APPEXECFWK_CLONE_INSTALL_APP_NOT_SUPPORTED_MULTI_TYPE;
4641     }
4642 
4643     if (appIndex < 0) {
4644         APP_LOGE("appIndex:%{public}d not in valid range", appIndex);
4645         return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4646     }
4647     if (appIndex == 0) {
4648         ErrCode availableRes = GetAvailableCloneAppIndex(userId, appIndex);
4649         if (availableRes != ERR_OK) {
4650             APP_LOGE("Get Available Clone AppIndex Fail for, errCode: %{public}d", availableRes);
4651             return availableRes;
4652         }
4653     } else {
4654         bool found = false;
4655         ErrCode isExistedRes = IsCloneAppIndexExisted(userId, appIndex, found);
4656         if (isExistedRes != ERR_OK) {
4657             return isExistedRes;
4658         }
4659         if (found) {
4660             APP_LOGE("AppIndex %{public}d existed in userId %{public}d", appIndex, userId);
4661             return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
4662         }
4663     }
4664     int32_t maxCount = std::min(multiAppModeData.maxCount, ServiceConstants::CLONE_APP_INDEX_MAX);
4665     if (appIndex > maxCount) {
4666         APP_LOGE("AppIndex %{public}d exceed max limit %{public}d in userId: %{public}d",
4667             appIndex, maxCount, userId);
4668         return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXCEED_MAX_NUMBER;
4669     }
4670     return ERR_OK;
4671 }
4672 
UpdateMultiAppMode(const InnerBundleInfo & newInfo)4673 void InnerBundleInfo::UpdateMultiAppMode(const InnerBundleInfo &newInfo)
4674 {
4675     std::string moduleType = newInfo.GetModuleTypeByPackage(newInfo.GetCurrentModulePackage());
4676     if (moduleType == Profile::MODULE_TYPE_ENTRY || moduleType == Profile::MODULE_TYPE_FEATURE) {
4677         baseApplicationInfo_->multiAppMode = newInfo.GetBaseApplicationInfo().multiAppMode;
4678     }
4679 }
4680 
UpdateReleaseType(const InnerBundleInfo & newInfo)4681 void InnerBundleInfo::UpdateReleaseType(const InnerBundleInfo &newInfo)
4682 {
4683     if (baseBundleInfo_->releaseType.empty() ||
4684         baseApplicationInfo_->apiReleaseType.empty() ||
4685         !newInfo.IsHsp()) {
4686         baseBundleInfo_->releaseType = newInfo.GetBaseBundleInfo().releaseType;
4687         baseApplicationInfo_->apiReleaseType = newInfo.GetBaseApplicationInfo().apiReleaseType;
4688     }
4689 }
4690 
AdaptMainLauncherResourceInfo(ApplicationInfo & applicationInfo) const4691 void InnerBundleInfo::AdaptMainLauncherResourceInfo(ApplicationInfo &applicationInfo) const
4692 {
4693     if (ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.find(GetBundleName()) !=
4694         ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.end()) {
4695         return;
4696     }
4697     AbilityInfo mainAbilityInfo;
4698     GetMainAbilityInfo(mainAbilityInfo);
4699     if ((mainAbilityInfo.labelId != 0) && (mainAbilityInfo.iconId != 0)) {
4700         applicationInfo.labelId = mainAbilityInfo.labelId ;
4701         applicationInfo.labelResource.id = mainAbilityInfo.labelId;
4702         applicationInfo.labelResource.moduleName = mainAbilityInfo.moduleName;
4703         applicationInfo.labelResource.bundleName = mainAbilityInfo.bundleName;
4704 
4705         applicationInfo.iconId = mainAbilityInfo.iconId ;
4706         applicationInfo.iconResource.id = mainAbilityInfo.iconId;
4707         applicationInfo.iconResource.moduleName = mainAbilityInfo.moduleName;
4708         applicationInfo.iconResource.bundleName = mainAbilityInfo.bundleName;
4709     }
4710 }
4711 
GetCloneBundleAppIndexes() const4712 std::set<int32_t> InnerBundleInfo::GetCloneBundleAppIndexes() const
4713 {
4714     std::set<int32_t> appIndexes;
4715     for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
4716         for (const auto &cloneInfo : innerBundleUserInfo.second.cloneInfos) {
4717             appIndexes.insert(cloneInfo.second.appIndex);
4718         }
4719     }
4720     return appIndexes;
4721 }
4722 
GetSanitizerFlag(GetInnerModuleInfoFlag flag)4723 uint8_t InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag flag)
4724 {
4725     return 1 << (static_cast<uint8_t>(flag) - 1);
4726 }
4727 
PrintSetEnabledInfo(bool isEnabled,int32_t userId,int32_t appIndex,const std::string & bundleName,const std::string & caller) const4728 void InnerBundleInfo::PrintSetEnabledInfo(bool isEnabled, int32_t userId, int32_t appIndex,
4729     const std::string &bundleName, const std::string &caller) const
4730 {
4731     if (!isEnabled) {
4732         APP_LOGW_NOFUNC("-n %{public}s -u %{public}d -i %{public}d disabled caller is %{public}s",
4733             bundleName.c_str(), userId, appIndex, caller.c_str());
4734     }
4735 }
4736 }  // namespace AppExecFwk
4737 }  // namespace OHOS
4738