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