1 /*
2 * Copyright (c) 2021-2025 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 #include "inner_bundle_info.h"
17
18 #include <regex>
19
20 #ifdef BUNDLE_FRAMEWORK_APP_CONTROL
21 #include "app_control_constants.h"
22 #include "app_control_manager.h"
23 #endif
24 #include "app_log_tag_wrapper.h"
25 #include "bms_extension_data_mgr.h"
26 #include "bundle_extractor.h"
27 #include "bundle_mgr_client.h"
28 #include "bundle_permission_mgr.h"
29 #include "bundle_util.h"
30 #include "common_json_converter.h"
31 #include "free_install_params.h"
32 #include "installd_client.h"
33
34 namespace OHOS {
35 namespace AppExecFwk {
36 namespace {
37 constexpr const char* APP_TYPE = "appType";
38 constexpr const char* BASE_APPLICATION_INFO = "baseApplicationInfo";
39 constexpr const char* BASE_BUNDLE_INFO = "baseBundleInfo";
40 constexpr const char* BASE_ABILITY_INFO = "baseAbilityInfos";
41 constexpr const char* INNER_MODULE_INFO = "innerModuleInfos";
42 constexpr const char* SKILL_INFOS = "skillInfos";
43 constexpr const char* USER_ID = "userId_";
44 constexpr const char* APP_FEATURE = "appFeature";
45 constexpr const char* NAME = "name";
46 constexpr const char* MODULE_PACKAGE = "modulePackage";
47 constexpr const char* MODULE_PATH = "modulePath";
48 constexpr const char* MODULE_NAME = "moduleName";
49 constexpr const char* MODULE_DESCRIPTION = "description";
50 constexpr const char* MODULE_DESCRIPTION_ID = "descriptionId";
51 constexpr const char* MODULE_ICON = "icon";
52 constexpr const char* MODULE_ICON_ID = "iconId";
53 constexpr const char* MODULE_LABEL = "label";
54 constexpr const char* MODULE_LABEL_ID = "labelId";
55 constexpr const char* MODULE_DESCRIPTION_INSTALLATION_FREE = "installationFree";
56 constexpr const char* MODULE_IS_REMOVABLE = "isRemovable";
57 constexpr const char* MODULE_UPGRADE_FLAG = "upgradeFlag";
58 constexpr const char* MODULE_IS_ENTRY = "isEntry";
59 constexpr const char* MODULE_METADATA = "metaData";
60 constexpr const char* MODULE_HNP_PACKAGE = "hnpPackage";
61 constexpr const char* MODULE_COLOR_MODE = "colorMode";
62 constexpr const char* MODULE_DISTRO = "distro";
63 constexpr const char* MODULE_REQ_CAPABILITIES = "reqCapabilities";
64 constexpr const char* MODULE_DATA_DIR = "moduleDataDir";
65 constexpr const char* MODULE_RES_PATH = "moduleResPath";
66 constexpr const char* MODULE_HAP_PATH = "hapPath";
67 constexpr const char* MODULE_ABILITY_KEYS = "abilityKeys";
68 constexpr const char* MODULE_SKILL_KEYS = "skillKeys";
69 constexpr const char* MODULE_FORMS = "formInfos";
70 constexpr const char* MODULE_SHORTCUT = "shortcutInfos";
71 constexpr const char* MODULE_COMMON_EVENT = "commonEvents";
72 constexpr const char* MODULE_MAIN_ABILITY = "mainAbility";
73 constexpr const char* MODULE_ENTRY_ABILITY_KEY = "entryAbilityKey";
74 constexpr const char* MODULE_DEPENDENCIES = "dependencies";
75 constexpr const char* MODULE_IS_LIB_ISOLATED = "isLibIsolated";
76 constexpr const char* MODULE_NATIVE_LIBRARY_PATH = "nativeLibraryPath";
77 constexpr const char* MODULE_CPU_ABI = "cpuAbi";
78 constexpr const char* MODULE_SRC_PATH = "srcPath";
79 constexpr const char* MODULE_HASH_VALUE = "hashValue";
80 constexpr const char* PORT_SEPARATOR = ":";
81 constexpr const char* INSTALL_MARK = "installMark";
82 constexpr const char* INNER_BUNDLE_USER_INFOS = "innerBundleUserInfos";
83 constexpr const char* MODULE_PROCESS = "process";
84 constexpr const char* MODULE_SRC_ENTRANCE = "srcEntrance";
85 constexpr const char* MODULE_DEVICE_TYPES = "deviceTypes";
86 constexpr const char* MODULE_REQUIRED_DEVICE_FEATURES = "requiredDeviceFeatures";
87 constexpr const char* MODULE_VIRTUAL_MACHINE = "virtualMachine";
88 constexpr const char* MODULE_UI_SYNTAX = "uiSyntax";
89 constexpr const char* MODULE_PAGES = "pages";
90 constexpr const char* MODULE_SYSTEM_THEME = "systemTheme";
91 constexpr const char* MODULE_META_DATA = "metadata";
92 constexpr const char* MODULE_REQUEST_PERMISSIONS = "requestPermissions";
93 constexpr const char* MODULE_DEFINE_PERMISSIONS = "definePermissions";
94 constexpr const char* MODULE_EXTENSION_KEYS = "extensionKeys";
95 constexpr const char* MODULE_EXTENSION_SKILL_KEYS = "extensionSkillKeys";
96 constexpr const char* MODULE_IS_MODULE_JSON = "isModuleJson";
97 constexpr const char* MODULE_IS_STAGE_BASED_MODEL = "isStageBasedModel";
98 constexpr const char* BUNDLE_IS_NEW_VERSION = "isNewVersion";
99 constexpr const char* BUNDLE_BASE_EXTENSION_INFOS = "baseExtensionInfos";
100 constexpr const char* BUNDLE_EXTENSION_SKILL_INFOS = "extensionSkillInfos";
101 constexpr const char* BUNDLE_EXTEND_RESOURCES = "extendResources";
102 constexpr const char* CUR_DYNAMIC_ICON_MODULE = "curDynamicIconModule";
103 constexpr const char* BUNDLE_PACK_INFO = "bundlePackInfo";
104 constexpr const char* ALLOWED_ACLS = "allowedAcls";
105 constexpr const char* APP_INDEX = "appIndex";
106 constexpr const char* BUNDLE_IS_SANDBOX_APP = "isSandboxApp";
107 constexpr const char* MODULE_COMPILE_MODE = "compileMode";
108 constexpr const char* BUNDLE_HQF_INFOS = "hqfInfos";
109 constexpr const char* MODULE_TARGET_MODULE_NAME = "targetModuleName";
110 constexpr const char* MODULE_TARGET_PRIORITY = "targetPriority";
111 constexpr const char* MODULE_OVERLAY_MODULE_INFO = "overlayModuleInfo";
112 constexpr const char* OVERLAY_BUNDLE_INFO = "overlayBundleInfo";
113 constexpr const char* OVERLAY_TYPE = "overlayType";
114 constexpr const char* APPLY_QUICK_FIX_FREQUENCY = "applyQuickFixFrequency";
115 constexpr const char* MODULE_PRELOADS = "preloads";
116 constexpr const char* INNER_SHARED_MODULE_INFO = "innerSharedModuleInfos";
117 constexpr const char* MODULE_BUNDLE_TYPE = "bundleType";
118 constexpr const char* MODULE_VERSION_CODE = "versionCode";
119 constexpr const char* MODULE_VERSION_NAME = "versionName";
120 constexpr const char* MODULE_PROXY_DATAS = "proxyDatas";
121 constexpr const char* MODULE_BUILD_HASH = "buildHash";
122 constexpr const char* MODULE_ISOLATION_MODE = "isolationMode";
123 constexpr const char* MODULE_COMPRESS_NATIVE_LIBS = "compressNativeLibs";
124 constexpr const char* MODULE_NATIVE_LIBRARY_FILE_NAMES = "nativeLibraryFileNames";
125 constexpr const char* MODULE_AOT_COMPILE_STATUS = "aotCompileStatus";
126 constexpr const char* DATA_GROUP_INFOS = "dataGroupInfos";
127 constexpr const char* MODULE_FILE_CONTEXT_MENU = "fileContextMenu";
128 constexpr const char* MODULE_IS_ENCRYPTED = "isEncrypted";
129 constexpr const char* MODULE_RESIZEABLE = "resizeable";
130 constexpr const char* MODULE_ROUTER_MAP = "routerMap";
131 constexpr const char* MODULE_DEDUPLICATE_HAR = "deduplicateHar";
132 constexpr const char* EXT_RESOURCE_MODULE_NAME = "moduleName";
133 constexpr const char* EXT_RESOURCE_ICON_ID = "iconId";
134 constexpr const char* EXT_RESOURCE_FILE_PATH = "filePath";
135 constexpr const char* DEVELOPER_ID = "developerId";
136 constexpr const char* ODID = "odid";
137 constexpr const char* UNINSTALL_STATE = "uninstallState";
138 constexpr const char* PLUGIN_BUNDLE_INFOS = "pluginBundleInfos";
139 constexpr int8_t SINGLE_HSP_VERSION = 1;
140 const std::map<std::string, IsolationMode> ISOLATION_MODE_MAP = {
141 {"isolationOnly", IsolationMode::ISOLATION_ONLY},
142 {"nonisolationOnly", IsolationMode::NONISOLATION_ONLY},
143 {"isolationFirst", IsolationMode::ISOLATION_FIRST},
144 };
145 constexpr const char* NATIVE_LIBRARY_PATH_SYMBOL = "!/";
146
147 constexpr const char* MODULE_QUERY_SCHEMES = "querySchemes";
148 constexpr const char* MODULE_APP_ENVIRONMENTS = "appEnvironments";
149 constexpr const char* MODULE_ASAN_ENABLED = "asanEnabled";
150 constexpr const char* MODULE_GWP_ASAN_ENABLED = "gwpAsanEnabled";
151 constexpr const char* MODULE_TSAN_ENABLED = "tsanEnabled";
152 constexpr const char* MODULE_PACKAGE_NAME = "packageName";
153 constexpr const char* MODULE_APP_STARTUP = "appStartup";
154 constexpr const char* MODULE_FORM_EXTENSION_MODULE = "formExtensionModule";
155 constexpr const char* MODULE_FORM_WIDGET_MODULE = "formWidgetModule";
156 constexpr const char* MODULE_HWASAN_ENABLED = "hwasanEnabled";
157 constexpr const char* MODULE_UBSAN_ENABLED = "ubsanEnabled";
158 constexpr const char* MODULE_DEBUG = "debug";
159 constexpr const char* MODULE_CROS_APP_SHARED_CONFIG = "crossAppSharedConfig";
160 constexpr const char* MODULE_ABILITY_SRC_ENTRY_DELEGATOR = "abilitySrcEntryDelegator";
161 constexpr const char* MODULE_ABILITY_STAGE_SRC_ENTRY_DELEGATOR = "abilityStageSrcEntryDelegator";
162 constexpr const char* MODULE_BOOL_SET = "boolSet";
163 constexpr uint32_t PREINSTALL_SOURCE_CLEAN_MASK = ~0B1110;
164 constexpr int32_t CPM_KEY_NOT_EXIST = 0x7A000005;
165
ConvertCompileMode(const std::string & compileMode)166 inline CompileMode ConvertCompileMode(const std::string& compileMode)
167 {
168 if (compileMode == Profile::COMPILE_MODE_ES_MODULE) {
169 return CompileMode::ES_MODULE;
170 } else {
171 return CompileMode::JS_BUNDLE;
172 }
173 }
174
NameAndUserIdToKey(const std::string & bundleName,int32_t userId)175 const std::string NameAndUserIdToKey(const std::string &bundleName, int32_t userId)
176 {
177 return bundleName + Constants::FILE_UNDERLINE + std::to_string(userId);
178 }
179 } // namespace
180
from_json(const nlohmann::json & jsonObject,InnerAbilityInfo & innerAbilityInfo)181 void from_json(const nlohmann::json &jsonObject, InnerAbilityInfo &innerAbilityInfo)
182 {
183 AbilityFromJson(jsonObject, innerAbilityInfo);
184 }
185
to_json(nlohmann::json & jsonObject,const InnerAbilityInfo & innerAbilityInfo)186 void to_json(nlohmann::json &jsonObject, const InnerAbilityInfo &innerAbilityInfo)
187 {
188 AbilityToJson(jsonObject, innerAbilityInfo);
189 }
190
from_json(const nlohmann::json & jsonObject,InnerExtensionInfo & innerExtensionInfo)191 void from_json(const nlohmann::json &jsonObject, InnerExtensionInfo &innerExtensionInfo)
192 {
193 ExtensionFromJson(jsonObject, innerExtensionInfo);
194 }
195
to_json(nlohmann::json & jsonObject,const InnerExtensionInfo & innerExtensionInfo)196 void to_json(nlohmann::json &jsonObject, const InnerExtensionInfo &innerExtensionInfo)
197 {
198 ExtensionToJson(jsonObject, innerExtensionInfo);
199 }
200
from_json(const nlohmann::json & jsonObject,ExtendResourceInfo & extendResourceInfo)201 void from_json(const nlohmann::json &jsonObject, ExtendResourceInfo &extendResourceInfo)
202 {
203 const auto &jsonObjectEnd = jsonObject.end();
204 int32_t parseResult = ERR_OK;
205 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
206 jsonObjectEnd,
207 EXT_RESOURCE_MODULE_NAME,
208 extendResourceInfo.moduleName,
209 false,
210 parseResult);
211 GetValueIfFindKey<int32_t>(jsonObject,
212 jsonObjectEnd,
213 EXT_RESOURCE_ICON_ID,
214 extendResourceInfo.iconId,
215 JsonType::NUMBER,
216 false,
217 parseResult,
218 ArrayType::NOT_ARRAY);
219 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
220 jsonObjectEnd,
221 EXT_RESOURCE_FILE_PATH,
222 extendResourceInfo.filePath,
223 false,
224 parseResult);
225 if (parseResult != ERR_OK) {
226 APP_LOGE("read ExtendResourceInfo from json error, error code : %{public}d", parseResult);
227 }
228 }
229
to_json(nlohmann::json & jsonObject,const ExtendResourceInfo & extendResourceInfo)230 void to_json(nlohmann::json &jsonObject, const ExtendResourceInfo &extendResourceInfo)
231 {
232 jsonObject = nlohmann::json {
233 {EXT_RESOURCE_MODULE_NAME, extendResourceInfo.moduleName},
234 {EXT_RESOURCE_ICON_ID, extendResourceInfo.iconId},
235 {EXT_RESOURCE_FILE_PATH, extendResourceInfo.filePath}
236 };
237 }
238
SetAOTCompileStatus(const std::string & moduleName,AOTCompileStatus aotCompileStatus)239 void InnerBundleInfo::SetAOTCompileStatus(const std::string &moduleName, AOTCompileStatus aotCompileStatus)
240 {
241 auto item = innerModuleInfos_.find(moduleName);
242 if (item == innerModuleInfos_.end()) {
243 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
244 return;
245 }
246 item->second.aotCompileStatus = aotCompileStatus;
247 }
248
GetAOTCompileStatus(const std::string & moduleName) const249 AOTCompileStatus InnerBundleInfo::GetAOTCompileStatus(const std::string &moduleName) const
250 {
251 auto item = innerModuleInfos_.find(moduleName);
252 if (item == innerModuleInfos_.end()) {
253 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
254 return AOTCompileStatus::NOT_COMPILED;
255 }
256 return item->second.aotCompileStatus;
257 }
258
IsAOTFlagsInitial() const259 bool InnerBundleInfo::IsAOTFlagsInitial() const
260 {
261 if (!baseApplicationInfo_->arkNativeFilePath.empty()) {
262 return false;
263 }
264 if (!baseApplicationInfo_->arkNativeFileAbi.empty()) {
265 return false;
266 }
267 for (const auto &item : innerModuleInfos_) {
268 if (item.second.aotCompileStatus != AOTCompileStatus::NOT_COMPILED) {
269 return false;
270 }
271 }
272 return true;
273 }
274
ResetAOTFlags()275 void InnerBundleInfo::ResetAOTFlags()
276 {
277 baseApplicationInfo_->arkNativeFilePath.clear();
278 baseApplicationInfo_->arkNativeFileAbi.clear();
279 std::for_each(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](auto &item) {
280 item.second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
281 });
282 }
283
ResetAOTCompileStatus(const std::string & moduleName)284 ErrCode InnerBundleInfo::ResetAOTCompileStatus(const std::string &moduleName)
285 {
286 auto item = innerModuleInfos_.find(moduleName);
287 if (item == innerModuleInfos_.end()) {
288 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
289 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
290 }
291 item->second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
292 return ERR_OK;
293 }
294
GetInternalDependentHspInfo(const std::string & moduleName,std::vector<HspInfo> & hspInfoVector) const295 void InnerBundleInfo::GetInternalDependentHspInfo(
296 const std::string &moduleName, std::vector<HspInfo> &hspInfoVector) const
297 {
298 std::vector<std::string> dependentModuleNames;
299 if (!GetAllDependentModuleNames(moduleName, dependentModuleNames)) {
300 return;
301 }
302 for (const auto &name : dependentModuleNames) {
303 auto item = innerModuleInfos_.find(name);
304 if (item == innerModuleInfos_.end()) {
305 continue;
306 }
307 HspInfo hspInfo;
308 hspInfo.bundleName = baseApplicationInfo_->bundleName;
309 hspInfo.moduleName = item->second.moduleName;
310 hspInfo.hapPath = item->second.hapPath;
311 hspInfo.moduleArkTSMode = item->second.moduleArkTSMode;
312 hspInfoVector.emplace_back(hspInfo);
313 }
314 }
315
InnerBundleInfo()316 InnerBundleInfo::InnerBundleInfo()
317 {
318 baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
319 baseBundleInfo_ = std::make_shared<BundleInfo>();
320 bundlePackInfo_ = std::make_shared<BundlePackInfo>();
321 APP_LOGD("inner bundle info instance is created");
322 }
323
operator =(const InnerBundleInfo & info)324 InnerBundleInfo &InnerBundleInfo::operator=(const InnerBundleInfo &info)
325 {
326 if (this == &info) {
327 return *this;
328 }
329 this->appType_ = info.appType_;
330
331 this->userId_ = info.userId_;
332 this->bundleStatus_ = info.bundleStatus_;
333 this->appFeature_ = info.appFeature_;
334 this->allowedAcls_ = info.allowedAcls_;
335 this->mark_ = info.mark_;
336 this->appIndex_ = info.appIndex_;
337 this->isSandboxApp_ = info.isSandboxApp_;
338 this->currentPackage_ = info.currentPackage_;
339 this->onlyCreateBundleUser_ = info.onlyCreateBundleUser_;
340 this->innerModuleInfos_ = info.innerModuleInfos_;
341 this->innerSharedModuleInfos_ = info.innerSharedModuleInfos_;
342 this->formInfos_ = info.formInfos_;
343 this->commonEvents_ = info.commonEvents_;
344 this->shortcutInfos_ = info.shortcutInfos_;
345 this->baseAbilityInfos_ = info.baseAbilityInfos_;
346 this->skillInfos_ = info.skillInfos_;
347 this->innerBundleUserInfos_ = info.innerBundleUserInfos_;
348 this->bundlePackInfo_ = std::make_shared<BundlePackInfo>();
349 if (info.bundlePackInfo_ != nullptr) {
350 *(this->bundlePackInfo_) = *(info.bundlePackInfo_);
351 }
352 this->isNewVersion_ = info.isNewVersion_;
353 this->baseExtensionInfos_= info.baseExtensionInfos_;
354 this->extensionSkillInfos_ = info.extensionSkillInfos_;
355 this->extendResourceInfos_ = info.extendResourceInfos_;
356 this->curDynamicIconModule_ = info.curDynamicIconModule_;
357 this->baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
358 if (info.baseApplicationInfo_ != nullptr) {
359 *(this->baseApplicationInfo_) = *(info.baseApplicationInfo_);
360 }
361 this->baseBundleInfo_ = std::make_shared<BundleInfo>();
362 if (info.baseBundleInfo_ != nullptr) {
363 *(this->baseBundleInfo_) = *(info.baseBundleInfo_);
364 }
365 this->hqfInfos_ = info.hqfInfos_;
366 this->overlayBundleInfo_ = info.overlayBundleInfo_;
367 this->overlayType_ = info.overlayType_;
368 this->applyQuickFixFrequency_ = info.applyQuickFixFrequency_;
369 this->provisionMetadatas_ = info.provisionMetadatas_;
370 this->dataGroupInfos_ = info.dataGroupInfos_;
371 this->developerId_ = info.developerId_;
372 this->odid_ = info.odid_;
373 this->uninstallState_ = info.uninstallState_;
374 this->pluginBundleInfos_ = info.pluginBundleInfos_;
375 return *this;
376 }
377
~InnerBundleInfo()378 InnerBundleInfo::~InnerBundleInfo()
379 {
380 APP_LOGD("inner bundle info instance is destroyed");
381 }
382
to_json(nlohmann::json & jsonObject,const Distro & distro)383 void to_json(nlohmann::json &jsonObject, const Distro &distro)
384 {
385 jsonObject = nlohmann::json {
386 {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_DELIVERY_WITH_INSTALL, distro.deliveryWithInstall},
387 {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_NAME, distro.moduleName},
388 {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_TYPE, distro.moduleType},
389 {ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_INSTALLATION_FREE, distro.installationFree}
390 };
391 }
392
to_json(nlohmann::json & jsonObject,const DefinePermission & definePermission)393 void to_json(nlohmann::json &jsonObject, const DefinePermission &definePermission)
394 {
395 jsonObject = nlohmann::json {
396 {Profile::DEFINEPERMISSION_NAME, definePermission.name},
397 {Profile::DEFINEPERMISSION_GRANT_MODE, definePermission.grantMode},
398 {Profile::DEFINEPERMISSION_AVAILABLE_LEVEL, definePermission.availableLevel},
399 {Profile::DEFINEPERMISSION_PROVISION_ENABLE, definePermission.provisionEnable},
400 {Profile::DEFINEPERMISSION_DISTRIBUTED_SCENE_ENABLE, definePermission.distributedSceneEnable},
401 {Profile::DEFINEPERMISSION_IS_KERNEL_EFFECT, definePermission.isKernelEffect},
402 {Profile::DEFINEPERMISSION_HAS_VALUE, definePermission.hasValue},
403 {Profile::LABEL, definePermission.label},
404 {Profile::LABEL_ID, definePermission.labelId},
405 {Profile::DESCRIPTION, definePermission.description},
406 {Profile::DESCRIPTION_ID, definePermission.descriptionId},
407 {Profile::DEFINEPERMISSION_AVAILABLE_TYPE, definePermission.availableType}
408 };
409 }
410
to_json(nlohmann::json & jsonObject,const Dependency & dependency)411 void to_json(nlohmann::json &jsonObject, const Dependency &dependency)
412 {
413 jsonObject = nlohmann::json {
414 {Profile::DEPENDENCIES_MODULE_NAME, dependency.moduleName},
415 {Profile::DEPENDENCIES_BUNDLE_NAME, dependency.bundleName},
416 {Profile::APP_VERSION_CODE, dependency.versionCode}
417 };
418 }
419
to_json(nlohmann::json & jsonObject,const InnerModuleInfo & info)420 void to_json(nlohmann::json &jsonObject, const InnerModuleInfo &info)
421 {
422 jsonObject = nlohmann::json {
423 {NAME, info.name},
424 {MODULE_PACKAGE, info.modulePackage},
425 {MODULE_NAME, info.moduleName},
426 {MODULE_PATH, info.modulePath},
427 {MODULE_DATA_DIR, info.moduleDataDir},
428 {MODULE_RES_PATH, info.moduleResPath},
429 {MODULE_IS_ENTRY, info.isEntry},
430 {MODULE_METADATA, info.metaData},
431 {MODULE_COLOR_MODE, info.colorMode},
432 {MODULE_DISTRO, info.distro},
433 {Constants::MODULE_ARKTS_MODE, info.moduleArkTSMode},
434 {Constants::ARKTS_MODE, info.arkTSMode},
435 {MODULE_DESCRIPTION, info.description},
436 {MODULE_DESCRIPTION_ID, info.descriptionId},
437 {MODULE_ICON, info.icon},
438 {MODULE_ICON_ID, info.iconId},
439 {MODULE_LABEL, info.label},
440 {MODULE_LABEL_ID, info.labelId},
441 {MODULE_DESCRIPTION_INSTALLATION_FREE, info.installationFree},
442 {MODULE_IS_REMOVABLE, info.isRemovable},
443 {MODULE_UPGRADE_FLAG, info.upgradeFlag},
444 {MODULE_REQ_CAPABILITIES, info.reqCapabilities},
445 {MODULE_ABILITY_KEYS, info.abilityKeys},
446 {MODULE_SKILL_KEYS, info.skillKeys},
447 {MODULE_MAIN_ABILITY, info.mainAbility},
448 {MODULE_ENTRY_ABILITY_KEY, info.entryAbilityKey},
449 {MODULE_SRC_PATH, info.srcPath},
450 {MODULE_HASH_VALUE, info.hashValue},
451 {MODULE_PROCESS, info.process},
452 {MODULE_SRC_ENTRANCE, info.srcEntrance},
453 {MODULE_DEVICE_TYPES, info.deviceTypes},
454 {MODULE_REQUIRED_DEVICE_FEATURES, info.requiredDeviceFeatures},
455 {MODULE_VIRTUAL_MACHINE, info.virtualMachine},
456 {MODULE_UI_SYNTAX, info.uiSyntax},
457 {MODULE_PAGES, info.pages},
458 {MODULE_SYSTEM_THEME, info.systemTheme},
459 {MODULE_META_DATA, info.metadata},
460 {MODULE_HNP_PACKAGE, info.hnpPackages},
461 {MODULE_REQUEST_PERMISSIONS, info.requestPermissions},
462 {MODULE_DEFINE_PERMISSIONS, info.definePermissions},
463 {MODULE_EXTENSION_KEYS, info.extensionKeys},
464 {MODULE_EXTENSION_SKILL_KEYS, info.extensionSkillKeys},
465 {MODULE_IS_MODULE_JSON, info.isModuleJson},
466 {MODULE_IS_STAGE_BASED_MODEL, info.isStageBasedModel},
467 {MODULE_DEPENDENCIES, info.dependencies},
468 {MODULE_IS_LIB_ISOLATED, info.isLibIsolated},
469 {MODULE_NATIVE_LIBRARY_PATH, info.nativeLibraryPath},
470 {MODULE_CPU_ABI, info.cpuAbi},
471 {MODULE_HAP_PATH, info.hapPath},
472 {MODULE_COMPILE_MODE, info.compileMode},
473 {MODULE_TARGET_MODULE_NAME, info.targetModuleName},
474 {MODULE_TARGET_PRIORITY, info.targetPriority},
475 {MODULE_OVERLAY_MODULE_INFO, info.overlayModuleInfo},
476 {MODULE_PRELOADS, info.preloads},
477 {MODULE_RESIZEABLE, info.resizeable},
478 {MODULE_BUNDLE_TYPE, info.bundleType},
479 {MODULE_VERSION_CODE, info.versionCode},
480 {MODULE_VERSION_NAME, info.versionName},
481 {MODULE_PROXY_DATAS, info.proxyDatas},
482 {MODULE_BUILD_HASH, info.buildHash},
483 {MODULE_ISOLATION_MODE, info.isolationMode},
484 {MODULE_COMPRESS_NATIVE_LIBS, info.compressNativeLibs},
485 {MODULE_NATIVE_LIBRARY_FILE_NAMES, info.nativeLibraryFileNames},
486 {MODULE_AOT_COMPILE_STATUS, info.aotCompileStatus},
487 {MODULE_FILE_CONTEXT_MENU, info.fileContextMenu},
488 {MODULE_IS_ENCRYPTED, info.isEncrypted},
489 {MODULE_QUERY_SCHEMES, info.querySchemes},
490 {MODULE_ROUTER_MAP, info.routerMap},
491 {MODULE_APP_ENVIRONMENTS, info.appEnvironments},
492 {MODULE_ASAN_ENABLED, info.asanEnabled},
493 {MODULE_GWP_ASAN_ENABLED, info.gwpAsanEnabled},
494 {MODULE_TSAN_ENABLED, info.tsanEnabled},
495 {MODULE_PACKAGE_NAME, info.packageName},
496 {MODULE_APP_STARTUP, info.appStartup},
497 {MODULE_FORM_EXTENSION_MODULE, info.formExtensionModule},
498 {MODULE_FORM_WIDGET_MODULE, info.formWidgetModule},
499 {MODULE_CROS_APP_SHARED_CONFIG, info.crossAppSharedConfig},
500 {MODULE_ABILITY_SRC_ENTRY_DELEGATOR, info.abilitySrcEntryDelegator},
501 {MODULE_ABILITY_STAGE_SRC_ENTRY_DELEGATOR, info.abilityStageSrcEntryDelegator},
502 {MODULE_HWASAN_ENABLED, static_cast<bool>(info.innerModuleInfoFlag &
503 InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED))},
504 {MODULE_UBSAN_ENABLED, static_cast<bool>(info.innerModuleInfoFlag &
505 InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED))},
506 {MODULE_DEBUG, info.debug},
507 {MODULE_BOOL_SET, info.boolSet},
508 {MODULE_DEDUPLICATE_HAR, info.deduplicateHar},
509 };
510 }
511
to_json(nlohmann::json & jsonObject,const InstallMark & installMark)512 void to_json(nlohmann::json &jsonObject, const InstallMark &installMark)
513 {
514 jsonObject = nlohmann::json {
515 {ProfileReader::BUNDLE_INSTALL_MARK_BUNDLE, installMark.bundleName},
516 {ProfileReader::BUNDLE_INSTALL_MARK_PACKAGE, installMark.packageName},
517 {ProfileReader::BUNDLE_INSTALL_MARK_STATUS, installMark.status}
518 };
519 }
520
ToJson(nlohmann::json & jsonObject) const521 void InnerBundleInfo::ToJson(nlohmann::json &jsonObject) const
522 {
523 jsonObject[APP_TYPE] = appType_;
524 jsonObject[ALLOWED_ACLS] = allowedAcls_;
525 jsonObject[BASE_APPLICATION_INFO] = *baseApplicationInfo_;
526 jsonObject[BASE_BUNDLE_INFO] = *baseBundleInfo_;
527 jsonObject[BASE_ABILITY_INFO] = baseAbilityInfos_;
528 jsonObject[INNER_MODULE_INFO] = innerModuleInfos_;
529 jsonObject[INNER_SHARED_MODULE_INFO] = innerSharedModuleInfos_;
530 jsonObject[SKILL_INFOS] = skillInfos_;
531 jsonObject[USER_ID] = userId_;
532 jsonObject[APP_FEATURE] = appFeature_;
533 jsonObject[MODULE_FORMS] = formInfos_;
534 jsonObject[MODULE_SHORTCUT] = shortcutInfos_;
535 jsonObject[MODULE_COMMON_EVENT] = commonEvents_;
536 jsonObject[INSTALL_MARK] = mark_;
537 jsonObject[INNER_BUNDLE_USER_INFOS] = innerBundleUserInfos_;
538 jsonObject[BUNDLE_IS_NEW_VERSION] = isNewVersion_;
539 jsonObject[BUNDLE_BASE_EXTENSION_INFOS] = baseExtensionInfos_;
540 jsonObject[BUNDLE_EXTENSION_SKILL_INFOS] = extensionSkillInfos_;
541 jsonObject[BUNDLE_EXTEND_RESOURCES] = extendResourceInfos_;
542 jsonObject[CUR_DYNAMIC_ICON_MODULE] = curDynamicIconModule_;
543 jsonObject[BUNDLE_PACK_INFO] = *bundlePackInfo_;
544 jsonObject[APP_INDEX] = appIndex_;
545 jsonObject[BUNDLE_IS_SANDBOX_APP] = isSandboxApp_;
546 jsonObject[BUNDLE_HQF_INFOS] = hqfInfos_;
547 jsonObject[OVERLAY_BUNDLE_INFO] = overlayBundleInfo_;
548 jsonObject[OVERLAY_TYPE] = overlayType_;
549 jsonObject[APPLY_QUICK_FIX_FREQUENCY] = applyQuickFixFrequency_;
550 jsonObject[DATA_GROUP_INFOS] = dataGroupInfos_;
551 jsonObject[PLUGIN_BUNDLE_INFOS] = pluginBundleInfos_;
552 jsonObject[DEVELOPER_ID] = developerId_;
553 jsonObject[ODID] = odid_;
554 jsonObject[UNINSTALL_STATE] = uninstallState_;
555 }
556
from_json(const nlohmann::json & jsonObject,InnerModuleInfo & info)557 void from_json(const nlohmann::json &jsonObject, InnerModuleInfo &info)
558 {
559 // these are not required fields.
560 const auto &jsonObjectEnd = jsonObject.end();
561 int32_t parseResult = ERR_OK;
562 bool hwasanEnabled = static_cast<bool>(info.innerModuleInfoFlag &
563 InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
564 bool ubsanEnabled = static_cast<bool>(info.innerModuleInfoFlag &
565 InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED));
566 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
567 jsonObjectEnd,
568 NAME,
569 info.name,
570 false,
571 parseResult);
572 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
573 jsonObjectEnd,
574 MODULE_PACKAGE,
575 info.modulePackage,
576 false,
577 parseResult);
578 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
579 jsonObjectEnd,
580 MODULE_NAME,
581 info.moduleName,
582 false,
583 parseResult);
584 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
585 jsonObjectEnd,
586 MODULE_PATH,
587 info.modulePath,
588 false,
589 parseResult);
590 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
591 jsonObjectEnd,
592 MODULE_DATA_DIR,
593 info.moduleDataDir,
594 false,
595 parseResult);
596 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
597 jsonObjectEnd,
598 MODULE_HAP_PATH,
599 info.hapPath,
600 false,
601 parseResult);
602 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
603 jsonObjectEnd,
604 MODULE_RES_PATH,
605 info.moduleResPath,
606 false,
607 parseResult);
608 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
609 jsonObjectEnd,
610 MODULE_IS_ENTRY,
611 info.isEntry,
612 false,
613 parseResult);
614 GetValueIfFindKey<MetaData>(jsonObject,
615 jsonObjectEnd,
616 MODULE_METADATA,
617 info.metaData,
618 JsonType::OBJECT,
619 false,
620 parseResult,
621 ArrayType::NOT_ARRAY);
622 GetValueIfFindKey<ModuleColorMode>(jsonObject,
623 jsonObjectEnd,
624 MODULE_COLOR_MODE,
625 info.colorMode,
626 JsonType::NUMBER,
627 false,
628 parseResult,
629 ArrayType::NOT_ARRAY);
630 GetValueIfFindKey<Distro>(jsonObject,
631 jsonObjectEnd,
632 MODULE_DISTRO,
633 info.distro,
634 JsonType::OBJECT,
635 false,
636 parseResult,
637 ArrayType::NOT_ARRAY);
638 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
639 jsonObjectEnd,
640 Constants::MODULE_ARKTS_MODE,
641 info.moduleArkTSMode,
642 false,
643 parseResult);
644 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
645 jsonObjectEnd,
646 Constants::ARKTS_MODE,
647 info.arkTSMode,
648 false,
649 parseResult);
650 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
651 jsonObjectEnd,
652 MODULE_DESCRIPTION,
653 info.description,
654 false,
655 parseResult);
656 GetValueIfFindKey<int32_t>(jsonObject,
657 jsonObjectEnd,
658 MODULE_DESCRIPTION_ID,
659 info.descriptionId,
660 JsonType::NUMBER,
661 false,
662 parseResult,
663 ArrayType::NOT_ARRAY);
664 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
665 jsonObjectEnd,
666 MODULE_ICON,
667 info.icon,
668 false,
669 parseResult);
670 GetValueIfFindKey<int32_t>(jsonObject,
671 jsonObjectEnd,
672 MODULE_ICON_ID,
673 info.iconId,
674 JsonType::NUMBER,
675 false,
676 parseResult,
677 ArrayType::NOT_ARRAY);
678 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
679 jsonObjectEnd,
680 MODULE_LABEL,
681 info.label,
682 false,
683 parseResult);
684 GetValueIfFindKey<int32_t>(jsonObject,
685 jsonObjectEnd,
686 MODULE_LABEL_ID,
687 info.labelId,
688 JsonType::NUMBER,
689 false,
690 parseResult,
691 ArrayType::NOT_ARRAY);
692 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
693 jsonObjectEnd,
694 MODULE_MAIN_ABILITY,
695 info.mainAbility,
696 false,
697 parseResult);
698 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
699 jsonObjectEnd,
700 MODULE_ENTRY_ABILITY_KEY,
701 info.entryAbilityKey,
702 false,
703 parseResult);
704 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
705 jsonObjectEnd,
706 MODULE_SRC_PATH,
707 info.srcPath,
708 false,
709 parseResult);
710 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
711 jsonObjectEnd,
712 MODULE_HASH_VALUE,
713 info.hashValue,
714 false,
715 parseResult);
716 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
717 jsonObjectEnd,
718 MODULE_DESCRIPTION_INSTALLATION_FREE,
719 info.installationFree,
720 false,
721 parseResult);
722 GetValueIfFindKey<std::map<std::string, bool>>(jsonObject,
723 jsonObjectEnd,
724 MODULE_IS_REMOVABLE,
725 info.isRemovable,
726 JsonType::OBJECT,
727 false,
728 parseResult,
729 ArrayType::NOT_ARRAY);
730 GetValueIfFindKey<int32_t>(jsonObject,
731 jsonObjectEnd,
732 MODULE_UPGRADE_FLAG,
733 info.upgradeFlag,
734 JsonType::NUMBER,
735 false,
736 parseResult,
737 ArrayType::NOT_ARRAY);
738 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
739 jsonObjectEnd,
740 MODULE_REQ_CAPABILITIES,
741 info.reqCapabilities,
742 JsonType::ARRAY,
743 false,
744 parseResult,
745 ArrayType::STRING);
746 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
747 jsonObjectEnd,
748 MODULE_ABILITY_KEYS,
749 info.abilityKeys,
750 JsonType::ARRAY,
751 false,
752 parseResult,
753 ArrayType::STRING);
754 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
755 jsonObjectEnd,
756 MODULE_SKILL_KEYS,
757 info.skillKeys,
758 JsonType::ARRAY,
759 false,
760 parseResult,
761 ArrayType::STRING);
762 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
763 jsonObjectEnd,
764 MODULE_PROCESS,
765 info.process,
766 false,
767 parseResult);
768 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
769 jsonObjectEnd,
770 MODULE_SRC_ENTRANCE,
771 info.srcEntrance,
772 false,
773 parseResult);
774 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
775 jsonObjectEnd,
776 MODULE_DEVICE_TYPES,
777 info.deviceTypes,
778 JsonType::ARRAY,
779 false,
780 parseResult,
781 ArrayType::STRING);
782 GetValueIfFindKey<std::map<std::string, std::vector<std::string>>>(jsonObject,
783 jsonObjectEnd,
784 MODULE_REQUIRED_DEVICE_FEATURES,
785 info.requiredDeviceFeatures,
786 JsonType::OBJECT,
787 false,
788 parseResult,
789 ArrayType::NOT_ARRAY);
790 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
791 jsonObjectEnd,
792 MODULE_VIRTUAL_MACHINE,
793 info.virtualMachine,
794 false,
795 parseResult);
796 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
797 jsonObjectEnd,
798 MODULE_UI_SYNTAX,
799 info.uiSyntax,
800 false,
801 parseResult);
802 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
803 jsonObjectEnd,
804 MODULE_PAGES,
805 info.pages,
806 false,
807 parseResult);
808 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
809 jsonObjectEnd,
810 MODULE_SYSTEM_THEME,
811 info.systemTheme,
812 false,
813 parseResult);
814 GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
815 jsonObjectEnd,
816 MODULE_META_DATA,
817 info.metadata,
818 JsonType::ARRAY,
819 false,
820 parseResult,
821 ArrayType::OBJECT);
822 GetValueIfFindKey<std::vector<HnpPackage>>(jsonObject,
823 jsonObjectEnd,
824 MODULE_HNP_PACKAGE,
825 info.hnpPackages,
826 JsonType::ARRAY,
827 false,
828 parseResult,
829 ArrayType::OBJECT);
830 GetValueIfFindKey<std::vector<RequestPermission>>(jsonObject,
831 jsonObjectEnd,
832 MODULE_REQUEST_PERMISSIONS,
833 info.requestPermissions,
834 JsonType::ARRAY,
835 false,
836 parseResult,
837 ArrayType::OBJECT);
838 GetValueIfFindKey<std::vector<DefinePermission>>(jsonObject,
839 jsonObjectEnd,
840 MODULE_DEFINE_PERMISSIONS,
841 info.definePermissions,
842 JsonType::ARRAY,
843 false,
844 parseResult,
845 ArrayType::OBJECT);
846 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
847 jsonObjectEnd,
848 MODULE_EXTENSION_KEYS,
849 info.extensionKeys,
850 JsonType::ARRAY,
851 false,
852 parseResult,
853 ArrayType::STRING);
854 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
855 jsonObjectEnd,
856 MODULE_EXTENSION_SKILL_KEYS,
857 info.extensionSkillKeys,
858 JsonType::ARRAY,
859 false,
860 parseResult,
861 ArrayType::STRING);
862 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
863 jsonObjectEnd,
864 MODULE_IS_MODULE_JSON,
865 info.isModuleJson,
866 false,
867 parseResult);
868 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
869 jsonObjectEnd,
870 MODULE_IS_STAGE_BASED_MODEL,
871 info.isStageBasedModel,
872 false,
873 parseResult);
874 GetValueIfFindKey<std::vector<Dependency>>(jsonObject,
875 jsonObjectEnd,
876 MODULE_DEPENDENCIES,
877 info.dependencies,
878 JsonType::ARRAY,
879 false,
880 parseResult,
881 ArrayType::OBJECT);
882 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
883 jsonObjectEnd,
884 MODULE_COMPILE_MODE,
885 info.compileMode,
886 false,
887 parseResult);
888 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
889 jsonObjectEnd,
890 MODULE_IS_LIB_ISOLATED,
891 info.isLibIsolated,
892 false,
893 parseResult);
894 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
895 jsonObjectEnd,
896 MODULE_NATIVE_LIBRARY_PATH,
897 info.nativeLibraryPath,
898 false,
899 parseResult);
900 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
901 jsonObjectEnd,
902 MODULE_CPU_ABI,
903 info.cpuAbi,
904 false,
905 parseResult);
906 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
907 jsonObjectEnd,
908 MODULE_TARGET_MODULE_NAME,
909 info.targetModuleName,
910 false,
911 parseResult);
912 GetValueIfFindKey<int32_t>(jsonObject,
913 jsonObjectEnd,
914 MODULE_TARGET_PRIORITY,
915 info.targetPriority,
916 JsonType::NUMBER,
917 false,
918 parseResult,
919 ArrayType::NOT_ARRAY);
920 GetValueIfFindKey<std::vector<OverlayModuleInfo>>(jsonObject,
921 jsonObjectEnd,
922 MODULE_OVERLAY_MODULE_INFO,
923 info.overlayModuleInfo,
924 JsonType::ARRAY,
925 false,
926 parseResult,
927 ArrayType::OBJECT);
928 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
929 jsonObjectEnd,
930 MODULE_PRELOADS,
931 info.preloads,
932 JsonType::ARRAY,
933 false,
934 parseResult,
935 ArrayType::STRING);
936 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
937 jsonObjectEnd,
938 MODULE_RESIZEABLE,
939 info.resizeable,
940 false,
941 parseResult);
942 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
943 jsonObjectEnd,
944 MODULE_DEDUPLICATE_HAR,
945 info.deduplicateHar,
946 false,
947 parseResult);
948 GetValueIfFindKey<BundleType>(jsonObject,
949 jsonObjectEnd,
950 MODULE_BUNDLE_TYPE,
951 info.bundleType,
952 JsonType::NUMBER,
953 false,
954 parseResult,
955 ArrayType::NOT_ARRAY);
956 GetValueIfFindKey<uint32_t>(jsonObject,
957 jsonObjectEnd,
958 MODULE_VERSION_CODE,
959 info.versionCode,
960 JsonType::NUMBER,
961 false,
962 parseResult,
963 ArrayType::NOT_ARRAY);
964 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
965 jsonObjectEnd,
966 MODULE_VERSION_NAME,
967 info.versionName,
968 false,
969 parseResult);
970 GetValueIfFindKey<std::vector<ProxyData>>(jsonObject,
971 jsonObjectEnd,
972 MODULE_PROXY_DATAS,
973 info.proxyDatas,
974 JsonType::ARRAY,
975 false,
976 parseResult,
977 ArrayType::OBJECT);
978 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
979 jsonObjectEnd,
980 MODULE_BUILD_HASH,
981 info.buildHash,
982 false,
983 parseResult);
984 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
985 jsonObjectEnd,
986 MODULE_ISOLATION_MODE,
987 info.isolationMode,
988 false,
989 parseResult);
990 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
991 jsonObjectEnd,
992 MODULE_COMPRESS_NATIVE_LIBS,
993 info.compressNativeLibs,
994 false,
995 parseResult);
996 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
997 jsonObjectEnd,
998 MODULE_NATIVE_LIBRARY_FILE_NAMES,
999 info.nativeLibraryFileNames,
1000 JsonType::ARRAY,
1001 false,
1002 parseResult,
1003 ArrayType::STRING);
1004 GetValueIfFindKey<AOTCompileStatus>(jsonObject,
1005 jsonObjectEnd,
1006 MODULE_AOT_COMPILE_STATUS,
1007 info.aotCompileStatus,
1008 JsonType::NUMBER,
1009 false,
1010 parseResult,
1011 ArrayType::NOT_ARRAY);
1012 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1013 jsonObjectEnd,
1014 MODULE_FILE_CONTEXT_MENU,
1015 info.fileContextMenu,
1016 false,
1017 parseResult);
1018 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1019 jsonObjectEnd,
1020 MODULE_IS_ENCRYPTED,
1021 info.isEncrypted,
1022 false,
1023 parseResult);
1024 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1025 jsonObjectEnd,
1026 MODULE_QUERY_SCHEMES,
1027 info.querySchemes,
1028 JsonType::ARRAY,
1029 false,
1030 parseResult,
1031 ArrayType::STRING);
1032 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1033 jsonObjectEnd,
1034 MODULE_ROUTER_MAP,
1035 info.routerMap,
1036 false,
1037 parseResult);
1038 GetValueIfFindKey<std::vector<AppEnvironment>>(jsonObject,
1039 jsonObjectEnd,
1040 MODULE_APP_ENVIRONMENTS,
1041 info.appEnvironments,
1042 JsonType::ARRAY,
1043 false,
1044 parseResult,
1045 ArrayType::OBJECT);
1046 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1047 jsonObjectEnd,
1048 MODULE_ASAN_ENABLED,
1049 info.asanEnabled,
1050 false,
1051 parseResult);
1052 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1053 jsonObjectEnd,
1054 MODULE_GWP_ASAN_ENABLED,
1055 info.gwpAsanEnabled,
1056 false,
1057 parseResult);
1058 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1059 jsonObjectEnd,
1060 MODULE_TSAN_ENABLED,
1061 info.tsanEnabled,
1062 false,
1063 parseResult);
1064 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1065 jsonObjectEnd,
1066 MODULE_PACKAGE_NAME,
1067 info.packageName,
1068 false,
1069 parseResult);
1070 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1071 jsonObjectEnd,
1072 MODULE_APP_STARTUP,
1073 info.appStartup,
1074 false,
1075 parseResult);
1076 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1077 jsonObjectEnd,
1078 MODULE_FORM_EXTENSION_MODULE,
1079 info.formExtensionModule,
1080 false,
1081 parseResult);
1082 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1083 jsonObjectEnd,
1084 MODULE_FORM_WIDGET_MODULE,
1085 info.formWidgetModule,
1086 false,
1087 parseResult);
1088 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1089 jsonObjectEnd,
1090 MODULE_CROS_APP_SHARED_CONFIG,
1091 info.crossAppSharedConfig,
1092 false,
1093 parseResult);
1094 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1095 jsonObjectEnd,
1096 MODULE_ABILITY_SRC_ENTRY_DELEGATOR,
1097 info.abilitySrcEntryDelegator,
1098 false,
1099 parseResult);
1100 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1101 jsonObjectEnd,
1102 MODULE_ABILITY_STAGE_SRC_ENTRY_DELEGATOR,
1103 info.abilityStageSrcEntryDelegator,
1104 false,
1105 parseResult);
1106 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1107 jsonObjectEnd,
1108 MODULE_HWASAN_ENABLED,
1109 hwasanEnabled,
1110 false,
1111 parseResult);
1112 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1113 jsonObjectEnd,
1114 MODULE_UBSAN_ENABLED,
1115 ubsanEnabled,
1116 false,
1117 parseResult);
1118 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1119 jsonObjectEnd,
1120 MODULE_DEBUG,
1121 info.debug,
1122 false,
1123 parseResult);
1124 GetValueIfFindKey<uint8_t>(jsonObject,
1125 jsonObjectEnd,
1126 MODULE_BOOL_SET,
1127 info.boolSet,
1128 JsonType::NUMBER,
1129 false,
1130 parseResult,
1131 ArrayType::NOT_ARRAY);
1132 if (parseResult != ERR_OK) {
1133 APP_LOGE("read InnerModuleInfo from database error code : %{public}d", parseResult);
1134 } else {
1135 info.innerModuleInfoFlag = hwasanEnabled ? info.innerModuleInfoFlag | InnerBundleInfo::GetSanitizerFlag(
1136 GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED) : info.innerModuleInfoFlag &
1137 (~InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
1138 info.innerModuleInfoFlag = ubsanEnabled ? info.innerModuleInfoFlag | InnerBundleInfo::GetSanitizerFlag(
1139 GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED) : info.innerModuleInfoFlag &
1140 (~InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED));
1141 }
1142 }
1143
from_json(const nlohmann::json & jsonObject,Distro & distro)1144 void from_json(const nlohmann::json &jsonObject, Distro &distro)
1145 {
1146 const auto &jsonObjectEnd = jsonObject.end();
1147 int32_t parseResult = ERR_OK;
1148 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1149 jsonObjectEnd,
1150 ProfileReader::BUNDLE_MODULE_PROFILE_KEY_DELIVERY_WITH_INSTALL,
1151 distro.deliveryWithInstall,
1152 true,
1153 parseResult);
1154 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1155 jsonObjectEnd,
1156 ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_NAME,
1157 distro.moduleName,
1158 true,
1159 parseResult);
1160 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1161 jsonObjectEnd,
1162 ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_TYPE,
1163 distro.moduleType,
1164 true,
1165 parseResult);
1166 // mustFlag decide by distro.moduleType
1167 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1168 jsonObjectEnd,
1169 ProfileReader::BUNDLE_MODULE_PROFILE_KEY_MODULE_INSTALLATION_FREE,
1170 distro.installationFree,
1171 false,
1172 parseResult);
1173 if (parseResult != ERR_OK) {
1174 APP_LOGE("Distro from_json error, error code : %{public}d", parseResult);
1175 }
1176 }
1177
from_json(const nlohmann::json & jsonObject,InstallMark & installMark)1178 void from_json(const nlohmann::json &jsonObject, InstallMark &installMark)
1179 {
1180 const auto &jsonObjectEnd = jsonObject.end();
1181 int32_t parseResult = ERR_OK;
1182 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1183 jsonObjectEnd,
1184 ProfileReader::BUNDLE_INSTALL_MARK_BUNDLE,
1185 installMark.bundleName,
1186 false,
1187 parseResult);
1188 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1189 jsonObjectEnd,
1190 ProfileReader::BUNDLE_INSTALL_MARK_PACKAGE,
1191 installMark.packageName,
1192 false,
1193 parseResult);
1194 GetValueIfFindKey<int32_t>(jsonObject,
1195 jsonObjectEnd,
1196 ProfileReader::BUNDLE_INSTALL_MARK_STATUS,
1197 installMark.status,
1198 JsonType::NUMBER,
1199 false,
1200 parseResult,
1201 ArrayType::NOT_ARRAY);
1202 if (parseResult != ERR_OK) {
1203 APP_LOGE("InstallMark from_json error, error code : %{public}d", parseResult);
1204 }
1205 }
1206
from_json(const nlohmann::json & jsonObject,DefinePermission & definePermission)1207 void from_json(const nlohmann::json &jsonObject, DefinePermission &definePermission)
1208 {
1209 const auto &jsonObjectEnd = jsonObject.end();
1210 int32_t parseResult = ERR_OK;
1211 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1212 jsonObjectEnd,
1213 Profile::DEFINEPERMISSION_NAME,
1214 definePermission.name,
1215 false,
1216 parseResult);
1217 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1218 jsonObjectEnd,
1219 Profile::DEFINEPERMISSION_GRANT_MODE,
1220 definePermission.grantMode,
1221 false,
1222 parseResult);
1223 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1224 jsonObjectEnd,
1225 Profile::DEFINEPERMISSION_AVAILABLE_LEVEL,
1226 definePermission.availableLevel,
1227 false,
1228 parseResult);
1229 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1230 jsonObjectEnd,
1231 Profile::DEFINEPERMISSION_PROVISION_ENABLE,
1232 definePermission.provisionEnable,
1233 false,
1234 parseResult);
1235 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1236 jsonObjectEnd,
1237 Profile::DEFINEPERMISSION_DISTRIBUTED_SCENE_ENABLE,
1238 definePermission.distributedSceneEnable,
1239 false,
1240 parseResult);
1241 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1242 jsonObjectEnd,
1243 Profile::DEFINEPERMISSION_IS_KERNEL_EFFECT,
1244 definePermission.isKernelEffect,
1245 false,
1246 parseResult);
1247 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1248 jsonObjectEnd,
1249 Profile::DEFINEPERMISSION_HAS_VALUE,
1250 definePermission.hasValue,
1251 false,
1252 parseResult);
1253 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1254 jsonObjectEnd,
1255 Profile::LABEL,
1256 definePermission.label,
1257 false,
1258 parseResult);
1259 GetValueIfFindKey<int32_t>(jsonObject,
1260 jsonObjectEnd,
1261 Profile::LABEL_ID,
1262 definePermission.labelId,
1263 JsonType::NUMBER,
1264 false,
1265 parseResult,
1266 ArrayType::NOT_ARRAY);
1267 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1268 jsonObjectEnd,
1269 Profile::DESCRIPTION,
1270 definePermission.description,
1271 false,
1272 parseResult);
1273 GetValueIfFindKey<int32_t>(jsonObject,
1274 jsonObjectEnd,
1275 Profile::DESCRIPTION_ID,
1276 definePermission.descriptionId,
1277 JsonType::NUMBER,
1278 false,
1279 parseResult,
1280 ArrayType::NOT_ARRAY);
1281 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1282 jsonObjectEnd,
1283 Profile::DEFINEPERMISSION_AVAILABLE_TYPE,
1284 definePermission.availableType,
1285 false,
1286 parseResult);
1287 if (parseResult != ERR_OK) {
1288 APP_LOGE("DefinePermission from_json error, error code : %{public}d", parseResult);
1289 }
1290 }
1291
from_json(const nlohmann::json & jsonObject,Dependency & dependency)1292 void from_json(const nlohmann::json &jsonObject, Dependency &dependency)
1293 {
1294 const auto &jsonObjectEnd = jsonObject.end();
1295 int32_t parseResult = ERR_OK;
1296 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1297 jsonObjectEnd,
1298 Profile::DEPENDENCIES_MODULE_NAME,
1299 dependency.moduleName,
1300 false,
1301 parseResult);
1302 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1303 jsonObjectEnd,
1304 Profile::DEPENDENCIES_BUNDLE_NAME,
1305 dependency.bundleName,
1306 false,
1307 parseResult);
1308 GetValueIfFindKey<int>(jsonObject,
1309 jsonObjectEnd,
1310 Profile::APP_VERSION_CODE,
1311 dependency.versionCode,
1312 JsonType::NUMBER,
1313 false,
1314 parseResult,
1315 ArrayType::NOT_ARRAY);
1316 if (parseResult != ERR_OK) {
1317 APP_LOGE("Dependency from_json error, error code : %{public}d", parseResult);
1318 }
1319 }
1320
FromJson(const nlohmann::json & jsonObject)1321 int32_t InnerBundleInfo::FromJson(const nlohmann::json &jsonObject)
1322 {
1323 const auto &jsonObjectEnd = jsonObject.end();
1324 int32_t parseResult = ERR_OK;
1325 GetValueIfFindKey<Constants::AppType>(jsonObject,
1326 jsonObjectEnd,
1327 APP_TYPE,
1328 appType_,
1329 JsonType::NUMBER,
1330 true,
1331 parseResult,
1332 ArrayType::NOT_ARRAY);
1333 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1334 jsonObjectEnd,
1335 ALLOWED_ACLS,
1336 allowedAcls_,
1337 JsonType::ARRAY,
1338 false,
1339 parseResult,
1340 ArrayType::STRING);
1341 GetValueIfFindKey<BundleInfo>(jsonObject,
1342 jsonObjectEnd,
1343 BASE_BUNDLE_INFO,
1344 *baseBundleInfo_,
1345 JsonType::OBJECT,
1346 true,
1347 parseResult,
1348 ArrayType::NOT_ARRAY);
1349 GetValueIfFindKey<ApplicationInfo>(jsonObject,
1350 jsonObjectEnd,
1351 BASE_APPLICATION_INFO,
1352 *baseApplicationInfo_,
1353 JsonType::OBJECT,
1354 true,
1355 parseResult,
1356 ArrayType::NOT_ARRAY);
1357 GetValueIfFindKey<std::map<std::string, InnerAbilityInfo>>(jsonObject,
1358 jsonObjectEnd,
1359 BASE_ABILITY_INFO,
1360 baseAbilityInfos_,
1361 JsonType::OBJECT,
1362 true,
1363 parseResult,
1364 ArrayType::NOT_ARRAY);
1365 GetValueIfFindKey<std::map<std::string, InnerModuleInfo>>(jsonObject,
1366 jsonObjectEnd,
1367 INNER_MODULE_INFO,
1368 innerModuleInfos_,
1369 JsonType::OBJECT,
1370 true,
1371 parseResult,
1372 ArrayType::NOT_ARRAY);
1373 GetValueIfFindKey<std::map<std::string, std::vector<InnerModuleInfo>>>(jsonObject,
1374 jsonObjectEnd,
1375 INNER_SHARED_MODULE_INFO,
1376 innerSharedModuleInfos_,
1377 JsonType::OBJECT,
1378 false,
1379 parseResult,
1380 ArrayType::NOT_ARRAY);
1381 GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
1382 jsonObjectEnd,
1383 SKILL_INFOS,
1384 skillInfos_,
1385 JsonType::OBJECT,
1386 true,
1387 parseResult,
1388 ArrayType::NOT_ARRAY);
1389 GetValueIfFindKey<int>(jsonObject,
1390 jsonObjectEnd,
1391 USER_ID,
1392 userId_,
1393 JsonType::NUMBER,
1394 true,
1395 parseResult,
1396 ArrayType::NOT_ARRAY);
1397 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1398 jsonObjectEnd,
1399 APP_FEATURE,
1400 appFeature_,
1401 true,
1402 parseResult);
1403 GetValueIfFindKey<std::map<std::string, std::vector<FormInfo>>>(jsonObject,
1404 jsonObjectEnd,
1405 MODULE_FORMS,
1406 formInfos_,
1407 JsonType::OBJECT,
1408 true,
1409 parseResult,
1410 ArrayType::NOT_ARRAY);
1411 GetValueIfFindKey<std::map<std::string, ShortcutInfo>>(jsonObject,
1412 jsonObjectEnd,
1413 MODULE_SHORTCUT,
1414 shortcutInfos_,
1415 JsonType::OBJECT,
1416 true,
1417 parseResult,
1418 ArrayType::NOT_ARRAY);
1419 GetValueIfFindKey<std::map<std::string, CommonEventInfo>>(jsonObject,
1420 jsonObjectEnd,
1421 MODULE_COMMON_EVENT,
1422 commonEvents_,
1423 JsonType::OBJECT,
1424 true,
1425 parseResult,
1426 ArrayType::NOT_ARRAY);
1427 GetValueIfFindKey<InstallMark>(jsonObject,
1428 jsonObjectEnd,
1429 INSTALL_MARK,
1430 mark_,
1431 JsonType::OBJECT,
1432 false,
1433 parseResult,
1434 ArrayType::NOT_ARRAY);
1435 int32_t isOldVersion = ERR_OK;
1436 GetValueIfFindKey<std::map<std::string, InnerBundleUserInfo>>(jsonObject,
1437 jsonObjectEnd,
1438 INNER_BUNDLE_USER_INFOS,
1439 innerBundleUserInfos_,
1440 JsonType::OBJECT,
1441 true,
1442 isOldVersion,
1443 ArrayType::NOT_ARRAY);
1444 if (parseResult == ERR_OK && isOldVersion == ERR_APPEXECFWK_PARSE_PROFILE_MISSING_PROP) {
1445 // To be compatible with the old database,
1446 // if the old data does not have bundleUserInfos,
1447 // the default user information needs to be constructed.
1448 BuildDefaultUserInfo();
1449 }
1450 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1451 jsonObjectEnd,
1452 BUNDLE_IS_NEW_VERSION,
1453 isNewVersion_,
1454 false,
1455 parseResult);
1456 GetValueIfFindKey<std::map<std::string, InnerExtensionInfo>>(jsonObject,
1457 jsonObjectEnd,
1458 BUNDLE_BASE_EXTENSION_INFOS,
1459 baseExtensionInfos_,
1460 JsonType::OBJECT,
1461 false,
1462 parseResult,
1463 ArrayType::NOT_ARRAY);
1464 GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
1465 jsonObjectEnd,
1466 BUNDLE_EXTENSION_SKILL_INFOS,
1467 extensionSkillInfos_,
1468 JsonType::OBJECT,
1469 false,
1470 parseResult,
1471 ArrayType::NOT_ARRAY);
1472 GetValueIfFindKey<std::map<std::string, ExtendResourceInfo>>(jsonObject,
1473 jsonObjectEnd,
1474 BUNDLE_EXTEND_RESOURCES,
1475 extendResourceInfos_,
1476 JsonType::OBJECT,
1477 false,
1478 parseResult,
1479 ArrayType::NOT_ARRAY);
1480 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1481 jsonObjectEnd,
1482 CUR_DYNAMIC_ICON_MODULE,
1483 curDynamicIconModule_,
1484 false,
1485 parseResult);
1486 GetValueIfFindKey<BundlePackInfo>(jsonObject,
1487 jsonObjectEnd,
1488 BUNDLE_PACK_INFO,
1489 *bundlePackInfo_,
1490 JsonType::OBJECT,
1491 false,
1492 parseResult,
1493 ArrayType::NOT_ARRAY);
1494 GetValueIfFindKey<int>(jsonObject,
1495 jsonObjectEnd,
1496 APP_INDEX,
1497 appIndex_,
1498 JsonType::NUMBER,
1499 false,
1500 parseResult,
1501 ArrayType::NOT_ARRAY);
1502 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1503 jsonObjectEnd,
1504 BUNDLE_IS_SANDBOX_APP,
1505 isSandboxApp_,
1506 false,
1507 parseResult);
1508 GetValueIfFindKey<std::vector<HqfInfo>>(jsonObject,
1509 jsonObjectEnd,
1510 BUNDLE_HQF_INFOS,
1511 hqfInfos_,
1512 JsonType::ARRAY,
1513 false,
1514 parseResult,
1515 ArrayType::OBJECT);
1516 GetValueIfFindKey<std::vector<OverlayBundleInfo>>(jsonObject,
1517 jsonObjectEnd,
1518 OVERLAY_BUNDLE_INFO,
1519 overlayBundleInfo_,
1520 JsonType::ARRAY,
1521 false,
1522 parseResult,
1523 ArrayType::OBJECT);
1524 GetValueIfFindKey<int32_t>(jsonObject,
1525 jsonObjectEnd,
1526 OVERLAY_TYPE,
1527 overlayType_,
1528 JsonType::NUMBER,
1529 false,
1530 parseResult,
1531 ArrayType::NOT_ARRAY);
1532 GetValueIfFindKey<int32_t>(jsonObject,
1533 jsonObjectEnd,
1534 APPLY_QUICK_FIX_FREQUENCY,
1535 applyQuickFixFrequency_,
1536 JsonType::NUMBER,
1537 false,
1538 parseResult,
1539 ArrayType::NOT_ARRAY);
1540 GetValueIfFindKey<std::unordered_map<std::string, std::vector<DataGroupInfo>>>(jsonObject,
1541 jsonObjectEnd,
1542 DATA_GROUP_INFOS,
1543 dataGroupInfos_,
1544 JsonType::OBJECT,
1545 false,
1546 parseResult,
1547 ArrayType::NOT_ARRAY);
1548 GetValueIfFindKey<std::unordered_map<std::string, PluginBundleInfo>>(jsonObject,
1549 jsonObjectEnd,
1550 PLUGIN_BUNDLE_INFOS,
1551 pluginBundleInfos_,
1552 JsonType::OBJECT,
1553 false,
1554 parseResult,
1555 ArrayType::NOT_ARRAY);
1556 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1557 jsonObjectEnd,
1558 DEVELOPER_ID,
1559 developerId_,
1560 false,
1561 parseResult);
1562 BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1563 jsonObjectEnd,
1564 ODID,
1565 odid_,
1566 false,
1567 parseResult);
1568 BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1569 jsonObjectEnd,
1570 UNINSTALL_STATE,
1571 uninstallState_,
1572 false,
1573 parseResult);
1574 if (parseResult != ERR_OK) {
1575 APP_LOGE("read InnerBundleInfo from database error code : %{public}d", parseResult);
1576 }
1577 return parseResult;
1578 }
1579
BuildDefaultUserInfo()1580 void InnerBundleInfo::BuildDefaultUserInfo()
1581 {
1582 APP_LOGD("BuildDefaultUserInfo: bundleName: %{public}s",
1583 baseApplicationInfo_->bundleName.c_str());
1584 InnerBundleUserInfo defaultInnerBundleUserInfo;
1585 defaultInnerBundleUserInfo.bundleUserInfo.userId = GetUserId();
1586 defaultInnerBundleUserInfo.uid = Constants::INVALID_UID;
1587 defaultInnerBundleUserInfo.gids.emplace_back(ServiceConstants::INVALID_GID);
1588 defaultInnerBundleUserInfo.installTime = baseBundleInfo_->installTime;
1589 defaultInnerBundleUserInfo.updateTime = baseBundleInfo_->updateTime;
1590 defaultInnerBundleUserInfo.firstInstallTime = baseBundleInfo_->firstInstallTime;
1591 defaultInnerBundleUserInfo.bundleName = baseApplicationInfo_->bundleName;
1592 defaultInnerBundleUserInfo.bundleUserInfo.enabled = baseApplicationInfo_->enabled;
1593 AddInnerBundleUserInfo(defaultInnerBundleUserInfo);
1594 }
1595
FindHapModuleInfo(const std::string & modulePackage,int32_t userId,int32_t appIndex) const1596 std::optional<HapModuleInfo> InnerBundleInfo::FindHapModuleInfo(
1597 const std::string &modulePackage, int32_t userId, int32_t appIndex) const
1598 {
1599 auto it = innerModuleInfos_.find(modulePackage);
1600 if (it == innerModuleInfos_.end()) {
1601 APP_LOGE("not find module %{public}s", modulePackage.c_str());
1602 return std::nullopt;
1603 }
1604 HapModuleInfo hapInfo;
1605 hapInfo.name = it->second.name;
1606 hapInfo.package = it->second.modulePackage;
1607 hapInfo.moduleName = it->second.moduleName;
1608 hapInfo.description = it->second.description;
1609 hapInfo.descriptionId = it->second.descriptionId;
1610 hapInfo.label = it->second.label;
1611 hapInfo.labelId = it->second.labelId;
1612 hapInfo.iconPath = it->second.icon;
1613 hapInfo.iconId = it->second.iconId;
1614 hapInfo.mainAbility = it->second.mainAbility;
1615 hapInfo.srcPath = it->second.srcPath;
1616 hapInfo.hapPath = it->second.hapPath;
1617 hapInfo.supportedModes = baseApplicationInfo_->supportedModes;
1618 hapInfo.reqCapabilities = it->second.reqCapabilities;
1619 hapInfo.colorMode = it->second.colorMode;
1620 hapInfo.isRemovable = it->second.isRemovable;
1621 hapInfo.upgradeFlag = it->second.upgradeFlag;
1622 hapInfo.isLibIsolated = it->second.isLibIsolated;
1623 hapInfo.nativeLibraryPath = it->second.nativeLibraryPath;
1624 hapInfo.cpuAbi = it->second.cpuAbi;
1625
1626 hapInfo.bundleName = baseApplicationInfo_->bundleName;
1627 hapInfo.mainElementName = it->second.mainAbility;
1628 hapInfo.pages = it->second.pages;
1629 hapInfo.systemTheme = it->second.systemTheme;
1630 hapInfo.process = it->second.process;
1631 hapInfo.resourcePath = it->second.moduleResPath;
1632 hapInfo.srcEntrance = it->second.srcEntrance;
1633 hapInfo.uiSyntax = it->second.uiSyntax;
1634 hapInfo.virtualMachine = it->second.virtualMachine;
1635 hapInfo.deliveryWithInstall = it->second.distro.deliveryWithInstall;
1636 hapInfo.installationFree = it->second.distro.installationFree;
1637 hapInfo.isModuleJson = it->second.isModuleJson;
1638 hapInfo.isStageBasedModel = it->second.isStageBasedModel;
1639 hapInfo.deviceTypes = it->second.deviceTypes;
1640 hapInfo.requiredDeviceFeatures = it->second.requiredDeviceFeatures;
1641 hapInfo.appStartup = it->second.appStartup;
1642 hapInfo.formExtensionModule = it->second.formExtensionModule;
1643 hapInfo.formWidgetModule = it->second.formWidgetModule;
1644 hapInfo.hasIntent = BundleUtil::GetBitValue(it->second.boolSet, InnerModuleInfoBoolFlag::HAS_INTENT);
1645 std::string moduleType = it->second.distro.moduleType;
1646 if (moduleType == Profile::MODULE_TYPE_ENTRY) {
1647 hapInfo.moduleType = ModuleType::ENTRY;
1648 } else if (moduleType == Profile::MODULE_TYPE_FEATURE) {
1649 hapInfo.moduleType = ModuleType::FEATURE;
1650 } else if (moduleType == Profile::MODULE_TYPE_SHARED) {
1651 hapInfo.moduleType = ModuleType::SHARED;
1652 } else {
1653 hapInfo.moduleType = ModuleType::UNKNOWN;
1654 }
1655 std::string key;
1656 key.append(".").append(modulePackage).append(".");
1657 for (const auto &extension : baseExtensionInfos_) {
1658 if ((extension.first.find(key) != std::string::npos) && (extension.second.moduleName == hapInfo.moduleName)) {
1659 hapInfo.extensionInfos.emplace_back(InnerExtensionInfo::ConvertToExtensionInfo(extension.second));
1660 }
1661 }
1662 hapInfo.metadata = it->second.metadata;
1663 for (auto &ability : baseAbilityInfos_) {
1664 if (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1665 continue;
1666 }
1667 if ((ability.first.find(key) != std::string::npos) && (ability.second.moduleName == hapInfo.moduleName)) {
1668 AbilityInfo abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(ability.second);
1669 auto &abilityInfoRef = hapInfo.abilityInfos.emplace_back(abilityInfo);
1670 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1671 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1672 abilityInfoRef.applicationInfo, appIndex);
1673 }
1674 }
1675 hapInfo.dependencies = it->second.dependencies;
1676 hapInfo.compileMode = ConvertCompileMode(it->second.compileMode);
1677 for (const auto &hqf : hqfInfos_) {
1678 if (hqf.moduleName == it->second.moduleName) {
1679 hapInfo.hqfInfo = hqf;
1680 break;
1681 }
1682 }
1683 for (const auto &item : it->second.preloads) {
1684 PreloadItem preload(item);
1685 hapInfo.preloads.emplace_back(preload);
1686 }
1687 hapInfo.resizeable = it->second.resizeable;
1688 for (const auto &item : it->second.proxyDatas) {
1689 ProxyData proxyData(item);
1690 hapInfo.proxyDatas.emplace_back(proxyData);
1691 }
1692 hapInfo.buildHash = it->second.buildHash;
1693 hapInfo.isolationMode = GetIsolationMode(it->second.isolationMode);
1694 hapInfo.compressNativeLibs = it->second.compressNativeLibs;
1695 hapInfo.nativeLibraryFileNames = it->second.nativeLibraryFileNames;
1696 hapInfo.aotCompileStatus = it->second.aotCompileStatus;
1697 hapInfo.fileContextMenu = it->second.fileContextMenu;
1698 hapInfo.routerMap = it->second.routerMap;
1699 hapInfo.appEnvironments = it->second.appEnvironments;
1700 hapInfo.packageName = it->second.packageName;
1701 hapInfo.crossAppSharedConfig = it->second.crossAppSharedConfig;
1702 hapInfo.abilitySrcEntryDelegator = it->second.abilitySrcEntryDelegator;
1703 hapInfo.abilityStageSrcEntryDelegator = it->second.abilityStageSrcEntryDelegator;
1704 hapInfo.moduleArkTSMode = it->second.moduleArkTSMode;
1705 hapInfo.arkTSMode = it->second.arkTSMode;
1706 hapInfo.deduplicateHar = it->second.deduplicateHar;
1707 return hapInfo;
1708 }
1709
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,int32_t userId) const1710 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfo(
1711 const std::string &moduleName,
1712 const std::string &abilityName,
1713 int32_t userId) const
1714 {
1715 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
1716 if ((innerAbilityInfo.name == abilityName) &&
1717 (moduleName.empty() || (innerAbilityInfo.moduleName == moduleName))) {
1718 AbilityInfo abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
1719 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1720 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1721 abilityInfo.applicationInfo);
1722 return abilityInfo;
1723 }
1724 }
1725
1726 return std::nullopt;
1727 }
1728
FindAbilityInfoV9(const std::string & moduleName,const std::string & abilityName) const1729 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfoV9(
1730 const std::string &moduleName, const std::string &abilityName) const
1731 {
1732 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
1733 if ((innerAbilityInfo.name == abilityName) &&
1734 (moduleName.empty() || (innerAbilityInfo.moduleName == moduleName))) {
1735 return InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
1736 }
1737 }
1738 APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s",
1739 GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str());
1740 return std::nullopt;
1741 }
1742
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,AbilityInfo & info) const1743 ErrCode InnerBundleInfo::FindAbilityInfo(
1744 const std::string &moduleName, const std::string &abilityName, AbilityInfo &info) const
1745 {
1746 bool isModuleFind = false;
1747 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
1748 if ((innerAbilityInfo.moduleName == moduleName)) {
1749 isModuleFind = true;
1750 if (innerAbilityInfo.name == abilityName) {
1751 info = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
1752 return ERR_OK;
1753 }
1754 }
1755 }
1756 APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s, isModuleFind:%{public}d",
1757 GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str(), isModuleFind);
1758 if (isModuleFind) {
1759 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
1760 } else {
1761 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
1762 }
1763 }
1764
FindAbilityInfos(int32_t userId) const1765 std::optional<std::vector<AbilityInfo>> InnerBundleInfo::FindAbilityInfos(int32_t userId) const
1766 {
1767 if (!HasInnerBundleUserInfo(userId)) {
1768 return std::nullopt;
1769 }
1770
1771 std::vector<AbilityInfo> abilitys;
1772 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
1773 if (innerAbilityInfo.name == ServiceConstants::APP_DETAIL_ABILITY) {
1774 continue;
1775 }
1776 auto abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
1777 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1778 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1779 abilityInfo.applicationInfo);
1780 abilitys.emplace_back(abilityInfo);
1781 }
1782
1783 if (abilitys.empty()) {
1784 return std::nullopt;
1785 }
1786 return abilitys;
1787 }
1788
FindAbilityInfo(const std::string continueType,int32_t userId) const1789 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfo(const std::string continueType, int32_t userId) const
1790 {
1791 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
1792 std::vector<std::string> continueTypes = innerAbilityInfo.continueType;
1793 auto item = std::find(continueTypes.begin(), continueTypes.end(), continueType);
1794 if (item != continueTypes.end()) {
1795 AbilityInfo abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
1796 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
1797 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1798 abilityInfo.applicationInfo);
1799 return abilityInfo;
1800 }
1801 }
1802 return std::nullopt;
1803 }
1804
FindExtensionInfo(const std::string & moduleName,const std::string & extensionName) const1805 std::optional<ExtensionAbilityInfo> InnerBundleInfo::FindExtensionInfo(
1806 const std::string &moduleName, const std::string &extensionName) const
1807 {
1808 for (const auto &extension : baseExtensionInfos_) {
1809 if ((extension.second.name == extensionName) &&
1810 (moduleName.empty() || (extension.second.moduleName == moduleName))) {
1811 return InnerExtensionInfo::ConvertToExtensionInfo(extension.second);
1812 }
1813 }
1814
1815 return std::nullopt;
1816 }
1817
AddModuleInfo(const InnerBundleInfo & newInfo)1818 bool InnerBundleInfo::AddModuleInfo(const InnerBundleInfo &newInfo)
1819 {
1820 if (newInfo.currentPackage_.empty()) {
1821 APP_LOGE("current package is empty");
1822 return false;
1823 }
1824 if (FindModule(newInfo.currentPackage_)) {
1825 APP_LOGE("current package %{public}s exist", currentPackage_.c_str());
1826 return false;
1827 }
1828 AddInnerModuleInfo(newInfo.innerModuleInfos_);
1829 AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
1830 AddModuleSkillInfo(newInfo.skillInfos_);
1831 AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
1832 AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
1833 AddModuleFormInfo(newInfo.formInfos_);
1834 AddModuleShortcutInfo(newInfo.shortcutInfos_);
1835 AddModuleCommonEvent(newInfo.commonEvents_);
1836 UpdateIsCompressNativeLibs();
1837 return true;
1838 }
1839
UpdateBaseBundleInfo(const BundleInfo & bundleInfo,bool isEntry)1840 void InnerBundleInfo::UpdateBaseBundleInfo(const BundleInfo &bundleInfo, bool isEntry)
1841 {
1842 baseBundleInfo_->name = bundleInfo.name;
1843
1844 baseBundleInfo_->versionCode = bundleInfo.versionCode;
1845 baseBundleInfo_->versionName = bundleInfo.versionName;
1846 baseBundleInfo_->minCompatibleVersionCode = bundleInfo.minCompatibleVersionCode;
1847 baseBundleInfo_->compatibleVersion = bundleInfo.compatibleVersion;
1848 baseBundleInfo_->targetVersion = bundleInfo.targetVersion;
1849 baseBundleInfo_->targetMinorApiVersion = bundleInfo.targetMinorApiVersion;
1850 baseBundleInfo_->targetPatchApiVersion = bundleInfo.targetPatchApiVersion;
1851
1852 baseBundleInfo_->isKeepAlive = bundleInfo.isKeepAlive;
1853 baseBundleInfo_->singleton = bundleInfo.singleton;
1854 if (!baseBundleInfo_->isPreInstallApp) {
1855 baseBundleInfo_->isPreInstallApp = bundleInfo.isPreInstallApp;
1856 }
1857
1858 baseBundleInfo_->vendor = bundleInfo.vendor;
1859 if (!baseBundleInfo_->isNativeApp) {
1860 baseBundleInfo_->isNativeApp = bundleInfo.isNativeApp;
1861 }
1862
1863 if (isEntry) {
1864 baseBundleInfo_->mainEntry = bundleInfo.mainEntry;
1865 baseBundleInfo_->entryModuleName = bundleInfo.entryModuleName;
1866 }
1867 }
1868
UpdateBaseApplicationInfo(const InnerBundleInfo & newInfo)1869 void InnerBundleInfo::UpdateBaseApplicationInfo(const InnerBundleInfo &newInfo)
1870 {
1871 const ApplicationInfo &applicationInfo = newInfo.GetBaseApplicationInfo();
1872 baseApplicationInfo_->name = applicationInfo.name;
1873 baseApplicationInfo_->bundleName = applicationInfo.bundleName;
1874
1875 baseApplicationInfo_->versionCode = applicationInfo.versionCode;
1876 baseApplicationInfo_->versionName = applicationInfo.versionName;
1877 baseApplicationInfo_->minCompatibleVersionCode = applicationInfo.minCompatibleVersionCode;
1878 baseApplicationInfo_->apiCompatibleVersion = applicationInfo.apiCompatibleVersion;
1879 baseApplicationInfo_->apiTargetVersion = applicationInfo.apiTargetVersion;
1880 baseApplicationInfo_->targetMinorApiVersion = applicationInfo.targetMinorApiVersion;
1881 baseApplicationInfo_->targetPatchApiVersion = applicationInfo.targetPatchApiVersion;
1882
1883 baseApplicationInfo_->iconPath = applicationInfo.iconPath;
1884 baseApplicationInfo_->iconId = applicationInfo.iconId;
1885 baseApplicationInfo_->label = applicationInfo.label;
1886 baseApplicationInfo_->labelId = applicationInfo.labelId;
1887 baseApplicationInfo_->description = applicationInfo.description;
1888 baseApplicationInfo_->descriptionId = applicationInfo.descriptionId;
1889 baseApplicationInfo_->iconResource = applicationInfo.iconResource;
1890 baseApplicationInfo_->labelResource = applicationInfo.labelResource;
1891 baseApplicationInfo_->descriptionResource = applicationInfo.descriptionResource;
1892 baseApplicationInfo_->singleton = applicationInfo.singleton;
1893 baseApplicationInfo_->userDataClearable = applicationInfo.userDataClearable;
1894 baseApplicationInfo_->accessible = applicationInfo.accessible;
1895 baseApplicationInfo_->cloudFileSyncEnabled = applicationInfo.cloudFileSyncEnabled;
1896 baseApplicationInfo_->cloudStructuredDataSyncEnabled = applicationInfo.cloudStructuredDataSyncEnabled;
1897
1898 if (!baseApplicationInfo_->isSystemApp) {
1899 baseApplicationInfo_->isSystemApp = applicationInfo.isSystemApp;
1900 }
1901 if (!baseApplicationInfo_->isLauncherApp) {
1902 baseApplicationInfo_->isLauncherApp = applicationInfo.isLauncherApp;
1903 }
1904
1905 baseApplicationInfo_->deviceId = applicationInfo.deviceId;
1906 baseApplicationInfo_->distributedNotificationEnabled = applicationInfo.distributedNotificationEnabled;
1907 baseApplicationInfo_->entityType = applicationInfo.entityType;
1908 baseApplicationInfo_->process = applicationInfo.process;
1909 baseApplicationInfo_->supportedModes = applicationInfo.supportedModes;
1910 baseApplicationInfo_->vendor = applicationInfo.vendor;
1911 baseApplicationInfo_->appDistributionType = applicationInfo.appDistributionType;
1912 baseApplicationInfo_->appProvisionType = applicationInfo.appProvisionType;
1913 baseApplicationInfo_->formVisibleNotify = applicationInfo.formVisibleNotify;
1914 baseApplicationInfo_->needAppDetail = applicationInfo.needAppDetail;
1915 baseApplicationInfo_->appDetailAbilityLibraryPath = applicationInfo.appDetailAbilityLibraryPath;
1916 baseApplicationInfo_->bundleType = applicationInfo.bundleType;
1917 baseApplicationInfo_->allowMultiProcess = applicationInfo.allowMultiProcess;
1918 baseApplicationInfo_->allowArkTsLargeHeap = applicationInfo.allowArkTsLargeHeap;
1919 UpdatePrivilegeCapability(applicationInfo);
1920 SetHideDesktopIcon(applicationInfo.hideDesktopIcon);
1921 #ifdef BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION
1922 baseApplicationInfo_->targetBundleName = applicationInfo.targetBundleName;
1923 baseApplicationInfo_->targetPriority = applicationInfo.targetPriority;
1924 #endif
1925 UpdateDebug(newInfo);
1926 baseApplicationInfo_->organization = applicationInfo.organization;
1927 baseApplicationInfo_->multiProjects = applicationInfo.multiProjects;
1928 baseApplicationInfo_->appEnvironments = applicationInfo.appEnvironments;
1929 baseApplicationInfo_->maxChildProcess = applicationInfo.maxChildProcess;
1930 baseApplicationInfo_->configuration = applicationInfo.configuration;
1931 baseApplicationInfo_->startMode = applicationInfo.startMode;
1932 if (newInfo.HasEntry()) {
1933 baseApplicationInfo_->assetAccessGroups = applicationInfo.assetAccessGroups;
1934 baseApplicationInfo_->appPreloadPhase = applicationInfo.appPreloadPhase;
1935 }
1936 }
1937
GetApplicationEnabledV9(int32_t userId,bool & isEnabled,int32_t appIndex) const1938 ErrCode InnerBundleInfo::GetApplicationEnabledV9(int32_t userId, bool &isEnabled, int32_t appIndex) const
1939 {
1940 InnerBundleUserInfo innerBundleUserInfo;
1941 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1942 APP_LOGD("can not find bundleUserInfo in userId: %{public}d when GetApplicationEnabled", userId);
1943 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1944 }
1945 if (appIndex == 0) {
1946 isEnabled = innerBundleUserInfo.bundleUserInfo.enabled;
1947 PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1948 innerBundleUserInfo.bundleUserInfo.setEnabledCaller);
1949 return ERR_OK;
1950 } else if (appIndex > 0 && appIndex <= Constants::INITIAL_SANDBOX_APP_INDEX) {
1951 const std::map<std::string, InnerBundleCloneInfo> mpCloneInfos = innerBundleUserInfo.cloneInfos;
1952 std::string key = InnerBundleUserInfo::AppIndexToKey(appIndex);
1953 if (mpCloneInfos.find(key) == mpCloneInfos.end()) {
1954 return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
1955 }
1956 isEnabled = mpCloneInfos.at(key).enabled;
1957 PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1958 mpCloneInfos.at(key).setEnabledCaller);
1959 return ERR_OK;
1960 } else {
1961 return ERR_APPEXECFWK_APP_INDEX_OUT_OF_RANGE;
1962 }
1963 }
1964
UpdateAppDetailAbilityAttrs()1965 void InnerBundleInfo::UpdateAppDetailAbilityAttrs()
1966 {
1967 if (IsExistLauncherAbility()) {
1968 baseApplicationInfo_->needAppDetail = false;
1969 baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
1970 }
1971 for (auto iter = baseAbilityInfos_.begin(); iter != baseAbilityInfos_.end(); ++iter) {
1972 if (iter->second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1973 baseAbilityInfos_.erase(iter);
1974 return;
1975 }
1976 }
1977 }
1978
IsHideDesktopIcon() const1979 bool InnerBundleInfo::IsHideDesktopIcon() const
1980 {
1981 return baseApplicationInfo_->hideDesktopIcon ? true : !IsExistLauncherAbility();
1982 }
1983
IsExistLauncherAbility() const1984 bool InnerBundleInfo::IsExistLauncherAbility() const
1985 {
1986 bool isExistLauncherAbility = false;
1987 OHOS::AAFwk::Want want;
1988 want.SetAction(OHOS::AAFwk::Want::ACTION_HOME);
1989 want.AddEntity(OHOS::AAFwk::Want::ENTITY_HOME);
1990 for (const auto& abilityInfoPair : baseAbilityInfos_) {
1991 auto skillsPair = skillInfos_.find(abilityInfoPair.first);
1992 if (skillsPair == skillInfos_.end()) {
1993 continue;
1994 }
1995 for (const Skill& skill : skillsPair->second) {
1996 if (skill.MatchLauncher(want) && (abilityInfoPair.second.type == AbilityType::PAGE)) {
1997 isExistLauncherAbility = true;
1998 break;
1999 }
2000 }
2001 }
2002 return isExistLauncherAbility;
2003 }
2004
UpdateNativeLibAttrs(const ApplicationInfo & applicationInfo)2005 void InnerBundleInfo::UpdateNativeLibAttrs(const ApplicationInfo &applicationInfo)
2006 {
2007 LOG_NOFUNC_I(BMS_TAG_COMMON, "libPath:%{public}s", applicationInfo.nativeLibraryPath.c_str());
2008 baseApplicationInfo_->cpuAbi = applicationInfo.cpuAbi;
2009 baseApplicationInfo_->nativeLibraryPath = applicationInfo.nativeLibraryPath;
2010 }
2011
UpdateArkNativeAttrs(const ApplicationInfo & applicationInfo)2012 void InnerBundleInfo::UpdateArkNativeAttrs(const ApplicationInfo &applicationInfo)
2013 {
2014 baseApplicationInfo_->arkNativeFileAbi = applicationInfo.arkNativeFileAbi;
2015 baseApplicationInfo_->arkNativeFilePath = applicationInfo.arkNativeFilePath;
2016 }
2017
UpdatePrivilegeCapability(const ApplicationInfo & applicationInfo)2018 void InnerBundleInfo::UpdatePrivilegeCapability(const ApplicationInfo &applicationInfo)
2019 {
2020 // only json can be configured with the following privileges
2021 SetKeepAlive(applicationInfo.keepAlive);
2022 baseApplicationInfo_->runningResourcesApply = applicationInfo.runningResourcesApply;
2023 baseApplicationInfo_->associatedWakeUp = applicationInfo.associatedWakeUp;
2024 SetAllowCommonEvent(applicationInfo.allowCommonEvent);
2025 SetAllowAppRunWhenDeviceFirstLocked(applicationInfo.allowAppRunWhenDeviceFirstLocked);
2026 baseApplicationInfo_->resourcesApply = applicationInfo.resourcesApply;
2027 baseApplicationInfo_->allowEnableNotification = applicationInfo.allowEnableNotification;
2028
2029 // both json and signature can be configured with the following privileges
2030 // this function is also used to update json privileges during reboot.
2031 if (applicationInfo.allowMultiProcess) {
2032 baseApplicationInfo_->allowMultiProcess = true;
2033 }
2034 if (applicationInfo.hideDesktopIcon) {
2035 SetHideDesktopIcon(true);
2036 }
2037 if (!applicationInfo.userDataClearable) {
2038 baseApplicationInfo_->userDataClearable = false; // not allow to clear data
2039 }
2040 if (applicationInfo.formVisibleNotify) {
2041 baseApplicationInfo_->formVisibleNotify = true;
2042 }
2043 }
2044
UpdateRemovable(bool isPreInstall,bool removable)2045 void InnerBundleInfo::UpdateRemovable(bool isPreInstall, bool removable)
2046 {
2047 #ifdef USE_PRE_BUNDLE_PROFILE
2048 if (!isPreInstall) {
2049 return;
2050 }
2051 #endif
2052
2053 baseApplicationInfo_->removable = removable;
2054 }
2055
UpdateModuleInfo(const InnerBundleInfo & newInfo)2056 void InnerBundleInfo::UpdateModuleInfo(const InnerBundleInfo &newInfo)
2057 {
2058 if (newInfo.currentPackage_.empty()) {
2059 APP_LOGE("no package in new info");
2060 return;
2061 }
2062
2063 RemoveModuleInfo(newInfo.currentPackage_);
2064 AddInnerModuleInfo(newInfo.innerModuleInfos_);
2065 AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
2066 AddModuleSkillInfo(newInfo.skillInfos_);
2067 AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
2068 AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
2069 AddModuleFormInfo(newInfo.formInfos_);
2070 AddModuleShortcutInfo(newInfo.shortcutInfos_);
2071 AddModuleCommonEvent(newInfo.commonEvents_);
2072 UpdateIsCompressNativeLibs();
2073 }
2074
GetMaxVerBaseSharedBundleInfo(const std::string & moduleName,BaseSharedBundleInfo & baseSharedBundleInfo) const2075 bool InnerBundleInfo::GetMaxVerBaseSharedBundleInfo(const std::string &moduleName,
2076 BaseSharedBundleInfo &baseSharedBundleInfo) const
2077 {
2078 auto it = innerSharedModuleInfos_.find(moduleName);
2079 if (it == innerSharedModuleInfos_.end()) {
2080 APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2081 return false;
2082 }
2083 auto sharedModuleInfoVector = it->second;
2084 if (sharedModuleInfoVector.empty()) {
2085 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2086 return false;
2087 }
2088 InnerModuleInfo innerModuleInfo = sharedModuleInfoVector.front();
2089 if (innerModuleInfo.bundleType != BundleType::SHARED) {
2090 APP_LOGE("GetMaxVerBaseSharedBundleInfo failed, bundleType is invalid");
2091 return false;
2092 }
2093 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2094 baseSharedBundleInfo.moduleName = innerModuleInfo.moduleName;
2095 baseSharedBundleInfo.versionCode = innerModuleInfo.versionCode;
2096 baseSharedBundleInfo.nativeLibraryPath = innerModuleInfo.nativeLibraryPath;
2097 baseSharedBundleInfo.hapPath = innerModuleInfo.hapPath;
2098 baseSharedBundleInfo.moduleArkTSMode = innerModuleInfo.moduleArkTSMode;
2099 baseSharedBundleInfo.compressNativeLibs = innerModuleInfo.compressNativeLibs;
2100 baseSharedBundleInfo.nativeLibraryFileNames = innerModuleInfo.nativeLibraryFileNames;
2101 return true;
2102 }
2103
GetBaseSharedBundleInfo(const std::string & moduleName,uint32_t versionCode,BaseSharedBundleInfo & baseSharedBundleInfo) const2104 bool InnerBundleInfo::GetBaseSharedBundleInfo(const std::string &moduleName, uint32_t versionCode,
2105 BaseSharedBundleInfo &baseSharedBundleInfo) const
2106 {
2107 auto it = innerSharedModuleInfos_.find(moduleName);
2108 if (it == innerSharedModuleInfos_.end()) {
2109 APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2110 return false;
2111 }
2112 auto sharedModuleInfoVector = it->second;
2113 if (sharedModuleInfoVector.empty()) {
2114 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2115 return false;
2116 }
2117 for (const auto &item : sharedModuleInfoVector) {
2118 if (item.bundleType != BundleType::SHARED) {
2119 APP_LOGE("GetBaseSharedBundleInfo failed, bundleType is invalid");
2120 return false;
2121 }
2122 if (item.versionCode == versionCode) {
2123 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2124 baseSharedBundleInfo.moduleName = item.moduleName;
2125 baseSharedBundleInfo.versionCode = item.versionCode;
2126 baseSharedBundleInfo.nativeLibraryPath = item.nativeLibraryPath;
2127 baseSharedBundleInfo.hapPath = item.hapPath;
2128 baseSharedBundleInfo.moduleArkTSMode = item.moduleArkTSMode;
2129 baseSharedBundleInfo.compressNativeLibs = item.compressNativeLibs;
2130 baseSharedBundleInfo.nativeLibraryFileNames = item.nativeLibraryFileNames;
2131 return true;
2132 }
2133 }
2134 APP_LOGE("GetBaseSharedBundleInfo failed, the version(%{public}d) not exists for this module(%{public}s)",
2135 versionCode, moduleName.c_str());
2136 return false;
2137 }
2138
InsertInnerSharedModuleInfo(const std::string & moduleName,const InnerModuleInfo & innerModuleInfo)2139 void InnerBundleInfo::InsertInnerSharedModuleInfo(const std::string &moduleName,
2140 const InnerModuleInfo &innerModuleInfo)
2141 {
2142 auto iterator = innerSharedModuleInfos_.find(moduleName);
2143 if (iterator != innerSharedModuleInfos_.end()) {
2144 auto innerModuleInfoVector = iterator->second;
2145 bool insertFlag = false;
2146 for (unsigned long i = 0; i < innerModuleInfoVector.size(); i++) {
2147 if (innerModuleInfo.versionCode == innerModuleInfoVector.at(i).versionCode) {
2148 // if the inserted versionCode same as the existing one, replace old innerModuleInfo.
2149 innerModuleInfoVector.at(i) = innerModuleInfo;
2150 insertFlag = true;
2151 break;
2152 } else if (innerModuleInfo.versionCode > innerModuleInfoVector.at(i).versionCode) {
2153 // if the inserted versionCode bigger then the existing one, insert the specified location.
2154 innerModuleInfoVector.emplace(innerModuleInfoVector.begin() + i, innerModuleInfo);
2155 insertFlag = true;
2156 break;
2157 } else {
2158 continue;
2159 }
2160 }
2161 if (!insertFlag) {
2162 // insert innerModuleInfo in last location.
2163 innerModuleInfoVector.emplace(innerModuleInfoVector.end(), innerModuleInfo);
2164 }
2165 innerSharedModuleInfos_[moduleName] = innerModuleInfoVector;
2166 } else {
2167 std::vector<InnerModuleInfo> newInnerModuleInfoVector;
2168 newInnerModuleInfoVector.emplace_back(innerModuleInfo);
2169 innerSharedModuleInfos_.try_emplace(moduleName, newInnerModuleInfoVector);
2170 }
2171 }
2172
SetSharedModuleNativeLibraryPath(const std::string & nativeLibraryPath)2173 void InnerBundleInfo::SetSharedModuleNativeLibraryPath(const std::string &nativeLibraryPath)
2174 {
2175 auto sharedModuleInfoIterator = innerSharedModuleInfos_.find(currentPackage_);
2176 auto moduleInfoIterator = innerModuleInfos_.find(currentPackage_);
2177 if ((sharedModuleInfoIterator == innerSharedModuleInfos_.end()) ||
2178 (moduleInfoIterator == innerModuleInfos_.end())) {
2179 LOG_NOFUNC_W(BMS_TAG_COMMON, "The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
2180 return;
2181 }
2182 auto &innerModuleInfoVector = sharedModuleInfoIterator->second;
2183 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
2184 if (iter->versionCode == moduleInfoIterator->second.versionCode) {
2185 iter->nativeLibraryPath = nativeLibraryPath;
2186 return;
2187 }
2188 }
2189 }
2190
GetSharedBundleInfo(SharedBundleInfo & sharedBundleInfo) const2191 bool InnerBundleInfo::GetSharedBundleInfo(SharedBundleInfo &sharedBundleInfo) const
2192 {
2193 sharedBundleInfo.name = GetBundleName();
2194 sharedBundleInfo.compatiblePolicy = CompatiblePolicy::BACKWARD_COMPATIBILITY;
2195 std::vector<SharedModuleInfo> sharedModuleInfos;
2196 for (const auto &infoVector : innerSharedModuleInfos_) {
2197 for (const auto &info : infoVector.second) {
2198 SharedModuleInfo sharedModuleInfo;
2199 sharedModuleInfo.name = info.name;
2200 sharedModuleInfo.versionCode = info.versionCode;
2201 sharedModuleInfo.versionName = info.versionName;
2202 sharedModuleInfo.description = info.description;
2203 sharedModuleInfo.descriptionId = info.descriptionId;
2204 sharedModuleInfo.compressNativeLibs = info.compressNativeLibs;
2205 sharedModuleInfo.hapPath = info.hapPath;
2206 sharedModuleInfo.cpuAbi = info.cpuAbi;
2207 sharedModuleInfo.nativeLibraryPath = info.nativeLibraryPath;
2208 sharedModuleInfo.nativeLibraryFileNames = info.nativeLibraryFileNames;
2209 sharedModuleInfos.emplace_back(sharedModuleInfo);
2210 }
2211 }
2212 sharedBundleInfo.sharedModuleInfos = sharedModuleInfos;
2213 return true;
2214 }
2215
GetSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2216 bool InnerBundleInfo::GetSharedDependencies(const std::string &moduleName,
2217 std::vector<Dependency> &dependencies) const
2218 {
2219 if (innerModuleInfos_.find(moduleName) != innerModuleInfos_.end()) {
2220 dependencies = innerModuleInfos_.at(moduleName).dependencies;
2221 return true;
2222 }
2223 APP_LOGE("GetSharedDependencies not find module %{public}s", moduleName.c_str());
2224 return false;
2225 }
2226
GetAllSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2227 bool InnerBundleInfo::GetAllSharedDependencies(const std::string &moduleName,
2228 std::vector<Dependency> &dependencies) const
2229 {
2230 if (!GetSharedDependencies(moduleName, dependencies)) {
2231 return false;
2232 }
2233 std::deque<Dependency> dependenciesDeque;
2234 std::copy(dependencies.begin(), dependencies.end(), std::back_inserter(dependenciesDeque));
2235 dependencies.clear();
2236 while (!dependenciesDeque.empty()) {
2237 bool isAdd = true;
2238 Dependency itemDependency = dependenciesDeque.front();
2239 dependenciesDeque.pop_front();
2240 for (const auto &item : dependencies) {
2241 if (item.bundleName == itemDependency.bundleName && item.moduleName == itemDependency.moduleName &&
2242 item.versionCode == itemDependency.versionCode) {
2243 isAdd = false;
2244 break;
2245 }
2246 }
2247 if (isAdd) {
2248 dependencies.push_back(itemDependency);
2249 std::vector<Dependency> tempDependencies;
2250 if (GetSharedDependencies(itemDependency.moduleName, tempDependencies)) {
2251 std::copy(tempDependencies.begin(), tempDependencies.end(), std::back_inserter(dependenciesDeque));
2252 }
2253 }
2254 }
2255 return true;
2256 }
2257
RemoveModuleInfo(const std::string & modulePackage)2258 void InnerBundleInfo::RemoveModuleInfo(const std::string &modulePackage)
2259 {
2260 auto it = innerModuleInfos_.find(modulePackage);
2261 if (it == innerModuleInfos_.end()) {
2262 APP_LOGE("The module(%{public}s) infomation not exist", modulePackage.c_str());
2263 return;
2264 }
2265
2266 auto oldModuleInfo = it->second;
2267 if (oldModuleInfo.isEntry) {
2268 baseBundleInfo_->mainEntry.clear();
2269 baseBundleInfo_->entryModuleName.clear();
2270 }
2271 innerModuleInfos_.erase(it);
2272 std::string key;
2273 key.append(".").append(modulePackage).append(".");
2274 for (auto iter = shortcutInfos_.begin(); iter != shortcutInfos_.end();) {
2275 if (iter->first.find(key) != std::string::npos) {
2276 shortcutInfos_.erase(iter++);
2277 } else {
2278 ++iter;
2279 }
2280 }
2281
2282 for (auto iter = commonEvents_.begin(); iter != commonEvents_.end();) {
2283 if (iter->first.find(key) != std::string::npos) {
2284 commonEvents_.erase(iter++);
2285 } else {
2286 ++iter;
2287 }
2288 }
2289
2290 // delete old abilityInfos
2291 for (auto abilityKey : oldModuleInfo.abilityKeys) {
2292 auto abilityItem = baseAbilityInfos_.find(abilityKey);
2293 if (abilityItem == baseAbilityInfos_.end()) {
2294 continue;
2295 }
2296
2297 baseAbilityInfos_.erase(abilityItem);
2298 formInfos_.erase(abilityKey);
2299 }
2300
2301 // delete old skillInfos
2302 for (auto skillKey : oldModuleInfo.skillKeys) {
2303 auto skillItem = skillInfos_.find(skillKey);
2304 if (skillItem == skillInfos_.end()) {
2305 continue;
2306 }
2307
2308 skillInfos_.erase(skillItem);
2309 }
2310
2311 // delete old extensionInfos
2312 for (auto extensionKey : oldModuleInfo.extensionKeys) {
2313 auto extensionItem = baseExtensionInfos_.find(extensionKey);
2314 if (extensionItem == baseExtensionInfos_.end()) {
2315 continue;
2316 }
2317
2318 baseExtensionInfos_.erase(extensionItem);
2319 }
2320
2321 // delete old extensionSkillInfos
2322 for (auto extensionSkillKey : oldModuleInfo.extensionSkillKeys) {
2323 auto extensionSkillItem = extensionSkillInfos_.find(extensionSkillKey);
2324 if (extensionSkillItem == extensionSkillInfos_.end()) {
2325 continue;
2326 }
2327
2328 extensionSkillInfos_.erase(extensionSkillItem);
2329 }
2330
2331 // update application debug
2332 baseApplicationInfo_->debug = GetDebugFromModules(innerModuleInfos_);
2333 }
2334
ToString() const2335 std::string InnerBundleInfo::ToString() const
2336 {
2337 nlohmann::json j;
2338 ToJson(j);
2339 return j.dump();
2340 }
2341
GetApplicationInfo(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2342 void InnerBundleInfo::GetApplicationInfo(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2343 int32_t appIndex) const
2344 {
2345 InnerBundleUserInfo innerBundleUserInfo;
2346 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2347 LOG_W(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2348 return;
2349 }
2350
2351 if (baseApplicationInfo_ == nullptr) {
2352 LOG_E(BMS_TAG_QUERY, "baseApplicationInfo_ is nullptr");
2353 return;
2354 }
2355 appInfo = *baseApplicationInfo_;
2356 appInfo.arkTSMode = GetApplicationArkTSMode();
2357 if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2358 return;
2359 }
2360
2361 for (const auto &info : innerModuleInfos_) {
2362 bool deCompress = info.second.hapPath.empty();
2363 ModuleInfo moduleInfo;
2364 moduleInfo.moduleName = info.second.moduleName;
2365 if (deCompress) {
2366 moduleInfo.moduleSourceDir = info.second.modulePath;
2367 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2368 }
2369 if (info.second.hnpPackages.size() > 0) {
2370 appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2371 }
2372 moduleInfo.preloads = info.second.preloads;
2373 appInfo.moduleInfos.emplace_back(moduleInfo);
2374 if (deCompress && info.second.isEntry) {
2375 appInfo.entryDir = info.second.modulePath;
2376 }
2377 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_PERMISSION) ==
2378 GET_APPLICATION_INFO_WITH_PERMISSION) {
2379 for (const auto &item : info.second.requestPermissions) {
2380 appInfo.permissions.push_back(item.name);
2381 }
2382 }
2383 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_METADATA) == GET_APPLICATION_INFO_WITH_METADATA) {
2384 bool isModuleJson = info.second.isModuleJson;
2385 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2386 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2387 }
2388 if (isModuleJson && info.second.metadata.size() > 0) {
2389 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2390 }
2391 }
2392 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) !=
2393 GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) {
2394 appInfo.fingerprint.clear();
2395 }
2396 }
2397 if (!appInfo.permissions.empty()) {
2398 RemoveDuplicateName(appInfo.permissions);
2399 }
2400 appInfo.appIndex = appIndex;
2401 appInfo.hasPlugin = innerBundleUserInfo.installedPluginSet.empty() ? false : true;
2402 // The label and icon are first used under main ability
2403 AdaptMainLauncherResourceInfo(appInfo);
2404
2405 GetPreInstallApplicationFlags(appInfo);
2406 }
2407
GetApplicationInfoV9(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2408 ErrCode InnerBundleInfo::GetApplicationInfoV9(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2409 int32_t appIndex) const
2410 {
2411 InnerBundleUserInfo innerBundleUserInfo;
2412 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2413 LOG_W(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2414 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2415 }
2416
2417 appInfo = *baseApplicationInfo_;
2418 appInfo.arkTSMode = GetApplicationArkTSMode();
2419 if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2420 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
2421 }
2422
2423 for (const auto &info : innerModuleInfos_) {
2424 bool deCompress = info.second.hapPath.empty();
2425 ModuleInfo moduleInfo;
2426 moduleInfo.moduleName = info.second.moduleName;
2427 if (deCompress) {
2428 moduleInfo.moduleSourceDir = info.second.modulePath;
2429 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2430 }
2431 if (info.second.hnpPackages.size() > 0) {
2432 appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2433 }
2434 moduleInfo.preloads = info.second.preloads;
2435 appInfo.moduleInfos.emplace_back(moduleInfo);
2436 if (deCompress && info.second.isEntry) {
2437 appInfo.entryDir = info.second.modulePath;
2438 }
2439 if ((static_cast<uint32_t>(flags) &
2440 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) ==
2441 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) {
2442 for (const auto &item : info.second.requestPermissions) {
2443 appInfo.permissions.push_back(item.name);
2444 }
2445 }
2446 if ((static_cast<uint32_t>(flags) &
2447 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) ==
2448 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) {
2449 bool isModuleJson = info.second.isModuleJson;
2450 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2451 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2452 }
2453 if (isModuleJson && info.second.metadata.size() > 0) {
2454 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2455 }
2456 }
2457 }
2458 if (!appInfo.permissions.empty()) {
2459 RemoveDuplicateName(appInfo.permissions);
2460 }
2461 appInfo.hasPlugin = innerBundleUserInfo.installedPluginSet.empty() ? false : true;
2462 // The label and icon are first used under main ability
2463 AdaptMainLauncherResourceInfo(appInfo);
2464
2465 GetPreInstallApplicationFlags(appInfo);
2466 return ERR_OK;
2467 }
2468
GetPreInstallApplicationFlags(ApplicationInfo & appInfo) const2469 void InnerBundleInfo::GetPreInstallApplicationFlags(ApplicationInfo &appInfo) const
2470 {
2471 if (IsPreInstallApp()) {
2472 uint32_t applicationFlags = static_cast<uint32_t>(appInfo.applicationFlags);
2473 applicationFlags |= static_cast<uint32_t>(ApplicationInfoFlag::FLAG_PREINSTALLED_APP);
2474 appInfo.applicationFlags = static_cast<int32_t>(applicationFlags);
2475 for (const auto &moduleEnt: innerModuleInfos_) {
2476 const auto &hapPath = moduleEnt.second.hapPath;
2477 if (hapPath.find(Constants::BUNDLE_CODE_DIR) != 0) {
2478 return;
2479 }
2480 }
2481 applicationFlags |= static_cast<uint32_t>(ApplicationInfoFlag::FLAG_PREINSTALLED_APP_UPDATE);
2482 appInfo.applicationFlags = static_cast<int32_t>(applicationFlags);
2483 }
2484 }
2485
GetBundleInfo(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2486 bool InnerBundleInfo::GetBundleInfo(int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2487 {
2488 InnerBundleUserInfo innerBundleUserInfo;
2489 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2490 LOG_W(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo bundleName:%{public}s",
2491 userId, GetBundleName().c_str());
2492 return false;
2493 }
2494
2495 bundleInfo = *baseBundleInfo_;
2496 if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2497 LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2498 return false;
2499 }
2500 bundleInfo.overlayType = overlayType_;
2501 bundleInfo.isNewVersion = isNewVersion_;
2502
2503 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
2504 bundleInfo.applicationInfo, appIndex);
2505 for (const auto &info : innerModuleInfos_) {
2506 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2507 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2508 for (const auto &item : info.second.requestPermissions) {
2509 bundleInfo.reqPermissions.push_back(item.name);
2510 }
2511 for (const auto &item : info.second.definePermissions) {
2512 bundleInfo.defPermissions.push_back(item.name);
2513 }
2514 }
2515 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2516 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
2517 if (hapmoduleinfo) {
2518 GetModuleWithHashValue(flags, info.second.modulePackage, *hapmoduleinfo);
2519 bundleInfo.hapModuleInfos.emplace_back(*hapmoduleinfo);
2520 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2521 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2522 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2523 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2524 } else {
2525 LOG_E(BMS_TAG_QUERY, "can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
2526 }
2527 }
2528 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2529 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2530 if (!bundleInfo.reqPermissions.empty()) {
2531 RemoveDuplicateName(bundleInfo.reqPermissions);
2532 }
2533 if (!bundleInfo.defPermissions.empty()) {
2534 RemoveDuplicateName(bundleInfo.defPermissions);
2535 }
2536 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo,
2537 bundleInfo.applicationInfo.accessTokenId, bundleInfo.applicationInfo.deviceId)) {
2538 LOG_E(BMS_TAG_QUERY, "get request permission state failed");
2539 }
2540 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2541 }
2542 GetBundleWithAbilities(flags, bundleInfo, appIndex, userId);
2543 GetBundleWithExtension(flags, bundleInfo, appIndex, userId);
2544 return true;
2545 }
2546
GetBundleInfoV9(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2547 ErrCode InnerBundleInfo::GetBundleInfoV9(int32_t flags, BundleInfo &bundleInfo, int32_t userId,
2548 int32_t appIndex) const
2549 {
2550 InnerBundleUserInfo innerBundleUserInfo;
2551 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2552 LOG_W(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo", userId);
2553 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2554 }
2555
2556 bundleInfo = *baseBundleInfo_;
2557 if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2558 LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2559 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2560 }
2561 bundleInfo.overlayType = overlayType_;
2562 bundleInfo.isNewVersion = isNewVersion_;
2563
2564 for (const auto &info : innerModuleInfos_) {
2565 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2566 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2567 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2568 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2569 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2570 }
2571 ProcessBundleFlags(flags, userId, bundleInfo, appIndex);
2572 return ERR_OK;
2573 }
2574
GetSharedBundleInfo(int32_t flags,BundleInfo & bundleInfo) const2575 bool InnerBundleInfo::GetSharedBundleInfo(int32_t flags, BundleInfo &bundleInfo) const
2576 {
2577 bundleInfo = *baseBundleInfo_;
2578 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, Constants::ALL_USERID);
2579 bundleInfo.applicationInfo = *baseApplicationInfo_;
2580 bundleInfo.applicationInfo.arkTSMode = GetApplicationArkTSMode();
2581 return true;
2582 }
2583
ProcessBundleFlags(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2584 void InnerBundleInfo::ProcessBundleFlags(
2585 int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2586 {
2587 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
2588 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
2589 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2590 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2591 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), userId,
2592 bundleInfo.applicationInfo, appIndex);
2593 } else {
2594 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_DEFAULT), userId,
2595 bundleInfo.applicationInfo, appIndex);
2596 }
2597 BmsExtensionDataMgr bmsExtensionDataMgr;
2598 if (bundleInfo.applicationInfo.removable &&
2599 !bmsExtensionDataMgr.IsTargetApp(GetBundleName(), GetAppIdentifier())) {
2600 bundleInfo.applicationInfo.removable = GetUninstallState();
2601 }
2602 }
2603 bundleInfo.applicationInfo.appIndex = appIndex;
2604 GetBundleWithReqPermissionsV9(flags, userId, bundleInfo, appIndex);
2605 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, userId, appIndex);
2606 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
2607 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
2608 bundleInfo.signatureInfo.appId = baseBundleInfo_->appId;
2609 bundleInfo.signatureInfo.fingerprint = baseApplicationInfo_->fingerprint;
2610 }
2611 }
2612
GetBundleWithReqPermissionsV9(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2613 void InnerBundleInfo::GetBundleWithReqPermissionsV9(
2614 int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2615 {
2616 if ((static_cast<uint32_t>(flags) &
2617 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION))
2618 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION)) {
2619 return;
2620 }
2621 for (const auto &info : innerModuleInfos_) {
2622 for (const auto &item : info.second.requestPermissions) {
2623 bundleInfo.reqPermissions.push_back(item.name);
2624 }
2625 for (const auto &item : info.second.definePermissions) {
2626 bundleInfo.defPermissions.push_back(item.name);
2627 }
2628 }
2629 if (!bundleInfo.reqPermissions.empty()) {
2630 RemoveDuplicateName(bundleInfo.reqPermissions);
2631 }
2632 if (!bundleInfo.defPermissions.empty()) {
2633 RemoveDuplicateName(bundleInfo.defPermissions);
2634 }
2635 InnerBundleUserInfo innerBundleUserInfo;
2636 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2637 APP_LOGE("not find userId %{public}d when get applicationInfo", userId);
2638 return;
2639 }
2640 uint32_t tokenId = innerBundleUserInfo.accessTokenId;
2641 std::string deviceId = baseApplicationInfo_->deviceId;
2642 if (appIndex != 0) {
2643 // clone app
2644 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = innerBundleUserInfo.cloneInfos;
2645 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
2646 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
2647 LOG_W(BMS_TAG_QUERY,
2648 "can not find userId %{public}d, appIndex %{public}d when get applicationInfo", userId, appIndex);
2649 return;
2650 }
2651 const InnerBundleCloneInfo &cloneInfo = mpCloneInfos.at(appIndexKey);
2652 tokenId = cloneInfo.accessTokenId;
2653 }
2654 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo, tokenId, deviceId)) {
2655 APP_LOGE("get request permission state failed");
2656 }
2657 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2658 }
2659
GetModuleWithHashValue(int32_t flags,const std::string & modulePackage,HapModuleInfo & hapModuleInfo) const2660 void InnerBundleInfo::GetModuleWithHashValue(
2661 int32_t flags, const std::string &modulePackage, HapModuleInfo &hapModuleInfo) const
2662 {
2663 if (!(static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_HASH_VALUE)) {
2664 return;
2665 }
2666
2667 auto it = innerModuleInfos_.find(modulePackage);
2668 if (it == innerModuleInfos_.end()) {
2669 APP_LOGE("not find module %{public}s", modulePackage.c_str());
2670 return;
2671 }
2672
2673 hapModuleInfo.hashValue = it->second.hashValue;
2674 }
2675
ProcessBundleWithHapModuleInfoFlag(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2676 void InnerBundleInfo::ProcessBundleWithHapModuleInfoFlag(
2677 int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2678 {
2679 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE))
2680 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE)) {
2681 bundleInfo.hapModuleInfos.clear();
2682 return;
2683 }
2684 for (const auto &info : innerModuleInfos_) {
2685 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId, appIndex);
2686 if (hapmoduleinfo) {
2687 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
2688 auto it = innerModuleInfos_.find(info.second.modulePackage);
2689 if (it == innerModuleInfos_.end()) {
2690 APP_LOGE("not find module %{public}s", info.second.modulePackage.c_str());
2691 } else {
2692 hapModuleInfo.hashValue = it->second.hashValue;
2693 }
2694 if (hapModuleInfo.hapPath.empty()) {
2695 hapModuleInfo.moduleSourceDir = info.second.modulePath;
2696 }
2697 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2698 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2699 hapModuleInfo.metadata.clear();
2700 }
2701
2702 GetBundleWithAbilitiesV9(flags, hapModuleInfo, userId, appIndex);
2703 GetBundleWithExtensionAbilitiesV9(flags, hapModuleInfo, appIndex);
2704 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
2705 }
2706 }
2707 }
2708
GetBundleWithAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t userId,int32_t appIndex) const2709 void InnerBundleInfo::GetBundleWithAbilitiesV9(
2710 int32_t flags, HapModuleInfo &hapModuleInfo, int32_t userId, int32_t appIndex) const
2711 {
2712 hapModuleInfo.abilityInfos.clear();
2713 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY))
2714 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY)) {
2715 return;
2716 }
2717 APP_LOGD("Get bundleInfo with abilities");
2718 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
2719 if ((innerAbilityInfo.moduleName != hapModuleInfo.moduleName) ||
2720 (innerAbilityInfo.name == ServiceConstants::APP_DETAIL_ABILITY)) {
2721 continue;
2722 }
2723 AbilityInfo abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
2724 bool isEnabled = IsAbilityEnabled(abilityInfo, userId, appIndex);
2725 if (!(static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE))
2726 && !isEnabled) {
2727 continue;
2728 }
2729 abilityInfo.enabled = isEnabled;
2730 abilityInfo.appIndex = appIndex;
2731
2732 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2733 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2734 abilityInfo.metaData.customizeData.clear();
2735 abilityInfo.metadata.clear();
2736 }
2737 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2738 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2739 abilityInfo.skills.clear();
2740 }
2741
2742 hapModuleInfo.abilityInfos.emplace_back(abilityInfo);
2743 }
2744 }
2745
GetBundleWithExtensionAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t appIndex) const2746 void InnerBundleInfo::GetBundleWithExtensionAbilitiesV9(
2747 int32_t flags, HapModuleInfo &hapModuleInfo, int32_t appIndex) const
2748 {
2749 hapModuleInfo.extensionInfos.clear();
2750 if ((static_cast<uint32_t>(flags) &
2751 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY))
2752 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY)) {
2753 return;
2754 }
2755 APP_LOGD("Get bundleInfo with extensionAbilities");
2756 for (const auto &extensionInfo : baseExtensionInfos_) {
2757 if (extensionInfo.second.moduleName != hapModuleInfo.moduleName || !extensionInfo.second.enabled) {
2758 continue;
2759 }
2760 ExtensionAbilityInfo info = InnerExtensionInfo::ConvertToExtensionInfo(extensionInfo.second);
2761 info.appIndex = appIndex;
2762
2763 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2764 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2765 info.metadata.clear();
2766 }
2767 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2768 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2769 info.skills.clear();
2770 }
2771 hapModuleInfo.extensionInfos.emplace_back(info);
2772 }
2773 }
2774
GetBundleWithAbilities(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2775 void InnerBundleInfo::GetBundleWithAbilities(
2776 int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2777 {
2778 APP_LOGD("bundleName:%{public}s userid:%{public}d", bundleInfo.name.c_str(), userId);
2779 if (static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_ABILITIES) {
2780 for (const auto &[key, innerAbilityInfo] : baseAbilityInfos_) {
2781 if (innerAbilityInfo.name == ServiceConstants::APP_DETAIL_ABILITY) {
2782 continue;
2783 }
2784 AbilityInfo abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(innerAbilityInfo);
2785 bool isEnabled = IsAbilityEnabled(abilityInfo, userId);
2786 if (!(static_cast<uint32_t>(flags) & GET_ABILITY_INFO_WITH_DISABLE)
2787 && !isEnabled) {
2788 continue;
2789 }
2790 abilityInfo.enabled = isEnabled;
2791 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2792 abilityInfo.skills.clear();
2793 }
2794 abilityInfo.appIndex = appIndex;
2795 bundleInfo.abilityInfos.emplace_back(abilityInfo);
2796 }
2797 }
2798 }
2799
GetBundleWithExtension(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2800 void InnerBundleInfo::GetBundleWithExtension(
2801 int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2802 {
2803 APP_LOGD("get bundleInfo with extensionInfo begin");
2804 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_EXTENSION_INFO) == GET_BUNDLE_WITH_EXTENSION_INFO) {
2805 for (const auto &extensionInfo : baseExtensionInfos_) {
2806 if (!extensionInfo.second.enabled) {
2807 continue;
2808 }
2809 ExtensionAbilityInfo info = InnerExtensionInfo::ConvertToExtensionInfo(extensionInfo.second);
2810 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2811 info.skills.clear();
2812 }
2813 info.appIndex = appIndex;
2814 bundleInfo.extensionInfos.emplace_back(info);
2815 }
2816 }
2817 APP_LOGD("get bundleInfo with extensionInfo end");
2818 }
2819
CheckSpecialMetaData(const std::string & metaData) const2820 bool InnerBundleInfo::CheckSpecialMetaData(const std::string &metaData) const
2821 {
2822 if (isNewVersion_) {
2823 for (const auto &moduleInfo : innerModuleInfos_) {
2824 for (const auto &data : moduleInfo.second.metadata) {
2825 if (metaData == data.name) {
2826 return true;
2827 }
2828 }
2829 }
2830 return false;
2831 }
2832 // old version
2833 for (const auto &moduleInfo : innerModuleInfos_) {
2834 for (const auto &data : moduleInfo.second.metaData.customizeData) {
2835 if (metaData == data.name) {
2836 return true;
2837 }
2838 }
2839 }
2840 return false;
2841 }
2842
GetFormsInfoByModule(const std::string & moduleName,std::vector<FormInfo> & formInfos) const2843 void InnerBundleInfo::GetFormsInfoByModule(const std::string &moduleName, std::vector<FormInfo> &formInfos) const
2844 {
2845 for (const auto &data : formInfos_) {
2846 for (auto &form : data.second) {
2847 if (form.moduleName == moduleName) {
2848 formInfos.emplace_back(form);
2849 }
2850 }
2851 }
2852 }
2853
GetFormsInfoByApp(std::vector<FormInfo> & formInfos) const2854 void InnerBundleInfo::GetFormsInfoByApp(std::vector<FormInfo> &formInfos) const
2855 {
2856 for (const auto &data : formInfos_) {
2857 std::copy(data.second.begin(), data.second.end(), std::back_inserter(formInfos));
2858 }
2859 }
2860
GetShortcutInfos(std::vector<ShortcutInfo> & shortcutInfos) const2861 void InnerBundleInfo::GetShortcutInfos(std::vector<ShortcutInfo> &shortcutInfos) const
2862 {
2863 for (const auto &shortcut : shortcutInfos_) {
2864 shortcutInfos.emplace_back(shortcut.second);
2865 }
2866 }
2867
GetCommonEvents(const std::string & eventKey,std::vector<CommonEventInfo> & commonEvents) const2868 void InnerBundleInfo::GetCommonEvents(const std::string &eventKey, std::vector<CommonEventInfo> &commonEvents) const
2869 {
2870 CommonEventInfo item;
2871 for (const auto &commonEvent : commonEvents_) {
2872 for (const auto &event : commonEvent.second.events) {
2873 if (event == eventKey) {
2874 item = commonEvent.second;
2875 item.uid = GetUid(GetUserId());
2876 commonEvents.emplace_back(item);
2877 break;
2878 }
2879 }
2880 }
2881 }
2882
GetInnerModuleInfoByModuleName(const std::string & moduleName) const2883 std::optional<InnerModuleInfo> InnerBundleInfo::GetInnerModuleInfoByModuleName(const std::string &moduleName) const
2884 {
2885 for (const auto &innerModuleInfo : innerModuleInfos_) {
2886 APP_LOGD("info.moduleName = %{public}s, moduleName= %{public}s",
2887 innerModuleInfo.second.moduleName.c_str(), moduleName.c_str());
2888 if (innerModuleInfo.second.moduleName == moduleName) {
2889 return innerModuleInfo.second;
2890 }
2891 }
2892 return std::nullopt;
2893 }
2894
GetInnerModuleInfoHnpInfo(const std::string & moduleName) const2895 std::optional<std::vector<HnpPackage>> InnerBundleInfo::GetInnerModuleInfoHnpInfo(const std::string &moduleName) const
2896 {
2897 for (const auto &innerModuleInfo : innerModuleInfos_) {
2898 if (!(innerModuleInfo.second.hnpPackages.empty())) {
2899 if (innerModuleInfo.second.moduleName == moduleName) {
2900 return innerModuleInfo.second.hnpPackages;
2901 }
2902 }
2903 }
2904 return std::nullopt;
2905 }
2906
GetInnerModuleInfoHnpPath(const std::string & moduleName) const2907 std::string InnerBundleInfo::GetInnerModuleInfoHnpPath(const std::string &moduleName) const
2908 {
2909 for (const auto &innerModuleInfo : innerModuleInfos_) {
2910 if (!(innerModuleInfo.second.hnpPackages.empty())) {
2911 if (innerModuleInfo.second.moduleName == moduleName) {
2912 return innerModuleInfo.second.moduleHnpsPath;
2913 }
2914 }
2915 }
2916 return "";
2917 }
2918
GetModuleNames(std::vector<std::string> & moduleNames) const2919 void InnerBundleInfo::GetModuleNames(std::vector<std::string> &moduleNames) const
2920 {
2921 for (const auto &innerModuleInfo : innerModuleInfos_) {
2922 moduleNames.emplace_back(innerModuleInfo.second.moduleName);
2923 }
2924 }
2925
GetModuleSize() const2926 int32_t InnerBundleInfo::GetModuleSize() const
2927 {
2928 return innerModuleInfos_.size();
2929 }
2930
ResetBundleState(int32_t userId)2931 void InnerBundleInfo::ResetBundleState(int32_t userId)
2932 {
2933 if (userId == Constants::ALL_USERID) {
2934 for (auto& innerBundleUserInfo : innerBundleUserInfos_) {
2935 innerBundleUserInfo.second.bundleUserInfo.Reset();
2936 }
2937
2938 return;
2939 }
2940
2941 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2942 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
2943 APP_LOGD("no this user %{public}s", key.c_str());
2944 return;
2945 }
2946
2947 innerBundleUserInfos_.at(key).bundleUserInfo.Reset();
2948 }
2949
RemoveInnerBundleUserInfo(int32_t userId)2950 void InnerBundleInfo::RemoveInnerBundleUserInfo(int32_t userId)
2951 {
2952 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2953 auto infoItem = innerBundleUserInfos_.find(key);
2954 if (infoItem == innerBundleUserInfos_.end()) {
2955 return;
2956 }
2957
2958 auto result = innerBundleUserInfos_.erase(key);
2959 if (result == 0) {
2960 APP_LOGE("remove userId:%{public}d key:%{public}s info failed", userId, key.c_str());
2961 }
2962 for (auto &innerModuleInfo : innerModuleInfos_) {
2963 DeleteModuleRemovable(innerModuleInfo.second.moduleName, userId);
2964 }
2965 }
2966
AddInnerBundleUserInfo(const InnerBundleUserInfo & innerBundleUserInfo)2967 void InnerBundleInfo::AddInnerBundleUserInfo(
2968 const InnerBundleUserInfo& innerBundleUserInfo)
2969 {
2970 auto& key = NameAndUserIdToKey(
2971 GetBundleName(), innerBundleUserInfo.bundleUserInfo.userId);
2972 auto infoItem = innerBundleUserInfos_.find(key);
2973 if (infoItem == innerBundleUserInfos_.end()) {
2974 innerBundleUserInfos_.emplace(key, innerBundleUserInfo);
2975 return;
2976 }
2977
2978 innerBundleUserInfos_[key] = innerBundleUserInfo;
2979 }
2980
GetInnerBundleUserInfo(int32_t userId,InnerBundleUserInfo & innerBundleUserInfo) const2981 bool InnerBundleInfo::GetInnerBundleUserInfo(
2982 int32_t userId, InnerBundleUserInfo& innerBundleUserInfo) const
2983 {
2984 if (userId == ServiceConstants::NOT_EXIST_USERID) {
2985 return true;
2986 }
2987
2988 if (userId == Constants::ALL_USERID) {
2989 if (innerBundleUserInfos_.empty()) {
2990 return false;
2991 }
2992
2993 innerBundleUserInfo = innerBundleUserInfos_.begin()->second;
2994 return true;
2995 }
2996
2997 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2998 auto infoItem = innerBundleUserInfos_.find(key);
2999 if (infoItem == innerBundleUserInfos_.end()) {
3000 return false;
3001 }
3002
3003 innerBundleUserInfo = infoItem->second;
3004 if (innerBundleUserInfo.firstInstallTime == ServiceConstants::DEFAULT_FIRST_INSTALL_TIME) {
3005 innerBundleUserInfo.firstInstallTime = IsPreInstallApp() ?
3006 ServiceConstants::PREINSTALL_FIRST_INSTALL_TIME : innerBundleUserInfo.installTime;
3007 }
3008 return true;
3009 }
3010
HasInnerBundleUserInfo(int32_t userId) const3011 bool InnerBundleInfo::HasInnerBundleUserInfo(int32_t userId) const
3012 {
3013 if (userId == Constants::ALL_USERID || userId == Constants::ANY_USERID) {
3014 return !innerBundleUserInfos_.empty();
3015 }
3016
3017 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3018 auto infoItem = innerBundleUserInfos_.find(key);
3019 return infoItem != innerBundleUserInfos_.end();
3020 }
3021
SetBundleInstallTime(const int64_t time,int32_t userId)3022 void InnerBundleInfo::SetBundleInstallTime(const int64_t time, int32_t userId)
3023 {
3024 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3025 auto infoItem = innerBundleUserInfos_.find(key);
3026 if (infoItem == innerBundleUserInfos_.end()) {
3027 return;
3028 }
3029
3030 infoItem->second.installTime = time;
3031 infoItem->second.updateTime = time;
3032 }
3033
SetFirstInstallTime(const int64_t time,int32_t userId)3034 void InnerBundleInfo::SetFirstInstallTime(const int64_t time, int32_t userId)
3035 {
3036 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3037 auto infoItem = innerBundleUserInfos_.find(key);
3038 if (infoItem == innerBundleUserInfos_.end()) {
3039 return;
3040 }
3041
3042 infoItem->second.firstInstallTime = IsPreInstallApp() ? ServiceConstants::PREINSTALL_FIRST_INSTALL_TIME : time;
3043 }
3044
SetAccessTokenId(uint32_t accessToken,const int32_t userId)3045 void InnerBundleInfo::SetAccessTokenId(uint32_t accessToken, const int32_t userId)
3046 {
3047 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3048 auto infoItem = innerBundleUserInfos_.find(key);
3049 if (infoItem == innerBundleUserInfos_.end()) {
3050 return;
3051 }
3052
3053 infoItem->second.accessTokenId = accessToken;
3054 }
3055
SetAccessTokenIdEx(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId)3056 void InnerBundleInfo::SetAccessTokenIdEx(
3057 const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
3058 const int32_t userId)
3059 {
3060 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3061 auto infoItem = innerBundleUserInfos_.find(key);
3062 if (infoItem == innerBundleUserInfos_.end()) {
3063 return;
3064 }
3065
3066 infoItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
3067 infoItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
3068 }
3069
SetAccessTokenIdExWithAppIndex(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId,const int32_t appIndex)3070 void InnerBundleInfo::SetAccessTokenIdExWithAppIndex(
3071 const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
3072 const int32_t userId, const int32_t appIndex)
3073 {
3074 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3075 auto infoItem = innerBundleUserInfos_.find(key);
3076 if (infoItem == innerBundleUserInfos_.end()) {
3077 return;
3078 }
3079
3080 auto& userInfo = infoItem->second;
3081 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
3082
3083 auto cloneKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3084 auto cloneItem = cloneInfos.find(cloneKey);
3085 if (cloneItem == cloneInfos.end()) {
3086 return;
3087 }
3088 cloneItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
3089 cloneItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
3090 }
3091
SetkeyId(const int32_t userId,const std::string & keyId,const int32_t appIndex)3092 void InnerBundleInfo::SetkeyId(const int32_t userId, const std::string &keyId, const int32_t appIndex)
3093 {
3094 if (keyId.empty()) {
3095 APP_LOGE("SetkeyId failed, keyId is empty");
3096 return;
3097 }
3098 InnerSetKeyId(userId, keyId, appIndex);
3099 }
3100
InnerSetKeyId(const int32_t userId,const std::string & keyId,const int32_t appIndex)3101 void InnerBundleInfo::InnerSetKeyId(const int32_t userId, const std::string &keyId, const int32_t appIndex)
3102 {
3103 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3104 auto infoItem = innerBundleUserInfos_.find(key);
3105 if (infoItem == innerBundleUserInfos_.end()) {
3106 APP_LOGE("SetkeyId failed, not find userInfo for userId %{public}d", userId);
3107 return;
3108 }
3109 if (appIndex == 0) {
3110 infoItem->second.keyId = keyId;
3111 return;
3112 }
3113 std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3114 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3115 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3116 APP_LOGE("key:%{public}s not found", key.c_str());
3117 return;
3118 }
3119 mpCloneInfos.at(appIndexKey).keyId = keyId;
3120 }
3121
GetKeyId(const int32_t userId,const int32_t appIndex)3122 std::string InnerBundleInfo::GetKeyId(const int32_t userId, const int32_t appIndex)
3123 {
3124 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3125 auto infoItem = innerBundleUserInfos_.find(key);
3126 if (infoItem == innerBundleUserInfos_.end()) {
3127 APP_LOGE("GetKeyId failed, not find userInfo for userId %{public}d", userId);
3128 return "";
3129 }
3130 if (appIndex == 0) {
3131 return infoItem->second.keyId;
3132 }
3133 std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3134 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3135 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3136 APP_LOGE("key:%{public}s not found", key.c_str());
3137 return "";
3138 }
3139 return mpCloneInfos.at(appIndexKey).keyId;
3140 }
3141
SetBundleUpdateTime(const int64_t time,int32_t userId)3142 void InnerBundleInfo::SetBundleUpdateTime(const int64_t time, int32_t userId)
3143 {
3144 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3145 auto infoItem = innerBundleUserInfos_.find(key);
3146 if (infoItem == innerBundleUserInfos_.end()) {
3147 return;
3148 }
3149
3150 infoItem->second.updateTime = time;
3151 }
3152
IsAbilityEnabled(const AbilityInfo & abilityInfo,int32_t userId,int32_t appIndex) const3153 bool InnerBundleInfo::IsAbilityEnabled(const AbilityInfo &abilityInfo, int32_t userId, int32_t appIndex) const
3154 {
3155 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3156 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3157 return true;
3158 }
3159 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3160 auto infoItem = innerBundleUserInfos_.find(key);
3161 if (infoItem == innerBundleUserInfos_.end()) {
3162 APP_LOGW_NOFUNC("key:%{public}s not found", key.c_str());
3163 return false;
3164 }
3165
3166 if (appIndex == 0) {
3167 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3168 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3169 != disabledAbilities.end()) {
3170 APP_LOGW_NOFUNC("-n %{public}s -a %{public}s disabled",
3171 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
3172 return false;
3173 } else {
3174 return true;
3175 }
3176 }
3177
3178 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3179 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3180 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3181 APP_LOGW_NOFUNC("key:%{public}s not found", key.c_str());
3182 return false;
3183 }
3184 auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3185 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3186 != disabledAbilities.end()) {
3187 APP_LOGW_NOFUNC("-n %{public}s -a %{public}s disabled",
3188 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
3189 return false;
3190 } else {
3191 return true;
3192 }
3193 }
3194
SetOverlayModuleState(const std::string & moduleName,int32_t state,int32_t userId)3195 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state, int32_t userId)
3196 {
3197 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3198 if (overlayType_ == NON_OVERLAY_TYPE) {
3199 APP_LOGW("no overlay module");
3200 return;
3201 }
3202 for (auto &innerUserInfo : innerBundleUserInfos_) {
3203 if (innerUserInfo.second.bundleUserInfo.userId != userId) {
3204 continue;
3205 }
3206
3207 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3208 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3209 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3210 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3211 return true;
3212 }
3213 return false;
3214 });
3215 if (!isSetSucc) {
3216 APP_LOGD("no overlay module state info under user %{public}d", userId);
3217 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3218 }
3219 }
3220 }
3221
SetOverlayModuleState(const std::string & moduleName,int32_t state)3222 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state)
3223 {
3224 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3225 if (overlayType_ == NON_OVERLAY_TYPE) {
3226 APP_LOGW("no overlay module");
3227 return;
3228 }
3229 for (auto &innerUserInfo : innerBundleUserInfos_) {
3230 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3231 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3232 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3233 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3234 return true;
3235 }
3236 return false;
3237 });
3238 if (!isSetSucc) {
3239 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3240 }
3241 }
3242 }
3243
GetOverlayModuleState(const std::string & moduleName,int32_t userId,int32_t & state) const3244 bool InnerBundleInfo::GetOverlayModuleState(const std::string &moduleName, int32_t userId, int32_t &state) const
3245 {
3246 APP_LOGD("start to get overlay state of moduleName:%{public}s, userId:%{public}d", moduleName.c_str(), userId);
3247 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3248 APP_LOGE("invalid userId %{public}d", userId);
3249 return false;
3250 }
3251 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3252 auto infoItem = innerBundleUserInfos_.find(key);
3253 if (infoItem == innerBundleUserInfos_.end()) {
3254 APP_LOGE("no userInfo under userId %{public}d", userId);
3255 return false;
3256 }
3257
3258 auto overlayModulesState = infoItem->second.bundleUserInfo.overlayModulesState;
3259 if (overlayModulesState.empty()) {
3260 APP_LOGE("no overlay module installed under userId %{public}d", userId);
3261 return false;
3262 }
3263 for (const auto &item : overlayModulesState) {
3264 auto pos = item.find(moduleName + Constants::FILE_UNDERLINE);
3265 if (pos == std::string::npos) {
3266 continue;
3267 }
3268 return OHOS::StrToInt(item.substr(moduleName.length() + 1), state);
3269 }
3270 APP_LOGE("no overlay module installed under userId %{public}d", userId);
3271 return false;
3272 }
3273
ClearOverlayModuleStates(const std::string & moduleName)3274 void InnerBundleInfo::ClearOverlayModuleStates(const std::string &moduleName)
3275 {
3276 // delete overlay module state
3277 for (auto &innerUserInfo : innerBundleUserInfos_) {
3278 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3279 auto iter = std::find_if(overlayStates.begin(), overlayStates.end(), [&moduleName](const auto &item) {
3280 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3281 return true;
3282 }
3283 return false;
3284 });
3285 if (iter != overlayStates.end()) {
3286 overlayStates.erase(iter);
3287 }
3288 }
3289 }
3290
IsAbilityEnabledV9(const AbilityInfo & abilityInfo,int32_t userId,bool & isEnable,int32_t appIndex) const3291 ErrCode InnerBundleInfo::IsAbilityEnabledV9(const AbilityInfo &abilityInfo,
3292 int32_t userId, bool &isEnable, int32_t appIndex) const
3293 {
3294 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3295 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3296 isEnable = true;
3297 return ERR_OK;
3298 }
3299 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3300 auto infoItem = innerBundleUserInfos_.find(key);
3301 if (infoItem == innerBundleUserInfos_.end()) {
3302 APP_LOGW_NOFUNC("key:%{public}s not found", key.c_str());
3303 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3304 }
3305 if (appIndex == 0) {
3306 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3307 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3308 != disabledAbilities.end()) {
3309 APP_LOGW_NOFUNC("-n %{public}s -a %{public}s disabled",
3310 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
3311 isEnable = false;
3312 } else {
3313 isEnable = true;
3314 }
3315 return ERR_OK;
3316 }
3317 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3318 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3319 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3320 APP_LOGW_NOFUNC("key:%{public}s not found", key.c_str());
3321 return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
3322 }
3323 auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3324 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3325 != disabledAbilities.end()) {
3326 APP_LOGW_NOFUNC("-n %{public}s -a %{public}s disabled",
3327 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
3328 isEnable = false;
3329 } else {
3330 isEnable = true;
3331 }
3332 return ERR_OK;
3333 }
3334
SetAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId)3335 ErrCode InnerBundleInfo::SetAbilityEnabled(
3336 const std::string &moduleName, const std::string &abilityName, bool isEnabled, int32_t userId)
3337 {
3338 APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d",
3339 moduleName.c_str(), abilityName.c_str(), userId);
3340 for (const auto &ability : baseAbilityInfos_) {
3341 if ((ability.second.name == abilityName) &&
3342 (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3343 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3344 auto infoItem = innerBundleUserInfos_.find(key);
3345 if (infoItem == innerBundleUserInfos_.end()) {
3346 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3347 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3348 }
3349
3350 auto iter = std::find(infoItem->second.bundleUserInfo.disabledAbilities.begin(),
3351 infoItem->second.bundleUserInfo.disabledAbilities.end(),
3352 abilityName);
3353 if (iter != infoItem->second.bundleUserInfo.disabledAbilities.end()) {
3354 if (isEnabled) {
3355 infoItem->second.bundleUserInfo.disabledAbilities.erase(iter);
3356 }
3357 } else {
3358 if (!isEnabled) {
3359 infoItem->second.bundleUserInfo.disabledAbilities.push_back(abilityName);
3360 }
3361 }
3362 return ERR_OK;
3363 }
3364 }
3365 APP_LOGE("SetAbilityEnabled find abilityInfo failed");
3366 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3367 }
3368
SetCloneAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId,int32_t appIndex)3369 ErrCode InnerBundleInfo::SetCloneAbilityEnabled(const std::string &moduleName, const std::string &abilityName,
3370 bool isEnabled, int32_t userId, int32_t appIndex)
3371 {
3372 APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d for appIndex %{public}d",
3373 moduleName.c_str(), abilityName.c_str(), userId, appIndex);
3374 for (const auto &ability : baseAbilityInfos_) {
3375 if ((ability.second.name == abilityName) &&
3376 (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3377 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3378 auto infoItem = innerBundleUserInfos_.find(key);
3379 if (infoItem == innerBundleUserInfos_.end()) {
3380 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3381 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3382 }
3383
3384 auto cloneIter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3385 if (cloneIter == infoItem->second.cloneInfos.end()) {
3386 APP_LOGW("appIndex %{public}d invalid", appIndex);
3387 return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3388 }
3389
3390 auto iter = std::find(cloneIter->second.disabledAbilities.begin(),
3391 cloneIter->second.disabledAbilities.end(),
3392 abilityName);
3393 if (iter != cloneIter->second.disabledAbilities.end() && isEnabled) {
3394 cloneIter->second.disabledAbilities.erase(iter);
3395 }
3396 if (iter == cloneIter->second.disabledAbilities.end() && !isEnabled) {
3397 cloneIter->second.disabledAbilities.push_back(abilityName);
3398 }
3399 return ERR_OK;
3400 }
3401 }
3402 APP_LOGW("SetCloneAbilityEnabled find abilityInfo failed");
3403 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3404 }
3405
RemoveDuplicateName(std::vector<std::string> & name) const3406 void InnerBundleInfo::RemoveDuplicateName(std::vector<std::string> &name) const
3407 {
3408 std::sort(name.begin(), name.end());
3409 auto iter = std::unique(name.begin(), name.end());
3410 name.erase(iter, name.end());
3411 }
3412
SetInnerModuleNeedDelete(const std::string & moduleName,const bool needDelete)3413 void InnerBundleInfo::SetInnerModuleNeedDelete(const std::string &moduleName, const bool needDelete)
3414 {
3415 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3416 APP_LOGE("innerBundleInfo does not contain the module module %{public}s", moduleName.c_str());
3417 return;
3418 }
3419 innerModuleInfos_.at(moduleName).needDelete = needDelete;
3420 }
3421
GetInnerModuleNeedDelete(const std::string & moduleName)3422 bool InnerBundleInfo::GetInnerModuleNeedDelete(const std::string &moduleName)
3423 {
3424 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3425 APP_LOGE("innerBundleInfo does not contain the module %{public}s", moduleName.c_str());
3426 return true;
3427 }
3428 return innerModuleInfos_.at(moduleName).needDelete;
3429 }
3430
GetAllDefinePermissions() const3431 std::vector<DefinePermission> InnerBundleInfo::GetAllDefinePermissions() const
3432 {
3433 std::vector<DefinePermission> definePermissions;
3434 for (const auto &info : innerModuleInfos_) {
3435 if (info.second.needDelete) {
3436 continue;
3437 }
3438 std::transform(info.second.definePermissions.begin(),
3439 info.second.definePermissions.end(),
3440 std::back_inserter(definePermissions),
3441 [](const auto &p) { return p; });
3442 }
3443 if (!definePermissions.empty()) {
3444 std::sort(definePermissions.begin(), definePermissions.end(),
3445 [](DefinePermission defPermA, DefinePermission defPermB) {
3446 return defPermA.name < defPermB.name;
3447 });
3448 auto iter = std::unique(definePermissions.begin(), definePermissions.end(),
3449 [](DefinePermission defPermA, DefinePermission defPermB) {
3450 return defPermA.name == defPermB.name;
3451 });
3452 definePermissions.erase(iter, definePermissions.end());
3453 }
3454 return definePermissions;
3455 }
3456
GetAllRequestPermissions() const3457 std::vector<RequestPermission> InnerBundleInfo::GetAllRequestPermissions() const
3458 {
3459 std::unordered_map<std::string, std::string> moduleNameMap;
3460 std::vector<RequestPermission> requestPermissions;
3461 for (const auto &info : innerModuleInfos_) {
3462 if (info.second.needDelete) {
3463 continue;
3464 }
3465 for (auto item : info.second.requestPermissions) {
3466 item.moduleName = info.second.moduleName;
3467 requestPermissions.push_back(item);
3468 if (moduleNameMap.find(item.moduleName) == moduleNameMap.end()) {
3469 moduleNameMap[item.moduleName] = info.second.distro.moduleType;
3470 }
3471 }
3472 }
3473 if (!requestPermissions.empty()) {
3474 InnerProcessRequestPermissions(moduleNameMap, requestPermissions);
3475 }
3476 return requestPermissions;
3477 }
3478
InnerProcessRequestPermissions(const std::unordered_map<std::string,std::string> & moduleNameMap,std::vector<RequestPermission> & requestPermissions) const3479 void InnerBundleInfo::InnerProcessRequestPermissions(
3480 const std::unordered_map<std::string, std::string> &moduleNameMap,
3481 std::vector<RequestPermission> &requestPermissions) const
3482 {
3483 std::map<std::string, RequestPermission> permissionMap;
3484 for (const auto &item : requestPermissions) {
3485 auto iter = permissionMap.find(item.name);
3486 if (iter == permissionMap.end()) {
3487 permissionMap[item.name] = item;
3488 } else {
3489 if (ShouldReplacePermission(iter->second, item, moduleNameMap)) {
3490 permissionMap[item.name] = item;
3491 }
3492 }
3493 }
3494 requestPermissions.clear();
3495 for (const auto &item : permissionMap) {
3496 requestPermissions.emplace_back(item.second);
3497 }
3498 }
3499
ShouldReplacePermission(const RequestPermission & oldPermission,const RequestPermission & newPermission,const std::unordered_map<std::string,std::string> & moduleNameTypeMap) const3500 bool InnerBundleInfo::ShouldReplacePermission(
3501 const RequestPermission &oldPermission, const RequestPermission &newPermission,
3502 const std::unordered_map<std::string, std::string> &moduleNameTypeMap) const
3503 {
3504 if (oldPermission.name != newPermission.name) {
3505 return false;
3506 }
3507 std::string oldType;
3508 std::string newType;
3509 auto iter = moduleNameTypeMap.find(oldPermission.moduleName);
3510 if (iter != moduleNameTypeMap.end()) {
3511 oldType = iter->second;
3512 }
3513 iter = moduleNameTypeMap.find(newPermission.moduleName);
3514 if (iter != moduleNameTypeMap.end()) {
3515 newType = iter->second;
3516 }
3517 if (oldPermission.reasonId == 0) {
3518 if (newPermission.reasonId != 0) {
3519 return true;
3520 }
3521 if (newType == Profile::MODULE_TYPE_ENTRY) {
3522 return true;
3523 }
3524 return false;
3525 }
3526 if (newPermission.reasonId != 0) {
3527 if (oldType != Profile::MODULE_TYPE_ENTRY) {
3528 if (newType == Profile::MODULE_TYPE_ENTRY || newPermission.reasonId > oldPermission.reasonId) {
3529 return true;
3530 }
3531 } else {
3532 if (newType == Profile::MODULE_TYPE_ENTRY && newPermission.reasonId > oldPermission.reasonId) {
3533 return true;
3534 }
3535 }
3536 }
3537 return false;
3538 }
3539
SetApplicationEnabled(bool enabled,const std::string & caller,int32_t userId)3540 ErrCode InnerBundleInfo::SetApplicationEnabled(bool enabled, const std::string &caller, int32_t userId)
3541 {
3542 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3543 auto infoItem = innerBundleUserInfos_.find(key);
3544 if (infoItem == innerBundleUserInfos_.end()) {
3545 APP_LOGE("SetApplicationEnabled not find:%{public}s bundleUserInfo in userId: %{public}d",
3546 GetBundleName().c_str(), userId);
3547 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3548 }
3549
3550 infoItem->second.bundleUserInfo.enabled = enabled;
3551 if (!caller.empty()) {
3552 infoItem->second.bundleUserInfo.setEnabledCaller = caller;
3553 }
3554 return ERR_OK;
3555 }
3556
SetCloneApplicationEnabled(bool enabled,int32_t appIndex,const std::string & caller,int32_t userId)3557 ErrCode InnerBundleInfo::SetCloneApplicationEnabled(bool enabled, int32_t appIndex, const std::string &caller,
3558 int32_t userId)
3559 {
3560 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3561 auto infoItem = innerBundleUserInfos_.find(key);
3562 if (infoItem == innerBundleUserInfos_.end()) {
3563 APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}s bundleUserInfo in userId:%{public}d",
3564 GetBundleName().c_str(), userId);
3565 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3566 }
3567
3568 auto iter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3569 if (iter == infoItem->second.cloneInfos.end()) {
3570 APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}d appIndex in userId:%{public}d",
3571 appIndex, userId);
3572 return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3573 }
3574 iter->second.enabled = enabled;
3575 iter->second.setEnabledCaller = caller;
3576 return ERR_OK;
3577 }
3578
GetCurModuleName() const3579 const std::string InnerBundleInfo::GetCurModuleName() const
3580 {
3581 if (innerModuleInfos_.find(currentPackage_) != innerModuleInfos_.end()) {
3582 return innerModuleInfos_.at(currentPackage_).moduleName;
3583 }
3584
3585 return Constants::EMPTY_STRING;
3586 }
3587
IsBundleCrossAppSharedConfig() const3588 bool InnerBundleInfo::IsBundleCrossAppSharedConfig() const
3589 {
3590 for (const auto &info : innerModuleInfos_) {
3591 if (!info.second.crossAppSharedConfig.empty()) {
3592 return true;
3593 }
3594 }
3595 return false;
3596 }
3597
IsBundleRemovable() const3598 bool InnerBundleInfo::IsBundleRemovable() const
3599 {
3600 if (IsPreInstallApp()) {
3601 APP_LOGE("PreInstallApp should not be cleaned");
3602 return false;
3603 }
3604
3605 for (const auto &innerModuleInfo : innerModuleInfos_) {
3606 if (!innerModuleInfo.second.installationFree) {
3607 return false;
3608 }
3609
3610 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3611 if (!stateIter.second) {
3612 return false;
3613 }
3614 }
3615 }
3616
3617 return true;
3618 }
3619
GetLastInstallationTime() const3620 int64_t InnerBundleInfo::GetLastInstallationTime() const
3621 {
3622 int64_t installTime = 0;
3623 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3624 installTime = innerBundleUserInfo.second.updateTime > installTime ?
3625 innerBundleUserInfo.second.updateTime : installTime;
3626 }
3627
3628 return installTime;
3629 }
3630
GetRemovableModules(std::vector<std::string> & moduleToDelete) const3631 bool InnerBundleInfo::GetRemovableModules(std::vector<std::string> &moduleToDelete) const
3632 {
3633 for (const auto &innerModuleInfo : innerModuleInfos_) {
3634 if (!innerModuleInfo.second.installationFree) {
3635 continue;
3636 }
3637
3638 bool canDelete = true;
3639 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3640 if (!stateIter.second) {
3641 canDelete = false;
3642 break;
3643 }
3644 }
3645
3646 if (canDelete) {
3647 moduleToDelete.emplace_back(innerModuleInfo.second.moduleName);
3648 }
3649 }
3650
3651 return !moduleToDelete.empty();
3652 }
3653
GetFreeInstallModules(std::vector<std::string> & freeInstallModule) const3654 bool InnerBundleInfo::GetFreeInstallModules(std::vector<std::string> &freeInstallModule) const
3655 {
3656 for (const auto &innerModuleInfo : innerModuleInfos_) {
3657 if (!innerModuleInfo.second.installationFree) {
3658 continue;
3659 }
3660
3661 freeInstallModule.emplace_back(innerModuleInfo.second.moduleName);
3662 }
3663
3664 return !freeInstallModule.empty();
3665 }
3666
IsUserExistModule(const std::string & moduleName,int32_t userId) const3667 bool InnerBundleInfo::IsUserExistModule(const std::string &moduleName, int32_t userId) const
3668 {
3669 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3670 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3671 if (!modInfoItem) {
3672 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3673 return false;
3674 }
3675
3676 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3677 if (item == modInfoItem->isRemovable.end()) {
3678 LOG_NOFUNC_W(BMS_TAG_COMMON, "-u %{public}d has not -m %{public}s", userId, moduleName.c_str());
3679 return false;
3680 }
3681
3682 APP_LOGD("userId:%{public}d exist moduleName:%{public}s", userId, moduleName.c_str());
3683 return true;
3684 }
3685
IsModuleRemovable(const std::string & moduleName,int32_t userId,bool & isRemovable) const3686 ErrCode InnerBundleInfo::IsModuleRemovable(
3687 const std::string &moduleName, int32_t userId, bool &isRemovable) const
3688 {
3689 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3690 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3691 if (!modInfoItem) {
3692 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3693 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3694 }
3695
3696 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3697 if (item == modInfoItem->isRemovable.end()) {
3698 APP_LOGW("userId:%{public}d not moduleName:%{public}s", userId, moduleName.c_str());
3699 isRemovable = false;
3700 return ERR_OK;
3701 }
3702
3703 isRemovable = item->second;
3704 APP_LOGD("userId:%{public}d, moduleName:%{public}s, isRemovable:%{public}d,",
3705 userId, moduleName.c_str(), isRemovable);
3706 return ERR_OK;
3707 }
3708
AddModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId,bool isEnable) const3709 bool InnerBundleInfo::AddModuleRemovableInfo(
3710 InnerModuleInfo &info, const std::string &stringUserId, bool isEnable) const
3711 {
3712 auto item = info.isRemovable.find(stringUserId);
3713 if (item == info.isRemovable.end()) {
3714 auto result = info.isRemovable.try_emplace(stringUserId, isEnable);
3715 if (!result.second) {
3716 APP_LOGE("add userId:%{public}s isRemovable:%{public}d failed", stringUserId.c_str(), isEnable);
3717 return false;
3718 }
3719
3720 APP_LOGD("add userId:%{public}s isRemovable:%{public}d into map", stringUserId.c_str(), isEnable);
3721 return true;
3722 }
3723
3724 item->second = isEnable;
3725 APP_LOGD("set userId:%{public}s isEnable:%{public}d ok", stringUserId.c_str(), isEnable);
3726 return true;
3727 }
3728
SetModuleRemovable(const std::string & moduleName,bool isEnable,int32_t userId)3729 bool InnerBundleInfo::SetModuleRemovable(const std::string &moduleName, bool isEnable, int32_t userId)
3730 {
3731 std::string stringUserId = std::to_string(userId);
3732 APP_LOGD("userId:%{public}d moduleName:%{public}s isEnable:%{public}d", userId, moduleName.c_str(), isEnable);
3733 for (auto &innerModuleInfo : innerModuleInfos_) {
3734 if (innerModuleInfo.second.moduleName == moduleName) {
3735 return AddModuleRemovableInfo(innerModuleInfo.second, stringUserId, isEnable);
3736 }
3737 }
3738
3739 return false;
3740 }
3741
UpdateAppEncryptedStatus(const std::string & bundleName,bool isExisted,int32_t appIndex)3742 ErrCode InnerBundleInfo::UpdateAppEncryptedStatus(const std::string &bundleName, bool isExisted, int32_t appIndex)
3743 {
3744 APP_LOGI("update encrypted key %{public}s %{public}d %{public}d", bundleName.c_str(), isExisted, appIndex);
3745 if (isExisted) {
3746 // Set the second bit to 1
3747 SetApplicationReservedFlag(static_cast<uint32_t>(ApplicationReservedFlag::ENCRYPTED_KEY_EXISTED));
3748 } else {
3749 // Set the second bit to 0
3750 ClearApplicationReservedFlag(static_cast<uint32_t>(ApplicationReservedFlag::ENCRYPTED_KEY_EXISTED));
3751 }
3752 return ERR_OK;
3753 }
3754
DeleteModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId)3755 void InnerBundleInfo::DeleteModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId)
3756 {
3757 auto item = info.isRemovable.find(stringUserId);
3758 if (item == info.isRemovable.end()) {
3759 return;
3760 }
3761
3762 info.isRemovable.erase(stringUserId);
3763 }
3764
DeleteModuleRemovable(const std::string & moduleName,int32_t userId)3765 void InnerBundleInfo::DeleteModuleRemovable(const std::string &moduleName, int32_t userId)
3766 {
3767 std::string stringUserId = std::to_string(userId);
3768 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3769 for (auto &innerModuleInfo : innerModuleInfos_) {
3770 if (innerModuleInfo.second.moduleName == moduleName) {
3771 DeleteModuleRemovableInfo(innerModuleInfo.second, stringUserId);
3772 return;
3773 }
3774 }
3775 }
3776
SetModuleUpgradeFlag(std::string moduleName,int32_t upgradeFlag)3777 ErrCode InnerBundleInfo::SetModuleUpgradeFlag(std::string moduleName, int32_t upgradeFlag)
3778 {
3779 APP_LOGD("moduleName= %{public}s, upgradeFlag = %{public}d", moduleName.c_str(), upgradeFlag);
3780 for (auto &innerModuleInfo : innerModuleInfos_) {
3781 if (innerModuleInfo.second.moduleName == moduleName) {
3782 innerModuleInfo.second.upgradeFlag = upgradeFlag;
3783 return ERR_OK;
3784 }
3785 }
3786 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3787 }
3788
GetModuleUpgradeFlag(std::string moduleName) const3789 int32_t InnerBundleInfo::GetModuleUpgradeFlag(std::string moduleName) const
3790 {
3791 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3792 if (!moduleInfo) {
3793 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3794 return UpgradeFlag::NOT_UPGRADE;
3795 }
3796 APP_LOGD("innerModuleInfo.upgradeFlag : %{public}d", moduleInfo->upgradeFlag);
3797 return moduleInfo->upgradeFlag;
3798 }
3799
GetResponseUserId(int32_t requestUserId) const3800 int32_t InnerBundleInfo::GetResponseUserId(int32_t requestUserId) const
3801 {
3802 if (innerBundleUserInfos_.empty()) {
3803 APP_LOGD("user map is empty");
3804 return Constants::INVALID_USERID;
3805 }
3806
3807 if (requestUserId == Constants::ANY_USERID) {
3808 return innerBundleUserInfos_.begin()->second.bundleUserInfo.userId;
3809 }
3810
3811 if (HasInnerBundleUserInfo(requestUserId)) {
3812 return requestUserId;
3813 }
3814
3815 if (requestUserId < Constants::START_USERID) {
3816 APP_LOGD("requestUserId(%{public}d) less than start userId", requestUserId);
3817 return Constants::INVALID_USERID;
3818 }
3819
3820 int32_t responseUserId = Constants::INVALID_USERID;
3821 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3822 if (innerBundleUserInfo.second.bundleUserInfo.userId < Constants::START_USERID) {
3823 responseUserId = innerBundleUserInfo.second.bundleUserInfo.userId;
3824 break;
3825 }
3826 }
3827
3828 APP_LOGD("requestUserId(%{public}d) and responseUserId(%{public}d)", requestUserId, responseUserId);
3829 return responseUserId;
3830 }
3831
GetDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3832 bool InnerBundleInfo::GetDependentModuleNames(const std::string &moduleName,
3833 std::vector<std::string> &dependentModuleNames) const
3834 {
3835 for (auto iter = innerModuleInfos_.begin(); iter != innerModuleInfos_.end(); ++iter) {
3836 if (iter->second.moduleName == moduleName) {
3837 for (const auto &dependency : iter->second.dependencies) {
3838 dependentModuleNames.push_back(dependency.moduleName);
3839 }
3840 return true;
3841 }
3842 }
3843 APP_LOGE("GetDependentModuleNames not find module %{public}s", moduleName.c_str());
3844 return false;
3845 }
3846
GetAllDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3847 bool InnerBundleInfo::GetAllDependentModuleNames(const std::string &moduleName,
3848 std::vector<std::string> &dependentModuleNames) const
3849 {
3850 if (!GetDependentModuleNames(moduleName, dependentModuleNames)) {
3851 return false;
3852 }
3853 std::deque<std::string> moduleDeque;
3854 std::copy(dependentModuleNames.begin(), dependentModuleNames.end(), std::back_inserter(moduleDeque));
3855 dependentModuleNames.clear();
3856 while (!moduleDeque.empty()) {
3857 std::string name = moduleDeque.front();
3858 moduleDeque.pop_front();
3859 if (std::find(dependentModuleNames.begin(), dependentModuleNames.end(), name) == dependentModuleNames.end()) {
3860 dependentModuleNames.push_back(name);
3861 std::vector<std::string> tempModuleNames;
3862 if (GetDependentModuleNames(name, tempModuleNames)) {
3863 std::copy(tempModuleNames.begin(), tempModuleNames.end(), std::back_inserter(moduleDeque));
3864 }
3865 }
3866 }
3867 return true;
3868 }
3869
GetMainAbility() const3870 std::string InnerBundleInfo::GetMainAbility() const
3871 {
3872 AbilityInfo abilityInfo;
3873 GetMainAbilityInfo(abilityInfo);
3874 return abilityInfo.name;
3875 }
3876
GetMainAbilityInfo(AbilityInfo & abilityInfo) const3877 void InnerBundleInfo::GetMainAbilityInfo(AbilityInfo &abilityInfo) const
3878 {
3879 for (const auto& item : innerModuleInfos_) {
3880 const std::string& key = item.second.entryAbilityKey;
3881 if (!key.empty() && (baseAbilityInfos_.count(key) != 0)) {
3882 abilityInfo = InnerAbilityInfo::ConvertToAbilityInfo(baseAbilityInfos_.at(key));
3883 if (item.second.isEntry) {
3884 return;
3885 }
3886 }
3887 }
3888 }
3889
HasEntry() const3890 bool InnerBundleInfo::HasEntry() const
3891 {
3892 return std::any_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3893 return item.second.isEntry;
3894 });
3895 }
3896
IsHsp() const3897 bool InnerBundleInfo::IsHsp() const
3898 {
3899 if (!innerModuleInfos_.empty()) {
3900 return std::all_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3901 return item.second.distro.moduleType == Profile::MODULE_TYPE_SHARED;
3902 });
3903 }
3904 return false;
3905 }
3906
SetAppDistributionType(const std::string & appDistributionType)3907 void InnerBundleInfo::SetAppDistributionType(const std::string &appDistributionType)
3908 {
3909 baseApplicationInfo_->appDistributionType = appDistributionType;
3910 }
3911
GetAppDistributionType() const3912 std::string InnerBundleInfo::GetAppDistributionType() const
3913 {
3914 return baseApplicationInfo_->appDistributionType;
3915 }
3916
SetAppProvisionType(const std::string & appProvisionType)3917 void InnerBundleInfo::SetAppProvisionType(const std::string &appProvisionType)
3918 {
3919 baseApplicationInfo_->appProvisionType = appProvisionType;
3920 }
3921
GetAppProvisionType() const3922 std::string InnerBundleInfo::GetAppProvisionType() const
3923 {
3924 return baseApplicationInfo_->appProvisionType;
3925 }
3926
SetAppCrowdtestDeadline(int64_t crowdtestDeadline)3927 void InnerBundleInfo::SetAppCrowdtestDeadline(int64_t crowdtestDeadline)
3928 {
3929 baseApplicationInfo_->crowdtestDeadline = crowdtestDeadline;
3930 }
3931
GetAppCrowdtestDeadline() const3932 int64_t InnerBundleInfo::GetAppCrowdtestDeadline() const
3933 {
3934 return baseApplicationInfo_->crowdtestDeadline;
3935 }
3936
GetDistroModuleName() const3937 std::vector<std::string> InnerBundleInfo::GetDistroModuleName() const
3938 {
3939 std::vector<std::string> moduleVec;
3940 for (const auto &item : innerModuleInfos_) {
3941 moduleVec.push_back(item.second.moduleName);
3942 }
3943 return moduleVec;
3944 }
3945
GetModuleNameByPackage(const std::string & packageName) const3946 std::string InnerBundleInfo::GetModuleNameByPackage(const std::string &packageName) const
3947 {
3948 auto it = innerModuleInfos_.find(packageName);
3949 if (it == innerModuleInfos_.end()) {
3950 return Constants::EMPTY_STRING;
3951 }
3952 return it->second.moduleName;
3953 }
3954
GetModuleTypeByPackage(const std::string & packageName) const3955 std::string InnerBundleInfo::GetModuleTypeByPackage(const std::string &packageName) const
3956 {
3957 auto it = innerModuleInfos_.find(packageName);
3958 if (it == innerModuleInfos_.end()) {
3959 return Constants::EMPTY_STRING;
3960 }
3961 return it->second.distro.moduleType;
3962 }
3963
GetAppQuickFix() const3964 AppQuickFix InnerBundleInfo::GetAppQuickFix() const
3965 {
3966 return baseApplicationInfo_->appQuickFix;
3967 }
3968
SetAppQuickFix(const AppQuickFix & appQuickFix)3969 void InnerBundleInfo::SetAppQuickFix(const AppQuickFix &appQuickFix)
3970 {
3971 baseApplicationInfo_->appQuickFix = appQuickFix;
3972 if (appQuickFix.deployedAppqfInfo.hqfInfos.empty() && appQuickFix.deployingAppqfInfo.hqfInfos.empty()) {
3973 baseApplicationInfo_->appQuickFix.bundleName = Constants::EMPTY_STRING;
3974 baseApplicationInfo_->appQuickFix.versionCode = 0;
3975 baseApplicationInfo_->appQuickFix.versionName = Constants::EMPTY_STRING;
3976 }
3977 SetQuickFixHqfInfos(appQuickFix.deployedAppqfInfo.hqfInfos);
3978 }
3979
GetQuickFixHqfInfos() const3980 std::vector<HqfInfo> InnerBundleInfo::GetQuickFixHqfInfos() const
3981 {
3982 return hqfInfos_;
3983 }
3984
SetQuickFixHqfInfos(const std::vector<HqfInfo> & hqfInfos)3985 void InnerBundleInfo::SetQuickFixHqfInfos(const std::vector<HqfInfo> &hqfInfos)
3986 {
3987 hqfInfos_ = hqfInfos;
3988 }
3989
FetchNativeSoAttrs(const std::string & requestPackage,std::string & cpuAbi,std::string & nativeLibraryPath) const3990 bool InnerBundleInfo::FetchNativeSoAttrs(
3991 const std::string &requestPackage, std::string &cpuAbi, std::string &nativeLibraryPath) const
3992 {
3993 auto moduleIter = innerModuleInfos_.find(requestPackage);
3994 if (moduleIter == innerModuleInfos_.end()) {
3995 APP_LOGE("requestPackage(%{public}s) not exist", requestPackage.c_str());
3996 return false;
3997 }
3998
3999 auto &moduleInfo = moduleIter->second;
4000 if (!moduleInfo.compressNativeLibs) {
4001 cpuAbi = moduleInfo.cpuAbi;
4002 nativeLibraryPath = moduleInfo.nativeLibraryPath;
4003 return !nativeLibraryPath.empty();
4004 }
4005
4006 if (moduleInfo.isLibIsolated) {
4007 cpuAbi = moduleInfo.cpuAbi;
4008 nativeLibraryPath = moduleInfo.nativeLibraryPath;
4009 } else {
4010 cpuAbi = baseApplicationInfo_->cpuAbi;
4011 nativeLibraryPath = baseApplicationInfo_->nativeLibraryPath;
4012 }
4013
4014 return !nativeLibraryPath.empty();
4015 }
4016
IsLibIsolated(const std::string & moduleName) const4017 bool InnerBundleInfo::IsLibIsolated(const std::string &moduleName) const
4018 {
4019 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
4020 if (!moduleInfo) {
4021 APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
4022 return false;
4023 }
4024
4025 return moduleInfo->isLibIsolated;
4026 }
4027
GetDeviceType(const std::string & packageName) const4028 std::vector<std::string> InnerBundleInfo::GetDeviceType(const std::string &packageName) const
4029 {
4030 auto it = innerModuleInfos_.find(packageName);
4031 if (it == innerModuleInfos_.end()) {
4032 APP_LOGW("%{public}s not existed", packageName.c_str());
4033 return std::vector<std::string>();
4034 }
4035 return innerModuleInfos_.at(packageName).deviceTypes;
4036 }
4037
GetRequiredDeviceFeatures(const std::string & packageName) const4038 std::map<std::string, std::vector<std::string>> InnerBundleInfo::GetRequiredDeviceFeatures(
4039 const std::string &packageName) const
4040 {
4041 auto it = innerModuleInfos_.find(packageName);
4042 if (it == innerModuleInfos_.end()) {
4043 APP_LOGW("%{public}s not existed", packageName.c_str());
4044 return {};
4045 }
4046 return innerModuleInfos_.at(packageName).requiredDeviceFeatures;
4047 }
4048
AddApplyQuickFixFrequency()4049 void InnerBundleInfo::AddApplyQuickFixFrequency()
4050 {
4051 ++applyQuickFixFrequency_;
4052 }
4053
GetApplyQuickFixFrequency() const4054 int32_t InnerBundleInfo::GetApplyQuickFixFrequency() const
4055 {
4056 return applyQuickFixFrequency_;
4057 }
4058
ResetApplyQuickFixFrequency()4059 void InnerBundleInfo::ResetApplyQuickFixFrequency()
4060 {
4061 applyQuickFixFrequency_ = 0;
4062 }
4063
GetAllHspVersion() const4064 std::vector<uint32_t> InnerBundleInfo::GetAllHspVersion() const
4065 {
4066 std::vector<uint32_t> versionCodes;
4067 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4068 for (const auto &module : modules) {
4069 if (std::find(versionCodes.begin(), versionCodes.end(), module.versionCode) == versionCodes.end()) {
4070 versionCodes.emplace_back(module.versionCode);
4071 }
4072 }
4073 }
4074 return versionCodes;
4075 }
4076
DeleteHspModuleByVersion(int32_t versionCode)4077 void InnerBundleInfo::DeleteHspModuleByVersion(int32_t versionCode)
4078 {
4079 for (auto modulesIt = innerSharedModuleInfos_.begin(); modulesIt != innerSharedModuleInfos_.end();) {
4080 if (modulesIt->second.size() == SINGLE_HSP_VERSION &&
4081 modulesIt->second.front().versionCode == static_cast<uint32_t>(versionCode)) {
4082 modulesIt = innerSharedModuleInfos_.erase(modulesIt);
4083 } else {
4084 modulesIt->second.erase(
4085 std::remove_if(modulesIt->second.begin(), modulesIt->second.end(),
4086 [versionCode] (InnerModuleInfo &module) {
4087 return module.versionCode == static_cast<uint32_t>(versionCode);
4088 }));
4089 ++modulesIt;
4090 }
4091 }
4092 }
4093
GetProxyDataInfos(const std::string & moduleName,std::vector<ProxyData> & proxyDatas) const4094 ErrCode InnerBundleInfo::GetProxyDataInfos(
4095 const std::string &moduleName, std::vector<ProxyData> &proxyDatas) const
4096 {
4097 if (moduleName == Constants::EMPTY_STRING) {
4098 GetAllProxyDataInfos(proxyDatas);
4099 return ERR_OK;
4100 }
4101 auto moduleIt = std::find_if(innerModuleInfos_.begin(), innerModuleInfos_.end(), [&moduleName](const auto &info) {
4102 return info.second.moduleName == moduleName;
4103 });
4104 if (moduleIt != innerModuleInfos_.end()) {
4105 proxyDatas.insert(
4106 proxyDatas.end(), moduleIt->second.proxyDatas.begin(), moduleIt->second.proxyDatas.end());
4107 } else {
4108 APP_LOGE("moduleName %{public}s not found", moduleName.c_str());
4109 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4110 }
4111 if (proxyDatas.empty()) {
4112 APP_LOGW("proxyDatas is empty");
4113 }
4114 return ERR_OK;
4115 }
4116
GetAllProxyDataInfos(std::vector<ProxyData> & proxyDatas) const4117 void InnerBundleInfo::GetAllProxyDataInfos(std::vector<ProxyData> &proxyDatas) const
4118 {
4119 for (const auto &innerModuleInfo : innerModuleInfos_) {
4120 proxyDatas.insert(
4121 proxyDatas.end(), innerModuleInfo.second.proxyDatas.begin(), innerModuleInfo.second.proxyDatas.end());
4122 }
4123 }
4124
GetIsolationMode(const std::string & isolationMode) const4125 IsolationMode InnerBundleInfo::GetIsolationMode(const std::string &isolationMode) const
4126 {
4127 auto isolationModeRes = ISOLATION_MODE_MAP.find(isolationMode);
4128 if (isolationModeRes != ISOLATION_MODE_MAP.end()) {
4129 return isolationModeRes->second;
4130 } else {
4131 return IsolationMode::NONISOLATION_FIRST;
4132 }
4133 }
4134
SetModuleHapPath(const std::string & hapPath)4135 void InnerBundleInfo::SetModuleHapPath(const std::string &hapPath)
4136 {
4137 if (innerModuleInfos_.count(currentPackage_) == 1) {
4138 innerModuleInfos_.at(currentPackage_).hapPath = hapPath;
4139 for (auto &abilityInfo : baseAbilityInfos_) {
4140 abilityInfo.second.hapPath = hapPath;
4141 }
4142 for (auto &extensionInfo : baseExtensionInfos_) {
4143 extensionInfo.second.hapPath = hapPath;
4144 }
4145 if (!innerModuleInfos_.at(currentPackage_).compressNativeLibs &&
4146 !innerModuleInfos_.at(currentPackage_).nativeLibraryPath.empty()) {
4147 auto pos = hapPath.rfind(ServiceConstants::PATH_SEPARATOR);
4148 if (pos != std::string::npos) {
4149 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
4150 hapPath.substr(pos + 1, hapPath.length() - pos - 1) + NATIVE_LIBRARY_PATH_SYMBOL +
4151 innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
4152 return;
4153 }
4154 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
4155 hapPath + NATIVE_LIBRARY_PATH_SYMBOL + innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
4156 }
4157 }
4158 }
4159
IsCompressNativeLibs(const std::string & moduleName) const4160 bool InnerBundleInfo::IsCompressNativeLibs(const std::string &moduleName) const
4161 {
4162 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
4163 if (!moduleInfo) {
4164 APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
4165 return true; // compressNativeLibs default true
4166 }
4167
4168 return moduleInfo->compressNativeLibs;
4169 }
4170
SetNativeLibraryFileNames(const std::string & moduleName,const std::vector<std::string> & fileNames)4171 void InnerBundleInfo::SetNativeLibraryFileNames(const std::string &moduleName,
4172 const std::vector<std::string> &fileNames)
4173 {
4174 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
4175 APP_LOGE("innerBundleInfo not contain the module: %{public}s", moduleName.c_str());
4176 return;
4177 }
4178 innerModuleInfos_.at(moduleName).nativeLibraryFileNames = fileNames;
4179 }
4180
UpdateSharedModuleInfo()4181 void InnerBundleInfo::UpdateSharedModuleInfo()
4182 {
4183 auto sharedModuleInfoIter = innerSharedModuleInfos_.find(currentPackage_);
4184 auto moduleInfoIter = innerModuleInfos_.find(currentPackage_);
4185 if ((sharedModuleInfoIter == innerSharedModuleInfos_.end()) ||
4186 (moduleInfoIter == innerModuleInfos_.end())) {
4187 APP_LOGE("The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
4188 return;
4189 }
4190 auto &innerModuleInfoVector = sharedModuleInfoIter->second;
4191 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
4192 if (iter->versionCode == moduleInfoIter->second.versionCode) {
4193 iter->hapPath = moduleInfoIter->second.hapPath;
4194 iter->arkTSMode = moduleInfoIter->second.arkTSMode;
4195 iter->moduleArkTSMode = moduleInfoIter->second.moduleArkTSMode;
4196 iter->compressNativeLibs = moduleInfoIter->second.compressNativeLibs;
4197 iter->cpuAbi = moduleInfoIter->second.cpuAbi;
4198 iter->nativeLibraryPath = moduleInfoIter->second.nativeLibraryPath;
4199 iter->nativeLibraryFileNames = moduleInfoIter->second.nativeLibraryFileNames;
4200 return;
4201 }
4202 }
4203 }
4204
SetExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4205 ErrCode InnerBundleInfo::SetExtName(
4206 const std::string &moduleName, const std::string &abilityName, const std::string extName)
4207 {
4208 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4209 if (abilityInfoPair == baseAbilityInfos_.end()) {
4210 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4211 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4212 }
4213 if (moduleName != abilityInfoPair->second.moduleName) {
4214 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4215 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4216 }
4217 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4218 bool duplicated = std::any_of(supportExtNames.begin(), supportExtNames.end(), [&extName](const auto &name) {
4219 return extName == name;
4220 });
4221 if (duplicated) {
4222 APP_LOGW("extName %{public}s already exist in ability %{public}s", extName.c_str(), abilityName.c_str());
4223 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4224 }
4225 supportExtNames.emplace_back(extName);
4226 return ERR_OK;
4227 }
4228
SetMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4229 ErrCode InnerBundleInfo::SetMimeType(
4230 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4231 {
4232 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4233 if (abilityInfoPair == baseAbilityInfos_.end()) {
4234 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4235 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4236 }
4237 if (moduleName != abilityInfoPair->second.moduleName) {
4238 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4239 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4240 }
4241 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4242 bool duplicated = std::any_of(supportMimeTypes.begin(), supportMimeTypes.end(), [&mimeType](const auto &type) {
4243 return mimeType == type;
4244 });
4245 if (duplicated) {
4246 APP_LOGW("MIME type %{public}s already exist in ability %{public}s", mimeType.c_str(), abilityName.c_str());
4247 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4248 }
4249 abilityInfoPair->second.supportMimeTypes.emplace_back(mimeType);
4250 return ERR_OK;
4251 }
4252
DelExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4253 ErrCode InnerBundleInfo::DelExtName(
4254 const std::string &moduleName, const std::string &abilityName, const std::string extName)
4255 {
4256 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4257 if (abilityInfoPair == baseAbilityInfos_.end()) {
4258 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4259 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4260 }
4261 if (moduleName != abilityInfoPair->second.moduleName) {
4262 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4263 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4264 }
4265 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4266 supportExtNames.erase(std::remove(supportExtNames.begin(), supportExtNames.end(), extName), supportExtNames.end());
4267 return ERR_OK;
4268 }
4269
DelMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4270 ErrCode InnerBundleInfo::DelMimeType(
4271 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4272 {
4273 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4274 if (abilityInfoPair == baseAbilityInfos_.end()) {
4275 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4276 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4277 }
4278 if (moduleName != abilityInfoPair->second.moduleName) {
4279 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4280 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4281 }
4282 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4283 supportMimeTypes.erase(
4284 std::remove(supportMimeTypes.begin(), supportMimeTypes.end(), mimeType), supportMimeTypes.end());
4285 return ERR_OK;
4286 }
4287
GetAppServiceHspInfo(BundleInfo & bundleInfo) const4288 ErrCode InnerBundleInfo::GetAppServiceHspInfo(BundleInfo &bundleInfo) const
4289 {
4290 if (baseApplicationInfo_->bundleType != BundleType::APP_SERVICE_FWK) {
4291 APP_LOGW("%{public}s is not app service", GetBundleName().c_str());
4292 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
4293 }
4294 bundleInfo = *baseBundleInfo_;
4295 bundleInfo.applicationInfo = *baseApplicationInfo_;
4296 bundleInfo.applicationInfo.arkTSMode = GetApplicationArkTSMode();
4297 for (const auto &info : innerModuleInfos_) {
4298 if (info.second.distro.moduleType == Profile::MODULE_TYPE_SHARED) {
4299 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, Constants::ALL_USERID);
4300 if (hapmoduleinfo) {
4301 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
4302 hapModuleInfo.moduleSourceDir = hapModuleInfo.hapPath.empty() ?
4303 info.second.modulePath : hapModuleInfo.moduleSourceDir;
4304 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
4305 }
4306 }
4307 }
4308 if (bundleInfo.hapModuleInfos.empty()) {
4309 APP_LOGE("bundleName:%{public}s no hsp module info", baseApplicationInfo_->bundleName.c_str());
4310 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4311 }
4312 return ERR_OK;
4313 }
4314
HandleOTACodeEncryption(std::vector<std::string> & withoutKeyBundles,std::vector<std::string> & withKeyBundles) const4315 void InnerBundleInfo::HandleOTACodeEncryption(std::vector<std::string> &withoutKeyBundles,
4316 std::vector<std::string> &withKeyBundles) const
4317 {
4318 BundleType bundleType = GetApplicationBundleType();
4319 if (bundleType != BundleType::APP && bundleType != BundleType::ATOMIC_SERVICE) {
4320 return;
4321 }
4322 if ((GetApplicationReservedFlag() & static_cast<uint32_t>(ApplicationReservedFlag::ENCRYPTED_APPLICATION))
4323 != static_cast<uint32_t>(ApplicationReservedFlag::ENCRYPTED_APPLICATION)) {
4324 return;
4325 }
4326 if (innerBundleUserInfos_.empty()) {
4327 APP_LOGE("user empty");
4328 return;
4329 }
4330 CodeProtectBundleInfo codeProtectBundleInfo;
4331 codeProtectBundleInfo.bundleName = GetBundleName();
4332 codeProtectBundleInfo.versionCode = GetVersionCode();
4333 codeProtectBundleInfo.applicationReservedFlag = GetApplicationReservedFlag();
4334 codeProtectBundleInfo.uid = innerBundleUserInfos_.begin()->second.uid;
4335 codeProtectBundleInfo.appIdentifier = GetAppIdentifier();
4336 std::vector<CodeProtectBundleInfo> codeProtectBundleInfos { codeProtectBundleInfo };
4337 BmsExtensionDataMgr bmsExtensionDataMgr;
4338 auto res = bmsExtensionDataMgr.KeyOperation(codeProtectBundleInfos, CodeOperation::OTA_CHECK);
4339 if (res != ERR_OK) {
4340 APP_LOGE("ota check for %{public}s failed", GetBundleName().c_str());
4341 if (res != CPM_KEY_NOT_EXIST) {
4342 return;
4343 }
4344 withoutKeyBundles.emplace_back(GetBundleName());
4345 } else {
4346 withKeyBundles.emplace_back(GetBundleName());
4347 }
4348 CheckEncryptionParam checkEncryptionParam;
4349 checkEncryptionParam.bundleId = innerBundleUserInfos_.begin()->second.uid -
4350 innerBundleUserInfos_.begin()->second.bundleUserInfo.userId * Constants::BASE_USER_RANGE;
4351 checkEncryptionParam.appIdentifier = GetAppIdentifier();
4352 checkEncryptionParam.versionCode = GetVersionCode();
4353 APP_LOGI("start");
4354 for (const auto &item : innerModuleInfos_) {
4355 CheckHapEncryption(checkEncryptionParam, item.second);
4356 CheckSoEncryption(checkEncryptionParam, item.first, item.second);
4357 }
4358 APP_LOGI("end");
4359 }
4360
CheckHapEncryption(const CheckEncryptionParam & checkEncryptionParam,const InnerModuleInfo & moduleInfo) const4361 void InnerBundleInfo::CheckHapEncryption(const CheckEncryptionParam &checkEncryptionParam,
4362 const InnerModuleInfo &moduleInfo) const
4363 {
4364 CheckEncryptionParam param { checkEncryptionParam };
4365 param.modulePath = moduleInfo.hapPath;
4366 param.isCompressNativeLibrary = moduleInfo.compressNativeLibs;
4367 param.installBundleType =
4368 moduleInfo.distro.moduleType == Profile::MODULE_TYPE_SHARED ?
4369 InstallBundleType::INTER_APP_HSP : InstallBundleType::HAP;
4370 bool isEncrypted = false;
4371 ErrCode result = InstalldClient::GetInstance()->CheckEncryption(param, isEncrypted);
4372 if (result != ERR_OK) {
4373 APP_LOGE("fail, error: %{public}d", result);
4374 }
4375 }
4376
CheckSoEncryption(const CheckEncryptionParam & checkEncryptionParam,const std::string & requestPackage,const InnerModuleInfo & moduleInfo) const4377 void InnerBundleInfo::CheckSoEncryption(const CheckEncryptionParam &checkEncryptionParam,
4378 const std::string &requestPackage, const InnerModuleInfo &moduleInfo) const
4379 {
4380 bool isCompressNativeLibrary = moduleInfo.compressNativeLibs;
4381 if (!isCompressNativeLibrary) {
4382 return;
4383 }
4384 std::string cpuAbi;
4385 std::string nativeLibraryPath;
4386 if (!FetchNativeSoAttrs(requestPackage, cpuAbi, nativeLibraryPath)) {
4387 APP_LOGE("fetch %{public}s failed", requestPackage.c_str());
4388 return;
4389 }
4390 std::string targetSoPath;
4391 targetSoPath.append(Constants::BUNDLE_CODE_DIR).append(ServiceConstants::PATH_SEPARATOR).append(GetBundleName())
4392 .append(ServiceConstants::PATH_SEPARATOR).append(nativeLibraryPath).append(ServiceConstants::PATH_SEPARATOR);
4393 CheckEncryptionParam param { checkEncryptionParam };
4394 param.modulePath = moduleInfo.hapPath;
4395 param.cpuAbi = cpuAbi;
4396 param.isCompressNativeLibrary = isCompressNativeLibrary;
4397 param.installBundleType =
4398 moduleInfo.distro.moduleType == Profile::MODULE_TYPE_SHARED ?
4399 InstallBundleType::INTER_APP_HSP : InstallBundleType::HAP;
4400 param.targetSoPath = targetSoPath;
4401 bool isEncrypted = false;
4402 ErrCode result = InstalldClient::GetInstance()->CheckEncryption(param, isEncrypted);
4403 if (result != ERR_OK) {
4404 APP_LOGE("fail, error: %{public}d", result);
4405 }
4406 }
4407
UpdateIsCompressNativeLibs()4408 void InnerBundleInfo::UpdateIsCompressNativeLibs()
4409 {
4410 if (innerModuleInfos_.empty()) {
4411 baseApplicationInfo_->isCompressNativeLibs = true;
4412 return;
4413 }
4414 baseApplicationInfo_->isCompressNativeLibs = false;
4415 for (const auto &info : innerModuleInfos_) {
4416 baseApplicationInfo_->isCompressNativeLibs =
4417 (baseApplicationInfo_->isCompressNativeLibs || info.second.compressNativeLibs) ? true : false;
4418 }
4419 }
4420
SetResourcesApply(const std::vector<int32_t> & resourcesApply)4421 void InnerBundleInfo::SetResourcesApply(const std::vector<int32_t> &resourcesApply)
4422 {
4423 baseApplicationInfo_->resourcesApply = resourcesApply;
4424 }
4425
InnerProcessShortcut(const Shortcut & oldShortcut,ShortcutInfo & shortcutInfo) const4426 void InnerBundleInfo::InnerProcessShortcut(const Shortcut &oldShortcut, ShortcutInfo &shortcutInfo) const
4427 {
4428 shortcutInfo.id = oldShortcut.shortcutId;
4429 shortcutInfo.icon = oldShortcut.icon;
4430 shortcutInfo.label = oldShortcut.label;
4431 shortcutInfo.visible = oldShortcut.visible;
4432 shortcutInfo.iconId = oldShortcut.iconId;
4433 if (shortcutInfo.iconId == 0) {
4434 auto iter = oldShortcut.icon.find(PORT_SEPARATOR);
4435 if (iter != std::string::npos) {
4436 shortcutInfo.iconId = static_cast<uint32_t>(atoi(oldShortcut.icon.substr(iter + 1).c_str()));
4437 }
4438 }
4439 shortcutInfo.labelId = oldShortcut.labelId;
4440 if (shortcutInfo.labelId == 0) {
4441 auto iter = oldShortcut.label.find(PORT_SEPARATOR);
4442 if (iter != std::string::npos) {
4443 shortcutInfo.labelId = static_cast<uint32_t>(atoi(oldShortcut.label.substr(iter + 1).c_str()));
4444 }
4445 }
4446 for (const ShortcutWant &shortcutWant : oldShortcut.wants) {
4447 ShortcutIntent shortcutIntent;
4448 shortcutIntent.targetBundle = shortcutWant.bundleName;
4449 shortcutIntent.targetModule = shortcutWant.moduleName;
4450 shortcutIntent.targetClass = shortcutWant.abilityName;
4451 shortcutIntent.parameters = shortcutWant.parameters;
4452 shortcutInfo.intents.emplace_back(shortcutIntent);
4453 }
4454 }
4455
GetEntryModuleName() const4456 std::string InnerBundleInfo::GetEntryModuleName() const
4457 {
4458 for (const auto &item : innerModuleInfos_) {
4459 if (item.second.isEntry) {
4460 return item.second.modulePackage;
4461 }
4462 }
4463 return Constants::EMPTY_STRING;
4464 }
4465
SetMoudleIsEncrpted(const std::string & packageName,bool isEncrypted)4466 void InnerBundleInfo::SetMoudleIsEncrpted(const std::string &packageName, bool isEncrypted)
4467 {
4468 auto it = innerModuleInfos_.find(packageName);
4469 if (it == innerModuleInfos_.end()) {
4470 return;
4471 }
4472 it->second.isEncrypted = isEncrypted;
4473 }
4474
IsEncryptedMoudle(const std::string & packageName) const4475 bool InnerBundleInfo::IsEncryptedMoudle(const std::string &packageName) const
4476 {
4477 auto it = innerModuleInfos_.find(packageName);
4478 if (it == innerModuleInfos_.end()) {
4479 return false;
4480 }
4481 return it->second.isEncrypted;
4482 }
4483
GetAllEncryptedModuleNames(std::vector<std::string> & moduleNames) const4484 void InnerBundleInfo::GetAllEncryptedModuleNames(std::vector<std::string> &moduleNames) const
4485 {
4486 for (const auto &info : innerModuleInfos_) {
4487 if (info.second.isEncrypted) {
4488 moduleNames.emplace_back(info.second.moduleName);
4489 }
4490 }
4491 }
4492
IsContainEncryptedModule() const4493 bool InnerBundleInfo::IsContainEncryptedModule() const
4494 {
4495 for (const auto &info : innerModuleInfos_) {
4496 if (info.second.isEncrypted) {
4497 return true;
4498 }
4499 }
4500 return false;
4501 }
4502
GetAppIdentifier() const4503 std::string InnerBundleInfo::GetAppIdentifier() const
4504 {
4505 return baseBundleInfo_->signatureInfo.appIdentifier;
4506 }
4507
SetAppIdentifier(const std::string & appIdentifier)4508 void InnerBundleInfo::SetAppIdentifier(const std::string &appIdentifier)
4509 {
4510 baseBundleInfo_->signatureInfo.appIdentifier = appIdentifier;
4511 }
4512
SetCertificate(const std::string & certificate)4513 void InnerBundleInfo::SetCertificate(const std::string &certificate)
4514 {
4515 baseBundleInfo_->signatureInfo.certificate = certificate;
4516 }
4517
GetCertificate() const4518 std::string InnerBundleInfo::GetCertificate() const
4519 {
4520 return baseBundleInfo_->signatureInfo.certificate;
4521 }
4522
UpdateDebug(const InnerBundleInfo & newInfo)4523 void InnerBundleInfo::UpdateDebug(const InnerBundleInfo &newInfo)
4524 {
4525 std::string moduleName = newInfo.GetCurrentModulePackage();
4526 auto it = innerModuleInfos_.find(moduleName);
4527 if (it != innerModuleInfos_.end()) {
4528 it->second.debug = newInfo.GetBaseApplicationInfo().debug;
4529 }
4530 if (newInfo.HasEntry()) {
4531 baseApplicationInfo_->debug = newInfo.GetBaseApplicationInfo().debug;
4532 } else if (!HasEntry()) {
4533 baseApplicationInfo_->debug =
4534 newInfo.GetBaseApplicationInfo().debug || GetDebugFromModules(innerModuleInfos_);
4535 }
4536 }
4537
GetDebugFromModules(const std::map<std::string,InnerModuleInfo> & innerModuleInfos)4538 bool InnerBundleInfo::GetDebugFromModules(const std::map<std::string, InnerModuleInfo> &innerModuleInfos)
4539 {
4540 bool debug = false;
4541 for (const auto &item : innerModuleInfos) {
4542 if (item.second.isEntry) {
4543 return item.second.debug;
4544 } else {
4545 debug = debug || item.second.debug;
4546 }
4547 }
4548 return debug;
4549 }
4550
AddOldAppId(const std::string & appId)4551 void InnerBundleInfo::AddOldAppId(const std::string &appId)
4552 {
4553 auto appIds = baseBundleInfo_->oldAppIds;
4554 if (std::find(appIds.begin(), appIds.end(), appId) == appIds.end()) {
4555 baseBundleInfo_->oldAppIds.emplace_back(appId);
4556 }
4557 }
4558
GetOldAppIds() const4559 std::vector<std::string> InnerBundleInfo::GetOldAppIds() const
4560 {
4561 return baseBundleInfo_->oldAppIds;
4562 }
4563
GetQuerySchemes() const4564 std::vector<std::string> InnerBundleInfo::GetQuerySchemes() const
4565 {
4566 std::string entryModuleName = GetEntryModuleName();
4567 auto it = innerModuleInfos_.find(entryModuleName);
4568 if (it == innerModuleInfos_.end()) {
4569 return std::vector<std::string>();
4570 }
4571 std::vector<std::string> querySchemes = innerModuleInfos_.at(entryModuleName).querySchemes;
4572 for (size_t i = 0; i < querySchemes.size(); i++) {
4573 transform(querySchemes[i].begin(), querySchemes[i].end(), querySchemes[i].begin(), ::tolower);
4574 }
4575 return querySchemes;
4576 }
4577
UpdateOdid(const std::string & developerId,const std::string & odid)4578 void InnerBundleInfo::UpdateOdid(const std::string &developerId, const std::string &odid)
4579 {
4580 developerId_ = developerId;
4581 odid_ = odid;
4582 }
4583
UpdateOdidByBundleInfo(const InnerBundleInfo & info)4584 void InnerBundleInfo::UpdateOdidByBundleInfo(const InnerBundleInfo &info)
4585 {
4586 std::string developerId;
4587 std::string odid;
4588 info.GetDeveloperidAndOdid(developerId, odid);
4589 developerId_ = developerId;
4590 odid_ = odid;
4591 }
4592
GetDeveloperidAndOdid(std::string & developerId,std::string & odid) const4593 void InnerBundleInfo::GetDeveloperidAndOdid(std::string &developerId, std::string &odid) const
4594 {
4595 developerId = developerId_;
4596 odid = odid_;
4597 }
4598
GetOdid(std::string & odid) const4599 void InnerBundleInfo::GetOdid(std::string &odid) const
4600 {
4601 odid = odid_;
4602 }
4603
AddAllowedAcls(const std::vector<std::string> & allowedAcls)4604 void InnerBundleInfo::AddAllowedAcls(const std::vector<std::string> &allowedAcls)
4605 {
4606 for (const auto &acl : allowedAcls) {
4607 if (!acl.empty() && (std::find(allowedAcls_.begin(), allowedAcls_.end(), acl) == allowedAcls_.end())) {
4608 allowedAcls_.emplace_back(acl);
4609 }
4610 }
4611 }
4612
IsAsanEnabled() const4613 bool InnerBundleInfo::IsAsanEnabled() const
4614 {
4615 for (const auto &item : innerModuleInfos_) {
4616 if (item.second.asanEnabled) {
4617 return true;
4618 }
4619 }
4620 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4621 for (const auto &module : modules) {
4622 if (module.asanEnabled) {
4623 return true;
4624 }
4625 }
4626 }
4627 return false;
4628 }
4629
IsGwpAsanEnabled() const4630 bool InnerBundleInfo::IsGwpAsanEnabled() const
4631 {
4632 for (const auto &item : innerModuleInfos_) {
4633 if (item.second.gwpAsanEnabled) {
4634 return true;
4635 }
4636 }
4637 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4638 for (const auto &module : modules) {
4639 if (module.gwpAsanEnabled) {
4640 return true;
4641 }
4642 }
4643 }
4644 return false;
4645 }
4646
IsTsanEnabled() const4647 bool InnerBundleInfo::IsTsanEnabled() const
4648 {
4649 for (const auto &item : innerModuleInfos_) {
4650 if (item.second.tsanEnabled) {
4651 return true;
4652 }
4653 }
4654 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4655 for (const auto &module : modules) {
4656 if (module.tsanEnabled) {
4657 return true;
4658 }
4659 }
4660 }
4661 return false;
4662 }
4663
IsHwasanEnabled() const4664 bool InnerBundleInfo::IsHwasanEnabled() const
4665 {
4666 bool hwasanEnabled = false;
4667 for (const auto &item : innerModuleInfos_) {
4668 hwasanEnabled = static_cast<bool>(item.second.innerModuleInfoFlag &
4669 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4670 if (hwasanEnabled) {
4671 return true;
4672 }
4673 }
4674 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4675 for (const auto &module : modules) {
4676 hwasanEnabled = static_cast<bool>(module.innerModuleInfoFlag &
4677 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4678 if (hwasanEnabled) {
4679 return true;
4680 }
4681 }
4682 }
4683 return false;
4684 }
4685
IsUbsanEnabled() const4686 bool InnerBundleInfo::IsUbsanEnabled() const
4687 {
4688 bool ubsanEnabled = false;
4689 for (const auto &item : innerModuleInfos_) {
4690 ubsanEnabled = static_cast<bool>(item.second.innerModuleInfoFlag &
4691 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED));
4692 if (ubsanEnabled) {
4693 return true;
4694 }
4695 }
4696 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4697 for (const auto &module : modules) {
4698 ubsanEnabled = static_cast<bool>(module.innerModuleInfoFlag &
4699 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_UBSANENABLED));
4700 if (ubsanEnabled) {
4701 return true;
4702 }
4703 }
4704 }
4705 return false;
4706 }
4707
NeedCreateEl5Dir() const4708 bool InnerBundleInfo::NeedCreateEl5Dir() const
4709 {
4710 std::vector<RequestPermission> reqPermissions = GetAllRequestPermissions();
4711 auto it = std::find_if(reqPermissions.begin(), reqPermissions.end(), [](const RequestPermission& permission) {
4712 return permission.name == ServiceConstants::PERMISSION_PROTECT_SCREEN_LOCK_DATA;
4713 });
4714 return it != reqPermissions.end();
4715 }
4716
GetUninstallState() const4717 bool InnerBundleInfo::GetUninstallState() const
4718 {
4719 return uninstallState_;
4720 }
4721
SetUninstallState(const bool & uninstallState)4722 void InnerBundleInfo::SetUninstallState(const bool &uninstallState)
4723 {
4724 uninstallState_ = uninstallState;
4725 }
4726
IsNeedSendNotify() const4727 bool InnerBundleInfo::IsNeedSendNotify() const
4728 {
4729 return isNeedSendNotify_;
4730 }
4731
SetNeedSendNotify(const bool needStatus)4732 void InnerBundleInfo::SetNeedSendNotify(const bool needStatus)
4733 {
4734 isNeedSendNotify_ = needStatus;
4735 }
4736
GetAllExtensionDirsInSpecifiedModule(const std::string & moduleName) const4737 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirsInSpecifiedModule(const std::string &moduleName) const
4738 {
4739 std::vector<std::string> dirVec;
4740 auto extensionInfoMap = GetInnerExtensionInfos();
4741 for (auto item : extensionInfoMap) {
4742 if (item.second.moduleName != moduleName || !item.second.needCreateSandbox) {
4743 continue;
4744 }
4745 std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4746 ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4747 ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4748 dirVec.emplace_back(dir);
4749 }
4750 return dirVec;
4751 }
4752
GetAllExtensionDirs() const4753 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirs() const
4754 {
4755 std::vector<std::string> dirVec;
4756 auto extensionInfoMap = GetInnerExtensionInfos();
4757 for (auto item : extensionInfoMap) {
4758 if (!item.second.needCreateSandbox) {
4759 continue;
4760 }
4761 // eg: +extension-entry-inputMethodExtAbility+com.example.myapplication
4762 std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4763 ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4764 ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4765 dirVec.emplace_back(dir);
4766 }
4767 return dirVec;
4768 }
4769
SetApplicationFlags(ApplicationInfoFlag flag)4770 void InnerBundleInfo::SetApplicationFlags(ApplicationInfoFlag flag)
4771 {
4772 uint32_t applicationFlags = static_cast<uint32_t>(baseApplicationInfo_->applicationFlags);
4773 uint32_t installSourceFlag = static_cast<uint32_t>(flag);
4774 baseApplicationInfo_->applicationFlags =
4775 static_cast<int32_t>((applicationFlags & PREINSTALL_SOURCE_CLEAN_MASK) | installSourceFlag);
4776 }
4777
UpdateExtensionSandboxInfo(const std::vector<std::string> & typeList)4778 void InnerBundleInfo::UpdateExtensionSandboxInfo(const std::vector<std::string> &typeList)
4779 {
4780 for (auto &extensionItem : baseExtensionInfos_) {
4781 extensionItem.second.needCreateSandbox = false;
4782 std::string typeName = extensionItem.second.extensionTypeName;
4783 auto it = std::find(typeList.begin(), typeList.end(), typeName);
4784 if (it != typeList.end()) {
4785 extensionItem.second.needCreateSandbox = true;
4786 }
4787 }
4788 }
4789
UpdateExtensionDataGroupInfo(const std::string & key,const std::vector<std::string> & dataGroupIds)4790 void InnerBundleInfo::UpdateExtensionDataGroupInfo(
4791 const std::string &key, const std::vector<std::string>& dataGroupIds)
4792 {
4793 auto it = baseExtensionInfos_.find(key);
4794 if (it == baseExtensionInfos_.end()) {
4795 APP_LOGW("UpdateExtensionDataGroupInfo not find key: %{public}s", key.c_str());
4796 return;
4797 }
4798 it->second.validDataGroupIds = dataGroupIds;
4799 }
4800
AddDataGroupInfo(const std::string & dataGroupId,const DataGroupInfo & info)4801 void InnerBundleInfo::AddDataGroupInfo(const std::string &dataGroupId, const DataGroupInfo &info)
4802 {
4803 APP_LOGD("AddDataGroupInfo, dataGroupId: %{public}s, dataGroupInfo: %{public}s",
4804 dataGroupId.c_str(), info.ToString().c_str());
4805 auto dataGroupInfosItem = dataGroupInfos_.find(dataGroupId);
4806 if (dataGroupInfosItem == dataGroupInfos_.end()) {
4807 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for dataGroupId: %{public}s", dataGroupId.c_str());
4808 dataGroupInfos_[dataGroupId] = std::vector<DataGroupInfo> { info };
4809 return;
4810 }
4811 int32_t userId = info.userId;
4812 auto iter = std::find_if(std::begin(dataGroupInfos_[dataGroupId]), std::end(dataGroupInfos_[dataGroupId]),
4813 [userId](const DataGroupInfo &dataGroupinfo) { return dataGroupinfo.userId == userId; });
4814 if (iter != std::end(dataGroupInfos_[dataGroupId])) {
4815 if ((iter->uid == info.uid) && (iter->uuid == info.uuid)) {
4816 return;
4817 }
4818 APP_LOGW("uid or uuid not same, dataGroupId: %{public}s", dataGroupId.c_str());
4819 dataGroupInfos_[dataGroupId].erase(iter);
4820 }
4821 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for user: %{public}d", info.userId);
4822 dataGroupInfos_[dataGroupId].emplace_back(info);
4823 }
4824
AddCloneBundle(const InnerBundleCloneInfo & attr)4825 ErrCode InnerBundleInfo::AddCloneBundle(const InnerBundleCloneInfo &attr)
4826 {
4827 int32_t userId = attr.userId;
4828 int32_t appIndex = attr.appIndex;
4829 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4830 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4831 APP_LOGE("Add Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4832 userId, GetBundleName().c_str());
4833 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4834 }
4835 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4836 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4837
4838 if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4839 APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4840 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4841 }
4842 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4843 if (cloneInfos.find(appIndexKey) != cloneInfos.end()) {
4844 APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d existed", appIndex);
4845 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
4846 }
4847
4848 InnerBundleCloneInfo cloneInfo;
4849 cloneInfo.userId = userId;
4850 cloneInfo.appIndex = appIndex;
4851 // copy from user
4852 cloneInfo.enabled = userInfo.bundleUserInfo.enabled;
4853 cloneInfo.disabledAbilities = userInfo.bundleUserInfo.disabledAbilities;
4854 cloneInfo.accessTokenId = attr.accessTokenId;
4855 cloneInfo.accessTokenIdEx = attr.accessTokenIdEx;
4856 cloneInfo.uid = attr.uid;
4857 cloneInfo.gids = attr.gids;
4858 int64_t now = BundleUtil::GetCurrentTimeMs();
4859 cloneInfo.installTime = now;
4860 cloneInfos[appIndexKey] = cloneInfo;
4861 APP_LOGD("Add clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4862 userId, appIndex, GetBundleName().c_str());
4863 return ERR_OK;
4864 }
4865
RemoveCloneBundle(const int32_t userId,const int32_t appIndex)4866 ErrCode InnerBundleInfo::RemoveCloneBundle(const int32_t userId, const int32_t appIndex)
4867 {
4868 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4869 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4870 APP_LOGE("Remove Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4871 userId, GetBundleName().c_str());
4872 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4873 }
4874 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4875 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4876
4877 if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4878 APP_LOGE("Remove Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4879 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4880 }
4881 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4882 if (cloneInfos.find(appIndexKey) == cloneInfos.end()) {
4883 APP_LOGD("appIndex: %{public}d not found", appIndex);
4884 return ERR_OK;
4885 }
4886 cloneInfos.erase(appIndexKey);
4887 APP_LOGD("Remove clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4888 userId, appIndex, GetBundleName().c_str());
4889 return ERR_OK;
4890 }
4891
GetAvailableCloneAppIndex(const int32_t userId,int32_t & appIndex)4892 ErrCode InnerBundleInfo::GetAvailableCloneAppIndex(const int32_t userId, int32_t &appIndex)
4893 {
4894 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4895 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4896 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4897 }
4898 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4899 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4900
4901 int32_t candidateAppIndex = 1;
4902 while (cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(candidateAppIndex)) != cloneInfos.end()) {
4903 candidateAppIndex++;
4904 }
4905 appIndex = candidateAppIndex;
4906 return ERR_OK;
4907 }
4908
IsCloneAppIndexExisted(const int32_t userId,const int32_t appIndex,bool & res)4909 ErrCode InnerBundleInfo::IsCloneAppIndexExisted(const int32_t userId, const int32_t appIndex, bool &res)
4910 {
4911 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4912 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4913 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4914 }
4915 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4916 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4917
4918 res = cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(appIndex)) != cloneInfos.end();
4919 return ERR_OK;
4920 }
4921
GetApplicationInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,ApplicationInfo & appInfo) const4922 bool InnerBundleInfo::GetApplicationInfoAdaptBundleClone(
4923 const InnerBundleUserInfo &innerBundleUserInfo,
4924 int32_t appIndex,
4925 ApplicationInfo &appInfo) const
4926 {
4927 if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4928 if (appInfo.removable && !innerBundleUserInfo.isRemovable) {
4929 appInfo.removable = false;
4930 }
4931
4932 appInfo.accessTokenId = innerBundleUserInfo.accessTokenId;
4933 appInfo.accessTokenIdEx = innerBundleUserInfo.accessTokenIdEx;
4934 appInfo.enabled = innerBundleUserInfo.bundleUserInfo.enabled;
4935 appInfo.uid = innerBundleUserInfo.uid;
4936 return true;
4937 }
4938 APP_LOGD("start appIndex: %{public}d", appIndex);
4939 auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4940 if (iter == innerBundleUserInfo.cloneInfos.end()) {
4941 APP_LOGE("appIndex %{public}d not exist", appIndex);
4942 return false;
4943 }
4944 appInfo.accessTokenId = iter->second.accessTokenId;
4945 appInfo.accessTokenIdEx = iter->second.accessTokenIdEx;
4946 appInfo.enabled = iter->second.enabled;
4947 appInfo.uid = iter->second.uid;
4948 appInfo.appIndex = iter->second.appIndex;
4949 return true;
4950 }
4951
GetBundleInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,BundleInfo & bundleInfo) const4952 bool InnerBundleInfo::GetBundleInfoAdaptBundleClone(
4953 const InnerBundleUserInfo &innerBundleUserInfo,
4954 int32_t appIndex,
4955 BundleInfo &bundleInfo) const
4956 {
4957 bundleInfo.firstInstallTime = innerBundleUserInfo.firstInstallTime;
4958 if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4959 bundleInfo.uid = innerBundleUserInfo.uid;
4960 if (!innerBundleUserInfo.gids.empty()) {
4961 bundleInfo.gid = innerBundleUserInfo.gids[0];
4962 }
4963 bundleInfo.installTime = innerBundleUserInfo.installTime;
4964 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4965 bundleInfo.appIndex = appIndex_;
4966 return true;
4967 }
4968 APP_LOGD("start appIndex: %{public}d", appIndex);
4969 auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4970 if (iter == innerBundleUserInfo.cloneInfos.end()) {
4971 APP_LOGE("appIndex %{public}d not exist", appIndex);
4972 return false;
4973 }
4974 bundleInfo.uid = iter->second.uid;
4975 bundleInfo.gid = iter->second.uid; // no gids, need add
4976 bundleInfo.installTime = iter->second.installTime;
4977 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4978 bundleInfo.appIndex = appIndex;
4979 return true;
4980 }
4981
VerifyAndAckCloneAppIndex(int32_t userId,int32_t & appIndex)4982 ErrCode InnerBundleInfo::VerifyAndAckCloneAppIndex(int32_t userId, int32_t &appIndex)
4983 {
4984 auto multiAppModeData = this->baseApplicationInfo_->multiAppMode;
4985 if (multiAppModeData.multiAppModeType != MultiAppModeType::APP_CLONE) {
4986 APP_LOGE("bundleName:%{public}s is not clone app", GetBundleName().c_str());
4987 return ERR_APPEXECFWK_CLONE_INSTALL_APP_NOT_SUPPORTED_MULTI_TYPE;
4988 }
4989
4990 if (appIndex < 0) {
4991 APP_LOGE("appIndex:%{public}d not in valid range", appIndex);
4992 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4993 }
4994 if (appIndex == 0) {
4995 ErrCode availableRes = GetAvailableCloneAppIndex(userId, appIndex);
4996 if (availableRes != ERR_OK) {
4997 APP_LOGE("Get Available Clone AppIndex Fail for, errCode: %{public}d", availableRes);
4998 return availableRes;
4999 }
5000 } else {
5001 bool found = false;
5002 ErrCode isExistedRes = IsCloneAppIndexExisted(userId, appIndex, found);
5003 if (isExistedRes != ERR_OK) {
5004 return isExistedRes;
5005 }
5006 if (found) {
5007 APP_LOGE("AppIndex %{public}d existed in userId %{public}d", appIndex, userId);
5008 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
5009 }
5010 }
5011 int32_t maxCount = std::min(multiAppModeData.maxCount, ServiceConstants::CLONE_APP_INDEX_MAX);
5012 if (appIndex > maxCount) {
5013 APP_LOGE("AppIndex %{public}d exceed max limit %{public}d in userId: %{public}d",
5014 appIndex, maxCount, userId);
5015 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXCEED_MAX_NUMBER;
5016 }
5017 return ERR_OK;
5018 }
5019
UpdateMultiAppMode(const InnerBundleInfo & newInfo)5020 void InnerBundleInfo::UpdateMultiAppMode(const InnerBundleInfo &newInfo)
5021 {
5022 std::string moduleType = newInfo.GetModuleTypeByPackage(newInfo.GetCurrentModulePackage());
5023 if (moduleType == Profile::MODULE_TYPE_ENTRY || moduleType == Profile::MODULE_TYPE_FEATURE) {
5024 baseApplicationInfo_->multiAppMode = newInfo.GetBaseApplicationInfo().multiAppMode;
5025 }
5026 }
5027
UpdateReleaseType(const InnerBundleInfo & newInfo)5028 void InnerBundleInfo::UpdateReleaseType(const InnerBundleInfo &newInfo)
5029 {
5030 if (baseBundleInfo_->releaseType.empty() ||
5031 baseApplicationInfo_->apiReleaseType.empty() ||
5032 !newInfo.IsHsp()) {
5033 baseBundleInfo_->releaseType = newInfo.GetBaseBundleInfo().releaseType;
5034 baseApplicationInfo_->apiReleaseType = newInfo.GetBaseApplicationInfo().apiReleaseType;
5035 }
5036 }
5037
AdaptMainLauncherResourceInfo(ApplicationInfo & applicationInfo) const5038 void InnerBundleInfo::AdaptMainLauncherResourceInfo(ApplicationInfo &applicationInfo) const
5039 {
5040 if (ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.find(GetBundleName()) !=
5041 ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.end()) {
5042 return;
5043 }
5044 for (const auto& item : innerModuleInfos_) {
5045 const std::string& key = item.second.entryAbilityKey;
5046 if (!key.empty() && (baseAbilityInfos_.count(key) != 0)) {
5047 const InnerAbilityInfo &mainAbilityInfo = baseAbilityInfos_.at(key);
5048 if ((mainAbilityInfo.labelId != 0) && (mainAbilityInfo.iconId != 0)) {
5049 applicationInfo.labelId = mainAbilityInfo.labelId ;
5050 applicationInfo.labelResource.id = mainAbilityInfo.labelId;
5051 applicationInfo.labelResource.moduleName = mainAbilityInfo.moduleName;
5052 applicationInfo.labelResource.bundleName = mainAbilityInfo.bundleName;
5053
5054 applicationInfo.iconId = mainAbilityInfo.iconId ;
5055 applicationInfo.iconResource.id = mainAbilityInfo.iconId;
5056 applicationInfo.iconResource.moduleName = mainAbilityInfo.moduleName;
5057 applicationInfo.iconResource.bundleName = mainAbilityInfo.bundleName;
5058 }
5059 if (item.second.isEntry) {
5060 return;
5061 }
5062 }
5063 }
5064 }
5065
GetCloneBundleAppIndexes() const5066 std::set<int32_t> InnerBundleInfo::GetCloneBundleAppIndexes() const
5067 {
5068 std::set<int32_t> appIndexes;
5069 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
5070 for (const auto &cloneInfo : innerBundleUserInfo.second.cloneInfos) {
5071 appIndexes.insert(cloneInfo.second.appIndex);
5072 }
5073 }
5074 return appIndexes;
5075 }
5076
GetSanitizerFlag(GetInnerModuleInfoFlag flag)5077 uint8_t InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag flag)
5078 {
5079 return 1 << (static_cast<uint8_t>(flag) - 1);
5080 }
5081
PrintSetEnabledInfo(bool isEnabled,int32_t userId,int32_t appIndex,const std::string & bundleName,const std::string & caller) const5082 void InnerBundleInfo::PrintSetEnabledInfo(bool isEnabled, int32_t userId, int32_t appIndex,
5083 const std::string &bundleName, const std::string &caller) const
5084 {
5085 if (!isEnabled) {
5086 APP_LOGW_NOFUNC("-n %{public}s -u %{public}d -i %{public}d disabled caller is %{public}s",
5087 bundleName.c_str(), userId, appIndex, caller.c_str());
5088 }
5089 }
5090
SetDFXParamStatus()5091 void InnerBundleInfo::SetDFXParamStatus()
5092 {
5093 SetAsanEnabled(IsAsanEnabled());
5094 SetGwpAsanEnabled(IsGwpAsanEnabled());
5095 SetTsanEnabled(IsTsanEnabled());
5096 SetHwasanEnabled(IsHwasanEnabled());
5097 SetUbsanEnabled(IsUbsanEnabled());
5098 }
5099
ConvertPluginBundleInfo(const std::string & bundleName,PluginBundleInfo & pluginBundleInfo) const5100 bool InnerBundleInfo::ConvertPluginBundleInfo(const std::string &bundleName,
5101 PluginBundleInfo &pluginBundleInfo) const
5102 {
5103 pluginBundleInfo.pluginBundleName = GetBundleName();
5104 pluginBundleInfo.versionCode = baseBundleInfo_->versionCode;
5105 pluginBundleInfo.versionName = baseBundleInfo_->versionName;
5106 pluginBundleInfo.label = baseApplicationInfo_->label;
5107 pluginBundleInfo.appIdentifier = GetAppIdentifier();
5108 pluginBundleInfo.appId = baseBundleInfo_->appId;
5109 pluginBundleInfo.icon = baseApplicationInfo_->icon;
5110 pluginBundleInfo.labelId = baseApplicationInfo_->labelId;
5111 pluginBundleInfo.iconId = baseApplicationInfo_->iconId;
5112 pluginBundleInfo.codePath = baseApplicationInfo_->codePath;
5113 pluginBundleInfo.nativeLibraryPath = bundleName + ServiceConstants::PATH_SEPARATOR +
5114 baseApplicationInfo_->nativeLibraryPath;
5115 for (const auto &item : baseAbilityInfos_) {
5116 pluginBundleInfo.abilityInfos.try_emplace(item.first, InnerAbilityInfo::ConvertToAbilityInfo(item.second));
5117 }
5118 pluginBundleInfo.appInfo = *baseApplicationInfo_;
5119 pluginBundleInfo.appInfo.arkTSMode = GetApplicationArkTSMode();
5120 for (const auto &info : innerModuleInfos_) {
5121 PluginModuleInfo pluginModuleInfo;
5122 pluginModuleInfo.moduleName = info.second.name;
5123 pluginModuleInfo.hapPath = info.second.hapPath;
5124 pluginModuleInfo.cpuAbi = info.second.cpuAbi;
5125 pluginModuleInfo.nativeLibraryPath = bundleName + ServiceConstants::PATH_SEPARATOR +
5126 info.second.nativeLibraryPath;
5127 pluginModuleInfo.nativeLibraryFileNames = info.second.nativeLibraryFileNames;
5128 pluginModuleInfo.descriptionId = info.second.descriptionId;
5129 pluginModuleInfo.description = info.second.description;
5130 pluginModuleInfo.compressNativeLibs = info.second.compressNativeLibs;
5131 pluginModuleInfo.isLibIsolated = info.second.isLibIsolated;
5132 pluginModuleInfo.packageName = info.second.packageName;
5133 pluginModuleInfo.compileMode = info.second.compileMode;
5134 pluginBundleInfo.pluginModuleInfos.emplace_back(pluginModuleInfo);
5135 ModuleInfo moduleInfo;
5136 moduleInfo.moduleName = info.second.name;
5137 moduleInfo.preloads = info.second.preloads;
5138 if (info.second.hapPath.empty()) {
5139 moduleInfo.moduleSourceDir = info.second.modulePath;
5140 pluginBundleInfo.appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
5141 }
5142 pluginBundleInfo.appInfo.moduleInfos.emplace_back(moduleInfo);
5143 }
5144 return true;
5145 }
5146
AddPluginBundleInfo(const PluginBundleInfo & pluginBundleInfo,const int32_t userId)5147 bool InnerBundleInfo::AddPluginBundleInfo(const PluginBundleInfo &pluginBundleInfo, const int32_t userId)
5148 {
5149 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
5150 auto infoItem = innerBundleUserInfos_.find(key);
5151 if (infoItem == innerBundleUserInfos_.end()) {
5152 APP_LOGE("add pluginBundleInfo:%{public}s failed, userId: %{public}d not found in bundleName:%{public}s",
5153 pluginBundleInfo.pluginBundleName.c_str(), userId, GetBundleName().c_str());
5154 return false;
5155 }
5156 auto &pluginSet = infoItem->second.installedPluginSet;
5157 pluginSet.insert(pluginBundleInfo.pluginBundleName);
5158 pluginBundleInfos_[pluginBundleInfo.pluginBundleName] = pluginBundleInfo;
5159 APP_LOGD("bundleName: %{public}s add plugin info, userId: %{public}d, plugin:%{public}s",
5160 GetBundleName().c_str(), userId, pluginBundleInfo.pluginBundleName.c_str());
5161 return true;
5162 }
5163
RemovePluginBundleInfo(const std::string & pluginBundleName,const int32_t userId)5164 bool InnerBundleInfo::RemovePluginBundleInfo(const std::string &pluginBundleName, const int32_t userId)
5165 {
5166 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
5167 auto infoItem = innerBundleUserInfos_.find(key);
5168 if (infoItem == innerBundleUserInfos_.end()) {
5169 APP_LOGE("remove pluginBundleInfo:%{public}s failed, userId: %{public}d not found in bundleName:%{public}s",
5170 pluginBundleName.c_str(), userId, GetBundleName().c_str());
5171 return false;
5172 }
5173 auto &pluginSet = infoItem->second.installedPluginSet;
5174 pluginSet.erase(pluginBundleName);
5175 pluginBundleInfos_.erase(pluginBundleName);
5176 APP_LOGD("bundleName: %{public}s remove plugin info, userId: %{public}d, plugin:%{public}s",
5177 GetBundleName().c_str(), userId, pluginBundleName.c_str());
5178 return true;
5179 }
5180
HasMultiUserPlugin(const std::string & pluginBundleName) const5181 bool InnerBundleInfo::HasMultiUserPlugin(const std::string &pluginBundleName) const
5182 {
5183 if (innerBundleUserInfos_.size() <= 1) {
5184 return false;
5185 }
5186 int32_t cnt = 0;
5187 for (auto &info : innerBundleUserInfos_) {
5188 if (info.second.IsPluginInstalled(pluginBundleName)) {
5189 cnt++;
5190 }
5191 }
5192 return cnt > 1;
5193 }
5194
UpdatePluginBundleInfo(const PluginBundleInfo & pluginBundleInfo)5195 bool InnerBundleInfo::UpdatePluginBundleInfo(const PluginBundleInfo &pluginBundleInfo)
5196 {
5197 auto it = pluginBundleInfos_.find(pluginBundleInfo.pluginBundleName);
5198 if (it == pluginBundleInfos_.end()) {
5199 APP_LOGW("bundleName: %{public}s can not find plugin:%{public}s",
5200 GetBundleName().c_str(), pluginBundleInfo.pluginBundleName.c_str());
5201 return false;
5202 }
5203 it->second = pluginBundleInfo;
5204 return true;
5205 }
5206
RemovePluginFromUserInfo(const std::string & pluginBundleName,const int32_t userId)5207 bool InnerBundleInfo::RemovePluginFromUserInfo(const std::string &pluginBundleName, const int32_t userId)
5208 {
5209 auto key = NameAndUserIdToKey(GetBundleName(), userId);
5210 auto infoItem = innerBundleUserInfos_.find(key);
5211 if (infoItem == innerBundleUserInfos_.end()) {
5212 APP_LOGE("remove plugin:%{public}s from userInfo failed, userId: %{public}d not found in bundleName:%{public}s",
5213 pluginBundleName.c_str(), userId, GetBundleName().c_str());
5214 return false;
5215 }
5216 auto &pluginSet = infoItem->second.installedPluginSet;
5217 pluginSet.erase(pluginBundleName);
5218 APP_LOGD("bundleName: %{public}s remove plugin from userInfo, userId: %{public}d, plugin:%{public}s",
5219 GetBundleName().c_str(), userId, pluginBundleName.c_str());
5220 return true;
5221 }
5222
GetPluginBundleInfos(const int32_t userId,std::unordered_map<std::string,PluginBundleInfo> & pluginBundleInfos) const5223 bool InnerBundleInfo::GetPluginBundleInfos(const int32_t userId,
5224 std::unordered_map<std::string, PluginBundleInfo> &pluginBundleInfos) const
5225 {
5226 InnerBundleUserInfo innerBundleUserInfo;
5227 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
5228 APP_LOGD("can not find userId %{public}d when GetPluginBundleInfos", userId);
5229 return false;
5230 }
5231 for (const auto &pluginName : innerBundleUserInfo.installedPluginSet) {
5232 auto it = pluginBundleInfos_.find(pluginName);
5233 if (it != pluginBundleInfos_.end()) {
5234 pluginBundleInfos.emplace(it->first, it->second);
5235 }
5236 }
5237 return true;
5238 }
5239
GetCurDynamicIconModule() const5240 const std::string InnerBundleInfo::GetCurDynamicIconModule() const
5241 {
5242 return curDynamicIconModule_;
5243 }
5244
SetCurDynamicIconModule(const std::string & curDynamicIconModule)5245 void InnerBundleInfo::SetCurDynamicIconModule(const std::string &curDynamicIconModule)
5246 {
5247 curDynamicIconModule_ = curDynamicIconModule;
5248 for (auto &item : innerBundleUserInfos_) {
5249 item.second.curDynamicIconModule = curDynamicIconModule_;
5250 for (auto &cloneInfo : item.second.cloneInfos) {
5251 cloneInfo.second.curDynamicIconModule = curDynamicIconModule_;
5252 }
5253 }
5254 }
5255
GetCurDynamicIconModule(const int32_t userId,const int32_t appIndex) const5256 const std::string InnerBundleInfo::GetCurDynamicIconModule(const int32_t userId, const int32_t appIndex) const
5257 {
5258 if ((userId == Constants::UNSPECIFIED_USERID) && (appIndex == Constants::DEFAULT_APP_INDEX)) {
5259 return GetCurDynamicIconModule();
5260 }
5261 std::string key = NameAndUserIdToKey(GetBundleName(), userId);
5262 auto infoItem = innerBundleUserInfos_.find(key);
5263 if (infoItem == innerBundleUserInfos_.end()) {
5264 APP_LOGE("can not find bundleUserInfo in userId: %{public}d", userId);
5265 return "";
5266 }
5267 if (appIndex == 0) {
5268 return infoItem->second.curDynamicIconModule;
5269 }
5270
5271 std::string cloneInfoKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
5272 auto cloneInfoItem = infoItem->second.cloneInfos.find(cloneInfoKey);
5273 if (cloneInfoItem == infoItem->second.cloneInfos.end()) {
5274 APP_LOGE("can not find cloneInfo in userId: %{public}d appIndex: %{public}d", userId, appIndex);
5275 return "";
5276 }
5277 return cloneInfoItem->second.curDynamicIconModule;
5278 }
5279
SetCurDynamicIconModule(const std::string & curDynamicIconModule,const int32_t userId,const int32_t appIndex)5280 bool InnerBundleInfo::SetCurDynamicIconModule(
5281 const std::string &curDynamicIconModule, const int32_t userId, const int32_t appIndex)
5282 {
5283 if ((userId == Constants::UNSPECIFIED_USERID) && (appIndex == Constants::DEFAULT_APP_INDEX)) {
5284 SetCurDynamicIconModule(curDynamicIconModule);
5285 return true;
5286 }
5287 std::string key = NameAndUserIdToKey(GetBundleName(), userId);
5288 auto infoItem = innerBundleUserInfos_.find(key);
5289 if (infoItem == innerBundleUserInfos_.end()) {
5290 APP_LOGE("can not find bundleUserInfo in userId: %{public}d", userId);
5291 return false;
5292 }
5293 if (appIndex == 0) {
5294 infoItem->second.curDynamicIconModule = curDynamicIconModule;
5295 return true;
5296 }
5297
5298 std::string cloneInfoKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
5299 auto cloneInfoItem = infoItem->second.cloneInfos.find(cloneInfoKey);
5300 if (cloneInfoItem == infoItem->second.cloneInfos.end()) {
5301 APP_LOGE("can not find cloneInfo in userId: %{public}d appIndex: %{public}d", userId, appIndex);
5302 return false;
5303 }
5304 cloneInfoItem->second.curDynamicIconModule = curDynamicIconModule;
5305 return true;
5306 }
5307
IsDynamicIconModuleExist() const5308 bool InnerBundleInfo::IsDynamicIconModuleExist() const
5309 {
5310 for (const auto &item : innerBundleUserInfos_) {
5311 if (!item.second.curDynamicIconModule.empty()) {
5312 return true;
5313 }
5314 for (const auto &clone : item.second.cloneInfos) {
5315 if (!clone.second.curDynamicIconModule.empty()) {
5316 return true;
5317 }
5318 }
5319 }
5320 return false;
5321 }
5322
GetAllDynamicIconInfo(const int32_t userId,std::vector<DynamicIconInfo> & dynamicIconInfos) const5323 void InnerBundleInfo::GetAllDynamicIconInfo(const int32_t userId, std::vector<DynamicIconInfo> &dynamicIconInfos) const
5324 {
5325 for (const auto &item : innerBundleUserInfos_) {
5326 if ((userId != Constants::UNSPECIFIED_USERID) && (userId != item.second.bundleUserInfo.userId)) {
5327 continue;
5328 }
5329 DynamicIconInfo dynamicIconInfo;
5330 dynamicIconInfo.bundleName = GetBundleName();
5331 if (!item.second.curDynamicIconModule.empty()) {
5332 dynamicIconInfo.moduleName = item.second.curDynamicIconModule;
5333 dynamicIconInfo.userId = item.second.bundleUserInfo.userId;
5334 dynamicIconInfo.appIndex = 0;
5335 dynamicIconInfos.emplace_back(dynamicIconInfo);
5336 }
5337 for (const auto &clone : item.second.cloneInfos) {
5338 if (!clone.second.curDynamicIconModule.empty()) {
5339 dynamicIconInfo.moduleName = clone.second.curDynamicIconModule;
5340 dynamicIconInfo.userId = clone.second.userId;
5341 dynamicIconInfo.appIndex = clone.second.appIndex;
5342 dynamicIconInfos.emplace_back(dynamicIconInfo);
5343 }
5344 }
5345 }
5346 }
5347
SetInnerModuleAtomicResizeable(const std::string & moduleName,bool resizeable)5348 bool InnerBundleInfo::SetInnerModuleAtomicResizeable(const std::string &moduleName, bool resizeable)
5349 {
5350 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
5351 APP_LOGE("innerBundleInfo does not contain the module");
5352 return false;
5353 }
5354 innerModuleInfos_.at(moduleName).resizeable = resizeable;
5355 return true;
5356 }
5357
GetApplicationArkTSMode() const5358 std::string InnerBundleInfo::GetApplicationArkTSMode() const
5359 {
5360 size_t dynamicCnt = 0;
5361 size_t staticCnt = 0;
5362 for (const auto& [moduleName, innerModuleInfo] : innerModuleInfos_) {
5363 if (innerModuleInfo.moduleArkTSMode == Constants::ARKTS_MODE_DYNAMIC) {
5364 dynamicCnt++;
5365 }
5366 if (innerModuleInfo.moduleArkTSMode == Constants::ARKTS_MODE_STATIC) {
5367 staticCnt++;
5368 }
5369 }
5370
5371 size_t moduleSize = innerModuleInfos_.size();
5372 if (dynamicCnt == moduleSize) {
5373 return Constants::ARKTS_MODE_DYNAMIC;
5374 }
5375 if (staticCnt == moduleSize) {
5376 return Constants::ARKTS_MODE_STATIC;
5377 }
5378 return Constants::ARKTS_MODE_HYBRID;
5379 }
5380
GetModuleArkTSMode(const std::string & moduleName) const5381 std::string InnerBundleInfo::GetModuleArkTSMode(const std::string &moduleName) const
5382 {
5383 auto item = innerModuleInfos_.find(moduleName);
5384 if (item == innerModuleInfos_.end()) {
5385 APP_LOGW_NOFUNC("moduleName %{public}s not exist", moduleName.c_str());
5386 return Constants::EMPTY_STRING;
5387 }
5388 return item->second.moduleArkTSMode;
5389 }
5390
UpdateHasCloudkitConfig()5391 void InnerBundleInfo::UpdateHasCloudkitConfig()
5392 {
5393 std::string entryModuleName = GetEntryModuleName();
5394 auto item = innerModuleInfos_.find(entryModuleName);
5395 if (item == innerModuleInfos_.end()) {
5396 APP_LOGE("entry module info is not found");
5397 return;
5398 }
5399 BundleExtractor bundleExtractor(item->second.hapPath);
5400 if (!bundleExtractor.Init()) {
5401 APP_LOGE("bundle extractor init failed");
5402 return;
5403 }
5404 bool hasConfig = bundleExtractor.HasEntry(ServiceConstants::CLOUD_PROFILE_PATH);
5405 APP_LOGD("cloudkit config exist: %{public}d", hasConfig);
5406 if (hasConfig) {
5407 BundleUtil::SetBit(InnerModuleInfoBoolFlag::HAS_CLOUD_KIT_CONFIG, item->second.boolSet);
5408 } else {
5409 BundleUtil::ResetBit(InnerModuleInfoBoolFlag::HAS_CLOUD_KIT_CONFIG, item->second.boolSet);
5410 }
5411 }
5412 } // namespace AppExecFwk
5413 } // namespace OHOS
5414