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