1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_APPEXECFWK_SERVICES_BUNDLEMGR_INCLUDE_INNER_BUNDLE_INFO_H
17 #define FOUNDATION_APPEXECFWK_SERVICES_BUNDLEMGR_INCLUDE_INNER_BUNDLE_INFO_H
18 
19 #include "nocopyable.h"
20 
21 #include "ability_info.h"
22 #include "access_token.h"
23 #include "aot/aot_args.h"
24 #include "bundle_constants.h"
25 #include "bundle_info.h"
26 #include "bundle_service_constants.h"
27 #include "common_event_info.h"
28 #include "common_profile.h"
29 #include "data_group_info.h"
30 #include "distributed_bundle_info.h"
31 #include "extension_ability_info.h"
32 #include "form_info.h"
33 #include "hap_module_info.h"
34 #include "inner_app_quick_fix.h"
35 #include "inner_bundle_clone_info.h"
36 #include "inner_bundle_user_info.h"
37 #include "json_util.h"
38 #include "preinstalled_application_info.h"
39 #include "quick_fix/app_quick_fix.h"
40 #include "quick_fix/hqf_info.h"
41 #include "shared/base_shared_bundle_info.h"
42 #include "shared/shared_bundle_info.h"
43 #include "shortcut_info.h"
44 #include "want.h"
45 
46 namespace OHOS {
47 namespace AppExecFwk {
48 struct Distro {
49     bool deliveryWithInstall = false;
50     std::string moduleName;
51     std::string moduleType;
52     bool installationFree = false;
53 };
54 
55 struct DefinePermission {
56     std::string name;
57     std::string grantMode = Profile::DEFINEPERMISSION_GRANT_MODE_SYSTEM_GRANT;
58     std::string availableLevel = Profile::DEFINEPERMISSION_AVAILABLE_LEVEL_DEFAULT_VALUE;
59     bool provisionEnable = true;
60     bool distributedSceneEnable = false;
61     std::string label;
62     uint32_t labelId = 0;
63     std::string description;
64     uint32_t descriptionId = 0;
65     std::string availableType;
66 };
67 
68 struct InnerModuleInfo {
69     std::string name;
70     std::string modulePackage;
71     std::string moduleName;
72     std::string modulePath;
73     std::string moduleDataDir;
74     std::string moduleResPath;
75     std::string moduleHnpsPath;
76     std::string label;
77     std::string hapPath;
78     uint32_t labelId = 0;
79     std::string description;
80     uint32_t descriptionId = 0;
81     std::string icon;
82     uint32_t iconId = 0;
83     std::string mainAbility; // config.json : mainAbility; module.json : mainElement
84     std::string entryAbilityKey; // skills contains "action.system.home" and "entity.system.home"
85     std::string srcPath;
86     std::string hashValue;
87     bool isEntry = false;
88     bool installationFree = false;
89     // all user's value of isRemovable
90     // key:userId
91     // value:isRemovable true or flase
92     std::map<std::string, bool> isRemovable;
93     MetaData metaData;
94     std::vector<HnpPackage> hnpPackages;
95     ModuleColorMode colorMode = ModuleColorMode::AUTO;
96     Distro distro;
97     std::vector<std::string> reqCapabilities;
98     std::vector<std::string> abilityKeys;
99     std::vector<std::string> skillKeys;
100     // new version fields
101     std::string pages;
102     std::string process;
103     std::string srcEntrance;
104     std::string uiSyntax;
105     std::string virtualMachine;
106     bool isModuleJson = false;
107     bool isStageBasedModel = false;
108     std::vector<DefinePermission> definePermissions;
109     std::vector<RequestPermission> requestPermissions;
110     std::vector<std::string> deviceTypes;
111     std::vector<std::string> extensionKeys;
112     std::vector<std::string> extensionSkillKeys;
113     std::vector<Metadata> metadata;
114     int32_t upgradeFlag = 0;
115     std::vector<Dependency> dependencies;
116     std::string compileMode;
117     bool isLibIsolated = false;
118     std::string nativeLibraryPath;
119     std::string cpuAbi;
120     std::string targetModuleName;
121     int32_t targetPriority;
122     std::vector<OverlayModuleInfo> overlayModuleInfo;
123     std::vector<std::string> preloads;
124     BundleType bundleType = BundleType::SHARED;
125     uint32_t versionCode = 0;
126     std::string versionName;
127     std::vector<ProxyData> proxyDatas;
128     std::string buildHash;
129     std::string isolationMode;
130     bool compressNativeLibs = true;
131     std::vector<std::string> nativeLibraryFileNames;
132     AOTCompileStatus aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
133     std::string fileContextMenu;
134     bool isEncrypted = false;
135     std::vector<std::string> querySchemes;
136     std::string routerMap;
137     std::vector<AppEnvironment> appEnvironments;
138     bool asanEnabled = false;
139     bool gwpAsanEnabled = false;
140     bool tsanEnabled = false;
141     std::string packageName;
142     std::string appStartup;
143     bool needDelete = false;
144     uint32_t innerModuleInfoFlag = 0;
145 };
146 
147 struct ExtendResourceInfo {
148     std::string moduleName;
149     uint32_t iconId;
150     std::string filePath;
151 };
152 
153 enum InstallExceptionStatus : int32_t {
154     INSTALL_START = 1,
155     INSTALL_FINISH,
156     UPDATING_EXISTED_START,
157     UPDATING_NEW_START,
158     UPDATING_FINISH,
159     UNINSTALL_BUNDLE_START,
160     UNINSTALL_PACKAGE_START,
161     UNKNOWN_STATUS,
162 };
163 
164 enum class GetInnerModuleInfoFlag : uint8_t {
165     GET_INNER_MODULE_INFO_WITH_HWASANENABLED = 1,
166 };
167 
168 struct InstallMark {
169     std::string bundleName;
170     std::string packageName;
171     int32_t status = InstallExceptionStatus::UNKNOWN_STATUS;
172 };
173 class InnerBundleInfo {
174 public:
175     enum class BundleStatus {
176         ENABLED = 1,
177         DISABLED,
178     };
179 
180     InnerBundleInfo();
181     InnerBundleInfo &operator=(const InnerBundleInfo &info);
182     ~InnerBundleInfo();
183     /**
184      * @brief Transform the InnerBundleInfo object to json.
185      * @param jsonObject Indicates the obtained json object.
186      * @return
187      */
188     void ToJson(nlohmann::json &jsonObject) const;
189     /**
190      * @brief Transform the json object to InnerBundleInfo object.
191      * @param jsonObject Indicates the obtained json object.
192      * @return Returns 0 if the json object parsed successfully; returns error code otherwise.
193      */
194     int32_t FromJson(const nlohmann::json &jsonObject);
195     /**
196      * @brief Add module info to old InnerBundleInfo object.
197      * @param newInfo Indicates the new InnerBundleInfo object.
198      * @return Returns true if the module successfully added; returns false otherwise.
199      */
200     bool AddModuleInfo(const InnerBundleInfo &newInfo);
201     /**
202      * @brief Update module info to old InnerBundleInfo object.
203      * @param newInfo Indicates the new InnerBundleInfo object.
204      * @return
205      */
206     void UpdateModuleInfo(const InnerBundleInfo &newInfo);
207     /**
208      * @brief Remove module info from InnerBundleInfo object.
209      * @param modulePackage Indicates the module package to be remove.
210      * @return
211      */
212     void RemoveModuleInfo(const std::string &modulePackage);
213     /**
214      * @brief Find hap module info by module package.
215      * @param modulePackage Indicates the module package.
216      * @param userId Indicates the user ID.
217      * @return Returns the HapModuleInfo object if find it; returns null otherwise.
218      */
219     std::optional<HapModuleInfo> FindHapModuleInfo(
220         const std::string &modulePackage, int32_t userId = Constants::UNSPECIFIED_USERID, int32_t appIndex = 0) const;
221     /**
222      * @brief Get module hashValue.
223      * @param modulePackage Indicates the module package.
224      * @param hapModuleInfo Indicates the hapModuleInfo.
225      * @return
226      */
227     void GetModuleWithHashValue(
228         int32_t flags, const std::string &modulePackage, HapModuleInfo &hapModuleInfo) const;
229     /**
230      * @brief Find abilityInfo by bundle name and ability name.
231      * @param moduleName Indicates the module name
232      * @param abilityName Indicates the ability name.
233      * @param userId Indicates the user ID.
234      * @return Returns the AbilityInfo object if find it; returns null otherwise.
235      */
236     std::optional<AbilityInfo> FindAbilityInfo(
237         const std::string &moduleName,
238         const std::string &abilityName,
239         int32_t userId = Constants::UNSPECIFIED_USERID) const;
240     /**
241      * @brief Find abilityInfo by bundle name and ability name.
242      * @param moduleName Indicates the module name
243      * @param abilityName Indicates the ability name.
244      * @return Returns the AbilityInfo object if find it; returns null otherwise.
245      */
246     std::optional<AbilityInfo> FindAbilityInfoV9(
247         const std::string &moduleName, const std::string &abilityName) const;
248     /**
249      * @brief Find abilityInfo by bundle name module name and ability name.
250      * @param moduleName Indicates the module name
251      * @param abilityName Indicates the ability name.
252      * @return Returns ERR_OK if abilityInfo find successfully obtained; returns other ErrCode otherwise.
253      */
254     ErrCode FindAbilityInfo(
255         const std::string &moduleName, const std::string &abilityName, AbilityInfo &info) const;
256     /**
257      * @brief Find abilityInfo of list by bundle name.
258      * @param bundleName Indicates the bundle name.
259      * @param userId Indicates the user ID.
260      * @return Returns the AbilityInfo of list if find it; returns null otherwise.
261      */
262     std::optional<std::vector<AbilityInfo>> FindAbilityInfos(
263         int32_t userId = Constants::UNSPECIFIED_USERID) const;
264     std::optional<AbilityInfo> FindAbilityInfo(const std::string continueType,
265         int32_t userId = Constants::UNSPECIFIED_USERID) const;
266     /**
267      * @brief Find extensionInfo by bundle name and extension name.
268      * @param moduleName Indicates the module name.
269      * @param extensionName Indicates the extension name
270      * @return Returns the ExtensionAbilityInfo object if find it; returns null otherwise.
271      */
272     std::optional<ExtensionAbilityInfo> FindExtensionInfo(
273         const std::string &moduleName, const std::string &extensionName) const;
274     /**
275      * @brief Find extensionInfos by bundle name.
276      * @param bundleName Indicates the bundle name.
277      * @return Returns the ExtensionAbilityInfo array if find it; returns null otherwise.
278      */
279     std::optional<std::vector<ExtensionAbilityInfo>> FindExtensionInfos() const;
280     /**
281      * @brief Transform the InnerBundleInfo object to string.
282      * @return Returns the string object
283      */
284     std::string ToString() const;
285     /**
286      * @brief Add ability infos to old InnerBundleInfo object.
287      * @param abilityInfos Indicates the AbilityInfo object to be add.
288      * @return
289      */
AddModuleAbilityInfo(const std::map<std::string,AbilityInfo> & abilityInfos)290     void AddModuleAbilityInfo(const std::map<std::string, AbilityInfo> &abilityInfos)
291     {
292         for (const auto &ability : abilityInfos) {
293             baseAbilityInfos_.try_emplace(ability.first, ability.second);
294         }
295     }
296 
AddModuleExtensionInfos(const std::map<std::string,ExtensionAbilityInfo> & extensionInfos)297     void AddModuleExtensionInfos(const std::map<std::string, ExtensionAbilityInfo> &extensionInfos)
298     {
299         for (const auto &extensionInfo : extensionInfos) {
300             baseExtensionInfos_.try_emplace(extensionInfo.first, extensionInfo.second);
301         }
302     }
303     /**
304      * @brief Add skill infos to old InnerBundleInfo object.
305      * @param skillInfos Indicates the Skill object to be add.
306      * @return
307      */
AddModuleSkillInfo(const std::map<std::string,std::vector<Skill>> & skillInfos)308     void AddModuleSkillInfo(const std::map<std::string, std::vector<Skill>> &skillInfos)
309     {
310         for (const auto &skills : skillInfos) {
311             skillInfos_.try_emplace(skills.first, skills.second);
312         }
313     }
AddModuleExtensionSkillInfos(const std::map<std::string,std::vector<Skill>> & extensionSkillInfos)314     void AddModuleExtensionSkillInfos(const std::map<std::string, std::vector<Skill>> &extensionSkillInfos)
315     {
316         for (const auto &skills : extensionSkillInfos) {
317             extensionSkillInfos_.try_emplace(skills.first, skills.second);
318         }
319     }
320     /**
321      * @brief Add form infos to old InnerBundleInfo object.
322      * @param formInfos Indicates the Forms object to be add.
323      * @return
324      */
AddModuleFormInfo(const std::map<std::string,std::vector<FormInfo>> & formInfos)325     void AddModuleFormInfo(const std::map<std::string, std::vector<FormInfo>> &formInfos)
326     {
327         for (const auto &forms : formInfos) {
328             formInfos_.try_emplace(forms.first, forms.second);
329         }
330     }
331     /**
332      * @brief Add common events to old InnerBundleInfo object.
333      * @param commonEvents Indicates the Common Event object to be add.
334      * @return
335      */
AddModuleCommonEvent(const std::map<std::string,CommonEventInfo> & commonEvents)336     void AddModuleCommonEvent(const std::map<std::string, CommonEventInfo> &commonEvents)
337     {
338         for (const auto &commonEvent : commonEvents) {
339             commonEvents_.try_emplace(commonEvent.first, commonEvent.second);
340         }
341     }
342     /**
343      * @brief Add shortcut infos to old InnerBundleInfo object.
344      * @param shortcutInfos Indicates the Shortcut object to be add.
345      * @return
346      */
AddModuleShortcutInfo(const std::map<std::string,ShortcutInfo> & shortcutInfos)347     void AddModuleShortcutInfo(const std::map<std::string, ShortcutInfo> &shortcutInfos)
348     {
349         for (const auto &shortcut : shortcutInfos) {
350             shortcutInfos_.try_emplace(shortcut.first, shortcut.second);
351         }
352     }
353     /**
354      * @brief Add innerModuleInfos to old InnerBundleInfo object.
355      * @param innerModuleInfos Indicates the InnerModuleInfo object to be add.
356      * @return
357      */
AddInnerModuleInfo(const std::map<std::string,InnerModuleInfo> & innerModuleInfos)358     void AddInnerModuleInfo(const std::map<std::string, InnerModuleInfo> &innerModuleInfos)
359     {
360         for (const auto &info : innerModuleInfos) {
361             innerModuleInfos_.try_emplace(info.first, info.second);
362         }
363     }
364     /**
365      * @brief Get application name.
366      * @return Return application name
367      */
GetApplicationName()368     std::string GetApplicationName() const
369     {
370         return baseApplicationInfo_->name;
371     }
372     /**
373      * @brief Set bundle status.
374      * @param status Indicates the BundleStatus object to set.
375      * @return
376      */
SetBundleStatus(const BundleStatus & status)377     void SetBundleStatus(const BundleStatus &status)
378     {
379         bundleStatus_ = status;
380     }
381     /**
382      * @brief Get bundle status.
383      * @return Return the BundleStatus object
384      */
GetBundleStatus()385     BundleStatus GetBundleStatus() const
386     {
387         return bundleStatus_;
388     }
389     /**
390      * @brief Set bundle install time.
391      * @param time Indicates the install time to set.
392      * @param userId Indicates the user ID.
393      * @return
394      */
395     void SetBundleInstallTime(
396         const int64_t time, int32_t userId = Constants::UNSPECIFIED_USERID);
397     /**
398      * @brief Get bundle install time.
399      * @param userId Indicates the user ID.
400      * @return Return the bundle install time.
401      */
402     int64_t GetBundleInstallTime(int32_t userId = Constants::UNSPECIFIED_USERID) const
403     {
404         InnerBundleUserInfo innerBundleUserInfo;
405         if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
406             APP_LOGE("can not find userId %{public}d when GetBundleInstallTime", userId);
407             return -1;
408         }
409         return innerBundleUserInfo.installTime;
410     }
411     /**
412      * @brief Set bundle update time.
413      * @param time Indicates the update time to set.
414      * @param userId Indicates the user ID.
415      * @return
416      */
417     void SetBundleUpdateTime(const int64_t time, int32_t userId = Constants::UNSPECIFIED_USERID);
418     /**
419      * @brief Get bundle update time.
420      * @param userId Indicates the user ID.
421      * @return Return the bundle update time.
422      */
423     int64_t GetBundleUpdateTime(int32_t userId = Constants::UNSPECIFIED_USERID) const
424     {
425         InnerBundleUserInfo innerBundleUserInfo;
426         if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
427             APP_LOGE("can not find userId %{public}d when GetBundleUpdateTime", userId);
428             return -1;
429         }
430         return innerBundleUserInfo.updateTime;
431     }
432     /**
433      * @brief Get bundle name.
434      * @return Return bundle name
435      */
GetBundleName()436     const std::string GetBundleName() const
437     {
438         return baseApplicationInfo_->bundleName;
439     }
440     /**
441      * @brief Get baseBundleInfo.
442      * @return Return the BundleInfo object.
443      */
GetBaseBundleInfo()444     BundleInfo GetBaseBundleInfo() const
445     {
446         return *baseBundleInfo_;
447     }
448     /**
449      * @brief Set baseBundleInfo.
450      * @param bundleInfo Indicates the BundleInfo object.
451      */
SetBaseBundleInfo(const BundleInfo & bundleInfo)452     void SetBaseBundleInfo(const BundleInfo &bundleInfo)
453     {
454         *baseBundleInfo_ = bundleInfo;
455     }
456     /**
457      * @brief Update baseBundleInfo.
458      * @param bundleInfo Indicates the new BundleInfo object.
459      * @return
460      */
461     void UpdateBaseBundleInfo(const BundleInfo &bundleInfo, bool isEntry);
462     /**
463      * @brief Get baseApplicationInfo.
464      * @return Return the ApplicationInfo object.
465      */
GetBaseApplicationInfo()466     ApplicationInfo GetBaseApplicationInfo() const
467     {
468         return *baseApplicationInfo_;
469     }
470     /**
471      * @brief Set baseApplicationInfo.
472      * @param applicationInfo Indicates the ApplicationInfo object.
473      */
SetBaseApplicationInfo(const ApplicationInfo & applicationInfo)474     void SetBaseApplicationInfo(const ApplicationInfo &applicationInfo)
475     {
476         *baseApplicationInfo_ = applicationInfo;
477     }
478     /**
479      * @brief Update baseApplicationInfo.
480      * @param applicationInfo Indicates the ApplicationInfo object.
481      * @param isEntry Indicates the isEntry.
482      */
483     void UpdateBaseApplicationInfo(const ApplicationInfo &applicationInfo, bool isEntry);
484     /**
485      * @brief Get application enabled.
486      * @param userId Indicates the user ID.
487      * @return Return whether the application is enabled.
488      */
489     bool GetApplicationEnabled(int32_t userId = Constants::UNSPECIFIED_USERID) const
490     {
491         InnerBundleUserInfo innerBundleUserInfo;
492         if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
493             APP_LOGD("can not find userId %{public}d when GetApplicationEnabled", userId);
494             return false;
495         }
496         PrintSetEnabledInfo(innerBundleUserInfo.bundleUserInfo.enabled, userId, 0, innerBundleUserInfo.bundleName,
497             innerBundleUserInfo.bundleUserInfo.setEnabledCaller);
498         return innerBundleUserInfo.bundleUserInfo.enabled;
499     }
500 
501     ErrCode GetApplicationEnabledV9(int32_t userId, bool &isEnabled,
502         int32_t appIndex = 0) const;
503     /**
504      * @brief Set application enabled.
505      * @param userId Indicates the user ID.
506      * @return Returns ERR_OK if the SetApplicationEnabled is successfully; returns error code otherwise.
507      */
508     ErrCode SetApplicationEnabled(bool enabled, const std::string &caller,
509         int32_t userId = Constants::UNSPECIFIED_USERID);
510     ErrCode SetCloneApplicationEnabled(bool enabled, int32_t appIndex, const std::string &caller, int32_t userId);
511     ErrCode SetCloneAbilityEnabled(const std::string &moduleName, const std::string &abilityName,
512         bool isEnabled, int32_t userId, int32_t appIndex);
513     /**
514      * @brief Get application code path.
515      * @return Return the string object.
516      */
GetAppCodePath()517     const std::string GetAppCodePath() const
518     {
519         return baseApplicationInfo_->codePath;
520     }
521     /**
522      * @brief Set application code path.
523      * @param codePath Indicates the code path to be set.
524      */
SetAppCodePath(const std::string codePath)525     void SetAppCodePath(const std::string codePath)
526     {
527         baseApplicationInfo_->codePath = codePath;
528     }
529     /**
530      * @brief Insert innerModuleInfos.
531      * @param modulePackage Indicates the modulePackage object as key.
532      * @param innerModuleInfo Indicates the InnerModuleInfo object as value.
533      */
InsertInnerModuleInfo(const std::string & modulePackage,const InnerModuleInfo & innerModuleInfo)534     void InsertInnerModuleInfo(const std::string &modulePackage, const InnerModuleInfo &innerModuleInfo)
535     {
536         innerModuleInfos_.try_emplace(modulePackage, innerModuleInfo);
537     }
538 
539       /**
540      * @brief replace innerModuleInfos.
541      * @param modulePackage Indicates the modulePackage object as key.
542      * @param innerModuleInfo Indicates the InnerModuleInfo object as value.
543      */
ReplaceInnerModuleInfo(const std::string & modulePackage,const InnerModuleInfo & innerModuleInfo)544     void ReplaceInnerModuleInfo(const std::string &modulePackage, const InnerModuleInfo &innerModuleInfo)
545     {
546         innerModuleInfos_[modulePackage] = innerModuleInfo;
547     }
548     /**
549      * @brief Insert AbilityInfo.
550      * @param key bundleName.moduleName.abilityName
551      * @param abilityInfo value.
552      */
InsertAbilitiesInfo(const std::string & key,const AbilityInfo & abilityInfo)553     void InsertAbilitiesInfo(const std::string &key, const AbilityInfo &abilityInfo)
554     {
555         baseAbilityInfos_.emplace(key, abilityInfo);
556     }
557     /**
558      * @brief Insert ExtensionAbilityInfo.
559      * @param key bundleName.moduleName.extensionName
560      * @param extensionInfo value.
561      */
InsertExtensionInfo(const std::string & key,const ExtensionAbilityInfo & extensionInfo)562     void InsertExtensionInfo(const std::string &key, const ExtensionAbilityInfo &extensionInfo)
563     {
564         baseExtensionInfos_.emplace(key, extensionInfo);
565     }
566     /**
567      * @brief Insert ability skillInfos.
568      * @param key bundleName.moduleName.abilityName
569      * @param skills ability skills.
570      */
InsertSkillInfo(const std::string & key,const std::vector<Skill> & skills)571     void InsertSkillInfo(const std::string &key, const std::vector<Skill> &skills)
572     {
573         skillInfos_.emplace(key, skills);
574     }
575     /**
576      * @brief Insert extension skillInfos.
577      * @param key bundleName.moduleName.extensionName
578      * @param skills extension skills.
579      */
InsertExtensionSkillInfo(const std::string & key,const std::vector<Skill> & skills)580     void InsertExtensionSkillInfo(const std::string &key, const std::vector<Skill> &skills)
581     {
582         extensionSkillInfos_.emplace(key, skills);
583     }
584     /**
585      * @brief Find AbilityInfo object by Uri.
586      * @param abilityUri Indicates the ability uri.
587      * @param userId Indicates the user ID.
588      * @return Returns the AbilityInfo object if find it; returns null otherwise.
589      */
FindAbilityInfoByUri(const std::string & abilityUri)590     std::optional<AbilityInfo> FindAbilityInfoByUri(const std::string &abilityUri) const
591     {
592         APP_LOGD("Uri is %{public}s", abilityUri.c_str());
593         for (const auto &ability : baseAbilityInfos_) {
594             auto abilityInfo = ability.second;
595             if (abilityInfo.uri.size() < strlen(ServiceConstants::DATA_ABILITY_URI_PREFIX)) {
596                 continue;
597             }
598 
599             auto configUri = abilityInfo.uri.substr(strlen(ServiceConstants::DATA_ABILITY_URI_PREFIX));
600             APP_LOGD("configUri is %{public}s", configUri.c_str());
601             if (configUri == abilityUri) {
602                 return abilityInfo;
603             }
604         }
605         return std::nullopt;
606     }
607 
FindExtensionAbilityInfoByUri(const std::string & uri,ExtensionAbilityInfo & extensionAbilityInfo)608     bool FindExtensionAbilityInfoByUri(const std::string &uri, ExtensionAbilityInfo &extensionAbilityInfo) const
609     {
610         for (const auto &item : baseExtensionInfos_) {
611             if (uri == item.second.uri) {
612                 extensionAbilityInfo = item.second;
613                 APP_LOGD("find target extension, bundleName : %{public}s, moduleName : %{public}s, name : %{public}s",
614                     extensionAbilityInfo.bundleName.c_str(), extensionAbilityInfo.moduleName.c_str(),
615                     extensionAbilityInfo.name.c_str());
616                 return true;
617             }
618         }
619         return false;
620     }
621 
622     /**
623      * @brief Find AbilityInfo object by Uri.
624      * @param abilityUri Indicates the ability uri.
625      * @param userId Indicates the user ID.
626      * @return Returns the AbilityInfo object if find it; returns null otherwise.
627      */
628     void FindAbilityInfosByUri(const std::string &abilityUri,
629         std::vector<AbilityInfo> &abilityInfos,  int32_t userId = Constants::UNSPECIFIED_USERID)
630     {
631         APP_LOGI("Uri is %{public}s", abilityUri.c_str());
632         for (auto &ability : baseAbilityInfos_) {
633             auto abilityInfo = ability.second;
634             if (abilityInfo.uri.size() < strlen(ServiceConstants::DATA_ABILITY_URI_PREFIX)) {
635                 continue;
636             }
637 
638             auto configUri = abilityInfo.uri.substr(strlen(ServiceConstants::DATA_ABILITY_URI_PREFIX));
639             APP_LOGI("configUri is %{public}s", configUri.c_str());
640             if (configUri == abilityUri) {
641                 GetApplicationInfo(
642                     ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION, userId, abilityInfo.applicationInfo);
643                 abilityInfos.emplace_back(abilityInfo);
644             }
645         }
646         return;
647     }
648     /**
649      * @brief Get all ability names in application.
650      * @return Returns ability names.
651      */
GetAbilityNames()652     auto GetAbilityNames() const
653     {
654         std::vector<std::string> abilityNames;
655         for (auto &ability : baseAbilityInfos_) {
656             abilityNames.emplace_back(ability.second.name);
657         }
658         return abilityNames;
659     }
660 
GetCloudFileSyncEnabled()661     bool GetCloudFileSyncEnabled() const
662     {
663         return baseApplicationInfo_->cloudFileSyncEnabled;
664     }
665 
SetCloudFileSyncEnabled(bool cloudFileSyncEnabled)666     void SetCloudFileSyncEnabled(bool cloudFileSyncEnabled)
667     {
668         baseApplicationInfo_->cloudFileSyncEnabled = cloudFileSyncEnabled;
669     }
670 
671     /**
672      * @brief Get version code in application.
673      * @return Returns version code.
674      */
GetVersionCode()675     uint32_t GetVersionCode() const
676     {
677         return baseBundleInfo_->versionCode;
678     }
679     /**
680      * @brief Get version name in application.
681      * @return Returns version name.
682      */
GetVersionName()683     std::string GetVersionName() const
684     {
685         return baseBundleInfo_->versionName;
686     }
687     /**
688      * @brief Get vendor in application.
689      * @return Returns vendor.
690      */
GetVendor()691     std::string GetVendor() const
692     {
693         return baseBundleInfo_->vendor;
694     }
695     /**
696      * @brief Get comparible version in application.
697      * @return Returns comparible version.
698      */
GetCompatibleVersion()699     uint32_t GetCompatibleVersion() const
700     {
701         return baseBundleInfo_->compatibleVersion;
702     }
703     /**
704      * @brief Get target version in application.
705      * @return Returns target version.
706      */
GetTargetVersion()707     uint32_t GetTargetVersion() const
708     {
709         return baseBundleInfo_->targetVersion;
710     }
711     /**
712      * @brief Get release type in application.
713      * @return Returns release type.
714      */
GetReleaseType()715     std::string GetReleaseType() const
716     {
717         return baseBundleInfo_->releaseType;
718     }
719     /**
720      * @brief Get minCompatibleVersionCode in base bundleInfo.
721      * @return Returns release type.
722      */
GetMinCompatibleVersionCode()723     uint32_t GetMinCompatibleVersionCode() const
724     {
725         return baseBundleInfo_->minCompatibleVersionCode;
726     }
727     /**
728      * @brief Get install mark in application.
729      * @return Returns install mark.
730      */
SetInstallMark(const std::string & bundleName,const std::string & packageName,const InstallExceptionStatus & status)731     void SetInstallMark(const std::string &bundleName, const std::string &packageName,
732         const InstallExceptionStatus &status)
733     {
734         mark_.bundleName = bundleName;
735         mark_.packageName = packageName;
736         mark_.status = status;
737     }
738     /**
739      * @brief Get install mark in application.
740      * @return Returns install mark.
741      */
GetInstallMark()742     InstallMark GetInstallMark() const
743     {
744         return mark_;
745     }
746     /**
747      * @brief Get application data dir.
748      * @return Return the string object.
749      */
GetAppDataDir()750     std::string GetAppDataDir() const
751     {
752         return baseApplicationInfo_->dataDir;
753     }
754     /**
755      * @brief Set application data dir.
756      * @param dataDir Indicates the data Dir to be set.
757      */
SetAppDataDir(std::string dataDir)758     void SetAppDataDir(std::string dataDir)
759     {
760         baseApplicationInfo_->dataDir = dataDir;
761     }
762     /**
763      * @brief Set application data base dir.
764      * @param dataBaseDir Indicates the data base Dir to be set.
765      */
SetAppDataBaseDir(std::string dataBaseDir)766     void SetAppDataBaseDir(std::string dataBaseDir)
767     {
768         baseApplicationInfo_->dataBaseDir = dataBaseDir;
769     }
770     /**
771      * @brief Set application cache dir.
772      * @param cacheDir Indicates the cache Dir to be set.
773      */
SetAppCacheDir(std::string cacheDir)774     void SetAppCacheDir(std::string cacheDir)
775     {
776         baseApplicationInfo_->cacheDir = cacheDir;
777     }
778     /**
779      * @brief Set application uid.
780      * @param uid Indicates the uid to be set.
781      */
SetUid(int uid)782     void SetUid(int uid) {}
783 
784     int32_t GetUid(int32_t userId = Constants::UNSPECIFIED_USERID, int32_t appIndex = 0) const
785     {
786         InnerBundleUserInfo innerBundleUserInfo;
787         if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
788             return Constants::INVALID_UID;
789         }
790         if (appIndex != 0) {
791             auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
792             if (iter != innerBundleUserInfo.cloneInfos.end()) {
793                 return iter->second.uid;
794             }
795             return Constants::INVALID_UID;
796         }
797 
798         return innerBundleUserInfo.uid;
799     }
800     /**
801      * @brief Get application gid.
802      * @param userId Indicates the user ID.
803      * @return Returns the gid.
804      */
805     int GetGid(int32_t userId = Constants::UNSPECIFIED_USERID) const
806     {
807         InnerBundleUserInfo innerBundleUserInfo;
808         if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
809             return ServiceConstants::INVALID_GID;
810         }
811 
812         if (innerBundleUserInfo.gids.empty()) {
813             return ServiceConstants::INVALID_GID;
814         }
815 
816         return innerBundleUserInfo.gids[0];
817     }
818     /**
819      * @brief Set application gid.
820      * @param gid Indicates the gid to be set.
821      */
SetGid(int gid)822     void SetGid(int gid) {}
823     /**
824      * @brief Get application AppType.
825      * @return Returns the AppType.
826      */
GetAppType()827     Constants::AppType GetAppType() const
828     {
829         return appType_;
830     }
831     /**
832      * @brief Set application AppType.
833      * @param gid Indicates the AppType to be set.
834      */
SetAppType(Constants::AppType appType)835     void SetAppType(Constants::AppType appType)
836     {
837         appType_ = appType;
838         if (appType_ == Constants::AppType::SYSTEM_APP) {
839             baseApplicationInfo_->isSystemApp = true;
840         } else {
841             baseApplicationInfo_->isSystemApp = false;
842         }
843     }
844     /**
845      * @brief Get application user id.
846      * @return Returns the user id.
847      */
GetUserId()848     int GetUserId() const
849     {
850         return userId_;
851     }
852     /**
853      * @brief Set application user id.
854      * @param gid Indicates the user id to be set.
855      */
SetUserId(int userId)856     void SetUserId(int userId)
857     {
858         userId_ = userId;
859     }
860 
GetUsers()861     const std::unordered_set<int32_t> GetUsers() const
862     {
863         std::unordered_set<int32_t> userIds;
864         for (const auto &userInfoItem : innerBundleUserInfos_) {
865             userIds.insert(userInfoItem.second.bundleUserInfo.userId);
866         }
867         return userIds;
868     }
869 
870     // only used in install progress with newInfo
GetCurrentModulePackage()871     std::string GetCurrentModulePackage() const
872     {
873         return currentPackage_;
874     }
SetCurrentModulePackage(const std::string & modulePackage)875     void SetCurrentModulePackage(const std::string &modulePackage)
876     {
877         currentPackage_ = modulePackage;
878     }
AddModuleSrcDir(const std::string & moduleSrcDir)879     void AddModuleSrcDir(const std::string &moduleSrcDir)
880     {
881         if (innerModuleInfos_.count(currentPackage_) == 1) {
882             innerModuleInfos_.at(currentPackage_).modulePath = moduleSrcDir;
883         }
884     }
AddModuleDataDir(const std::string & moduleDataDir)885     void AddModuleDataDir(const std::string &moduleDataDir)
886     {
887         if (innerModuleInfos_.count(currentPackage_) == 1) {
888             innerModuleInfos_.at(currentPackage_).moduleDataDir = moduleDataDir;
889         }
890     }
891 
AddModuleResPath(const std::string & moduleSrcDir)892     void AddModuleResPath(const std::string &moduleSrcDir)
893     {
894         if (innerModuleInfos_.count(currentPackage_) == 1) {
895             std::string moduleResPath;
896             if (isNewVersion_) {
897                 moduleResPath = moduleSrcDir + ServiceConstants::PATH_SEPARATOR + ServiceConstants::RESOURCES_INDEX;
898             } else {
899                 moduleResPath = moduleSrcDir + ServiceConstants::PATH_SEPARATOR + ServiceConstants::ASSETS_DIR +
900                     ServiceConstants::PATH_SEPARATOR +innerModuleInfos_.at(currentPackage_).distro.moduleName +
901                     ServiceConstants::PATH_SEPARATOR + ServiceConstants::RESOURCES_INDEX;
902             }
903 
904             innerModuleInfos_.at(currentPackage_).moduleResPath = moduleResPath;
905             for (auto &abilityInfo : baseAbilityInfos_) {
906                 abilityInfo.second.resourcePath = moduleResPath;
907             }
908             for (auto &extensionInfo : baseExtensionInfos_) {
909                 extensionInfo.second.resourcePath = moduleResPath;
910             }
911         }
912     }
913 
AddModuleHnpsPath(const std::string & moduleSrcDir)914     void AddModuleHnpsPath(const std::string &moduleSrcDir)
915     {
916         if (innerModuleInfos_.count(currentPackage_) == 1) {
917             std::string moduleHnpsPath = moduleSrcDir +  ServiceConstants::PATH_SEPARATOR +
918                 ServiceConstants::HNPS_FILE_PATH;
919             innerModuleInfos_.at(currentPackage_).moduleHnpsPath = moduleHnpsPath;
920         }
921     }
922 
923     void SetModuleHapPath(const std::string &hapPath);
924 
GetModuleHapPath(const std::string & modulePackage)925     const std::string GetModuleHapPath(const std::string &modulePackage) const
926     {
927         if (innerModuleInfos_.find(modulePackage) != innerModuleInfos_.end()) {
928             return innerModuleInfos_.at(modulePackage).hapPath;
929         }
930 
931         return Constants::EMPTY_STRING;
932     }
933 
GetModuleName(const std::string & modulePackage)934     const std::string GetModuleName(const std::string &modulePackage) const
935     {
936         if (innerModuleInfos_.find(modulePackage) != innerModuleInfos_.end()) {
937             return innerModuleInfos_.at(modulePackage).moduleName;
938         }
939 
940         return Constants::EMPTY_STRING;
941     }
942 
943     const std::string GetCurModuleName() const;
944 
GetDefinePermissions()945     std::vector<DefinePermission> GetDefinePermissions() const
946     {
947         std::vector<DefinePermission> definePermissions;
948         if (innerModuleInfos_.count(currentPackage_) == 1) {
949             definePermissions = innerModuleInfos_.at(currentPackage_).definePermissions;
950         }
951         return definePermissions;
952     }
953 
GetRequestPermissions()954     std::vector<RequestPermission> GetRequestPermissions() const
955     {
956         std::vector<RequestPermission> requestPermissions;
957         if (innerModuleInfos_.count(currentPackage_) == 1) {
958             requestPermissions = innerModuleInfos_.at(currentPackage_).requestPermissions;
959         }
960         return requestPermissions;
961     }
962 
963     std::vector<DefinePermission> GetAllDefinePermissions() const;
964 
965     std::vector<RequestPermission> GetAllRequestPermissions() const;
966 
FindModule(std::string modulePackage)967     bool FindModule(std::string modulePackage) const
968     {
969         return (innerModuleInfos_.find(modulePackage) != innerModuleInfos_.end());
970     }
971 
IsEntryModule(std::string modulePackage)972     bool IsEntryModule(std::string modulePackage) const
973     {
974         if (FindModule(modulePackage)) {
975             return innerModuleInfos_.at(modulePackage).isEntry;
976         }
977         return false;
978     }
979 
980     std::string GetEntryModuleName() const;
981 
GetIsKeepAlive()982     bool GetIsKeepAlive() const
983     {
984         return baseBundleInfo_->isKeepAlive;
985     }
986 
SetIsFreeInstallApp(bool isFreeInstall)987     void SetIsFreeInstallApp(bool isFreeInstall)
988     {
989         baseApplicationInfo_->isFreeInstallApp = isFreeInstall;
990     }
991 
GetIsFreeInstallApp()992     bool GetIsFreeInstallApp() const
993     {
994         return baseApplicationInfo_->isFreeInstallApp;
995     }
996 
997     std::string GetMainAbility() const;
998 
999     void GetMainAbilityInfo(AbilityInfo &abilityInfo) const;
1000 
GetModuleDir(std::string modulePackage)1001     std::string GetModuleDir(std::string modulePackage) const
1002     {
1003         if (innerModuleInfos_.find(modulePackage) != innerModuleInfos_.end()) {
1004             return innerModuleInfos_.at(modulePackage).modulePath;
1005         }
1006         return Constants::EMPTY_STRING;
1007     }
1008 
GetModuleDataDir(std::string modulePackage)1009     std::string GetModuleDataDir(std::string modulePackage) const
1010     {
1011         if (innerModuleInfos_.find(modulePackage) != innerModuleInfos_.end()) {
1012             return innerModuleInfos_.at(modulePackage).moduleDataDir;
1013         }
1014         return Constants::EMPTY_STRING;
1015     }
1016 
IsDisabled()1017     bool IsDisabled() const
1018     {
1019         return (bundleStatus_ == BundleStatus::DISABLED);
1020     }
1021 
IsEnabled()1022     bool IsEnabled() const
1023     {
1024         return (bundleStatus_ == BundleStatus::ENABLED);
1025     }
1026 
IsOnlyModule(const std::string & modulePackage)1027     bool IsOnlyModule(const std::string &modulePackage)
1028     {
1029         if ((innerModuleInfos_.size() == 1) && (innerModuleInfos_.count(modulePackage) == 1)) {
1030             return true;
1031         }
1032         return false;
1033     }
1034 
SetProvisionId(const std::string & provisionId)1035     void SetProvisionId(const std::string &provisionId)
1036     {
1037         baseBundleInfo_->appId = baseBundleInfo_->name + Constants::FILE_UNDERLINE + provisionId;
1038     }
1039 
GetProvisionId()1040     std::string GetProvisionId() const
1041     {
1042         if (!baseBundleInfo_->appId.empty()) {
1043             return baseBundleInfo_->appId.substr(baseBundleInfo_->name.size() + 1);
1044         }
1045         return "";
1046     }
1047 
GetAppId()1048     std::string GetAppId() const
1049     {
1050         return baseBundleInfo_->appId;
1051     }
1052 
SetAppFeature(const std::string & appFeature)1053     void SetAppFeature(const std::string &appFeature)
1054     {
1055         appFeature_ = appFeature;
1056     }
1057 
GetAppFeature()1058     std::string GetAppFeature() const
1059     {
1060         return appFeature_;
1061     }
1062 
SetAppPrivilegeLevel(const std::string & appPrivilegeLevel)1063     void SetAppPrivilegeLevel(const std::string &appPrivilegeLevel)
1064     {
1065         if (appPrivilegeLevel.empty()) {
1066             return;
1067         }
1068         baseApplicationInfo_->appPrivilegeLevel = appPrivilegeLevel;
1069     }
1070 
GetAppPrivilegeLevel()1071     std::string GetAppPrivilegeLevel() const
1072     {
1073         return baseApplicationInfo_->appPrivilegeLevel;
1074     }
1075 
1076     bool HasEntry() const;
1077 
1078     bool IsHsp() const;
1079 
1080     /**
1081      * @brief Insert formInfo.
1082      * @param keyName Indicates object as key.
1083      * @param formInfos Indicates the formInfo object as value.
1084      */
InsertFormInfos(const std::string & keyName,const std::vector<FormInfo> & formInfos)1085     void InsertFormInfos(const std::string &keyName, const std::vector<FormInfo> &formInfos)
1086     {
1087         formInfos_.emplace(keyName, formInfos);
1088     }
1089     /**
1090      * @brief Insert commonEvent.
1091      * @param keyName Indicates object as key.
1092      * @param commonEvents Indicates the common event object as value.
1093      */
InsertCommonEvents(const std::string & keyName,const CommonEventInfo & commonEvents)1094     void InsertCommonEvents(const std::string &keyName, const CommonEventInfo &commonEvents)
1095     {
1096         commonEvents_.emplace(keyName, commonEvents);
1097     }
1098     /**
1099      * @brief Insert shortcutInfos.
1100      * @param keyName Indicates object as key.
1101      * @param shortcutInfos Indicates the shortcutInfos object as value.
1102      */
InsertShortcutInfos(const std::string & keyName,const ShortcutInfo & shortcutInfos)1103     void InsertShortcutInfos(const std::string &keyName, const ShortcutInfo &shortcutInfos)
1104     {
1105         shortcutInfos_.emplace(keyName, shortcutInfos);
1106     }
1107     // use for new Info in updating progress
RestoreFromOldInfo(const InnerBundleInfo & oldInfo)1108     void RestoreFromOldInfo(const InnerBundleInfo &oldInfo)
1109     {
1110         SetAppCodePath(oldInfo.GetAppCodePath());
1111         SetUid(oldInfo.GetUid());
1112         SetGid(oldInfo.GetGid());
1113     }
RestoreModuleInfo(const InnerBundleInfo & oldInfo)1114     void RestoreModuleInfo(const InnerBundleInfo &oldInfo)
1115     {
1116         if (oldInfo.FindModule(currentPackage_)) {
1117             innerModuleInfos_.at(currentPackage_).moduleDataDir = oldInfo.GetModuleDataDir(currentPackage_);
1118         }
1119     }
1120 
SetModuleHashValue(const std::string & hashValue)1121     void SetModuleHashValue(const std::string &hashValue)
1122     {
1123         if (innerModuleInfos_.count(currentPackage_) == 1) {
1124             innerModuleInfos_.at(currentPackage_).hashValue = hashValue;
1125         }
1126     }
1127 
SetModuleCpuAbi(const std::string & cpuAbi)1128     void SetModuleCpuAbi(const std::string &cpuAbi)
1129     {
1130         if (innerModuleInfos_.count(currentPackage_) == 1) {
1131             innerModuleInfos_.at(currentPackage_).cpuAbi = cpuAbi;
1132         }
1133     }
1134 
SetModuleNativeLibraryPath(const std::string & nativeLibraryPath)1135     void SetModuleNativeLibraryPath(const std::string &nativeLibraryPath)
1136     {
1137         if (innerModuleInfos_.count(currentPackage_) == 1) {
1138             innerModuleInfos_.at(currentPackage_).nativeLibraryPath = nativeLibraryPath;
1139         }
1140     }
1141 
1142     /**
1143      * @brief Set ability enabled.
1144      * @param moduleName Indicates the moduleName.
1145      * @param abilityName Indicates the abilityName.
1146      * @param isEnabled Indicates the ability enabled.
1147      * @param userId Indicates the user id.
1148      * @return Returns ERR_OK if the setAbilityEnabled is successfully; returns error code otherwise.
1149      */
1150     ErrCode SetAbilityEnabled(
1151         const std::string &moduleName,
1152         const std::string &abilityName,
1153         bool isEnabled,
1154         int32_t userId);
1155     /**
1156      * @brief Set the Application Need Recover object
1157      * @param moduleName Indicates the module name of the application.
1158      * @param upgradeFlag Indicates the module is need update or not.
1159      * @return Return ERR_OK if set data successfully.
1160      */
1161     ErrCode SetModuleUpgradeFlag(std::string moduleName, int32_t upgradeFlag);
1162 
1163     /**
1164      * @brief Get the Application Need Recover object
1165      * @param moduleName Indicates the module name of the application.
1166      * @return upgradeFlag type,NOT_UPGRADE means not need to be upgraded,SINGLE_UPGRADE means
1167      *         single module need to be upgraded,RELATION_UPGRADE means relation module need to be upgraded.
1168      */
1169     int32_t GetModuleUpgradeFlag(std::string moduleName) const;
1170 
1171     void GetApplicationInfo(int32_t flags, int32_t userId, ApplicationInfo &appInfo, int32_t appIndex = 0) const;
1172     ErrCode GetApplicationInfoV9(int32_t flags, int32_t userId, ApplicationInfo &appInfo, int32_t appIndex = 0) const;
1173     bool GetBundleInfo(int32_t flags, BundleInfo &bundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID,
1174         int32_t appIndex = 0) const;
1175     ErrCode GetBundleInfoV9(int32_t flags,
1176         BundleInfo &bundleInfo, int32_t userId = Constants::UNSPECIFIED_USERID, int32_t appIndex = 0) const;
1177     bool CheckSpecialMetaData(const std::string &metaData) const;
1178     /**
1179      * @brief Obtains the FormInfo objects provided by all applications on the device.
1180      * @param moduleName Indicates the module name of the application.
1181      * @param formInfos List of FormInfo objects if obtained;
1182      */
1183     void GetFormsInfoByModule(const std::string &moduleName, std::vector<FormInfo> &formInfos) const;
1184     /**
1185      * @brief Obtains the FormInfo objects provided by a specified application on the device.
1186      * @param formInfos List of FormInfo objects if obtained;
1187      */
1188     void GetFormsInfoByApp(std::vector<FormInfo> &formInfos) const;
1189     /**
1190      * @brief Obtains the ShortcutInfo objects provided by a specified application on the device.
1191      * @param shortcutInfos List of ShortcutInfo objects if obtained.
1192      */
1193     void GetShortcutInfos(std::vector<ShortcutInfo> &shortcutInfos) const;
1194     /**
1195      * @brief Obtains the common event objects provided by a specified application on the device.
1196      * @param commonEvents List of common event objects if obtained.
1197      */
1198     void GetCommonEvents(const std::string &eventKey, std::vector<CommonEventInfo> &commonEvents) const;
1199 
1200 
1201     std::optional<InnerModuleInfo> GetInnerModuleInfoByModuleName(const std::string &moduleName) const;
1202     std::optional<std::vector<HnpPackage>> GetInnerModuleInfoHnpInfo(const std::string &moduleName) const;
1203     std::string GetInnerModuleInfoHnpPath(const std::string &moduleName) const;
1204     void GetModuleNames(std::vector<std::string> &moduleNames) const;
1205 
AddExtendResourceInfos(std::vector<ExtendResourceInfo> extendResourceInfos)1206     void AddExtendResourceInfos(std::vector<ExtendResourceInfo> extendResourceInfos)
1207     {
1208         for (const auto &extendResourceInfo : extendResourceInfos) {
1209             extendResourceInfos_[extendResourceInfo.moduleName] = extendResourceInfo;
1210         }
1211     }
1212 
RemoveExtendResourceInfo(const std::string & moduleName)1213     void RemoveExtendResourceInfo(const std::string &moduleName)
1214     {
1215         auto iter = extendResourceInfos_.find(moduleName);
1216         if (iter != extendResourceInfos_.end()) {
1217             extendResourceInfos_.erase(iter);
1218         }
1219     }
1220 
RemoveExtendResourceInfos(const std::vector<std::string> & moduleNames)1221     void RemoveExtendResourceInfos(const std::vector<std::string> &moduleNames)
1222     {
1223         for (const auto &moduleName : moduleNames) {
1224             RemoveExtendResourceInfo(moduleName);
1225         }
1226     }
1227 
GetExtendResourceInfos()1228     const std::map<std::string, ExtendResourceInfo> &GetExtendResourceInfos() const
1229     {
1230         return extendResourceInfos_;
1231     }
1232 
GetCurDynamicIconModule()1233     const std::string &GetCurDynamicIconModule() const
1234     {
1235         return curDynamicIconModule_;
1236     }
1237 
SetCurDynamicIconModule(const std::string & curDynamicIconModule)1238     void SetCurDynamicIconModule(const std::string &curDynamicIconModule)
1239     {
1240         curDynamicIconModule_ = curDynamicIconModule;
1241     }
1242 
GetIconId()1243     uint32_t GetIconId() const
1244     {
1245         return baseApplicationInfo_->iconId;
1246     }
1247 
SetIconId(uint32_t iconId)1248     void SetIconId(uint32_t iconId)
1249     {
1250         baseApplicationInfo_->iconId = iconId;
1251     }
1252 
GetInnerModuleInfos()1253     const std::map<std::string, InnerModuleInfo> &GetInnerModuleInfos() const
1254     {
1255         return innerModuleInfos_;
1256     }
1257     /**
1258      * @brief Fetch all innerModuleInfos, can be modify.
1259      */
FetchInnerModuleInfos()1260     std::map<std::string, InnerModuleInfo> &FetchInnerModuleInfos()
1261     {
1262         return innerModuleInfos_;
1263     }
1264     /**
1265      * @brief Fetch all abilityInfos, can be modify.
1266      */
FetchAbilityInfos()1267     std::map<std::string, AbilityInfo> &FetchAbilityInfos()
1268     {
1269         return baseAbilityInfos_;
1270     }
1271     /**
1272      * @brief Obtains all abilityInfos.
1273      */
GetInnerAbilityInfos()1274     const std::map<std::string, AbilityInfo> &GetInnerAbilityInfos() const
1275     {
1276         return baseAbilityInfos_;
1277     }
1278     /**
1279      * @brief Obtains all skillInfos.
1280      */
GetInnerSkillInfos()1281     const std::map<std::string, std::vector<Skill>> &GetInnerSkillInfos() const
1282     {
1283         return skillInfos_;
1284     }
1285     /**
1286      * @brief Fetch all extensionAbilityInfos, can be modify.
1287      */
FetchInnerExtensionInfos()1288     std::map<std::string, ExtensionAbilityInfo> &FetchInnerExtensionInfos()
1289     {
1290         return baseExtensionInfos_;
1291     }
1292     /**
1293      * @brief Obtains all extensionAbilityInfos.
1294      */
GetInnerExtensionInfos()1295     const std::map<std::string, ExtensionAbilityInfo> &GetInnerExtensionInfos() const
1296     {
1297         return baseExtensionInfos_;
1298     }
1299     /**
1300      * @brief Obtains all extensionSkillInfos.
1301      */
GetExtensionSkillInfos()1302     const std::map<std::string, std::vector<Skill>> &GetExtensionSkillInfos() const
1303     {
1304         return  extensionSkillInfos_;
1305     }
1306     /**
1307      * @brief Get the bundle is whether removable.
1308      * @return Return whether the bundle is removable.
1309      */
IsRemovable()1310     bool IsRemovable() const
1311     {
1312         return baseApplicationInfo_->removable;
1313     }
SetIsPreInstallApp(bool isPreInstallApp)1314     void SetIsPreInstallApp(bool isPreInstallApp)
1315     {
1316         baseBundleInfo_->isPreInstallApp = isPreInstallApp;
1317     }
IsPreInstallApp()1318     bool IsPreInstallApp() const
1319     {
1320         return baseBundleInfo_->isPreInstallApp;
1321     }
1322     /**
1323      * @brief Get whether the bundle is a system app.
1324      * @return Return whether the bundle is a system app.
1325      */
IsSystemApp()1326     bool IsSystemApp() const
1327     {
1328         return baseApplicationInfo_->isSystemApp;
1329     }
1330     /**
1331      * @brief Get all InnerBundleUserInfo.
1332      * @return Return about all userinfo under the app.
1333      */
GetInnerBundleUserInfos()1334     const std::map<std::string, InnerBundleUserInfo>& GetInnerBundleUserInfos() const
1335     {
1336         return innerBundleUserInfos_;
1337     }
1338     /**
1339      * @brief Reset bundle state.
1340      * @param userId Indicates the userId to set.
1341      */
1342     void ResetBundleState(int32_t userId);
1343     /**
1344      * @brief Set userId to remove userinfo.
1345      * @param userId Indicates the userId to set.
1346      */
1347     void RemoveInnerBundleUserInfo(int32_t userId);
1348     /**
1349      * @brief Set userId to add userinfo.
1350      * @param userId Indicates the userInfo to set.
1351      */
1352     void AddInnerBundleUserInfo(const InnerBundleUserInfo& userInfo);
1353     /**
1354      * @brief Set userId to add userinfo.
1355      * @param userId Indicates the userInfo to set.
1356      * @param userInfo Indicates the userInfo to get.
1357      * @return Return whether the user information is obtained successfully.
1358      */
1359     bool GetInnerBundleUserInfo(int32_t userId, InnerBundleUserInfo& userInfo) const;
1360     /**
1361      * @brief  Check whether the user exists.
1362      * @param userId Indicates the userInfo to set.
1363      * @return Return whether the user exists..
1364      */
1365     bool HasInnerBundleUserInfo(int32_t userId) const;
1366     /**
1367      * @brief  Check whether onlyCreateBundleUser.
1368      * @return Return onlyCreateBundleUser.
1369      */
IsOnlyCreateBundleUser()1370     bool IsOnlyCreateBundleUser() const
1371     {
1372         return onlyCreateBundleUser_;
1373     }
1374     /**
1375      * @brief Set onlyCreateBundleUser.
1376      * @param onlyCreateBundleUser Indicates the onlyCreateBundleUser.
1377      */
SetOnlyCreateBundleUser(bool onlyCreateBundleUser)1378     void SetOnlyCreateBundleUser(bool onlyCreateBundleUser)
1379     {
1380         onlyCreateBundleUser_ = onlyCreateBundleUser;
1381     }
1382     /**
1383      * @brief Check whether isSingleton.
1384      * @return Return isSingleton.
1385      */
IsSingleton()1386     bool IsSingleton() const
1387     {
1388         return baseApplicationInfo_->singleton;
1389     }
1390     /**
1391      * @brief Get response userId.
1392      * @param userId Indicates the request userId..
1393      * @return Return response userId.
1394      */
1395     int32_t GetResponseUserId(int32_t requestUserId) const;
1396 
GetModuleNameVec()1397     std::vector<std::string> GetModuleNameVec() const
1398     {
1399         std::vector<std::string> moduleVec;
1400         for (const auto &it : innerModuleInfos_) {
1401             moduleVec.emplace_back(it.first);
1402         }
1403         return moduleVec;
1404     }
1405 
GetAccessTokenId(const int32_t userId)1406     uint32_t GetAccessTokenId(const int32_t userId) const
1407     {
1408         InnerBundleUserInfo userInfo;
1409         if (GetInnerBundleUserInfo(userId, userInfo)) {
1410             return userInfo.accessTokenId;
1411         }
1412         return 0;
1413     }
1414 
1415     void SetAccessTokenId(uint32_t accessToken, const int32_t userId);
1416 
GetAccessTokenIdEx(const int32_t userId)1417     uint64_t GetAccessTokenIdEx(const int32_t userId) const
1418     {
1419         InnerBundleUserInfo userInfo;
1420         if (GetInnerBundleUserInfo(userId, userInfo)) {
1421             return userInfo.accessTokenIdEx;
1422         }
1423         return 0;
1424     }
1425 
1426     void SetAccessTokenIdEx(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx, const int32_t userId);
1427 
1428     void SetAccessTokenIdExWithAppIndex(
1429         const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
1430         const int32_t userId, const int32_t appIndex);
1431 
SetIsNewVersion(bool flag)1432     void SetIsNewVersion(bool flag)
1433     {
1434         isNewVersion_ = flag;
1435     }
1436 
GetIsNewVersion()1437     bool GetIsNewVersion() const
1438     {
1439         return isNewVersion_;
1440     }
1441 
GetAsanEnabled()1442     bool GetAsanEnabled() const
1443     {
1444         return baseApplicationInfo_->asanEnabled;
1445     }
1446 
SetAsanEnabled(bool asanEnabled)1447     void SetAsanEnabled(bool asanEnabled)
1448     {
1449         baseApplicationInfo_->asanEnabled = asanEnabled;
1450     }
1451 
SetAllowedAcls(const std::vector<std::string> & allowedAcls)1452     void SetAllowedAcls(const std::vector<std::string> &allowedAcls)
1453     {
1454         allowedAcls_.clear();
1455         for (const auto &acl : allowedAcls) {
1456             if (!acl.empty()) {
1457                 allowedAcls_.emplace_back(acl);
1458             }
1459         }
1460     }
1461 
GetAllowedAcls()1462     std::vector<std::string> GetAllowedAcls() const
1463     {
1464         return allowedAcls_;
1465     }
1466 
1467     /**
1468      * @brief ability is enabled.
1469      * @param abilityInfo Indicates the abilityInfo.
1470      * @param userId Indicates the user Id.
1471      * @return Return set ability enabled result.
1472      */
1473     bool IsAbilityEnabled(const AbilityInfo &abilityInfo, int32_t userId,
1474         int32_t appIndex = 0) const;
1475     ErrCode IsAbilityEnabledV9(const AbilityInfo &abilityInfo,
1476         int32_t userId, bool &isEnable, int32_t appIndex = 0) const;
1477 
IsAccessible()1478     bool IsAccessible() const
1479     {
1480         return baseApplicationInfo_->accessible;
1481     }
1482 
1483     bool GetDependentModuleNames(const std::string &moduleName, std::vector<std::string> &dependentModuleNames) const;
1484 
1485     bool GetAllDependentModuleNames(const std::string &moduleName,
1486         std::vector<std::string> &dependentModuleNames) const;
1487 
1488     bool IsBundleRemovable() const;
1489     /**
1490      * @brief Which modules can be removed.
1491      * @param moduleToDelete Indicates the modules.
1492      * @return Return get module isRemoved result
1493      */
1494     bool GetRemovableModules(std::vector<std::string> &moduleToDelete) const;
1495     /**
1496      * @brief Get freeInstall module.
1497      * @param freeInstallModule Indicates the modules.
1498      * @return Return get freeInstall module result
1499      */
1500     bool GetFreeInstallModules(std::vector<std::string> &freeInstallModule) const;
1501     /**
1502      * @brief Whether module of userId is exist.
1503      * @param moduleName Indicates the moduleName.
1504      * @param userId Indicates the userId.
1505      * @return Return get module exist result.
1506      */
1507     bool IsUserExistModule(const std::string &moduleName, int32_t userId) const;
1508     /**
1509      * @brief whether userId's module should be removed.
1510      * @param moduleName Indicates the moduleName.
1511      * @param userId Indicates the userId.
1512      * @param isRemovable Indicates the module whether is removable.
1513      * @return Return get module isRemoved result.
1514      */
1515     ErrCode IsModuleRemovable(const std::string &moduleName, int32_t userId, bool &isRemovable) const;
1516     /**
1517      * @brief Add module removable info
1518      * @param info Indicates the innerModuleInfo of module.
1519      * @param stringUserId Indicates the string userId add to isRemovable map.
1520      * @param isEnable Indicates the value of enable module is removed.
1521      * @return Return add module isRemovable info result.
1522      */
1523     bool AddModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId, bool isEnable) const;
1524     /**
1525      * @brief Set userId's module value of isRemoved.
1526      * @param moduleName Indicates the moduleName.
1527      * @param isEnable Indicates the module isRemovable is enable.
1528      * @param userId Indicates the userId.
1529      * @return Return set module isRemoved result.
1530      */
1531     bool SetModuleRemovable(const std::string &moduleName, bool isEnable, int32_t userId);
1532     /**
1533      * @brief Delete userId isRemoved info from module.
1534      * @param moduleName Indicates the moduleName.
1535      * @param userId Indicates the userId.
1536      * @return
1537      */
1538     void DeleteModuleRemovable(const std::string &moduleName, int32_t userId);
1539     /**
1540      * @brief Delete removable info.
1541      * @param info Indicates the innerModuleInfo of module.
1542      * @param stringUserId Indicates the string userId of isRemovable map.
1543      * @return
1544      */
1545     void DeleteModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId);
1546 
SetEntryInstallationFree(bool installationFree)1547     void SetEntryInstallationFree(bool installationFree)
1548     {
1549         baseBundleInfo_->entryInstallationFree = installationFree;
1550         if (installationFree) {
1551             baseApplicationInfo_->needAppDetail = false;
1552             baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
1553         }
1554     }
1555 
GetEntryInstallationFree()1556     bool GetEntryInstallationFree() const
1557     {
1558         return baseBundleInfo_->entryInstallationFree;
1559     }
1560 
SetBundlePackInfo(const BundlePackInfo & bundlePackInfo)1561     void SetBundlePackInfo(const BundlePackInfo &bundlePackInfo)
1562     {
1563         *bundlePackInfo_ = bundlePackInfo;
1564     }
1565 
GetBundlePackInfo()1566     BundlePackInfo GetBundlePackInfo() const
1567     {
1568         return *bundlePackInfo_;
1569     }
1570 
SetAppIndex(int32_t appIndex)1571     void SetAppIndex(int32_t appIndex)
1572     {
1573         appIndex_ = appIndex;
1574     }
1575 
GetAppIndex()1576     int32_t GetAppIndex() const
1577     {
1578         return appIndex_;
1579     }
1580 
SetIsSandbox(bool isSandbox)1581     void SetIsSandbox(bool isSandbox)
1582     {
1583         isSandboxApp_ = isSandbox;
1584     }
1585 
GetIsSandbox()1586     bool GetIsSandbox() const
1587     {
1588         return isSandboxApp_;
1589     }
1590 
CleanInnerBundleUserInfos()1591     void CleanInnerBundleUserInfos()
1592     {
1593         innerBundleUserInfos_.clear();
1594     }
1595 
GetCertificateFingerprint()1596     std::string GetCertificateFingerprint() const
1597     {
1598         return baseApplicationInfo_->fingerprint;
1599     }
1600 
SetCertificateFingerprint(const std::string & fingerprint)1601     void SetCertificateFingerprint(const std::string &fingerprint)
1602     {
1603         baseApplicationInfo_->fingerprint = fingerprint;
1604     }
1605 
GetNativeLibraryPath()1606     const std::string &GetNativeLibraryPath() const
1607     {
1608         return baseApplicationInfo_->nativeLibraryPath;
1609     }
1610 
SetNativeLibraryPath(const std::string & nativeLibraryPath)1611     void SetNativeLibraryPath(const std::string &nativeLibraryPath)
1612     {
1613         baseApplicationInfo_->nativeLibraryPath = nativeLibraryPath;
1614     }
1615 
GetArkNativeFileAbi()1616     const std::string &GetArkNativeFileAbi() const
1617     {
1618         return baseApplicationInfo_->arkNativeFileAbi;
1619     }
1620 
SetArkNativeFileAbi(const std::string & arkNativeFileAbi)1621     void SetArkNativeFileAbi(const std::string &arkNativeFileAbi)
1622     {
1623         baseApplicationInfo_->arkNativeFileAbi = arkNativeFileAbi;
1624     }
1625 
GetArkNativeFilePath()1626     const std::string &GetArkNativeFilePath() const
1627     {
1628         return baseApplicationInfo_->arkNativeFilePath;
1629     }
1630 
SetArkNativeFilePath(const std::string & arkNativeFilePath)1631     void SetArkNativeFilePath(const std::string &arkNativeFilePath)
1632     {
1633         baseApplicationInfo_->arkNativeFilePath = arkNativeFilePath;
1634     }
1635 
SetAllowAppRunWhenDeviceFirstLocked(bool allowAppRunWhenDeviceFirstLocked)1636     void SetAllowAppRunWhenDeviceFirstLocked(bool allowAppRunWhenDeviceFirstLocked)
1637     {
1638         baseApplicationInfo_->allowAppRunWhenDeviceFirstLocked = allowAppRunWhenDeviceFirstLocked;
1639     }
1640 
SetAllowEnableNotification(bool allowEnableNotification)1641     void SetAllowEnableNotification(bool allowEnableNotification)
1642     {
1643         baseApplicationInfo_->allowEnableNotification = allowEnableNotification;
1644     }
1645 
GetCpuAbi()1646     const std::string &GetCpuAbi() const
1647     {
1648         return baseApplicationInfo_->cpuAbi;
1649     }
1650 
SetCpuAbi(const std::string & cpuAbi)1651     void SetCpuAbi(const std::string &cpuAbi)
1652     {
1653         baseApplicationInfo_->cpuAbi = cpuAbi;
1654     }
1655 
SetRemovable(bool removable)1656     void SetRemovable(bool removable)
1657     {
1658         baseApplicationInfo_->removable = removable;
1659     }
1660 
SetKeepAlive(bool keepAlive)1661     void SetKeepAlive(bool keepAlive)
1662     {
1663         baseApplicationInfo_->keepAlive = keepAlive;
1664         baseBundleInfo_->isKeepAlive = keepAlive;
1665     }
1666 
SetSingleton(bool singleton)1667     void SetSingleton(bool singleton)
1668     {
1669         baseApplicationInfo_->singleton = singleton;
1670         baseBundleInfo_->singleton = singleton;
1671     }
1672 
SetRunningResourcesApply(bool runningResourcesApply)1673     void SetRunningResourcesApply(bool runningResourcesApply)
1674     {
1675         baseApplicationInfo_->runningResourcesApply = runningResourcesApply;
1676     }
1677 
SetAssociatedWakeUp(bool associatedWakeUp)1678     void SetAssociatedWakeUp(bool associatedWakeUp)
1679     {
1680         baseApplicationInfo_->associatedWakeUp = associatedWakeUp;
1681     }
1682 
SetUserDataClearable(bool userDataClearable)1683     void SetUserDataClearable(bool userDataClearable)
1684     {
1685         baseApplicationInfo_->userDataClearable = userDataClearable;
1686     }
1687 
SetHideDesktopIcon(bool hideDesktopIcon)1688     void SetHideDesktopIcon(bool hideDesktopIcon)
1689     {
1690         baseApplicationInfo_->hideDesktopIcon = hideDesktopIcon;
1691         if (hideDesktopIcon) {
1692             baseApplicationInfo_->needAppDetail = false;
1693             baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
1694         }
1695     }
1696 
SetFormVisibleNotify(bool formVisibleNotify)1697     void SetFormVisibleNotify(bool formVisibleNotify)
1698     {
1699         baseApplicationInfo_->formVisibleNotify = formVisibleNotify;
1700     }
1701 
SetAllowCommonEvent(const std::vector<std::string> & allowCommonEvent)1702     void SetAllowCommonEvent(const std::vector<std::string> &allowCommonEvent)
1703     {
1704         baseApplicationInfo_->allowCommonEvent.clear();
1705         for (const auto &event : allowCommonEvent) {
1706             baseApplicationInfo_->allowCommonEvent.emplace_back(event);
1707         }
1708     }
1709 
GetOverlayBundleInfo()1710     std::vector<OverlayBundleInfo> GetOverlayBundleInfo() const
1711     {
1712         return overlayBundleInfo_;
1713     }
1714 
AddOverlayBundleInfo(const OverlayBundleInfo & overlayBundleInfo)1715     void AddOverlayBundleInfo(const OverlayBundleInfo &overlayBundleInfo)
1716     {
1717         auto iterator = std::find_if(overlayBundleInfo_.begin(), overlayBundleInfo_.end(),
1718             [&overlayBundleInfo](const auto &overlayInfo) {
1719                 return overlayInfo.bundleName == overlayBundleInfo.bundleName;
1720         });
1721         if (iterator != overlayBundleInfo_.end()) {
1722             overlayBundleInfo_.erase(iterator);
1723         }
1724         overlayBundleInfo_.emplace_back(overlayBundleInfo);
1725     }
1726 
RemoveOverLayBundleInfo(const std::string & bundleName)1727     void RemoveOverLayBundleInfo(const std::string &bundleName)
1728     {
1729         auto iterator = std::find_if(overlayBundleInfo_.begin(), overlayBundleInfo_.end(),
1730             [&bundleName](const auto &overlayInfo) {
1731                 return overlayInfo.bundleName == bundleName;
1732         });
1733         if (iterator != overlayBundleInfo_.end()) {
1734             overlayBundleInfo_.erase(iterator);
1735         }
1736     }
1737 
CleanOverLayBundleInfo()1738     void CleanOverLayBundleInfo()
1739     {
1740         overlayBundleInfo_.clear();
1741     }
1742 
GetTargetBundleName()1743     std::string GetTargetBundleName() const
1744     {
1745         return baseApplicationInfo_->targetBundleName;
1746     }
1747 
SetTargetBundleName(const std::string & targetBundleName)1748     void SetTargetBundleName(const std::string &targetBundleName)
1749     {
1750         baseApplicationInfo_->targetBundleName = targetBundleName;
1751     }
1752 
GetTargetPriority()1753     int32_t GetTargetPriority() const
1754     {
1755         return baseApplicationInfo_->targetPriority;
1756     }
1757 
SetTargetPriority(int32_t priority)1758     void SetTargetPriority(int32_t priority)
1759     {
1760         baseApplicationInfo_->targetPriority = priority;
1761     }
1762 
GetOverlayState()1763     int32_t GetOverlayState() const
1764     {
1765         return baseApplicationInfo_->overlayState;
1766     }
1767 
SetOverlayState(int32_t state)1768     void SetOverlayState(int32_t state)
1769     {
1770         baseApplicationInfo_->overlayState = state;
1771     }
1772 
GetOverlayType()1773     int32_t GetOverlayType() const
1774     {
1775         return overlayType_;
1776     }
1777 
SetOverlayType(int32_t type)1778     void SetOverlayType(int32_t type)
1779     {
1780         overlayType_ = type;
1781     }
1782 
AddOverlayModuleInfo(const OverlayModuleInfo & overlayModuleInfo)1783     void AddOverlayModuleInfo(const OverlayModuleInfo &overlayModuleInfo)
1784     {
1785         auto iterator = innerModuleInfos_.find(overlayModuleInfo.targetModuleName);
1786         if (iterator == innerModuleInfos_.end()) {
1787             return;
1788         }
1789         auto innerModuleInfo = iterator->second;
1790         auto overlayModuleInfoIt = std::find_if(innerModuleInfo.overlayModuleInfo.begin(),
1791             innerModuleInfo.overlayModuleInfo.end(), [&overlayModuleInfo](const auto &overlayInfo) {
1792             return (overlayInfo.moduleName == overlayModuleInfo.moduleName) &&
1793                 (overlayInfo.bundleName == overlayModuleInfo.bundleName);
1794         });
1795         if (overlayModuleInfoIt != innerModuleInfo.overlayModuleInfo.end()) {
1796             innerModuleInfo.overlayModuleInfo.erase(overlayModuleInfoIt);
1797         }
1798         innerModuleInfo.overlayModuleInfo.emplace_back(overlayModuleInfo);
1799         innerModuleInfos_.erase(iterator);
1800         innerModuleInfos_.try_emplace(overlayModuleInfo.targetModuleName, innerModuleInfo);
1801     }
1802 
RemoveOverlayModuleInfo(const std::string & targetModuleName,const std::string & bundleName,const std::string & moduleName)1803     void RemoveOverlayModuleInfo(const std::string &targetModuleName, const std::string &bundleName,
1804         const std::string &moduleName)
1805     {
1806         auto iterator = innerModuleInfos_.find(targetModuleName);
1807         if (iterator == innerModuleInfos_.end()) {
1808             return;
1809         }
1810         auto innerModuleInfo = iterator->second;
1811         auto overlayModuleInfoIt = std::find_if(innerModuleInfo.overlayModuleInfo.begin(),
1812             innerModuleInfo.overlayModuleInfo.end(), [&moduleName, &bundleName](const auto &overlayInfo) {
1813             return (overlayInfo.moduleName == moduleName) && (overlayInfo.bundleName == bundleName);
1814         });
1815         if (overlayModuleInfoIt == innerModuleInfo.overlayModuleInfo.end()) {
1816             return;
1817         }
1818         innerModuleInfo.overlayModuleInfo.erase(overlayModuleInfoIt);
1819         innerModuleInfos_.erase(iterator);
1820         innerModuleInfos_.try_emplace(targetModuleName, innerModuleInfo);
1821     }
1822 
RemoveAllOverlayModuleInfo(const std::string & bundleName)1823     void RemoveAllOverlayModuleInfo(const std::string &bundleName)
1824     {
1825         for (auto &innerModuleInfo : innerModuleInfos_) {
1826             innerModuleInfo.second.overlayModuleInfo.erase(std::remove_if(
1827                 innerModuleInfo.second.overlayModuleInfo.begin(), innerModuleInfo.second.overlayModuleInfo.end(),
1828                 [&bundleName](const auto &overlayInfo) {
1829                     return overlayInfo.bundleName == bundleName;
1830                 }), innerModuleInfo.second.overlayModuleInfo.end());
1831         }
1832     }
1833 
CleanAllOverlayModuleInfo()1834     void CleanAllOverlayModuleInfo()
1835     {
1836         for (auto &innerModuleInfo : innerModuleInfos_) {
1837             innerModuleInfo.second.overlayModuleInfo.clear();
1838         }
1839     }
1840 
isOverlayModule(const std::string & moduleName)1841     bool isOverlayModule(const std::string &moduleName) const
1842     {
1843         if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
1844             return true;
1845         }
1846         return !innerModuleInfos_.at(moduleName).targetModuleName.empty();
1847     }
1848 
isExistedOverlayModule()1849     bool isExistedOverlayModule() const
1850     {
1851         for (const auto &innerModuleInfo : innerModuleInfos_) {
1852             if (!innerModuleInfo.second.targetModuleName.empty()) {
1853                 return true;
1854             }
1855         }
1856         return false;
1857     }
1858 
KeepOldOverlayConnection(InnerBundleInfo & info)1859     void KeepOldOverlayConnection(InnerBundleInfo &info)
1860     {
1861         auto &newInnerModuleInfos = info.FetchInnerModuleInfos();
1862         for (const auto &innerModuleInfo : innerModuleInfos_) {
1863             if ((!innerModuleInfo.second.overlayModuleInfo.empty()) &&
1864                 (newInnerModuleInfos.find(innerModuleInfo.second.moduleName) != newInnerModuleInfos.end())) {
1865                 newInnerModuleInfos[innerModuleInfo.second.moduleName].overlayModuleInfo =
1866                     innerModuleInfo.second.overlayModuleInfo;
1867                 return;
1868             }
1869         }
1870     }
1871 
SetAsanLogPath(const std::string & asanLogPath)1872     void SetAsanLogPath(const std::string& asanLogPath)
1873     {
1874         baseApplicationInfo_->asanLogPath = asanLogPath;
1875     }
1876 
GetAsanLogPath()1877     std::string GetAsanLogPath() const
1878     {
1879         return baseApplicationInfo_->asanLogPath;
1880     }
1881 
SetApplicationBundleType(BundleType type)1882     void SetApplicationBundleType(BundleType type)
1883     {
1884         baseApplicationInfo_->bundleType = type;
1885     }
1886 
GetApplicationBundleType()1887     BundleType GetApplicationBundleType() const
1888     {
1889         return baseApplicationInfo_->bundleType;
1890     }
1891 
SetInnerModuleAtomicPreload(const std::string & moduleName,const std::vector<std::string> & preloads)1892     bool SetInnerModuleAtomicPreload(const std::string &moduleName, const std::vector<std::string> &preloads)
1893     {
1894         if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
1895             APP_LOGE("innerBundleInfo does not contain the module");
1896             return false;
1897         }
1898         innerModuleInfos_.at(moduleName).preloads = preloads;
1899         return true;
1900     }
1901 
SetAppProvisionMetadata(const std::vector<Metadata> & metadatas)1902     void SetAppProvisionMetadata(const std::vector<Metadata> &metadatas)
1903     {
1904         provisionMetadatas_ = metadatas;
1905     }
1906 
GetAppProvisionMetadata()1907     std::vector<Metadata> GetAppProvisionMetadata() const
1908     {
1909         return provisionMetadatas_;
1910     }
1911 
GetInnerSharedModuleInfos()1912     const std::map<std::string, std::vector<InnerModuleInfo>> &GetInnerSharedModuleInfos() const
1913     {
1914         return innerSharedModuleInfos_;
1915     }
1916 
GetDependencies()1917     std::vector<Dependency> GetDependencies() const
1918     {
1919         std::vector<Dependency> dependenciesList;
1920         for (auto it = innerModuleInfos_.begin(); it != innerModuleInfos_.end(); it++) {
1921             for (const auto &item : it->second.dependencies) {
1922                 dependenciesList.emplace_back(item);
1923             }
1924         }
1925         return dependenciesList;
1926     }
1927 
GetAllHspModuleNamesForVersion(uint32_t versionCode)1928     std::vector<std::string> GetAllHspModuleNamesForVersion(uint32_t versionCode) const
1929     {
1930         std::vector<std::string> hspModuleNames;
1931         for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
1932             for (const auto &item : modules) {
1933                 if (item.versionCode == versionCode) {
1934                     hspModuleNames.emplace_back(moduleName);
1935                 }
1936             }
1937         }
1938         return hspModuleNames;
1939     }
1940 
1941     void AddAllowedAcls(const std::vector<std::string> &allowedAcls);
GetModuleBuildHash(const std::string & moduleName,std::string & buildHash)1942     bool GetModuleBuildHash(const std::string &moduleName, std::string &buildHash) const
1943     {
1944         if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
1945             APP_LOGE("innerBundleInfo does not contain the module");
1946             return false;
1947         }
1948         buildHash = innerModuleInfos_.at(moduleName).buildHash;
1949         return true;
1950     }
1951 
GetDataGroupInfos()1952     const std::unordered_map<std::string, std::vector<DataGroupInfo>> GetDataGroupInfos() const
1953     {
1954         return dataGroupInfos_;
1955     }
1956 
DeleteDataGroupInfo(const std::string & dataGroupId)1957     void DeleteDataGroupInfo(const std::string &dataGroupId)
1958     {
1959         if (dataGroupInfos_.find(dataGroupId) == dataGroupInfos_.end()) {
1960             return;
1961         }
1962         dataGroupInfos_.erase(dataGroupId);
1963     }
1964 
1965     void AddDataGroupInfo(const std::string &dataGroupId, const DataGroupInfo &info);
1966 
RemoveGroupInfos(int32_t userId,const std::string & dataGroupId)1967     void RemoveGroupInfos(int32_t userId, const std::string &dataGroupId)
1968     {
1969         auto iter = dataGroupInfos_.find(dataGroupId);
1970         if (iter == dataGroupInfos_.end()) {
1971             return;
1972         }
1973         for (auto dataGroupIter = iter->second.begin(); dataGroupIter != iter->second.end(); dataGroupIter++) {
1974             if (dataGroupIter->userId == userId) {
1975                 iter->second.erase(dataGroupIter);
1976                 return;
1977             }
1978         }
1979     }
1980 
UpdateDataGroupInfos(const std::unordered_map<std::string,std::vector<DataGroupInfo>> & dataGroupInfos)1981     void UpdateDataGroupInfos(const std::unordered_map<std::string, std::vector<DataGroupInfo>> &dataGroupInfos)
1982     {
1983         std::set<int32_t> userIdList;
1984         for (auto item = dataGroupInfos.begin(); item != dataGroupInfos.end(); item++) {
1985             for (const DataGroupInfo &info : item->second) {
1986                 userIdList.insert(info.userId);
1987             }
1988         }
1989 
1990         std::vector<std::string> deletedGroupIds;
1991         for (auto &item : dataGroupInfos_) {
1992             if (dataGroupInfos.find(item.first) == dataGroupInfos.end()) {
1993                 for (int32_t userId : userIdList) {
1994                     RemoveGroupInfos(userId, item.first);
1995                 }
1996             }
1997             if (item.second.empty()) {
1998                 deletedGroupIds.emplace_back(item.first);
1999             }
2000         }
2001         for (std::string groupId : deletedGroupIds) {
2002             dataGroupInfos_.erase(groupId);
2003         }
2004         for (auto item = dataGroupInfos.begin(); item != dataGroupInfos.end(); item++) {
2005             std::string dataGroupId = item->first;
2006             for (const DataGroupInfo &info : item->second) {
2007                 AddDataGroupInfo(dataGroupId, info);
2008             }
2009         }
2010     }
2011 
SetApplicationReservedFlag(uint32_t flag)2012     void SetApplicationReservedFlag(uint32_t flag)
2013     {
2014         baseApplicationInfo_->applicationReservedFlag |= flag;
2015     }
2016 
ClearApplicationReservedFlag(uint32_t flag)2017     void ClearApplicationReservedFlag(uint32_t flag)
2018     {
2019         baseApplicationInfo_->applicationReservedFlag &= ~flag;
2020     }
2021 
GetApplicationReservedFlag()2022     uint32_t GetApplicationReservedFlag() const
2023     {
2024         return baseApplicationInfo_->applicationReservedFlag;
2025     }
2026 
SetGwpAsanEnabled(bool gwpAsanEnabled)2027     void SetGwpAsanEnabled(bool gwpAsanEnabled)
2028     {
2029         baseApplicationInfo_->gwpAsanEnabled = gwpAsanEnabled;
2030     }
2031 
GetGwpAsanEnabled()2032     bool GetGwpAsanEnabled() const
2033     {
2034         return baseApplicationInfo_->gwpAsanEnabled;
2035     }
2036 
GetTsanEnabled()2037     bool GetTsanEnabled() const
2038     {
2039         return baseApplicationInfo_->tsanEnabled;
2040     }
2041 
SetTsanEnabled(bool tsanEnabled)2042     void SetTsanEnabled(bool tsanEnabled)
2043     {
2044         baseApplicationInfo_->tsanEnabled = tsanEnabled;
2045     }
2046 
GetHwasanEnabled()2047     bool GetHwasanEnabled() const
2048     {
2049         return baseApplicationInfo_->hwasanEnabled;
2050     }
2051 
SetHwasanEnabled(bool hwasanEnabled)2052     void SetHwasanEnabled(bool hwasanEnabled)
2053     {
2054         baseApplicationInfo_->hwasanEnabled = hwasanEnabled;
2055     }
2056 
GetAppEnvironments()2057     std::vector<ApplicationEnvironment> GetAppEnvironments() const
2058     {
2059         return baseApplicationInfo_->appEnvironments;
2060     }
2061 
SetAppEnvironments(std::vector<ApplicationEnvironment> appEnvironments)2062     void SetAppEnvironments(std::vector<ApplicationEnvironment> appEnvironments)
2063     {
2064         baseApplicationInfo_->appEnvironments = appEnvironments;
2065     }
2066 
GetMaxChildProcess()2067     int32_t GetMaxChildProcess() const
2068     {
2069         return baseApplicationInfo_->maxChildProcess;
2070     }
2071 
SetMaxChildProcess(int32_t maxChildProcess)2072     void SetMaxChildProcess(int32_t maxChildProcess)
2073     {
2074         baseApplicationInfo_->maxChildProcess = maxChildProcess;
2075     }
2076 
SetOrganization(const std::string & organization)2077     void SetOrganization(const std::string &organization)
2078     {
2079         baseApplicationInfo_->organization = organization;
2080     }
2081 
GetMultiAppMaxCount()2082     int32_t GetMultiAppMaxCount() const
2083     {
2084         return baseApplicationInfo_->multiAppMode.maxCount;
2085     }
2086 
GetMultiAppModeType()2087     MultiAppModeType GetMultiAppModeType() const
2088     {
2089         return baseApplicationInfo_->multiAppMode.multiAppModeType;
2090     }
2091 
SetInstallSource(const std::string & installSource)2092     void SetInstallSource(const std::string &installSource)
2093     {
2094         baseApplicationInfo_->installSource = installSource;
2095     }
2096 
2097     void SetApplicationFlags(ApplicationInfoFlag flag);
2098 
2099     void UpdateExtensionSandboxInfo(const std::vector<std::string> &typeList);
2100     std::vector<std::string> GetAllExtensionDirsInSpecifiedModule(const std::string &moduleName) const;
2101     std::vector<std::string> GetAllExtensionDirs() const;
2102     void UpdateExtensionDataGroupInfo(const std::string &key, const std::vector<std::string> &dataGroupIds);
2103     void SetAppDistributionType(const std::string &appDistributionType);
2104 
2105     std::string GetAppDistributionType() const;
2106 
2107     void SetAppProvisionType(const std::string &appProvisionType);
2108 
2109     std::string GetAppProvisionType() const;
2110 
2111     void SetAppCrowdtestDeadline(int64_t crowdtestDeadline);
2112 
2113     int64_t GetAppCrowdtestDeadline() const;
2114 
2115     std::vector<std::string> GetDistroModuleName() const;
2116 
2117     std::string GetModuleNameByPackage(const std::string &packageName) const;
2118 
2119     std::string GetModuleTypeByPackage(const std::string &packageName) const;
2120 
2121     AppQuickFix GetAppQuickFix() const;
2122 
2123     void SetAppQuickFix(const AppQuickFix &appQuickFix);
2124 
2125     std::vector<HqfInfo> GetQuickFixHqfInfos() const;
2126 
2127     void SetQuickFixHqfInfos(const std::vector<HqfInfo> &hqfInfos);
2128 
2129     void UpdatePrivilegeCapability(const ApplicationInfo &applicationInfo);
2130     void UpdateRemovable(bool isPreInstall, bool removable);
2131     bool FetchNativeSoAttrs(
2132         const std::string &requestPackage, std::string &cpuAbi, std::string &nativeLibraryPath) const;
2133     void UpdateNativeLibAttrs(const ApplicationInfo &applicationInfo);
2134     void UpdateArkNativeAttrs(const ApplicationInfo &applicationInfo);
2135     bool IsLibIsolated(const std::string &moduleName) const;
2136     std::vector<std::string> GetDeviceType(const std::string &packageName) const;
2137     int64_t GetLastInstallationTime() const;
2138     void UpdateAppDetailAbilityAttrs();
2139     bool IsHideDesktopIcon() const;
2140     void AddApplyQuickFixFrequency();
2141     int32_t GetApplyQuickFixFrequency() const;
2142     void ResetApplyQuickFixFrequency();
2143 
2144     bool GetOverlayModuleState(const std::string &moduleName, int32_t userId, int32_t &state) const;
2145 
2146     void SetOverlayModuleState(const std::string &moduleName, int32_t state, int32_t userId);
2147 
2148     void SetOverlayModuleState(const std::string &moduleName, int32_t state);
2149 
2150     void ClearOverlayModuleStates(const std::string &moduleName);
2151 
2152     void SetInnerModuleNeedDelete(const std::string &moduleName, const bool needDelete);
2153 
2154     bool GetInnerModuleNeedDelete(const std::string &moduleName);
2155 
2156     bool GetBaseSharedBundleInfo(const std::string &moduleName, uint32_t versionCode,
2157         BaseSharedBundleInfo &baseSharedBundleInfo) const;
2158     bool GetMaxVerBaseSharedBundleInfo(const std::string &moduleName,
2159         BaseSharedBundleInfo &baseSharedBundleInfo) const;
2160     void InsertInnerSharedModuleInfo(const std::string &moduleName, const InnerModuleInfo &innerModuleInfo);
2161     void SetSharedModuleNativeLibraryPath(const std::string &nativeLibraryPath);
2162     bool GetSharedBundleInfo(SharedBundleInfo &sharedBundleInfo) const;
2163     bool GetSharedDependencies(const std::string &moduleName, std::vector<Dependency> &dependencies) const;
2164     bool GetAllSharedDependencies(const std::string &moduleName, std::vector<Dependency> &dependencies) const;
2165     std::vector<uint32_t> GetAllHspVersion() const;
2166     void DeleteHspModuleByVersion(int32_t versionCode);
2167     bool GetSharedBundleInfo(int32_t flags, BundleInfo &bundleInfo) const;
2168     ErrCode GetProxyDataInfos(const std::string &moduleName, std::vector<ProxyData> &proxyDatas) const;
2169     void GetAllProxyDataInfos(std::vector<ProxyData> &proxyDatas) const;
2170     bool IsCompressNativeLibs(const std::string &moduleName) const;
2171     void SetNativeLibraryFileNames(const std::string &moduleName, const std::vector<std::string> &fileNames);
2172     void UpdateSharedModuleInfo();
2173     AOTCompileStatus GetAOTCompileStatus(const std::string &moduleName) const;
2174     void SetAOTCompileStatus(const std::string &moduleName, AOTCompileStatus aotCompileStatus);
2175     void ResetAOTFlags();
2176     ErrCode ResetAOTCompileStatus(const std::string &moduleName);
2177     void GetInternalDependentHspInfo(const std::string &moduleName, std::vector<HspInfo> &hspInfoVector) const;
2178     ErrCode SetExtName(const std::string &moduleName, const std::string &abilityName, const std::string extName);
2179     ErrCode SetMimeType(const std::string &moduleName, const std::string &abilityName, const std::string mimeType);
2180     ErrCode DelExtName(const std::string &moduleName, const std::string &abilityName, const std::string extName);
2181     ErrCode DelMimeType(const std::string &moduleName, const std::string &abilityName, const std::string extName);
2182     void SetResourcesApply(const std::vector<int32_t> &resourcesApply);
2183     void SetAppIdentifier(const std::string &appIdentifier);
2184     void SetCertificate(const std::string &certificate);
2185     std::string GetCertificate() const;
2186     std::string GetAppIdentifier() const;
2187     void AddOldAppId(const std::string &appId);
2188     std::vector<std::string> GetOldAppIds() const;
2189     void SetMoudleIsEncrpted(const std::string &packageName, bool isEncrypted);
2190     bool IsEncryptedMoudle(const std::string &packageName) const;
2191     void GetAllEncryptedModuleNames(std::vector<std::string> &moduleNames) const;
2192     bool IsContainEncryptedModule() const;
2193     void UpdateDebug(bool debug, bool isEntry);
2194     ErrCode GetAppServiceHspInfo(BundleInfo &bundleInfo) const;
2195     std::vector<std::string> GetQuerySchemes() const;
2196     void UpdateOdid(const std::string &developerId, const std::string &odid);
2197     void UpdateOdidByBundleInfo(const InnerBundleInfo &info);
2198     void GetDeveloperidAndOdid(std::string &developerId, std::string &odid) const;
2199     void GetOdid(std::string &odid) const;
2200     bool IsAsanEnabled() const;
2201     bool IsGwpAsanEnabled() const;
2202     bool IsTsanEnabled() const;
2203     bool GetUninstallState() const;
2204     void SetUninstallState(const bool &uninstallState);
2205     bool IsNeedSendNotify() const;
2206     void SetNeedSendNotify(const bool needStatus);
2207     void UpdateMultiAppMode(const InnerBundleInfo &newInfo);
2208     void UpdateReleaseType(const InnerBundleInfo &newInfo);
2209     ErrCode AddCloneBundle(const InnerBundleCloneInfo &attr);
2210     ErrCode RemoveCloneBundle(const int32_t userId, const int32_t appIndex);
2211     ErrCode GetAvailableCloneAppIndex(const int32_t userId, int32_t &appIndex);
2212     ErrCode IsCloneAppIndexExisted(const int32_t userId, const int32_t appIndex, bool &res);
2213     void SetkeyId(const int32_t userId, const std::string &keyId);
2214     bool GetApplicationInfoAdaptBundleClone(const InnerBundleUserInfo &innerBundleUserInfo, int32_t appIndex,
2215         ApplicationInfo &appInfo) const;
2216     bool GetBundleInfoAdaptBundleClone(const InnerBundleUserInfo &innerBundleUserInfo, int32_t appIndex,
2217         BundleInfo &bundleInfo) const;
2218     ErrCode VerifyAndAckCloneAppIndex(int32_t userId, int32_t &appIndex);
2219     void AdaptMainLauncherResourceInfo(ApplicationInfo &applicationInfo) const;
2220     bool IsHwasanEnabled() const;
2221     std::set<int32_t> GetCloneBundleAppIndexes() const;
2222     static uint8_t GetSanitizerFlag(GetInnerModuleInfoFlag flag);
2223     void InnerProcessShortcut(const Shortcut &oldShortcut, ShortcutInfo &shortcutInfo) const;
2224 
2225 private:
2226     bool IsExistLauncherAbility() const;
2227     void GetBundleWithAbilities(
2228         int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId = Constants::UNSPECIFIED_USERID) const;
2229     void GetBundleWithExtension(
2230         int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId = Constants::UNSPECIFIED_USERID) const;
2231     void BuildDefaultUserInfo();
2232     void RemoveDuplicateName(std::vector<std::string> &name) const;
2233     void GetBundleWithReqPermissionsV9(
2234         int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex = 0) const;
2235     void ProcessBundleFlags(
2236         int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex = 0) const;
2237     void ProcessBundleWithHapModuleInfoFlag(
2238         int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex = 0) const;
2239     void GetBundleWithAbilitiesV9(
2240         int32_t flags, HapModuleInfo &hapModuleInfo, int32_t userId, int32_t appIndex = 0) const;
2241     void GetBundleWithExtensionAbilitiesV9(int32_t flags, HapModuleInfo &hapModuleInfo, int32_t appIndex = 0) const;
2242     IsolationMode GetIsolationMode(const std::string &isolationMode) const;
2243     void UpdateIsCompressNativeLibs();
2244     void InnerProcessRequestPermissions(
2245         const std::unordered_map<std::string, std::string> &moduleNameMap,
2246         std::vector<RequestPermission> &requestPermissions) const;
2247     void PrintSetEnabledInfo(bool isEnabled, int32_t userId, int32_t appIndex,
2248         const std::string &bundleName, const std::string &caller) const;
2249 
2250     // using for get
2251     Constants::AppType appType_ = Constants::AppType::THIRD_PARTY_APP;
2252     int uid_ = Constants::INVALID_UID;
2253     int gid_ = ServiceConstants::INVALID_GID;
2254     int userId_ = Constants::DEFAULT_USERID;
2255     BundleStatus bundleStatus_ = BundleStatus::ENABLED;
2256     std::shared_ptr<ApplicationInfo> baseApplicationInfo_;
2257     std::shared_ptr<BundleInfo> baseBundleInfo_;  // applicationInfo and abilityInfo empty
2258     std::string appFeature_;
2259     std::vector<std::string> allowedAcls_;
2260     InstallMark mark_;
2261     int32_t appIndex_ = Constants::INITIAL_APP_INDEX;
2262     bool isSandboxApp_ = false;
2263 
2264     // only using for install or update progress, doesn't need to save to database
2265     std::string currentPackage_;
2266     // Auxiliary property, which is used when the application
2267     // has been installed when the user is created.
2268     bool onlyCreateBundleUser_ = false;
2269 
2270     std::map<std::string, InnerModuleInfo> innerModuleInfos_;
2271 
2272     std::map<std::string, std::vector<FormInfo>> formInfos_;
2273     std::map<std::string, CommonEventInfo> commonEvents_;
2274     std::map<std::string, ShortcutInfo> shortcutInfos_;
2275 
2276     std::map<std::string, AbilityInfo> baseAbilityInfos_;
2277     std::map<std::string, std::vector<Skill>> skillInfos_;
2278 
2279     std::map<std::string, InnerBundleUserInfo> innerBundleUserInfos_;
2280 
2281     std::shared_ptr<BundlePackInfo> bundlePackInfo_;
2282     // new version fields
2283     bool isNewVersion_ = false;
2284     std::map<std::string, ExtensionAbilityInfo> baseExtensionInfos_;
2285     std::map<std::string, std::vector<Skill>> extensionSkillInfos_;
2286 
2287     // quick fix hqf info
2288     std::vector<HqfInfo> hqfInfos_;
2289     // apply quick fix frequency
2290     int32_t applyQuickFixFrequency_ = 0;
2291 
2292     // overlay bundleInfo
2293     std::vector<OverlayBundleInfo> overlayBundleInfo_;
2294     int32_t overlayType_ = NON_OVERLAY_TYPE;
2295 
2296     // provision metadata
2297     std::vector<Metadata> provisionMetadatas_;
2298 
2299     // shared module info
2300     std::map<std::string, std::vector<InnerModuleInfo>> innerSharedModuleInfos_ ;
2301 
2302     // data group info
2303     std::unordered_map<std::string, std::vector<DataGroupInfo>> dataGroupInfos_;
2304 
2305     // key:moduleName value:ExtendResourceInfo
2306     std::map<std::string, ExtendResourceInfo> extendResourceInfos_;
2307     // curDynamicIconModule only in ExtendResourceInfos
2308     std::string curDynamicIconModule_;
2309 
2310     // for odid
2311     std::string developerId_;
2312     std::string odid_;
2313 
2314     // use to control uninstalling
2315     bool uninstallState_ = true;
2316 
2317     // need to send a notification when uninstallState_ change
2318     bool isNeedSendNotify_ = false;
2319 };
2320 
2321 void from_json(const nlohmann::json &jsonObject, InnerModuleInfo &info);
2322 void from_json(const nlohmann::json &jsonObject, Distro &distro);
2323 void from_json(const nlohmann::json &jsonObject, InstallMark &installMark);
2324 void from_json(const nlohmann::json &jsonObject, DefinePermission &definePermission);
2325 void from_json(const nlohmann::json &jsonObject, Dependency &dependency);
2326 void from_json(const nlohmann::json &jsonObject, OverlayBundleInfo &overlayBundleInfo);
2327 void from_json(const nlohmann::json &jsonObject, ExtendResourceInfo &extendResourceInfo);
2328 void to_json(nlohmann::json &jsonObject, const ExtendResourceInfo &extendResourceInfo);
2329 }  // namespace AppExecFwk
2330 }  // namespace OHOS
2331 #endif  // FOUNDATION_APPEXECFWK_SERVICES_BUNDLEMGR_INCLUDE_INNER_BUNDLE_INFO_H
2332