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