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