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