1 /* 2 * Copyright (c) 2023-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 OHOS_ABILITY_RUNTIME_SERVICE_ROUTER_FRAMEWORK_SERVICES_INCLUDE_SERVICE_ROUTER_UTIL_H 17 #define OHOS_ABILITY_RUNTIME_SERVICE_ROUTER_FRAMEWORK_SERVICES_INCLUDE_SERVICE_ROUTER_UTIL_H 18 19 #include <string> 20 #include <vector> 21 22 #include "bundle_constants.h" 23 #include "bundle_info.h" 24 #include "hilog_tag_wrapper.h" 25 #include "inner_service_info.h" 26 #include "service_info.h" 27 #include "sr_constants.h" 28 #include "string_ex.h" 29 30 namespace OHOS { 31 namespace AbilityRuntime { 32 namespace { 33 static std::unordered_map<std::string, BusinessType> BUSINESS_TYPE_MAP = { 34 {"share", BusinessType::SHARE}}; 35 } 36 class BundleInfoResolveUtil { 37 public: ResolveBundleInfo(const BundleInfo & bundleInfo,std::vector<PurposeInfo> & purposeInfos,std::vector<BusinessAbilityInfo> & businessAbilityInfos,const AppInfo & appInfo)38 static bool ResolveBundleInfo(const BundleInfo &bundleInfo, std::vector<PurposeInfo> &purposeInfos, 39 std::vector<BusinessAbilityInfo> &businessAbilityInfos, const AppInfo &appInfo) 40 { 41 if (bundleInfo.name.empty()) { 42 TAG_LOGE(AAFwkTag::SER_ROUTER, "BundleInfo invalid"); 43 return false; 44 } 45 ResolveAbilityInfos(bundleInfo.abilityInfos, purposeInfos, appInfo); 46 ResolveExtAbilityInfos(bundleInfo.extensionInfos, purposeInfos, businessAbilityInfos, appInfo); 47 if (purposeInfos.empty() && businessAbilityInfos.empty()) { 48 TAG_LOGE(AAFwkTag::SER_ROUTER, 49 "Not support, bundleName: %{public}s", bundleInfo.name.c_str()); 50 return false; 51 } 52 return true; 53 } 54 findBusinessType(const std::string businessType)55 static BusinessType findBusinessType(const std::string businessType) 56 { 57 if (businessType.empty()) { 58 return BusinessType::UNSPECIFIED; 59 } 60 61 auto item = BUSINESS_TYPE_MAP.find(LowerStr(businessType)); 62 if (item != BUSINESS_TYPE_MAP.end()) { 63 return item->second; 64 } 65 return BusinessType::UNSPECIFIED; 66 } 67 GetBusinessType(const std::vector<Metadata> & metadata)68 static BusinessType GetBusinessType(const std::vector<Metadata> &metadata) 69 { 70 std::string businessType = GetExtAbilityMetadataValue(metadata, SrConstants::METADATA_SERVICE_TYPE_KEY); 71 return findBusinessType(businessType); 72 } 73 74 private: ResolveAbilityInfos(const std::vector<AbilityInfo> & abilityInfos,std::vector<PurposeInfo> & purposeInfos,const AppInfo & appInfo)75 static void ResolveAbilityInfos(const std::vector<AbilityInfo> &abilityInfos, 76 std::vector<PurposeInfo> &purposeInfos, const AppInfo &appInfo) 77 { 78 if (abilityInfos.empty()) { 79 return; 80 } 81 for (const auto &abilityInfo : abilityInfos) { 82 ConvertAbilityToPurposes(abilityInfo, purposeInfos, appInfo); 83 } 84 } 85 ResolveExtAbilityInfos(const std::vector<ExtensionAbilityInfo> & extensionInfos,std::vector<PurposeInfo> & purposeInfos,std::vector<BusinessAbilityInfo> & businessAbilityInfos,const AppInfo & appInfo)86 static void ResolveExtAbilityInfos(const std::vector<ExtensionAbilityInfo> &extensionInfos, 87 std::vector<PurposeInfo> &purposeInfos, std::vector<BusinessAbilityInfo> &businessAbilityInfos, 88 const AppInfo &appInfo) 89 { 90 if (extensionInfos.empty()) { 91 return; 92 } 93 for (const auto &extensionInfo : extensionInfos) { 94 ConvertExtAbilityToPurposes(extensionInfo, purposeInfos, appInfo); 95 ConvertExtAbilityToService(extensionInfo, businessAbilityInfos, appInfo); 96 } 97 } 98 ConvertAbilityToPurposes(const AbilityInfo & abilityInfo,std::vector<PurposeInfo> & purposeInfos,const AppInfo & appInfo)99 static void ConvertAbilityToPurposes(const AbilityInfo &abilityInfo, std::vector<PurposeInfo> &purposeInfos, 100 const AppInfo &appInfo) 101 { 102 std::string supportPurpose = GetAbilityMetadataValue(abilityInfo, SrConstants::METADATA_SUPPORT_PURPOSE_KEY); 103 if (supportPurpose.empty()) { 104 return; 105 } 106 std::vector<std::string> purposeNames; 107 SplitStr(supportPurpose, SrConstants::MUTIL_SPLIT_KEY, purposeNames); 108 for (std::string &name : purposeNames) { 109 PurposeInfo purposeInfo; 110 purposeInfo.purposeName = name; 111 purposeInfo.abilityName = abilityInfo.name; 112 purposeInfo.moduleName = abilityInfo.moduleName; 113 purposeInfo.bundleName = abilityInfo.bundleName; 114 purposeInfo.componentType = ComponentType::UI_ABILITY; 115 purposeInfo.appInfo = appInfo; 116 purposeInfos.emplace_back(purposeInfo); 117 TAG_LOGD(AAFwkTag::SER_ROUTER, 118 "Bundle: %{public}s ,ability: %{public}s, purposeName: %{public}s", 119 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str(), name.c_str()); 120 } 121 } 122 ConvertExtAbilityToPurposes(const ExtensionAbilityInfo & extAbilityInfo,std::vector<PurposeInfo> & purposeInfos,const AppInfo & appInfo)123 static void ConvertExtAbilityToPurposes(const ExtensionAbilityInfo &extAbilityInfo, 124 std::vector<PurposeInfo> &purposeInfos, const AppInfo &appInfo) 125 { 126 if (extAbilityInfo.type != ExtensionAbilityType::FORM && extAbilityInfo.type != ExtensionAbilityType::UI) { 127 return; 128 } 129 std::string supportPurpose = GetExtAbilityMetadataValue(extAbilityInfo.metadata, 130 SrConstants::METADATA_SUPPORT_PURPOSE_KEY); 131 if (supportPurpose.empty()) { 132 return; 133 } 134 std::vector<std::string> purposes; 135 SplitStr(supportPurpose, SrConstants::MUTIL_SPLIT_KEY, purposes); 136 for (std::string &purposeAndCard : purposes) { 137 PurposeInfo purposeInfo; 138 purposeInfo.abilityName = extAbilityInfo.name; 139 purposeInfo.moduleName = extAbilityInfo.moduleName; 140 purposeInfo.bundleName = extAbilityInfo.bundleName; 141 purposeInfo.appInfo = appInfo; 142 if (extAbilityInfo.type == ExtensionAbilityType::UI) { 143 purposeInfo.purposeName = purposeAndCard; 144 purposeInfo.componentType = ComponentType::UI_EXTENSION; 145 purposeInfos.emplace_back(purposeInfo); 146 TAG_LOGD(AAFwkTag::SER_ROUTER, 147 "UIExtToPurposes, bundle: %{public}s, abilityName: %{public}s, purposeName: %{public}s", 148 extAbilityInfo.bundleName.c_str(), extAbilityInfo.name.c_str(), purposeAndCard.c_str()); 149 } else { 150 std::vector<std::string> purposeNameAndCardName; 151 SplitStr(purposeAndCard, SrConstants::FORM_PURPOSE_CARD_SPLIT_KEY, purposeNameAndCardName); 152 if (purposeNameAndCardName.size() == SrConstants::FORM_PURPOSE_CARD_SPLIT_SIZE) { 153 purposeInfo.purposeName = purposeNameAndCardName[0]; 154 purposeInfo.cardName = purposeNameAndCardName[1]; 155 purposeInfo.componentType = ComponentType::FORM; 156 purposeInfos.emplace_back(purposeInfo); 157 TAG_LOGD(AAFwkTag::SER_ROUTER, 158 "FormToPurposes, bundle: %{public}s, abilityName: %{public}s, purposeName: %{public}s", 159 extAbilityInfo.bundleName.c_str(), extAbilityInfo.name.c_str(), 160 purposeInfo.purposeName.c_str()); 161 } else { 162 TAG_LOGW(AAFwkTag::SER_ROUTER, "FormToPurposes invalid"); 163 } 164 } 165 } 166 } 167 ConvertExtAbilityToService(const ExtensionAbilityInfo & extAbilityInfo,std::vector<BusinessAbilityInfo> & businessAbilityInfos,const AppInfo & appInfo)168 static void ConvertExtAbilityToService(const ExtensionAbilityInfo &extAbilityInfo, 169 std::vector<BusinessAbilityInfo> &businessAbilityInfos, const AppInfo &appInfo) 170 { 171 if (extAbilityInfo.type != ExtensionAbilityType::UI) { 172 return; 173 } 174 BusinessType type = GetBusinessType(extAbilityInfo.metadata); 175 TAG_LOGD(AAFwkTag::SER_ROUTER, "AbilityName: %{public}s, businessType: %{public}d", 176 extAbilityInfo.name.c_str(), static_cast<int>(type)); 177 if (type != BusinessType::UNSPECIFIED) { 178 BusinessAbilityInfo businessAbilityInfo; 179 businessAbilityInfo.appInfo = appInfo; 180 businessAbilityInfo.abilityName = extAbilityInfo.name; 181 businessAbilityInfo.moduleName = extAbilityInfo.moduleName; 182 businessAbilityInfo.bundleName = extAbilityInfo.bundleName; 183 businessAbilityInfo.businessType = type; 184 businessAbilityInfo.iconId = extAbilityInfo.iconId; 185 businessAbilityInfo.labelId = extAbilityInfo.labelId; 186 businessAbilityInfo.descriptionId = extAbilityInfo.descriptionId; 187 businessAbilityInfo.permissions = extAbilityInfo.permissions; 188 businessAbilityInfos.emplace_back(businessAbilityInfo); 189 } 190 } 191 GetAbilityMetadataValue(const AbilityInfo & abilityInfo,const std::string & name)192 static std::string GetAbilityMetadataValue(const AbilityInfo &abilityInfo, const std::string &name) 193 { 194 if (abilityInfo.metadata.empty()) { 195 return Constants::EMPTY_STRING; 196 } 197 for (auto &metadata : abilityInfo.metadata) { 198 if (name == metadata.name && !metadata.value.empty()) { 199 return metadata.value; 200 } 201 } 202 return Constants::EMPTY_STRING; 203 } 204 GetExtAbilityMetadataValue(const std::vector<Metadata> & metadata,const std::string & name)205 static std::string GetExtAbilityMetadataValue(const std::vector<Metadata> &metadata, const std::string &name) 206 { 207 if (metadata.empty()) { 208 return Constants::EMPTY_STRING; 209 } 210 for (auto &metadata : metadata) { 211 if (name == metadata.name && !metadata.value.empty()) { 212 return metadata.value; 213 } 214 } 215 return Constants::EMPTY_STRING; 216 } 217 }; // namespace ServiceRouterUtil 218 } // namespace AbilityRuntime 219 } // namespace OHOS 220 #endif // OHOS_ABILITY_RUNTIME_SERVICE_ROUTER_FRAMEWORK_SERVICES_INCLUDE_SERVICE_ROUTER_UTIL_H 221