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