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