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_->configuration = applicationInfo.configuration;
1892 }
1893
GetApplicationEnabledV9(int32_t userId,bool & isEnabled,int32_t appIndex) const1894 ErrCode InnerBundleInfo::GetApplicationEnabledV9(int32_t userId, bool &isEnabled, int32_t appIndex) const
1895 {
1896 InnerBundleUserInfo innerBundleUserInfo;
1897 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1898 APP_LOGD("can not find bundleUserInfo in userId: %{public}d when GetApplicationEnabled", userId);
1899 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1900 }
1901 if (appIndex == 0) {
1902 isEnabled = innerBundleUserInfo.bundleUserInfo.enabled;
1903 PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1904 innerBundleUserInfo.bundleUserInfo.setEnabledCaller);
1905 return ERR_OK;
1906 } else if (appIndex > 0 && appIndex <= Constants::INITIAL_SANDBOX_APP_INDEX) {
1907 const std::map<std::string, InnerBundleCloneInfo> mpCloneInfos = innerBundleUserInfo.cloneInfos;
1908 std::string key = InnerBundleUserInfo::AppIndexToKey(appIndex);
1909 if (mpCloneInfos.find(key) == mpCloneInfos.end()) {
1910 return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
1911 }
1912 isEnabled = mpCloneInfos.at(key).enabled;
1913 PrintSetEnabledInfo(isEnabled, userId, appIndex, innerBundleUserInfo.bundleName,
1914 mpCloneInfos.at(key).setEnabledCaller);
1915 return ERR_OK;
1916 } else {
1917 return ERR_APPEXECFWK_APP_INDEX_OUT_OF_RANGE;
1918 }
1919 }
1920
UpdateAppDetailAbilityAttrs()1921 void InnerBundleInfo::UpdateAppDetailAbilityAttrs()
1922 {
1923 if (IsExistLauncherAbility()) {
1924 baseApplicationInfo_->needAppDetail = false;
1925 baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
1926 }
1927 for (auto iter = baseAbilityInfos_.begin(); iter != baseAbilityInfos_.end(); ++iter) {
1928 if (iter->second.name == ServiceConstants::APP_DETAIL_ABILITY) {
1929 baseAbilityInfos_.erase(iter);
1930 return;
1931 }
1932 }
1933 }
1934
IsHideDesktopIcon() const1935 bool InnerBundleInfo::IsHideDesktopIcon() const
1936 {
1937 return baseApplicationInfo_->hideDesktopIcon ? true : !IsExistLauncherAbility();
1938 }
1939
IsExistLauncherAbility() const1940 bool InnerBundleInfo::IsExistLauncherAbility() const
1941 {
1942 bool isExistLauncherAbility = false;
1943 OHOS::AAFwk::Want want;
1944 want.SetAction(OHOS::AAFwk::Want::ACTION_HOME);
1945 want.AddEntity(OHOS::AAFwk::Want::ENTITY_HOME);
1946 for (const auto& abilityInfoPair : baseAbilityInfos_) {
1947 auto skillsPair = skillInfos_.find(abilityInfoPair.first);
1948 if (skillsPair == skillInfos_.end()) {
1949 continue;
1950 }
1951 for (const Skill& skill : skillsPair->second) {
1952 if (skill.MatchLauncher(want) && (abilityInfoPair.second.type == AbilityType::PAGE)) {
1953 isExistLauncherAbility = true;
1954 break;
1955 }
1956 }
1957 }
1958 return isExistLauncherAbility;
1959 }
1960
UpdateNativeLibAttrs(const ApplicationInfo & applicationInfo)1961 void InnerBundleInfo::UpdateNativeLibAttrs(const ApplicationInfo &applicationInfo)
1962 {
1963 baseApplicationInfo_->cpuAbi = applicationInfo.cpuAbi;
1964 baseApplicationInfo_->nativeLibraryPath = applicationInfo.nativeLibraryPath;
1965 }
1966
UpdateArkNativeAttrs(const ApplicationInfo & applicationInfo)1967 void InnerBundleInfo::UpdateArkNativeAttrs(const ApplicationInfo &applicationInfo)
1968 {
1969 baseApplicationInfo_->arkNativeFileAbi = applicationInfo.arkNativeFileAbi;
1970 baseApplicationInfo_->arkNativeFilePath = applicationInfo.arkNativeFilePath;
1971 }
1972
UpdatePrivilegeCapability(const ApplicationInfo & applicationInfo)1973 void InnerBundleInfo::UpdatePrivilegeCapability(const ApplicationInfo &applicationInfo)
1974 {
1975 SetKeepAlive(applicationInfo.keepAlive);
1976 baseApplicationInfo_->runningResourcesApply = applicationInfo.runningResourcesApply;
1977 baseApplicationInfo_->associatedWakeUp = applicationInfo.associatedWakeUp;
1978 SetAllowCommonEvent(applicationInfo.allowCommonEvent);
1979 SetAllowAppRunWhenDeviceFirstLocked(applicationInfo.allowAppRunWhenDeviceFirstLocked);
1980 baseApplicationInfo_->resourcesApply = applicationInfo.resourcesApply;
1981 baseApplicationInfo_->allowEnableNotification = applicationInfo.allowEnableNotification;
1982 if (applicationInfo.hideDesktopIcon) {
1983 SetHideDesktopIcon(true);
1984 }
1985 }
1986
UpdateRemovable(bool isPreInstall,bool removable)1987 void InnerBundleInfo::UpdateRemovable(bool isPreInstall, bool removable)
1988 {
1989 #ifdef USE_PRE_BUNDLE_PROFILE
1990 if (!isPreInstall) {
1991 return;
1992 }
1993 #endif
1994
1995 baseApplicationInfo_->removable = removable;
1996 }
1997
UpdateModuleInfo(const InnerBundleInfo & newInfo)1998 void InnerBundleInfo::UpdateModuleInfo(const InnerBundleInfo &newInfo)
1999 {
2000 if (newInfo.currentPackage_.empty()) {
2001 APP_LOGE("no package in new info");
2002 return;
2003 }
2004
2005 RemoveModuleInfo(newInfo.currentPackage_);
2006 AddInnerModuleInfo(newInfo.innerModuleInfos_);
2007 AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
2008 AddModuleSkillInfo(newInfo.skillInfos_);
2009 AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
2010 AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
2011 AddModuleFormInfo(newInfo.formInfos_);
2012 AddModuleShortcutInfo(newInfo.shortcutInfos_);
2013 AddModuleCommonEvent(newInfo.commonEvents_);
2014 UpdateIsCompressNativeLibs();
2015 }
2016
GetMaxVerBaseSharedBundleInfo(const std::string & moduleName,BaseSharedBundleInfo & baseSharedBundleInfo) const2017 bool InnerBundleInfo::GetMaxVerBaseSharedBundleInfo(const std::string &moduleName,
2018 BaseSharedBundleInfo &baseSharedBundleInfo) const
2019 {
2020 auto it = innerSharedModuleInfos_.find(moduleName);
2021 if (it == innerSharedModuleInfos_.end()) {
2022 APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2023 return false;
2024 }
2025 auto sharedModuleInfoVector = it->second;
2026 if (sharedModuleInfoVector.empty()) {
2027 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2028 return false;
2029 }
2030 InnerModuleInfo innerModuleInfo = sharedModuleInfoVector.front();
2031 if (innerModuleInfo.bundleType != BundleType::SHARED) {
2032 APP_LOGE("GetMaxVerBaseSharedBundleInfo failed, bundleType is invalid");
2033 return false;
2034 }
2035 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2036 baseSharedBundleInfo.moduleName = innerModuleInfo.moduleName;
2037 baseSharedBundleInfo.versionCode = innerModuleInfo.versionCode;
2038 baseSharedBundleInfo.nativeLibraryPath = innerModuleInfo.nativeLibraryPath;
2039 baseSharedBundleInfo.hapPath = innerModuleInfo.hapPath;
2040 baseSharedBundleInfo.compressNativeLibs = innerModuleInfo.compressNativeLibs;
2041 baseSharedBundleInfo.nativeLibraryFileNames = innerModuleInfo.nativeLibraryFileNames;
2042 return true;
2043 }
2044
GetBaseSharedBundleInfo(const std::string & moduleName,uint32_t versionCode,BaseSharedBundleInfo & baseSharedBundleInfo) const2045 bool InnerBundleInfo::GetBaseSharedBundleInfo(const std::string &moduleName, uint32_t versionCode,
2046 BaseSharedBundleInfo &baseSharedBundleInfo) const
2047 {
2048 auto it = innerSharedModuleInfos_.find(moduleName);
2049 if (it == innerSharedModuleInfos_.end()) {
2050 APP_LOGE("The shared module(%{public}s) infomation not exist", moduleName.c_str());
2051 return false;
2052 }
2053 auto sharedModuleInfoVector = it->second;
2054 if (sharedModuleInfoVector.empty()) {
2055 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
2056 return false;
2057 }
2058 for (const auto &item : sharedModuleInfoVector) {
2059 if (item.bundleType != BundleType::SHARED) {
2060 APP_LOGE("GetBaseSharedBundleInfo failed, bundleType is invalid");
2061 return false;
2062 }
2063 if (item.versionCode == versionCode) {
2064 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
2065 baseSharedBundleInfo.moduleName = item.moduleName;
2066 baseSharedBundleInfo.versionCode = item.versionCode;
2067 baseSharedBundleInfo.nativeLibraryPath = item.nativeLibraryPath;
2068 baseSharedBundleInfo.hapPath = item.hapPath;
2069 baseSharedBundleInfo.compressNativeLibs = item.compressNativeLibs;
2070 baseSharedBundleInfo.nativeLibraryFileNames = item.nativeLibraryFileNames;
2071 return true;
2072 }
2073 }
2074 APP_LOGE("GetBaseSharedBundleInfo failed, the version(%{public}d) not exists for this module(%{public}s)",
2075 versionCode, moduleName.c_str());
2076 return false;
2077 }
2078
InsertInnerSharedModuleInfo(const std::string & moduleName,const InnerModuleInfo & innerModuleInfo)2079 void InnerBundleInfo::InsertInnerSharedModuleInfo(const std::string &moduleName,
2080 const InnerModuleInfo &innerModuleInfo)
2081 {
2082 auto iterator = innerSharedModuleInfos_.find(moduleName);
2083 if (iterator != innerSharedModuleInfos_.end()) {
2084 auto innerModuleInfoVector = iterator->second;
2085 bool insertFlag = false;
2086 for (unsigned long i = 0; i < innerModuleInfoVector.size(); i++) {
2087 if (innerModuleInfo.versionCode == innerModuleInfoVector.at(i).versionCode) {
2088 // if the inserted versionCode same as the existing one, replace old innerModuleInfo.
2089 innerModuleInfoVector.at(i) = innerModuleInfo;
2090 insertFlag = true;
2091 break;
2092 } else if (innerModuleInfo.versionCode > innerModuleInfoVector.at(i).versionCode) {
2093 // if the inserted versionCode bigger then the existing one, insert the specified location.
2094 innerModuleInfoVector.emplace(innerModuleInfoVector.begin() + i, innerModuleInfo);
2095 insertFlag = true;
2096 break;
2097 } else {
2098 continue;
2099 }
2100 }
2101 if (!insertFlag) {
2102 // insert innerModuleInfo in last location.
2103 innerModuleInfoVector.emplace(innerModuleInfoVector.end(), innerModuleInfo);
2104 }
2105 innerSharedModuleInfos_[moduleName] = innerModuleInfoVector;
2106 } else {
2107 std::vector<InnerModuleInfo> newInnerModuleInfoVector;
2108 newInnerModuleInfoVector.emplace_back(innerModuleInfo);
2109 innerSharedModuleInfos_.try_emplace(moduleName, newInnerModuleInfoVector);
2110 }
2111 }
2112
SetSharedModuleNativeLibraryPath(const std::string & nativeLibraryPath)2113 void InnerBundleInfo::SetSharedModuleNativeLibraryPath(const std::string &nativeLibraryPath)
2114 {
2115 auto sharedModuleInfoIterator = innerSharedModuleInfos_.find(currentPackage_);
2116 auto moduleInfoIterator = innerModuleInfos_.find(currentPackage_);
2117 if ((sharedModuleInfoIterator == innerSharedModuleInfos_.end()) ||
2118 (moduleInfoIterator == innerModuleInfos_.end())) {
2119 APP_LOGE("The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
2120 return;
2121 }
2122 auto &innerModuleInfoVector = sharedModuleInfoIterator->second;
2123 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
2124 if (iter->versionCode == moduleInfoIterator->second.versionCode) {
2125 iter->nativeLibraryPath = nativeLibraryPath;
2126 return;
2127 }
2128 }
2129 }
2130
GetSharedBundleInfo(SharedBundleInfo & sharedBundleInfo) const2131 bool InnerBundleInfo::GetSharedBundleInfo(SharedBundleInfo &sharedBundleInfo) const
2132 {
2133 sharedBundleInfo.name = GetBundleName();
2134 sharedBundleInfo.compatiblePolicy = CompatiblePolicy::BACKWARD_COMPATIBILITY;
2135 std::vector<SharedModuleInfo> sharedModuleInfos;
2136 for (const auto &infoVector : innerSharedModuleInfos_) {
2137 for (const auto &info : infoVector.second) {
2138 SharedModuleInfo sharedModuleInfo;
2139 sharedModuleInfo.name = info.name;
2140 sharedModuleInfo.versionCode = info.versionCode;
2141 sharedModuleInfo.versionName = info.versionName;
2142 sharedModuleInfo.description = info.description;
2143 sharedModuleInfo.descriptionId = info.descriptionId;
2144 sharedModuleInfo.compressNativeLibs = info.compressNativeLibs;
2145 sharedModuleInfo.hapPath = info.hapPath;
2146 sharedModuleInfo.cpuAbi = info.cpuAbi;
2147 sharedModuleInfo.nativeLibraryPath = info.nativeLibraryPath;
2148 sharedModuleInfo.nativeLibraryFileNames = info.nativeLibraryFileNames;
2149 sharedModuleInfos.emplace_back(sharedModuleInfo);
2150 }
2151 }
2152 sharedBundleInfo.sharedModuleInfos = sharedModuleInfos;
2153 return true;
2154 }
2155
GetSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2156 bool InnerBundleInfo::GetSharedDependencies(const std::string &moduleName,
2157 std::vector<Dependency> &dependencies) const
2158 {
2159 if (innerModuleInfos_.find(moduleName) != innerModuleInfos_.end()) {
2160 dependencies = innerModuleInfos_.at(moduleName).dependencies;
2161 return true;
2162 }
2163 APP_LOGE("GetSharedDependencies not find module %{public}s", moduleName.c_str());
2164 return false;
2165 }
2166
GetAllSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const2167 bool InnerBundleInfo::GetAllSharedDependencies(const std::string &moduleName,
2168 std::vector<Dependency> &dependencies) const
2169 {
2170 if (!GetSharedDependencies(moduleName, dependencies)) {
2171 return false;
2172 }
2173 std::deque<Dependency> dependenciesDeque;
2174 std::copy(dependencies.begin(), dependencies.end(), std::back_inserter(dependenciesDeque));
2175 dependencies.clear();
2176 while (!dependenciesDeque.empty()) {
2177 bool isAdd = true;
2178 Dependency itemDependency = dependenciesDeque.front();
2179 dependenciesDeque.pop_front();
2180 for (const auto &item : dependencies) {
2181 if (item.bundleName == itemDependency.bundleName && item.moduleName == itemDependency.moduleName &&
2182 item.versionCode == itemDependency.versionCode) {
2183 isAdd = false;
2184 break;
2185 }
2186 }
2187 if (isAdd) {
2188 dependencies.push_back(itemDependency);
2189 std::vector<Dependency> tempDependencies;
2190 if (GetSharedDependencies(itemDependency.moduleName, tempDependencies)) {
2191 std::copy(tempDependencies.begin(), tempDependencies.end(), std::back_inserter(dependenciesDeque));
2192 }
2193 }
2194 }
2195 return true;
2196 }
2197
RemoveModuleInfo(const std::string & modulePackage)2198 void InnerBundleInfo::RemoveModuleInfo(const std::string &modulePackage)
2199 {
2200 auto it = innerModuleInfos_.find(modulePackage);
2201 if (it == innerModuleInfos_.end()) {
2202 APP_LOGE("The module(%{public}s) infomation not exist", modulePackage.c_str());
2203 return;
2204 }
2205
2206 auto oldModuleInfo = it->second;
2207 if (oldModuleInfo.isEntry) {
2208 baseBundleInfo_->mainEntry.clear();
2209 baseBundleInfo_->entryModuleName.clear();
2210 }
2211 innerModuleInfos_.erase(it);
2212 std::string key;
2213 key.append(".").append(modulePackage).append(".");
2214 for (auto iter = shortcutInfos_.begin(); iter != shortcutInfos_.end();) {
2215 if (iter->first.find(key) != std::string::npos) {
2216 shortcutInfos_.erase(iter++);
2217 } else {
2218 ++iter;
2219 }
2220 }
2221
2222 for (auto iter = commonEvents_.begin(); iter != commonEvents_.end();) {
2223 if (iter->first.find(key) != std::string::npos) {
2224 commonEvents_.erase(iter++);
2225 } else {
2226 ++iter;
2227 }
2228 }
2229
2230 // delete old abilityInfos
2231 for (auto abilityKey : oldModuleInfo.abilityKeys) {
2232 auto abilityItem = baseAbilityInfos_.find(abilityKey);
2233 if (abilityItem == baseAbilityInfos_.end()) {
2234 continue;
2235 }
2236
2237 baseAbilityInfos_.erase(abilityItem);
2238 formInfos_.erase(abilityKey);
2239 }
2240
2241 // delete old skillInfos
2242 for (auto skillKey : oldModuleInfo.skillKeys) {
2243 auto skillItem = skillInfos_.find(skillKey);
2244 if (skillItem == skillInfos_.end()) {
2245 continue;
2246 }
2247
2248 skillInfos_.erase(skillItem);
2249 }
2250
2251 // delete old extensionInfos
2252 for (auto extensionKey : oldModuleInfo.extensionKeys) {
2253 auto extensionItem = baseExtensionInfos_.find(extensionKey);
2254 if (extensionItem == baseExtensionInfos_.end()) {
2255 continue;
2256 }
2257
2258 baseExtensionInfos_.erase(extensionItem);
2259 }
2260
2261 // delete old extensionSkillInfos
2262 for (auto extensionSkillKey : oldModuleInfo.extensionSkillKeys) {
2263 auto extensionSkillItem = extensionSkillInfos_.find(extensionSkillKey);
2264 if (extensionSkillItem == extensionSkillInfos_.end()) {
2265 continue;
2266 }
2267
2268 extensionSkillInfos_.erase(extensionSkillItem);
2269 }
2270 }
2271
ToString() const2272 std::string InnerBundleInfo::ToString() const
2273 {
2274 nlohmann::json j;
2275 ToJson(j);
2276 return j.dump();
2277 }
2278
GetApplicationInfo(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2279 void InnerBundleInfo::GetApplicationInfo(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2280 int32_t appIndex) const
2281 {
2282 InnerBundleUserInfo innerBundleUserInfo;
2283 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2284 LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2285 return;
2286 }
2287
2288 if (baseApplicationInfo_ == nullptr) {
2289 LOG_E(BMS_TAG_QUERY, "baseApplicationInfo_ is nullptr");
2290 return;
2291 }
2292 appInfo = *baseApplicationInfo_;
2293 if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2294 return;
2295 }
2296
2297 for (const auto &info : innerModuleInfos_) {
2298 bool deCompress = info.second.hapPath.empty();
2299 ModuleInfo moduleInfo;
2300 moduleInfo.moduleName = info.second.moduleName;
2301 if (deCompress) {
2302 moduleInfo.moduleSourceDir = info.second.modulePath;
2303 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2304 }
2305 if (info.second.hnpPackages.size() > 0) {
2306 appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2307 }
2308 moduleInfo.preloads = info.second.preloads;
2309 appInfo.moduleInfos.emplace_back(moduleInfo);
2310 if (deCompress && info.second.isEntry) {
2311 appInfo.entryDir = info.second.modulePath;
2312 }
2313 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_PERMISSION) ==
2314 GET_APPLICATION_INFO_WITH_PERMISSION) {
2315 for (const auto &item : info.second.requestPermissions) {
2316 appInfo.permissions.push_back(item.name);
2317 }
2318 }
2319 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_METADATA) == GET_APPLICATION_INFO_WITH_METADATA) {
2320 bool isModuleJson = info.second.isModuleJson;
2321 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2322 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2323 }
2324 if (isModuleJson && info.second.metadata.size() > 0) {
2325 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2326 }
2327 }
2328 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) !=
2329 GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) {
2330 appInfo.fingerprint.clear();
2331 }
2332 }
2333 if (!appInfo.permissions.empty()) {
2334 RemoveDuplicateName(appInfo.permissions);
2335 }
2336 appInfo.appIndex = appIndex;
2337 // The label and icon are first used under main ability
2338 AdaptMainLauncherResourceInfo(appInfo);
2339
2340 GetPreInstallApplicationFlags(appInfo);
2341 }
2342
GetApplicationInfoV9(int32_t flags,int32_t userId,ApplicationInfo & appInfo,int32_t appIndex) const2343 ErrCode InnerBundleInfo::GetApplicationInfoV9(int32_t flags, int32_t userId, ApplicationInfo &appInfo,
2344 int32_t appIndex) const
2345 {
2346 InnerBundleUserInfo innerBundleUserInfo;
2347 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2348 LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when get applicationInfo", userId);
2349 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2350 }
2351
2352 appInfo = *baseApplicationInfo_;
2353 if (!GetApplicationInfoAdaptBundleClone(innerBundleUserInfo, appIndex, appInfo)) {
2354 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
2355 }
2356
2357 for (const auto &info : innerModuleInfos_) {
2358 bool deCompress = info.second.hapPath.empty();
2359 ModuleInfo moduleInfo;
2360 moduleInfo.moduleName = info.second.moduleName;
2361 if (deCompress) {
2362 moduleInfo.moduleSourceDir = info.second.modulePath;
2363 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
2364 }
2365 if (info.second.hnpPackages.size() > 0) {
2366 appInfo.hnpPackages[info.second.moduleName] = info.second.hnpPackages;
2367 }
2368 moduleInfo.preloads = info.second.preloads;
2369 appInfo.moduleInfos.emplace_back(moduleInfo);
2370 if (deCompress && info.second.isEntry) {
2371 appInfo.entryDir = info.second.modulePath;
2372 }
2373 if ((static_cast<uint32_t>(flags) &
2374 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) ==
2375 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) {
2376 for (const auto &item : info.second.requestPermissions) {
2377 appInfo.permissions.push_back(item.name);
2378 }
2379 }
2380 if ((static_cast<uint32_t>(flags) &
2381 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) ==
2382 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) {
2383 bool isModuleJson = info.second.isModuleJson;
2384 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
2385 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
2386 }
2387 if (isModuleJson && info.second.metadata.size() > 0) {
2388 appInfo.metadata[info.second.moduleName] = info.second.metadata;
2389 }
2390 }
2391 }
2392 if (!appInfo.permissions.empty()) {
2393 RemoveDuplicateName(appInfo.permissions);
2394 }
2395 // The label and icon are first used under main ability
2396 AdaptMainLauncherResourceInfo(appInfo);
2397
2398 GetPreInstallApplicationFlags(appInfo);
2399 return ERR_OK;
2400 }
2401
GetPreInstallApplicationFlags(ApplicationInfo & appInfo) const2402 void InnerBundleInfo::GetPreInstallApplicationFlags(ApplicationInfo &appInfo) const
2403 {
2404 if (IsPreInstallApp()) {
2405 uint32_t applicationFlags = static_cast<uint32_t>(appInfo.applicationFlags);
2406 applicationFlags |= static_cast<uint32_t>(ApplicationInfoFlag::FLAG_PREINSTALLED_APP);
2407 appInfo.applicationFlags = static_cast<int32_t>(applicationFlags);
2408 for (const auto &moduleEnt: innerModuleInfos_) {
2409 const auto &hapPath = moduleEnt.second.hapPath;
2410 if (hapPath.find(Constants::BUNDLE_CODE_DIR) != 0) {
2411 return;
2412 }
2413 }
2414 applicationFlags |= static_cast<uint32_t>(ApplicationInfoFlag::FLAG_PREINSTALLED_APP_UPDATE);
2415 appInfo.applicationFlags = static_cast<int32_t>(applicationFlags);
2416 }
2417 }
2418
GetBundleInfo(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2419 bool InnerBundleInfo::GetBundleInfo(int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2420 {
2421 InnerBundleUserInfo innerBundleUserInfo;
2422 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2423 LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo bundleName:%{public}s",
2424 userId, GetBundleName().c_str());
2425 return false;
2426 }
2427
2428 bundleInfo = *baseBundleInfo_;
2429 if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2430 LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2431 return false;
2432 }
2433 bundleInfo.overlayType = overlayType_;
2434 bundleInfo.isNewVersion = isNewVersion_;
2435
2436 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
2437 bundleInfo.applicationInfo, appIndex);
2438 for (const auto &info : innerModuleInfos_) {
2439 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2440 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2441 for (const auto &item : info.second.requestPermissions) {
2442 bundleInfo.reqPermissions.push_back(item.name);
2443 }
2444 for (const auto &item : info.second.definePermissions) {
2445 bundleInfo.defPermissions.push_back(item.name);
2446 }
2447 }
2448 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2449 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
2450 if (hapmoduleinfo) {
2451 GetModuleWithHashValue(flags, info.second.modulePackage, *hapmoduleinfo);
2452 bundleInfo.hapModuleInfos.emplace_back(*hapmoduleinfo);
2453 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2454 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2455 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2456 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2457 } else {
2458 LOG_E(BMS_TAG_QUERY, "can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
2459 }
2460 }
2461 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
2462 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
2463 if (!bundleInfo.reqPermissions.empty()) {
2464 RemoveDuplicateName(bundleInfo.reqPermissions);
2465 }
2466 if (!bundleInfo.defPermissions.empty()) {
2467 RemoveDuplicateName(bundleInfo.defPermissions);
2468 }
2469 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo,
2470 bundleInfo.applicationInfo.accessTokenId, bundleInfo.applicationInfo.deviceId)) {
2471 LOG_E(BMS_TAG_QUERY, "get request permission state failed");
2472 }
2473 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2474 }
2475 GetBundleWithAbilities(flags, bundleInfo, appIndex, userId);
2476 GetBundleWithExtension(flags, bundleInfo, appIndex, userId);
2477 return true;
2478 }
2479
GetBundleInfoV9(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2480 ErrCode InnerBundleInfo::GetBundleInfoV9(int32_t flags, BundleInfo &bundleInfo, int32_t userId,
2481 int32_t appIndex) const
2482 {
2483 InnerBundleUserInfo innerBundleUserInfo;
2484 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2485 LOG_E(BMS_TAG_QUERY, "can not find userId %{public}d when GetBundleInfo", userId);
2486 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2487 }
2488
2489 bundleInfo = *baseBundleInfo_;
2490 if (!GetBundleInfoAdaptBundleClone(innerBundleUserInfo, appIndex, bundleInfo)) {
2491 LOG_E(BMS_TAG_QUERY, "userId %{public}d index %{public}d not exist", userId, appIndex);
2492 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
2493 }
2494 bundleInfo.overlayType = overlayType_;
2495 bundleInfo.isNewVersion = isNewVersion_;
2496
2497 for (const auto &info : innerModuleInfos_) {
2498 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
2499 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId, appIndex);
2500 if (hapmoduleinfo) {
2501 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
2502 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
2503 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
2504 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
2505 } else {
2506 LOG_E(BMS_TAG_QUERY, "can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
2507 }
2508 }
2509 ProcessBundleFlags(flags, userId, bundleInfo, appIndex);
2510 return ERR_OK;
2511 }
2512
GetSharedBundleInfo(int32_t flags,BundleInfo & bundleInfo) const2513 bool InnerBundleInfo::GetSharedBundleInfo(int32_t flags, BundleInfo &bundleInfo) const
2514 {
2515 bundleInfo = *baseBundleInfo_;
2516 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, Constants::ALL_USERID);
2517 bundleInfo.applicationInfo = *baseApplicationInfo_;
2518 return true;
2519 }
2520
ProcessBundleFlags(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2521 void InnerBundleInfo::ProcessBundleFlags(
2522 int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2523 {
2524 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
2525 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
2526 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2527 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2528 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), userId,
2529 bundleInfo.applicationInfo, appIndex);
2530 } else {
2531 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_DEFAULT), userId,
2532 bundleInfo.applicationInfo, appIndex);
2533 }
2534 }
2535 bundleInfo.applicationInfo.appIndex = appIndex;
2536 GetBundleWithReqPermissionsV9(flags, userId, bundleInfo, appIndex);
2537 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, userId, appIndex);
2538 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
2539 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
2540 bundleInfo.signatureInfo.appId = baseBundleInfo_->appId;
2541 bundleInfo.signatureInfo.fingerprint = baseApplicationInfo_->fingerprint;
2542 bundleInfo.signatureInfo.certificate = baseBundleInfo_->signatureInfo.certificate;
2543 }
2544 }
2545
GetBundleWithReqPermissionsV9(int32_t flags,int32_t userId,BundleInfo & bundleInfo,int32_t appIndex) const2546 void InnerBundleInfo::GetBundleWithReqPermissionsV9(
2547 int32_t flags, int32_t userId, BundleInfo &bundleInfo, int32_t appIndex) const
2548 {
2549 if ((static_cast<uint32_t>(flags) &
2550 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION))
2551 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION)) {
2552 return;
2553 }
2554 for (const auto &info : innerModuleInfos_) {
2555 for (const auto &item : info.second.requestPermissions) {
2556 bundleInfo.reqPermissions.push_back(item.name);
2557 }
2558 for (const auto &item : info.second.definePermissions) {
2559 bundleInfo.defPermissions.push_back(item.name);
2560 }
2561 }
2562 if (!bundleInfo.reqPermissions.empty()) {
2563 RemoveDuplicateName(bundleInfo.reqPermissions);
2564 }
2565 if (!bundleInfo.defPermissions.empty()) {
2566 RemoveDuplicateName(bundleInfo.defPermissions);
2567 }
2568 InnerBundleUserInfo innerBundleUserInfo;
2569 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
2570 APP_LOGE("not find userId %{public}d when get applicationInfo", userId);
2571 return;
2572 }
2573 uint32_t tokenId = innerBundleUserInfo.accessTokenId;
2574 std::string deviceId = baseApplicationInfo_->deviceId;
2575 if (appIndex != 0) {
2576 // clone app
2577 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = innerBundleUserInfo.cloneInfos;
2578 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
2579 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
2580 LOG_E(BMS_TAG_QUERY,
2581 "can not find userId %{public}d, appIndex %{public}d when get applicationInfo", userId, appIndex);
2582 return;
2583 }
2584 const InnerBundleCloneInfo &cloneInfo = mpCloneInfos.at(appIndexKey);
2585 tokenId = cloneInfo.accessTokenId;
2586 }
2587 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo, tokenId, deviceId)) {
2588 APP_LOGE("get request permission state failed");
2589 }
2590 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
2591 }
2592
GetModuleWithHashValue(int32_t flags,const std::string & modulePackage,HapModuleInfo & hapModuleInfo) const2593 void InnerBundleInfo::GetModuleWithHashValue(
2594 int32_t flags, const std::string &modulePackage, HapModuleInfo &hapModuleInfo) const
2595 {
2596 if (!(static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_HASH_VALUE)) {
2597 return;
2598 }
2599
2600 auto it = innerModuleInfos_.find(modulePackage);
2601 if (it == innerModuleInfos_.end()) {
2602 APP_LOGE("not find module %{public}s", modulePackage.c_str());
2603 return;
2604 }
2605
2606 hapModuleInfo.hashValue = it->second.hashValue;
2607 }
2608
ProcessBundleWithHapModuleInfoFlag(int32_t flags,BundleInfo & bundleInfo,int32_t userId,int32_t appIndex) const2609 void InnerBundleInfo::ProcessBundleWithHapModuleInfoFlag(
2610 int32_t flags, BundleInfo &bundleInfo, int32_t userId, int32_t appIndex) const
2611 {
2612 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE))
2613 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE)) {
2614 bundleInfo.hapModuleInfos.clear();
2615 return;
2616 }
2617 for (const auto &info : innerModuleInfos_) {
2618 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId, appIndex);
2619 if (hapmoduleinfo) {
2620 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
2621 auto it = innerModuleInfos_.find(info.second.modulePackage);
2622 if (it == innerModuleInfos_.end()) {
2623 APP_LOGE("not find module %{public}s", info.second.modulePackage.c_str());
2624 } else {
2625 hapModuleInfo.hashValue = it->second.hashValue;
2626 }
2627 if (hapModuleInfo.hapPath.empty()) {
2628 hapModuleInfo.moduleSourceDir = info.second.modulePath;
2629 }
2630 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2631 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2632 hapModuleInfo.metadata.clear();
2633 }
2634
2635 GetBundleWithAbilitiesV9(flags, hapModuleInfo, userId, appIndex);
2636 GetBundleWithExtensionAbilitiesV9(flags, hapModuleInfo, appIndex);
2637 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
2638 }
2639 }
2640 }
2641
GetBundleWithAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t userId,int32_t appIndex) const2642 void InnerBundleInfo::GetBundleWithAbilitiesV9(
2643 int32_t flags, HapModuleInfo &hapModuleInfo, int32_t userId, int32_t appIndex) const
2644 {
2645 hapModuleInfo.abilityInfos.clear();
2646 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY))
2647 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY)) {
2648 return;
2649 }
2650 APP_LOGD("Get bundleInfo with abilities");
2651 for (auto &ability : baseAbilityInfos_) {
2652 if ((ability.second.moduleName != hapModuleInfo.moduleName) ||
2653 (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY)) {
2654 continue;
2655 }
2656 bool isEnabled = IsAbilityEnabled(ability.second, userId, appIndex);
2657 if (!(static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE))
2658 && !isEnabled) {
2659 APP_LOGW_NOFUNC("ability:%{public}s disabled,", ability.second.name.c_str());
2660 continue;
2661 }
2662 AbilityInfo abilityInfo = ability.second;
2663 abilityInfo.enabled = isEnabled;
2664 abilityInfo.appIndex = appIndex;
2665
2666 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2667 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2668 abilityInfo.metaData.customizeData.clear();
2669 abilityInfo.metadata.clear();
2670 }
2671 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2672 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2673 abilityInfo.skills.clear();
2674 }
2675
2676 hapModuleInfo.abilityInfos.emplace_back(abilityInfo);
2677 }
2678 }
2679
GetBundleWithExtensionAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t appIndex) const2680 void InnerBundleInfo::GetBundleWithExtensionAbilitiesV9(
2681 int32_t flags, HapModuleInfo &hapModuleInfo, int32_t appIndex) const
2682 {
2683 hapModuleInfo.extensionInfos.clear();
2684 if ((static_cast<uint32_t>(flags) &
2685 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY))
2686 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY)) {
2687 return;
2688 }
2689 APP_LOGD("Get bundleInfo with extensionAbilities");
2690 for (const auto &extensionInfo : baseExtensionInfos_) {
2691 if (extensionInfo.second.moduleName != hapModuleInfo.moduleName || !extensionInfo.second.enabled) {
2692 continue;
2693 }
2694 ExtensionAbilityInfo info = extensionInfo.second;
2695 info.appIndex = appIndex;
2696
2697 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
2698 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
2699 info.metadata.clear();
2700 }
2701 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL))
2702 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SKILL)) {
2703 info.skills.clear();
2704 }
2705 hapModuleInfo.extensionInfos.emplace_back(info);
2706 }
2707 }
2708
GetBundleWithAbilities(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2709 void InnerBundleInfo::GetBundleWithAbilities(
2710 int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2711 {
2712 APP_LOGD("bundleName:%{public}s userid:%{public}d", bundleInfo.name.c_str(), userId);
2713 if (static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_ABILITIES) {
2714 for (auto &ability : baseAbilityInfos_) {
2715 if (ability.second.name == ServiceConstants::APP_DETAIL_ABILITY) {
2716 continue;
2717 }
2718 bool isEnabled = IsAbilityEnabled(ability.second, userId);
2719 if (!(static_cast<uint32_t>(flags) & GET_ABILITY_INFO_WITH_DISABLE)
2720 && !isEnabled) {
2721 APP_LOGW_NOFUNC("ability:%{public}s disabled,", ability.second.name.c_str());
2722 continue;
2723 }
2724 AbilityInfo abilityInfo = ability.second;
2725 abilityInfo.enabled = isEnabled;
2726 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2727 abilityInfo.skills.clear();
2728 }
2729 abilityInfo.appIndex = appIndex;
2730 bundleInfo.abilityInfos.emplace_back(abilityInfo);
2731 }
2732 }
2733 }
2734
GetBundleWithExtension(int32_t flags,BundleInfo & bundleInfo,int32_t appIndex,int32_t userId) const2735 void InnerBundleInfo::GetBundleWithExtension(
2736 int32_t flags, BundleInfo &bundleInfo, int32_t appIndex, int32_t userId) const
2737 {
2738 APP_LOGD("get bundleInfo with extensionInfo begin");
2739 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_EXTENSION_INFO) == GET_BUNDLE_WITH_EXTENSION_INFO) {
2740 for (const auto &extensionInfo : baseExtensionInfos_) {
2741 if (!extensionInfo.second.enabled) {
2742 continue;
2743 }
2744 ExtensionAbilityInfo info = extensionInfo.second;
2745 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_SKILL) != GET_BUNDLE_WITH_SKILL) {
2746 info.skills.clear();
2747 }
2748 info.appIndex = appIndex;
2749 bundleInfo.extensionInfos.emplace_back(info);
2750 }
2751 }
2752 APP_LOGD("get bundleInfo with extensionInfo end");
2753 }
2754
CheckSpecialMetaData(const std::string & metaData) const2755 bool InnerBundleInfo::CheckSpecialMetaData(const std::string &metaData) const
2756 {
2757 if (isNewVersion_) {
2758 for (const auto &moduleInfo : innerModuleInfos_) {
2759 for (const auto &data : moduleInfo.second.metadata) {
2760 if (metaData == data.name) {
2761 return true;
2762 }
2763 }
2764 }
2765 return false;
2766 }
2767 // old version
2768 for (const auto &moduleInfo : innerModuleInfos_) {
2769 for (const auto &data : moduleInfo.second.metaData.customizeData) {
2770 if (metaData == data.name) {
2771 return true;
2772 }
2773 }
2774 }
2775 return false;
2776 }
2777
GetFormsInfoByModule(const std::string & moduleName,std::vector<FormInfo> & formInfos) const2778 void InnerBundleInfo::GetFormsInfoByModule(const std::string &moduleName, std::vector<FormInfo> &formInfos) const
2779 {
2780 for (const auto &data : formInfos_) {
2781 for (auto &form : data.second) {
2782 if (form.moduleName == moduleName) {
2783 formInfos.emplace_back(form);
2784 }
2785 }
2786 }
2787 }
2788
GetFormsInfoByApp(std::vector<FormInfo> & formInfos) const2789 void InnerBundleInfo::GetFormsInfoByApp(std::vector<FormInfo> &formInfos) const
2790 {
2791 for (const auto &data : formInfos_) {
2792 std::copy(data.second.begin(), data.second.end(), std::back_inserter(formInfos));
2793 }
2794 }
2795
GetShortcutInfos(std::vector<ShortcutInfo> & shortcutInfos) const2796 void InnerBundleInfo::GetShortcutInfos(std::vector<ShortcutInfo> &shortcutInfos) const
2797 {
2798 for (const auto &shortcut : shortcutInfos_) {
2799 shortcutInfos.emplace_back(shortcut.second);
2800 }
2801 }
2802
GetCommonEvents(const std::string & eventKey,std::vector<CommonEventInfo> & commonEvents) const2803 void InnerBundleInfo::GetCommonEvents(const std::string &eventKey, std::vector<CommonEventInfo> &commonEvents) const
2804 {
2805 CommonEventInfo item;
2806 for (const auto &commonEvent : commonEvents_) {
2807 for (const auto &event : commonEvent.second.events) {
2808 if (event == eventKey) {
2809 item = commonEvent.second;
2810 item.uid = GetUid(GetUserId());
2811 commonEvents.emplace_back(item);
2812 break;
2813 }
2814 }
2815 }
2816 }
2817
GetInnerModuleInfoByModuleName(const std::string & moduleName) const2818 std::optional<InnerModuleInfo> InnerBundleInfo::GetInnerModuleInfoByModuleName(const std::string &moduleName) const
2819 {
2820 for (const auto &innerModuleInfo : innerModuleInfos_) {
2821 APP_LOGD("info.moduleName = %{public}s, moduleName= %{public}s",
2822 innerModuleInfo.second.moduleName.c_str(), moduleName.c_str());
2823 if (innerModuleInfo.second.moduleName == moduleName) {
2824 return innerModuleInfo.second;
2825 }
2826 }
2827 return std::nullopt;
2828 }
2829
GetInnerModuleInfoHnpInfo(const std::string & moduleName) const2830 std::optional<std::vector<HnpPackage>> InnerBundleInfo::GetInnerModuleInfoHnpInfo(const std::string &moduleName) const
2831 {
2832 for (const auto &innerModuleInfo : innerModuleInfos_) {
2833 if (!(innerModuleInfo.second.hnpPackages.empty())) {
2834 if (innerModuleInfo.second.moduleName == moduleName) {
2835 return innerModuleInfo.second.hnpPackages;
2836 }
2837 }
2838 }
2839 return std::nullopt;
2840 }
2841
GetInnerModuleInfoHnpPath(const std::string & moduleName) const2842 std::string InnerBundleInfo::GetInnerModuleInfoHnpPath(const std::string &moduleName) const
2843 {
2844 for (const auto &innerModuleInfo : innerModuleInfos_) {
2845 if (!(innerModuleInfo.second.hnpPackages.empty())) {
2846 if (innerModuleInfo.second.moduleName == moduleName) {
2847 return innerModuleInfo.second.moduleHnpsPath;
2848 }
2849 }
2850 }
2851 return "";
2852 }
2853
GetModuleNames(std::vector<std::string> & moduleNames) const2854 void InnerBundleInfo::GetModuleNames(std::vector<std::string> &moduleNames) const
2855 {
2856 for (const auto &innerModuleInfo : innerModuleInfos_) {
2857 moduleNames.emplace_back(innerModuleInfo.second.moduleName);
2858 }
2859 }
2860
ResetBundleState(int32_t userId)2861 void InnerBundleInfo::ResetBundleState(int32_t userId)
2862 {
2863 if (userId == Constants::ALL_USERID) {
2864 for (auto& innerBundleUserInfo : innerBundleUserInfos_) {
2865 innerBundleUserInfo.second.bundleUserInfo.Reset();
2866 }
2867
2868 return;
2869 }
2870
2871 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2872 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
2873 APP_LOGD("no this user %{public}s", key.c_str());
2874 return;
2875 }
2876
2877 innerBundleUserInfos_.at(key).bundleUserInfo.Reset();
2878 }
2879
RemoveInnerBundleUserInfo(int32_t userId)2880 void InnerBundleInfo::RemoveInnerBundleUserInfo(int32_t userId)
2881 {
2882 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2883 auto infoItem = innerBundleUserInfos_.find(key);
2884 if (infoItem == innerBundleUserInfos_.end()) {
2885 return;
2886 }
2887
2888 auto result = innerBundleUserInfos_.erase(key);
2889 if (result == 0) {
2890 APP_LOGE("remove userId:%{public}d key:%{public}s info failed", userId, key.c_str());
2891 }
2892 for (auto &innerModuleInfo : innerModuleInfos_) {
2893 DeleteModuleRemovable(innerModuleInfo.second.moduleName, userId);
2894 }
2895 }
2896
AddInnerBundleUserInfo(const InnerBundleUserInfo & innerBundleUserInfo)2897 void InnerBundleInfo::AddInnerBundleUserInfo(
2898 const InnerBundleUserInfo& innerBundleUserInfo)
2899 {
2900 auto& key = NameAndUserIdToKey(
2901 GetBundleName(), innerBundleUserInfo.bundleUserInfo.userId);
2902 auto infoItem = innerBundleUserInfos_.find(key);
2903 if (infoItem == innerBundleUserInfos_.end()) {
2904 innerBundleUserInfos_.emplace(key, innerBundleUserInfo);
2905 return;
2906 }
2907
2908 innerBundleUserInfos_[key] = innerBundleUserInfo;
2909 }
2910
GetInnerBundleUserInfo(int32_t userId,InnerBundleUserInfo & innerBundleUserInfo) const2911 bool InnerBundleInfo::GetInnerBundleUserInfo(
2912 int32_t userId, InnerBundleUserInfo& innerBundleUserInfo) const
2913 {
2914 if (userId == ServiceConstants::NOT_EXIST_USERID) {
2915 return true;
2916 }
2917
2918 if (userId == Constants::ALL_USERID) {
2919 if (innerBundleUserInfos_.empty()) {
2920 return false;
2921 }
2922
2923 innerBundleUserInfo = innerBundleUserInfos_.begin()->second;
2924 return true;
2925 }
2926
2927 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2928 auto infoItem = innerBundleUserInfos_.find(key);
2929 if (infoItem == innerBundleUserInfos_.end()) {
2930 return false;
2931 }
2932
2933 innerBundleUserInfo = infoItem->second;
2934 return true;
2935 }
2936
HasInnerBundleUserInfo(int32_t userId) const2937 bool InnerBundleInfo::HasInnerBundleUserInfo(int32_t userId) const
2938 {
2939 if (userId == Constants::ALL_USERID || userId == Constants::ANY_USERID) {
2940 return !innerBundleUserInfos_.empty();
2941 }
2942
2943 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2944 auto infoItem = innerBundleUserInfos_.find(key);
2945 return infoItem != innerBundleUserInfos_.end();
2946 }
2947
SetBundleInstallTime(const int64_t time,int32_t userId)2948 void InnerBundleInfo::SetBundleInstallTime(const int64_t time, int32_t userId)
2949 {
2950 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2951 auto infoItem = innerBundleUserInfos_.find(key);
2952 if (infoItem == innerBundleUserInfos_.end()) {
2953 return;
2954 }
2955
2956 infoItem->second.installTime = time;
2957 infoItem->second.updateTime = time;
2958 }
2959
SetAccessTokenId(uint32_t accessToken,const int32_t userId)2960 void InnerBundleInfo::SetAccessTokenId(uint32_t accessToken, const int32_t userId)
2961 {
2962 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2963 auto infoItem = innerBundleUserInfos_.find(key);
2964 if (infoItem == innerBundleUserInfos_.end()) {
2965 return;
2966 }
2967
2968 infoItem->second.accessTokenId = accessToken;
2969 }
2970
SetAccessTokenIdEx(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId)2971 void InnerBundleInfo::SetAccessTokenIdEx(
2972 const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
2973 const int32_t userId)
2974 {
2975 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2976 auto infoItem = innerBundleUserInfos_.find(key);
2977 if (infoItem == innerBundleUserInfos_.end()) {
2978 return;
2979 }
2980
2981 infoItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
2982 infoItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
2983 }
2984
SetAccessTokenIdExWithAppIndex(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId,const int32_t appIndex)2985 void InnerBundleInfo::SetAccessTokenIdExWithAppIndex(
2986 const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
2987 const int32_t userId, const int32_t appIndex)
2988 {
2989 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2990 auto infoItem = innerBundleUserInfos_.find(key);
2991 if (infoItem == innerBundleUserInfos_.end()) {
2992 return;
2993 }
2994
2995 auto& userInfo = infoItem->second;
2996 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
2997
2998 auto cloneKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
2999 auto cloneItem = cloneInfos.find(cloneKey);
3000 if (cloneItem == cloneInfos.end()) {
3001 return;
3002 }
3003 cloneItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
3004 cloneItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
3005 }
3006
SetkeyId(const int32_t userId,const std::string & keyId)3007 void InnerBundleInfo::SetkeyId(const int32_t userId, const std::string &keyId)
3008 {
3009 if (keyId.empty()) {
3010 APP_LOGE("SetkeyId failed, keyId is empty");
3011 return;
3012 }
3013 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3014 auto infoItem = innerBundleUserInfos_.find(key);
3015 if (infoItem == innerBundleUserInfos_.end()) {
3016 APP_LOGE("SetkeyId failed, not find userInfo for userId %{public}d", userId);
3017 return;
3018 }
3019 infoItem->second.keyId = keyId;
3020 }
3021
SetBundleUpdateTime(const int64_t time,int32_t userId)3022 void InnerBundleInfo::SetBundleUpdateTime(const int64_t time, int32_t userId)
3023 {
3024 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3025 auto infoItem = innerBundleUserInfos_.find(key);
3026 if (infoItem == innerBundleUserInfos_.end()) {
3027 return;
3028 }
3029
3030 infoItem->second.updateTime = time;
3031 }
3032
IsAbilityEnabled(const AbilityInfo & abilityInfo,int32_t userId,int32_t appIndex) const3033 bool InnerBundleInfo::IsAbilityEnabled(const AbilityInfo &abilityInfo, int32_t userId, int32_t appIndex) const
3034 {
3035 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3036 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3037 return true;
3038 }
3039 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3040 auto infoItem = innerBundleUserInfos_.find(key);
3041 if (infoItem == innerBundleUserInfos_.end()) {
3042 APP_LOGD("innerBundleUserInfos find key:%{public}s, error", key.c_str());
3043 return false;
3044 }
3045
3046 if (appIndex == 0) {
3047 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3048 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3049 != disabledAbilities.end()) {
3050 return false;
3051 } else {
3052 return true;
3053 }
3054 }
3055
3056 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3057 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3058 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3059 return false;
3060 }
3061 auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3062 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3063 != disabledAbilities.end()) {
3064 return false;
3065 } else {
3066 return true;
3067 }
3068 }
3069
SetOverlayModuleState(const std::string & moduleName,int32_t state,int32_t userId)3070 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state, int32_t userId)
3071 {
3072 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3073 if (overlayType_ == NON_OVERLAY_TYPE) {
3074 APP_LOGW("no overlay module");
3075 return;
3076 }
3077 for (auto &innerUserInfo : innerBundleUserInfos_) {
3078 if (innerUserInfo.second.bundleUserInfo.userId != userId) {
3079 continue;
3080 }
3081
3082 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3083 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3084 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3085 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3086 return true;
3087 }
3088 return false;
3089 });
3090 if (!isSetSucc) {
3091 APP_LOGD("no overlay module state info under user %{public}d", userId);
3092 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3093 }
3094 }
3095 }
3096
SetOverlayModuleState(const std::string & moduleName,int32_t state)3097 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state)
3098 {
3099 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
3100 if (overlayType_ == NON_OVERLAY_TYPE) {
3101 APP_LOGW("no overlay module");
3102 return;
3103 }
3104 for (auto &innerUserInfo : innerBundleUserInfos_) {
3105 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3106 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
3107 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3108 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
3109 return true;
3110 }
3111 return false;
3112 });
3113 if (!isSetSucc) {
3114 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
3115 }
3116 }
3117 }
3118
GetOverlayModuleState(const std::string & moduleName,int32_t userId,int32_t & state) const3119 bool InnerBundleInfo::GetOverlayModuleState(const std::string &moduleName, int32_t userId, int32_t &state) const
3120 {
3121 APP_LOGD("start to get overlay state of moduleName:%{public}s, userId:%{public}d", moduleName.c_str(), userId);
3122 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3123 APP_LOGE("invalid userId %{public}d", userId);
3124 return false;
3125 }
3126 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3127 auto infoItem = innerBundleUserInfos_.find(key);
3128 if (infoItem == innerBundleUserInfos_.end()) {
3129 APP_LOGE("no userInfo under userId %{public}d", userId);
3130 return false;
3131 }
3132
3133 auto overlayModulesState = infoItem->second.bundleUserInfo.overlayModulesState;
3134 if (overlayModulesState.empty()) {
3135 APP_LOGE("no overlay module installed under userId %{public}d", userId);
3136 return false;
3137 }
3138 for (const auto &item : overlayModulesState) {
3139 auto pos = item.find(moduleName + Constants::FILE_UNDERLINE);
3140 if (pos == std::string::npos) {
3141 continue;
3142 }
3143 return OHOS::StrToInt(item.substr(moduleName.length() + 1), state);
3144 }
3145 APP_LOGE("no overlay module installed under userId %{public}d", userId);
3146 return false;
3147 }
3148
ClearOverlayModuleStates(const std::string & moduleName)3149 void InnerBundleInfo::ClearOverlayModuleStates(const std::string &moduleName)
3150 {
3151 // delete overlay module state
3152 for (auto &innerUserInfo : innerBundleUserInfos_) {
3153 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
3154 auto iter = std::find_if(overlayStates.begin(), overlayStates.end(), [&moduleName](const auto &item) {
3155 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
3156 return true;
3157 }
3158 return false;
3159 });
3160 if (iter != overlayStates.end()) {
3161 overlayStates.erase(iter);
3162 }
3163 }
3164 }
3165
IsAbilityEnabledV9(const AbilityInfo & abilityInfo,int32_t userId,bool & isEnable,int32_t appIndex) const3166 ErrCode InnerBundleInfo::IsAbilityEnabledV9(const AbilityInfo &abilityInfo,
3167 int32_t userId, bool &isEnable, int32_t appIndex) const
3168 {
3169 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
3170 if (userId == ServiceConstants::NOT_EXIST_USERID) {
3171 isEnable = true;
3172 return ERR_OK;
3173 }
3174 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
3175 auto infoItem = innerBundleUserInfos_.find(key);
3176 if (infoItem == innerBundleUserInfos_.end()) {
3177 APP_LOGE("innerBundleUserInfos find key:%{public}s, error", key.c_str());
3178 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3179 }
3180 if (appIndex == 0) {
3181 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
3182 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3183 != disabledAbilities.end()) {
3184 isEnable = false;
3185 } else {
3186 isEnable = true;
3187 }
3188 return ERR_OK;
3189 }
3190 const std::map<std::string, InnerBundleCloneInfo> &mpCloneInfos = infoItem->second.cloneInfos;
3191 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
3192 if (mpCloneInfos.find(appIndexKey) == mpCloneInfos.end()) {
3193 return ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP;
3194 }
3195 auto disabledAbilities = mpCloneInfos.at(appIndexKey).disabledAbilities;
3196 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name)
3197 != disabledAbilities.end()) {
3198 isEnable = false;
3199 } else {
3200 isEnable = true;
3201 }
3202 return ERR_OK;
3203 }
3204
SetAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId)3205 ErrCode InnerBundleInfo::SetAbilityEnabled(
3206 const std::string &moduleName, const std::string &abilityName, bool isEnabled, int32_t userId)
3207 {
3208 APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d",
3209 moduleName.c_str(), abilityName.c_str(), userId);
3210 for (const auto &ability : baseAbilityInfos_) {
3211 if ((ability.second.name == abilityName) &&
3212 (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3213 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3214 auto infoItem = innerBundleUserInfos_.find(key);
3215 if (infoItem == innerBundleUserInfos_.end()) {
3216 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3217 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3218 }
3219
3220 auto iter = std::find(infoItem->second.bundleUserInfo.disabledAbilities.begin(),
3221 infoItem->second.bundleUserInfo.disabledAbilities.end(),
3222 abilityName);
3223 if (iter != infoItem->second.bundleUserInfo.disabledAbilities.end()) {
3224 if (isEnabled) {
3225 infoItem->second.bundleUserInfo.disabledAbilities.erase(iter);
3226 }
3227 } else {
3228 if (!isEnabled) {
3229 infoItem->second.bundleUserInfo.disabledAbilities.push_back(abilityName);
3230 }
3231 }
3232 return ERR_OK;
3233 }
3234 }
3235 APP_LOGE("SetAbilityEnabled find abilityInfo failed");
3236 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3237 }
3238
SetCloneAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId,int32_t appIndex)3239 ErrCode InnerBundleInfo::SetCloneAbilityEnabled(const std::string &moduleName, const std::string &abilityName,
3240 bool isEnabled, int32_t userId, int32_t appIndex)
3241 {
3242 APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d for appIndex %{public}d",
3243 moduleName.c_str(), abilityName.c_str(), userId, appIndex);
3244 for (const auto &ability : baseAbilityInfos_) {
3245 if ((ability.second.name == abilityName) &&
3246 (moduleName.empty() || (ability.second.moduleName == moduleName))) {
3247 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
3248 auto infoItem = innerBundleUserInfos_.find(key);
3249 if (infoItem == innerBundleUserInfos_.end()) {
3250 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
3251 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
3252 }
3253
3254 auto cloneIter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3255 if (cloneIter == infoItem->second.cloneInfos.end()) {
3256 APP_LOGW("appIndex %{public}d invalid", appIndex);
3257 return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3258 }
3259
3260 auto iter = std::find(cloneIter->second.disabledAbilities.begin(),
3261 cloneIter->second.disabledAbilities.end(),
3262 abilityName);
3263 if (iter != cloneIter->second.disabledAbilities.end() && isEnabled) {
3264 cloneIter->second.disabledAbilities.erase(iter);
3265 }
3266 if (iter == cloneIter->second.disabledAbilities.end() && !isEnabled) {
3267 cloneIter->second.disabledAbilities.push_back(abilityName);
3268 }
3269 return ERR_OK;
3270 }
3271 }
3272 APP_LOGW("SetCloneAbilityEnabled find abilityInfo failed");
3273 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
3274 }
3275
RemoveDuplicateName(std::vector<std::string> & name) const3276 void InnerBundleInfo::RemoveDuplicateName(std::vector<std::string> &name) const
3277 {
3278 std::sort(name.begin(), name.end());
3279 auto iter = std::unique(name.begin(), name.end());
3280 name.erase(iter, name.end());
3281 }
3282
SetInnerModuleNeedDelete(const std::string & moduleName,const bool needDelete)3283 void InnerBundleInfo::SetInnerModuleNeedDelete(const std::string &moduleName, const bool needDelete)
3284 {
3285 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3286 APP_LOGE("innerBundleInfo does not contain the module module %{public}s", moduleName.c_str());
3287 return;
3288 }
3289 innerModuleInfos_.at(moduleName).needDelete = needDelete;
3290 }
3291
GetInnerModuleNeedDelete(const std::string & moduleName)3292 bool InnerBundleInfo::GetInnerModuleNeedDelete(const std::string &moduleName)
3293 {
3294 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3295 APP_LOGE("innerBundleInfo does not contain the module %{public}s", moduleName.c_str());
3296 return true;
3297 }
3298 return innerModuleInfos_.at(moduleName).needDelete;
3299 }
3300
GetAllDefinePermissions() const3301 std::vector<DefinePermission> InnerBundleInfo::GetAllDefinePermissions() const
3302 {
3303 std::vector<DefinePermission> definePermissions;
3304 for (const auto &info : innerModuleInfos_) {
3305 if (info.second.needDelete) {
3306 continue;
3307 }
3308 std::transform(info.second.definePermissions.begin(),
3309 info.second.definePermissions.end(),
3310 std::back_inserter(definePermissions),
3311 [](const auto &p) { return p; });
3312 }
3313 if (!definePermissions.empty()) {
3314 std::sort(definePermissions.begin(), definePermissions.end(),
3315 [](DefinePermission defPermA, DefinePermission defPermB) {
3316 return defPermA.name < defPermB.name;
3317 });
3318 auto iter = std::unique(definePermissions.begin(), definePermissions.end(),
3319 [](DefinePermission defPermA, DefinePermission defPermB) {
3320 return defPermA.name == defPermB.name;
3321 });
3322 definePermissions.erase(iter, definePermissions.end());
3323 }
3324 return definePermissions;
3325 }
3326
GetAllRequestPermissions() const3327 std::vector<RequestPermission> InnerBundleInfo::GetAllRequestPermissions() const
3328 {
3329 std::unordered_map<std::string, std::string> moduleNameMap;
3330 std::vector<RequestPermission> requestPermissions;
3331 for (const auto &info : innerModuleInfos_) {
3332 if (info.second.needDelete) {
3333 continue;
3334 }
3335 for (auto item : info.second.requestPermissions) {
3336 item.moduleName = info.second.moduleName;
3337 requestPermissions.push_back(item);
3338 if (moduleNameMap.find(item.moduleName) == moduleNameMap.end()) {
3339 moduleNameMap[item.moduleName] = info.second.distro.moduleType;
3340 }
3341 }
3342 }
3343 if (!requestPermissions.empty()) {
3344 InnerProcessRequestPermissions(moduleNameMap, requestPermissions);
3345 }
3346 return requestPermissions;
3347 }
3348
InnerProcessRequestPermissions(const std::unordered_map<std::string,std::string> & moduleNameMap,std::vector<RequestPermission> & requestPermissions) const3349 void InnerBundleInfo::InnerProcessRequestPermissions(
3350 const std::unordered_map<std::string, std::string> &moduleNameMap,
3351 std::vector<RequestPermission> &requestPermissions) const
3352 {
3353 std::sort(requestPermissions.begin(), requestPermissions.end(),
3354 [&moduleNameMap](RequestPermission reqPermA, RequestPermission reqPermB) {
3355 if (reqPermA.name == reqPermB.name) {
3356 if ((reqPermA.reasonId == 0) || (reqPermB.reasonId == 0)) {
3357 return reqPermA.reasonId > reqPermB.reasonId;
3358 }
3359 auto moduleTypeA = moduleNameMap.find(reqPermA.moduleName);
3360 if (moduleTypeA == moduleNameMap.end()) {
3361 return reqPermA.reasonId > reqPermB.reasonId;
3362 }
3363 auto moduleTypeB = moduleNameMap.find(reqPermB.moduleName);
3364 if (moduleTypeB == moduleNameMap.end()) {
3365 return reqPermA.reasonId > reqPermB.reasonId;
3366 }
3367 if ((moduleTypeA->second == Profile::MODULE_TYPE_ENTRY) &&
3368 ((moduleTypeB->second == Profile::MODULE_TYPE_ENTRY))) {
3369 return reqPermA.reasonId > reqPermB.reasonId;
3370 } else if (moduleTypeA->second == Profile::MODULE_TYPE_ENTRY) {
3371 return true;
3372 } else if (moduleTypeB->second == Profile::MODULE_TYPE_ENTRY) {
3373 return false;
3374 }
3375 if ((moduleTypeA->second == Profile::MODULE_TYPE_FEATURE) &&
3376 ((moduleTypeB->second == Profile::MODULE_TYPE_FEATURE))) {
3377 return reqPermA.reasonId > reqPermB.reasonId;
3378 } else if (moduleTypeA->second == Profile::MODULE_TYPE_FEATURE) {
3379 return true;
3380 } else if (moduleTypeB->second == Profile::MODULE_TYPE_FEATURE) {
3381 return false;
3382 }
3383 return reqPermA.reasonId > reqPermB.reasonId;
3384 }
3385 return reqPermA.name < reqPermB.name;
3386 });
3387 auto iter = std::unique(requestPermissions.begin(), requestPermissions.end(),
3388 [](RequestPermission reqPermA, RequestPermission reqPermB) {
3389 return reqPermA.name == reqPermB.name;
3390 });
3391 requestPermissions.erase(iter, requestPermissions.end());
3392 }
3393
SetApplicationEnabled(bool enabled,const std::string & caller,int32_t userId)3394 ErrCode InnerBundleInfo::SetApplicationEnabled(bool enabled, const std::string &caller, int32_t userId)
3395 {
3396 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3397 auto infoItem = innerBundleUserInfos_.find(key);
3398 if (infoItem == innerBundleUserInfos_.end()) {
3399 APP_LOGE("SetApplicationEnabled not find:%{public}s bundleUserInfo in userId: %{public}d",
3400 GetBundleName().c_str(), userId);
3401 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
3402 }
3403
3404 infoItem->second.bundleUserInfo.enabled = enabled;
3405 if (!caller.empty()) {
3406 infoItem->second.bundleUserInfo.setEnabledCaller = caller;
3407 }
3408 return ERR_OK;
3409 }
3410
SetCloneApplicationEnabled(bool enabled,int32_t appIndex,const std::string & caller,int32_t userId)3411 ErrCode InnerBundleInfo::SetCloneApplicationEnabled(bool enabled, int32_t appIndex, const std::string &caller,
3412 int32_t userId)
3413 {
3414 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
3415 auto infoItem = innerBundleUserInfos_.find(key);
3416 if (infoItem == innerBundleUserInfos_.end()) {
3417 APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}s bundleUserInfo in userId:%{public}d",
3418 GetBundleName().c_str(), userId);
3419 return ERR_BUNDLE_MANAGER_INVALID_USER_ID;
3420 }
3421
3422 auto iter = infoItem->second.cloneInfos.find(std::to_string(appIndex));
3423 if (iter == infoItem->second.cloneInfos.end()) {
3424 APP_LOGE_NOFUNC("SetCloneApplicationEnabled not find:%{public}d appIndex in userId:%{public}d",
3425 appIndex, userId);
3426 return ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX;
3427 }
3428 iter->second.enabled = enabled;
3429 iter->second.setEnabledCaller = caller;
3430 return ERR_OK;
3431 }
3432
GetCurModuleName() const3433 const std::string InnerBundleInfo::GetCurModuleName() const
3434 {
3435 if (innerModuleInfos_.find(currentPackage_) != innerModuleInfos_.end()) {
3436 return innerModuleInfos_.at(currentPackage_).moduleName;
3437 }
3438
3439 return Constants::EMPTY_STRING;
3440 }
3441
IsBundleRemovable() const3442 bool InnerBundleInfo::IsBundleRemovable() const
3443 {
3444 if (IsPreInstallApp()) {
3445 APP_LOGE("PreInstallApp should not be cleaned");
3446 return false;
3447 }
3448
3449 for (const auto &innerModuleInfo : innerModuleInfos_) {
3450 if (!innerModuleInfo.second.installationFree) {
3451 return false;
3452 }
3453
3454 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3455 if (!stateIter.second) {
3456 return false;
3457 }
3458 }
3459 }
3460
3461 return true;
3462 }
3463
GetLastInstallationTime() const3464 int64_t InnerBundleInfo::GetLastInstallationTime() const
3465 {
3466 int64_t installTime = 0;
3467 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3468 installTime = innerBundleUserInfo.second.updateTime > installTime ?
3469 innerBundleUserInfo.second.updateTime : installTime;
3470 }
3471
3472 return installTime;
3473 }
3474
GetRemovableModules(std::vector<std::string> & moduleToDelete) const3475 bool InnerBundleInfo::GetRemovableModules(std::vector<std::string> &moduleToDelete) const
3476 {
3477 for (const auto &innerModuleInfo : innerModuleInfos_) {
3478 if (!innerModuleInfo.second.installationFree) {
3479 continue;
3480 }
3481
3482 bool canDelete = true;
3483 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
3484 if (!stateIter.second) {
3485 canDelete = false;
3486 break;
3487 }
3488 }
3489
3490 if (canDelete) {
3491 moduleToDelete.emplace_back(innerModuleInfo.second.moduleName);
3492 }
3493 }
3494
3495 return !moduleToDelete.empty();
3496 }
3497
GetFreeInstallModules(std::vector<std::string> & freeInstallModule) const3498 bool InnerBundleInfo::GetFreeInstallModules(std::vector<std::string> &freeInstallModule) const
3499 {
3500 for (const auto &innerModuleInfo : innerModuleInfos_) {
3501 if (!innerModuleInfo.second.installationFree) {
3502 continue;
3503 }
3504
3505 freeInstallModule.emplace_back(innerModuleInfo.second.moduleName);
3506 }
3507
3508 return !freeInstallModule.empty();
3509 }
3510
IsUserExistModule(const std::string & moduleName,int32_t userId) const3511 bool InnerBundleInfo::IsUserExistModule(const std::string &moduleName, int32_t userId) const
3512 {
3513 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3514 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3515 if (!modInfoItem) {
3516 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3517 return false;
3518 }
3519
3520 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3521 if (item == modInfoItem->isRemovable.end()) {
3522 APP_LOGE("userId:%{public}d not moduleName:%{public}s", userId, moduleName.c_str());
3523 return false;
3524 }
3525
3526 APP_LOGD("userId:%{public}d exist moduleName:%{public}s", userId, moduleName.c_str());
3527 return true;
3528 }
3529
IsModuleRemovable(const std::string & moduleName,int32_t userId,bool & isRemovable) const3530 ErrCode InnerBundleInfo::IsModuleRemovable(
3531 const std::string &moduleName, int32_t userId, bool &isRemovable) const
3532 {
3533 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3534 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
3535 if (!modInfoItem) {
3536 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3537 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3538 }
3539
3540 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
3541 if (item == modInfoItem->isRemovable.end()) {
3542 APP_LOGW("userId:%{public}d not moduleName:%{public}s", userId, moduleName.c_str());
3543 isRemovable = false;
3544 return ERR_OK;
3545 }
3546
3547 isRemovable = item->second;
3548 APP_LOGD("userId:%{public}d, moduleName:%{public}s, isRemovable:%{public}d,",
3549 userId, moduleName.c_str(), isRemovable);
3550 return ERR_OK;
3551 }
3552
AddModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId,bool isEnable) const3553 bool InnerBundleInfo::AddModuleRemovableInfo(
3554 InnerModuleInfo &info, const std::string &stringUserId, bool isEnable) const
3555 {
3556 auto item = info.isRemovable.find(stringUserId);
3557 if (item == info.isRemovable.end()) {
3558 auto result = info.isRemovable.try_emplace(stringUserId, isEnable);
3559 if (!result.second) {
3560 APP_LOGE("add userId:%{public}s isRemovable:%{public}d failed", stringUserId.c_str(), isEnable);
3561 return false;
3562 }
3563
3564 APP_LOGD("add userId:%{public}s isRemovable:%{public}d into map", stringUserId.c_str(), isEnable);
3565 return true;
3566 }
3567
3568 item->second = isEnable;
3569 APP_LOGD("set userId:%{public}s isEnable:%{public}d ok", stringUserId.c_str(), isEnable);
3570 return true;
3571 }
3572
SetModuleRemovable(const std::string & moduleName,bool isEnable,int32_t userId)3573 bool InnerBundleInfo::SetModuleRemovable(const std::string &moduleName, bool isEnable, int32_t userId)
3574 {
3575 std::string stringUserId = std::to_string(userId);
3576 APP_LOGD("userId:%{public}d moduleName:%{public}s isEnable:%{public}d", userId, moduleName.c_str(), isEnable);
3577 for (auto &innerModuleInfo : innerModuleInfos_) {
3578 if (innerModuleInfo.second.moduleName == moduleName) {
3579 return AddModuleRemovableInfo(innerModuleInfo.second, stringUserId, isEnable);
3580 }
3581 }
3582
3583 return false;
3584 }
3585
DeleteModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId)3586 void InnerBundleInfo::DeleteModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId)
3587 {
3588 auto item = info.isRemovable.find(stringUserId);
3589 if (item == info.isRemovable.end()) {
3590 return;
3591 }
3592
3593 info.isRemovable.erase(stringUserId);
3594 }
3595
DeleteModuleRemovable(const std::string & moduleName,int32_t userId)3596 void InnerBundleInfo::DeleteModuleRemovable(const std::string &moduleName, int32_t userId)
3597 {
3598 std::string stringUserId = std::to_string(userId);
3599 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
3600 for (auto &innerModuleInfo : innerModuleInfos_) {
3601 if (innerModuleInfo.second.moduleName == moduleName) {
3602 DeleteModuleRemovableInfo(innerModuleInfo.second, stringUserId);
3603 return;
3604 }
3605 }
3606 }
3607
SetModuleUpgradeFlag(std::string moduleName,int32_t upgradeFlag)3608 ErrCode InnerBundleInfo::SetModuleUpgradeFlag(std::string moduleName, int32_t upgradeFlag)
3609 {
3610 APP_LOGD("moduleName= %{public}s, upgradeFlag = %{public}d", moduleName.c_str(), upgradeFlag);
3611 for (auto &innerModuleInfo : innerModuleInfos_) {
3612 if (innerModuleInfo.second.moduleName == moduleName) {
3613 innerModuleInfo.second.upgradeFlag = upgradeFlag;
3614 return ERR_OK;
3615 }
3616 }
3617 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3618 }
3619
GetModuleUpgradeFlag(std::string moduleName) const3620 int32_t InnerBundleInfo::GetModuleUpgradeFlag(std::string moduleName) const
3621 {
3622 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3623 if (!moduleInfo) {
3624 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
3625 return UpgradeFlag::NOT_UPGRADE;
3626 }
3627 APP_LOGD("innerModuleInfo.upgradeFlag : %{public}d", moduleInfo->upgradeFlag);
3628 return moduleInfo->upgradeFlag;
3629 }
3630
GetResponseUserId(int32_t requestUserId) const3631 int32_t InnerBundleInfo::GetResponseUserId(int32_t requestUserId) const
3632 {
3633 if (innerBundleUserInfos_.empty()) {
3634 APP_LOGD("user map is empty");
3635 return Constants::INVALID_USERID;
3636 }
3637
3638 if (requestUserId == Constants::ANY_USERID) {
3639 return innerBundleUserInfos_.begin()->second.bundleUserInfo.userId;
3640 }
3641
3642 if (HasInnerBundleUserInfo(requestUserId)) {
3643 return requestUserId;
3644 }
3645
3646 if (requestUserId < Constants::START_USERID) {
3647 APP_LOGD("requestUserId(%{public}d) less than start userId", requestUserId);
3648 return Constants::INVALID_USERID;
3649 }
3650
3651 int32_t responseUserId = Constants::INVALID_USERID;
3652 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
3653 if (innerBundleUserInfo.second.bundleUserInfo.userId < Constants::START_USERID) {
3654 responseUserId = innerBundleUserInfo.second.bundleUserInfo.userId;
3655 break;
3656 }
3657 }
3658
3659 APP_LOGD("requestUserId(%{public}d) and responseUserId(%{public}d)", requestUserId, responseUserId);
3660 return responseUserId;
3661 }
3662
GetDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3663 bool InnerBundleInfo::GetDependentModuleNames(const std::string &moduleName,
3664 std::vector<std::string> &dependentModuleNames) const
3665 {
3666 for (auto iter = innerModuleInfos_.begin(); iter != innerModuleInfos_.end(); ++iter) {
3667 if (iter->second.moduleName == moduleName) {
3668 for (const auto &dependency : iter->second.dependencies) {
3669 dependentModuleNames.push_back(dependency.moduleName);
3670 }
3671 return true;
3672 }
3673 }
3674 APP_LOGE("GetDependentModuleNames not find module %{public}s", moduleName.c_str());
3675 return false;
3676 }
3677
GetAllDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const3678 bool InnerBundleInfo::GetAllDependentModuleNames(const std::string &moduleName,
3679 std::vector<std::string> &dependentModuleNames) const
3680 {
3681 if (!GetDependentModuleNames(moduleName, dependentModuleNames)) {
3682 return false;
3683 }
3684 std::deque<std::string> moduleDeque;
3685 std::copy(dependentModuleNames.begin(), dependentModuleNames.end(), std::back_inserter(moduleDeque));
3686 dependentModuleNames.clear();
3687 while (!moduleDeque.empty()) {
3688 std::string name = moduleDeque.front();
3689 moduleDeque.pop_front();
3690 if (std::find(dependentModuleNames.begin(), dependentModuleNames.end(), name) == dependentModuleNames.end()) {
3691 dependentModuleNames.push_back(name);
3692 std::vector<std::string> tempModuleNames;
3693 if (GetDependentModuleNames(name, tempModuleNames)) {
3694 std::copy(tempModuleNames.begin(), tempModuleNames.end(), std::back_inserter(moduleDeque));
3695 }
3696 }
3697 }
3698 return true;
3699 }
3700
GetMainAbility() const3701 std::string InnerBundleInfo::GetMainAbility() const
3702 {
3703 AbilityInfo abilityInfo;
3704 GetMainAbilityInfo(abilityInfo);
3705 return abilityInfo.name;
3706 }
3707
GetMainAbilityInfo(AbilityInfo & abilityInfo) const3708 void InnerBundleInfo::GetMainAbilityInfo(AbilityInfo &abilityInfo) const
3709 {
3710 for (const auto& item : innerModuleInfos_) {
3711 const std::string& key = item.second.entryAbilityKey;
3712 if (!key.empty() && (baseAbilityInfos_.count(key) != 0)) {
3713 abilityInfo = baseAbilityInfos_.at(key);
3714 if (item.second.isEntry) {
3715 return;
3716 }
3717 }
3718 }
3719 }
3720
HasEntry() const3721 bool InnerBundleInfo::HasEntry() const
3722 {
3723 return std::any_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3724 return item.second.isEntry;
3725 });
3726 }
3727
IsHsp() const3728 bool InnerBundleInfo::IsHsp() const
3729 {
3730 if (!innerModuleInfos_.empty()) {
3731 return std::all_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
3732 return item.second.distro.moduleType == Profile::MODULE_TYPE_SHARED;
3733 });
3734 }
3735 return false;
3736 }
3737
SetAppDistributionType(const std::string & appDistributionType)3738 void InnerBundleInfo::SetAppDistributionType(const std::string &appDistributionType)
3739 {
3740 baseApplicationInfo_->appDistributionType = appDistributionType;
3741 }
3742
GetAppDistributionType() const3743 std::string InnerBundleInfo::GetAppDistributionType() const
3744 {
3745 return baseApplicationInfo_->appDistributionType;
3746 }
3747
SetAppProvisionType(const std::string & appProvisionType)3748 void InnerBundleInfo::SetAppProvisionType(const std::string &appProvisionType)
3749 {
3750 baseApplicationInfo_->appProvisionType = appProvisionType;
3751 }
3752
GetAppProvisionType() const3753 std::string InnerBundleInfo::GetAppProvisionType() const
3754 {
3755 return baseApplicationInfo_->appProvisionType;
3756 }
3757
SetAppCrowdtestDeadline(int64_t crowdtestDeadline)3758 void InnerBundleInfo::SetAppCrowdtestDeadline(int64_t crowdtestDeadline)
3759 {
3760 baseApplicationInfo_->crowdtestDeadline = crowdtestDeadline;
3761 }
3762
GetAppCrowdtestDeadline() const3763 int64_t InnerBundleInfo::GetAppCrowdtestDeadline() const
3764 {
3765 return baseApplicationInfo_->crowdtestDeadline;
3766 }
3767
GetDistroModuleName() const3768 std::vector<std::string> InnerBundleInfo::GetDistroModuleName() const
3769 {
3770 std::vector<std::string> moduleVec;
3771 for (const auto &item : innerModuleInfos_) {
3772 moduleVec.push_back(item.second.moduleName);
3773 }
3774 return moduleVec;
3775 }
3776
GetModuleNameByPackage(const std::string & packageName) const3777 std::string InnerBundleInfo::GetModuleNameByPackage(const std::string &packageName) const
3778 {
3779 auto it = innerModuleInfos_.find(packageName);
3780 if (it == innerModuleInfos_.end()) {
3781 return Constants::EMPTY_STRING;
3782 }
3783 return it->second.moduleName;
3784 }
3785
GetModuleTypeByPackage(const std::string & packageName) const3786 std::string InnerBundleInfo::GetModuleTypeByPackage(const std::string &packageName) const
3787 {
3788 auto it = innerModuleInfos_.find(packageName);
3789 if (it == innerModuleInfos_.end()) {
3790 return Constants::EMPTY_STRING;
3791 }
3792 return it->second.distro.moduleType;
3793 }
3794
GetAppQuickFix() const3795 AppQuickFix InnerBundleInfo::GetAppQuickFix() const
3796 {
3797 return baseApplicationInfo_->appQuickFix;
3798 }
3799
SetAppQuickFix(const AppQuickFix & appQuickFix)3800 void InnerBundleInfo::SetAppQuickFix(const AppQuickFix &appQuickFix)
3801 {
3802 baseApplicationInfo_->appQuickFix = appQuickFix;
3803 if (appQuickFix.deployedAppqfInfo.hqfInfos.empty() && appQuickFix.deployingAppqfInfo.hqfInfos.empty()) {
3804 baseApplicationInfo_->appQuickFix.bundleName = Constants::EMPTY_STRING;
3805 baseApplicationInfo_->appQuickFix.versionCode = 0;
3806 baseApplicationInfo_->appQuickFix.versionName = Constants::EMPTY_STRING;
3807 }
3808 SetQuickFixHqfInfos(appQuickFix.deployedAppqfInfo.hqfInfos);
3809 }
3810
GetQuickFixHqfInfos() const3811 std::vector<HqfInfo> InnerBundleInfo::GetQuickFixHqfInfos() const
3812 {
3813 return hqfInfos_;
3814 }
3815
SetQuickFixHqfInfos(const std::vector<HqfInfo> & hqfInfos)3816 void InnerBundleInfo::SetQuickFixHqfInfos(const std::vector<HqfInfo> &hqfInfos)
3817 {
3818 hqfInfos_ = hqfInfos;
3819 }
3820
FetchNativeSoAttrs(const std::string & requestPackage,std::string & cpuAbi,std::string & nativeLibraryPath) const3821 bool InnerBundleInfo::FetchNativeSoAttrs(
3822 const std::string &requestPackage, std::string &cpuAbi, std::string &nativeLibraryPath) const
3823 {
3824 auto moduleIter = innerModuleInfos_.find(requestPackage);
3825 if (moduleIter == innerModuleInfos_.end()) {
3826 APP_LOGE("requestPackage(%{public}s) not exist", requestPackage.c_str());
3827 return false;
3828 }
3829
3830 auto &moduleInfo = moduleIter->second;
3831 if (!moduleInfo.compressNativeLibs) {
3832 cpuAbi = moduleInfo.cpuAbi;
3833 nativeLibraryPath = moduleInfo.nativeLibraryPath;
3834 return !nativeLibraryPath.empty();
3835 }
3836
3837 if (moduleInfo.isLibIsolated) {
3838 cpuAbi = moduleInfo.cpuAbi;
3839 nativeLibraryPath = moduleInfo.nativeLibraryPath;
3840 } else {
3841 cpuAbi = baseApplicationInfo_->cpuAbi;
3842 nativeLibraryPath = baseApplicationInfo_->nativeLibraryPath;
3843 }
3844
3845 return !nativeLibraryPath.empty();
3846 }
3847
IsLibIsolated(const std::string & moduleName) const3848 bool InnerBundleInfo::IsLibIsolated(const std::string &moduleName) const
3849 {
3850 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3851 if (!moduleInfo) {
3852 APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
3853 return false;
3854 }
3855
3856 return moduleInfo->isLibIsolated;
3857 }
3858
GetDeviceType(const std::string & packageName) const3859 std::vector<std::string> InnerBundleInfo::GetDeviceType(const std::string &packageName) const
3860 {
3861 auto it = innerModuleInfos_.find(packageName);
3862 if (it == innerModuleInfos_.end()) {
3863 APP_LOGW("%{public}s not existed", packageName.c_str());
3864 return std::vector<std::string>();
3865 }
3866 return innerModuleInfos_.at(packageName).deviceTypes;
3867 }
3868
AddApplyQuickFixFrequency()3869 void InnerBundleInfo::AddApplyQuickFixFrequency()
3870 {
3871 ++applyQuickFixFrequency_;
3872 }
3873
GetApplyQuickFixFrequency() const3874 int32_t InnerBundleInfo::GetApplyQuickFixFrequency() const
3875 {
3876 return applyQuickFixFrequency_;
3877 }
3878
ResetApplyQuickFixFrequency()3879 void InnerBundleInfo::ResetApplyQuickFixFrequency()
3880 {
3881 applyQuickFixFrequency_ = 0;
3882 }
3883
GetAllHspVersion() const3884 std::vector<uint32_t> InnerBundleInfo::GetAllHspVersion() const
3885 {
3886 std::vector<uint32_t> versionCodes;
3887 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
3888 for (const auto &module : modules) {
3889 if (std::find(versionCodes.begin(), versionCodes.end(), module.versionCode) == versionCodes.end()) {
3890 versionCodes.emplace_back(module.versionCode);
3891 }
3892 }
3893 }
3894 return versionCodes;
3895 }
3896
DeleteHspModuleByVersion(int32_t versionCode)3897 void InnerBundleInfo::DeleteHspModuleByVersion(int32_t versionCode)
3898 {
3899 for (auto modulesIt = innerSharedModuleInfos_.begin(); modulesIt != innerSharedModuleInfos_.end();) {
3900 if (modulesIt->second.size() == SINGLE_HSP_VERSION &&
3901 modulesIt->second.front().versionCode == static_cast<uint32_t>(versionCode)) {
3902 modulesIt = innerSharedModuleInfos_.erase(modulesIt);
3903 } else {
3904 modulesIt->second.erase(
3905 std::remove_if(modulesIt->second.begin(), modulesIt->second.end(),
3906 [versionCode] (InnerModuleInfo &module) {
3907 return module.versionCode == static_cast<uint32_t>(versionCode);
3908 }));
3909 ++modulesIt;
3910 }
3911 }
3912 }
3913
GetProxyDataInfos(const std::string & moduleName,std::vector<ProxyData> & proxyDatas) const3914 ErrCode InnerBundleInfo::GetProxyDataInfos(
3915 const std::string &moduleName, std::vector<ProxyData> &proxyDatas) const
3916 {
3917 if (moduleName == Constants::EMPTY_STRING) {
3918 GetAllProxyDataInfos(proxyDatas);
3919 return ERR_OK;
3920 }
3921 auto moduleIt = std::find_if(innerModuleInfos_.begin(), innerModuleInfos_.end(), [&moduleName](const auto &info) {
3922 return info.second.moduleName == moduleName;
3923 });
3924 if (moduleIt != innerModuleInfos_.end()) {
3925 proxyDatas.insert(
3926 proxyDatas.end(), moduleIt->second.proxyDatas.begin(), moduleIt->second.proxyDatas.end());
3927 } else {
3928 APP_LOGE("moduleName %{public}s not found", moduleName.c_str());
3929 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
3930 }
3931 if (proxyDatas.empty()) {
3932 APP_LOGW("proxyDatas is empty");
3933 }
3934 return ERR_OK;
3935 }
3936
GetAllProxyDataInfos(std::vector<ProxyData> & proxyDatas) const3937 void InnerBundleInfo::GetAllProxyDataInfos(std::vector<ProxyData> &proxyDatas) const
3938 {
3939 for (const auto &innerModuleInfo : innerModuleInfos_) {
3940 proxyDatas.insert(
3941 proxyDatas.end(), innerModuleInfo.second.proxyDatas.begin(), innerModuleInfo.second.proxyDatas.end());
3942 }
3943 }
3944
GetIsolationMode(const std::string & isolationMode) const3945 IsolationMode InnerBundleInfo::GetIsolationMode(const std::string &isolationMode) const
3946 {
3947 auto isolationModeRes = ISOLATION_MODE_MAP.find(isolationMode);
3948 if (isolationModeRes != ISOLATION_MODE_MAP.end()) {
3949 return isolationModeRes->second;
3950 } else {
3951 return IsolationMode::NONISOLATION_FIRST;
3952 }
3953 }
3954
SetModuleHapPath(const std::string & hapPath)3955 void InnerBundleInfo::SetModuleHapPath(const std::string &hapPath)
3956 {
3957 if (innerModuleInfos_.count(currentPackage_) == 1) {
3958 innerModuleInfos_.at(currentPackage_).hapPath = hapPath;
3959 for (auto &abilityInfo : baseAbilityInfos_) {
3960 abilityInfo.second.hapPath = hapPath;
3961 }
3962 for (auto &extensionInfo : baseExtensionInfos_) {
3963 extensionInfo.second.hapPath = hapPath;
3964 }
3965 if (!innerModuleInfos_.at(currentPackage_).compressNativeLibs &&
3966 !innerModuleInfos_.at(currentPackage_).nativeLibraryPath.empty()) {
3967 auto pos = hapPath.rfind(ServiceConstants::PATH_SEPARATOR);
3968 if (pos != std::string::npos) {
3969 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
3970 hapPath.substr(pos + 1, hapPath.length() - pos - 1) + NATIVE_LIBRARY_PATH_SYMBOL +
3971 innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
3972 return;
3973 }
3974 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
3975 hapPath + NATIVE_LIBRARY_PATH_SYMBOL + innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
3976 }
3977 }
3978 }
3979
IsCompressNativeLibs(const std::string & moduleName) const3980 bool InnerBundleInfo::IsCompressNativeLibs(const std::string &moduleName) const
3981 {
3982 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
3983 if (!moduleInfo) {
3984 APP_LOGE("Get moduleInfo(%{public}s) failed", moduleName.c_str());
3985 return true; // compressNativeLibs default true
3986 }
3987
3988 return moduleInfo->compressNativeLibs;
3989 }
3990
SetNativeLibraryFileNames(const std::string & moduleName,const std::vector<std::string> & fileNames)3991 void InnerBundleInfo::SetNativeLibraryFileNames(const std::string &moduleName,
3992 const std::vector<std::string> &fileNames)
3993 {
3994 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
3995 APP_LOGE("innerBundleInfo not contain the module: %{public}s", moduleName.c_str());
3996 return;
3997 }
3998 innerModuleInfos_.at(moduleName).nativeLibraryFileNames = fileNames;
3999 }
4000
UpdateSharedModuleInfo()4001 void InnerBundleInfo::UpdateSharedModuleInfo()
4002 {
4003 auto sharedModuleInfoIter = innerSharedModuleInfos_.find(currentPackage_);
4004 auto moduleInfoIter = innerModuleInfos_.find(currentPackage_);
4005 if ((sharedModuleInfoIter == innerSharedModuleInfos_.end()) ||
4006 (moduleInfoIter == innerModuleInfos_.end())) {
4007 APP_LOGE("The shared module(%{public}s) infomation not exist", currentPackage_.c_str());
4008 return;
4009 }
4010 auto &innerModuleInfoVector = sharedModuleInfoIter->second;
4011 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
4012 if (iter->versionCode == moduleInfoIter->second.versionCode) {
4013 iter->hapPath = moduleInfoIter->second.hapPath;
4014 iter->compressNativeLibs = moduleInfoIter->second.compressNativeLibs;
4015 iter->cpuAbi = moduleInfoIter->second.cpuAbi;
4016 iter->nativeLibraryPath = moduleInfoIter->second.nativeLibraryPath;
4017 iter->nativeLibraryFileNames = moduleInfoIter->second.nativeLibraryFileNames;
4018 return;
4019 }
4020 }
4021 }
4022
SetExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4023 ErrCode InnerBundleInfo::SetExtName(
4024 const std::string &moduleName, const std::string &abilityName, const std::string extName)
4025 {
4026 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4027 if (abilityInfoPair == baseAbilityInfos_.end()) {
4028 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4029 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4030 }
4031 if (moduleName != abilityInfoPair->second.moduleName) {
4032 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4033 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4034 }
4035 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4036 bool duplicated = std::any_of(supportExtNames.begin(), supportExtNames.end(), [&extName](const auto &name) {
4037 return extName == name;
4038 });
4039 if (duplicated) {
4040 APP_LOGW("extName %{public}s already exist in ability %{public}s", extName.c_str(), abilityName.c_str());
4041 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4042 }
4043 supportExtNames.emplace_back(extName);
4044 return ERR_OK;
4045 }
4046
SetMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4047 ErrCode InnerBundleInfo::SetMimeType(
4048 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4049 {
4050 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4051 if (abilityInfoPair == baseAbilityInfos_.end()) {
4052 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4053 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4054 }
4055 if (moduleName != abilityInfoPair->second.moduleName) {
4056 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4057 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4058 }
4059 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4060 bool duplicated = std::any_of(supportMimeTypes.begin(), supportMimeTypes.end(), [&mimeType](const auto &type) {
4061 return mimeType == type;
4062 });
4063 if (duplicated) {
4064 APP_LOGW("MIME type %{public}s already exist in ability %{public}s", mimeType.c_str(), abilityName.c_str());
4065 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
4066 }
4067 abilityInfoPair->second.supportMimeTypes.emplace_back(mimeType);
4068 return ERR_OK;
4069 }
4070
DelExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)4071 ErrCode InnerBundleInfo::DelExtName(
4072 const std::string &moduleName, const std::string &abilityName, const std::string extName)
4073 {
4074 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4075 if (abilityInfoPair == baseAbilityInfos_.end()) {
4076 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4077 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4078 }
4079 if (moduleName != abilityInfoPair->second.moduleName) {
4080 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4081 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4082 }
4083 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
4084 supportExtNames.erase(std::remove(supportExtNames.begin(), supportExtNames.end(), extName), supportExtNames.end());
4085 return ERR_OK;
4086 }
4087
DelMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)4088 ErrCode InnerBundleInfo::DelMimeType(
4089 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
4090 {
4091 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
4092 if (abilityInfoPair == baseAbilityInfos_.end()) {
4093 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
4094 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
4095 }
4096 if (moduleName != abilityInfoPair->second.moduleName) {
4097 APP_LOGE("module %{public}s not exists", moduleName.c_str());
4098 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4099 }
4100 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
4101 supportMimeTypes.erase(
4102 std::remove(supportMimeTypes.begin(), supportMimeTypes.end(), mimeType), supportMimeTypes.end());
4103 return ERR_OK;
4104 }
4105
GetAppServiceHspInfo(BundleInfo & bundleInfo) const4106 ErrCode InnerBundleInfo::GetAppServiceHspInfo(BundleInfo &bundleInfo) const
4107 {
4108 if (baseApplicationInfo_->bundleType != BundleType::APP_SERVICE_FWK) {
4109 APP_LOGW("%{public}s is not app service", GetBundleName().c_str());
4110 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
4111 }
4112 bundleInfo = *baseBundleInfo_;
4113 bundleInfo.applicationInfo = *baseApplicationInfo_;
4114 for (const auto &info : innerModuleInfos_) {
4115 if (info.second.distro.moduleType == Profile::MODULE_TYPE_SHARED) {
4116 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, Constants::ALL_USERID);
4117 if (hapmoduleinfo) {
4118 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
4119 hapModuleInfo.moduleSourceDir = hapModuleInfo.hapPath.empty() ?
4120 info.second.modulePath : hapModuleInfo.moduleSourceDir;
4121 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
4122 }
4123 }
4124 }
4125 if (bundleInfo.hapModuleInfos.empty()) {
4126 APP_LOGE("bundleName:%{public}s no hsp module info", baseApplicationInfo_->bundleName.c_str());
4127 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
4128 }
4129 return ERR_OK;
4130 }
4131
UpdateIsCompressNativeLibs()4132 void InnerBundleInfo::UpdateIsCompressNativeLibs()
4133 {
4134 if (innerModuleInfos_.empty()) {
4135 baseApplicationInfo_->isCompressNativeLibs = true;
4136 return;
4137 }
4138 baseApplicationInfo_->isCompressNativeLibs = false;
4139 for (const auto &info : innerModuleInfos_) {
4140 baseApplicationInfo_->isCompressNativeLibs =
4141 (baseApplicationInfo_->isCompressNativeLibs || info.second.compressNativeLibs) ? true : false;
4142 }
4143 }
4144
SetResourcesApply(const std::vector<int32_t> & resourcesApply)4145 void InnerBundleInfo::SetResourcesApply(const std::vector<int32_t> &resourcesApply)
4146 {
4147 baseApplicationInfo_->resourcesApply = resourcesApply;
4148 }
4149
InnerProcessShortcut(const Shortcut & oldShortcut,ShortcutInfo & shortcutInfo) const4150 void InnerBundleInfo::InnerProcessShortcut(const Shortcut &oldShortcut, ShortcutInfo &shortcutInfo) const
4151 {
4152 shortcutInfo.id = oldShortcut.shortcutId;
4153 shortcutInfo.icon = oldShortcut.icon;
4154 shortcutInfo.label = oldShortcut.label;
4155 shortcutInfo.iconId = oldShortcut.iconId;
4156 if (shortcutInfo.iconId == 0) {
4157 auto iter = oldShortcut.icon.find(PORT_SEPARATOR);
4158 if (iter != std::string::npos) {
4159 shortcutInfo.iconId = static_cast<uint32_t>(atoi(oldShortcut.icon.substr(iter + 1).c_str()));
4160 }
4161 }
4162 shortcutInfo.labelId = oldShortcut.labelId;
4163 if (shortcutInfo.labelId == 0) {
4164 auto iter = oldShortcut.label.find(PORT_SEPARATOR);
4165 if (iter != std::string::npos) {
4166 shortcutInfo.labelId = static_cast<uint32_t>(atoi(oldShortcut.label.substr(iter + 1).c_str()));
4167 }
4168 }
4169 for (const ShortcutWant &shortcutWant : oldShortcut.wants) {
4170 ShortcutIntent shortcutIntent;
4171 shortcutIntent.targetBundle = shortcutWant.bundleName;
4172 shortcutIntent.targetModule = shortcutWant.moduleName;
4173 shortcutIntent.targetClass = shortcutWant.abilityName;
4174 shortcutIntent.parameters = shortcutWant.parameters;
4175 shortcutInfo.intents.emplace_back(shortcutIntent);
4176 }
4177 }
4178
GetEntryModuleName() const4179 std::string InnerBundleInfo::GetEntryModuleName() const
4180 {
4181 for (const auto &item : innerModuleInfos_) {
4182 if (item.second.isEntry) {
4183 return item.second.modulePackage;
4184 }
4185 }
4186 return Constants::EMPTY_STRING;
4187 }
4188
SetMoudleIsEncrpted(const std::string & packageName,bool isEncrypted)4189 void InnerBundleInfo::SetMoudleIsEncrpted(const std::string &packageName, bool isEncrypted)
4190 {
4191 auto it = innerModuleInfos_.find(packageName);
4192 if (it == innerModuleInfos_.end()) {
4193 return;
4194 }
4195 it->second.isEncrypted = isEncrypted;
4196 }
4197
IsEncryptedMoudle(const std::string & packageName) const4198 bool InnerBundleInfo::IsEncryptedMoudle(const std::string &packageName) const
4199 {
4200 auto it = innerModuleInfos_.find(packageName);
4201 if (it == innerModuleInfos_.end()) {
4202 return false;
4203 }
4204 return it->second.isEncrypted;
4205 }
4206
GetAllEncryptedModuleNames(std::vector<std::string> & moduleNames) const4207 void InnerBundleInfo::GetAllEncryptedModuleNames(std::vector<std::string> &moduleNames) const
4208 {
4209 for (const auto &info : innerModuleInfos_) {
4210 if (info.second.isEncrypted) {
4211 moduleNames.emplace_back(info.second.moduleName);
4212 }
4213 }
4214 }
4215
IsContainEncryptedModule() const4216 bool InnerBundleInfo::IsContainEncryptedModule() const
4217 {
4218 for (const auto &info : innerModuleInfos_) {
4219 if (info.second.isEncrypted) {
4220 return true;
4221 }
4222 }
4223 return false;
4224 }
4225
GetAppIdentifier() const4226 std::string InnerBundleInfo::GetAppIdentifier() const
4227 {
4228 return baseBundleInfo_->signatureInfo.appIdentifier;
4229 }
4230
SetAppIdentifier(const std::string & appIdentifier)4231 void InnerBundleInfo::SetAppIdentifier(const std::string &appIdentifier)
4232 {
4233 baseBundleInfo_->signatureInfo.appIdentifier = appIdentifier;
4234 }
4235
SetCertificate(const std::string & certificate)4236 void InnerBundleInfo::SetCertificate(const std::string &certificate)
4237 {
4238 baseBundleInfo_->signatureInfo.certificate = certificate;
4239 }
4240
GetCertificate() const4241 std::string InnerBundleInfo::GetCertificate() const
4242 {
4243 return baseBundleInfo_->signatureInfo.certificate;
4244 }
4245
UpdateDebug(bool debug,bool isEntry)4246 void InnerBundleInfo::UpdateDebug(bool debug, bool isEntry)
4247 {
4248 if (isEntry) {
4249 baseApplicationInfo_->debug = debug;
4250 } else if (!HasEntry() && debug) {
4251 baseApplicationInfo_->debug = debug;
4252 }
4253 }
4254
AddOldAppId(const std::string & appId)4255 void InnerBundleInfo::AddOldAppId(const std::string &appId)
4256 {
4257 auto appIds = baseBundleInfo_->oldAppIds;
4258 if (std::find(appIds.begin(), appIds.end(), appId) == appIds.end()) {
4259 baseBundleInfo_->oldAppIds.emplace_back(appId);
4260 }
4261 }
4262
GetOldAppIds() const4263 std::vector<std::string> InnerBundleInfo::GetOldAppIds() const
4264 {
4265 return baseBundleInfo_->oldAppIds;
4266 }
4267
GetQuerySchemes() const4268 std::vector<std::string> InnerBundleInfo::GetQuerySchemes() const
4269 {
4270 std::string entryModuleName = GetEntryModuleName();
4271 auto it = innerModuleInfos_.find(entryModuleName);
4272 if (it == innerModuleInfos_.end()) {
4273 return std::vector<std::string>();
4274 }
4275 std::vector<std::string> querySchemes = innerModuleInfos_.at(entryModuleName).querySchemes;
4276 for (size_t i = 0; i < querySchemes.size(); i++) {
4277 transform(querySchemes[i].begin(), querySchemes[i].end(), querySchemes[i].begin(), ::tolower);
4278 }
4279 return querySchemes;
4280 }
4281
UpdateOdid(const std::string & developerId,const std::string & odid)4282 void InnerBundleInfo::UpdateOdid(const std::string &developerId, const std::string &odid)
4283 {
4284 developerId_ = developerId;
4285 odid_ = odid;
4286 }
4287
UpdateOdidByBundleInfo(const InnerBundleInfo & info)4288 void InnerBundleInfo::UpdateOdidByBundleInfo(const InnerBundleInfo &info)
4289 {
4290 std::string developerId;
4291 std::string odid;
4292 info.GetDeveloperidAndOdid(developerId, odid);
4293 developerId_ = developerId;
4294 odid_ = odid;
4295 }
4296
GetDeveloperidAndOdid(std::string & developerId,std::string & odid) const4297 void InnerBundleInfo::GetDeveloperidAndOdid(std::string &developerId, std::string &odid) const
4298 {
4299 developerId = developerId_;
4300 odid = odid_;
4301 }
4302
GetOdid(std::string & odid) const4303 void InnerBundleInfo::GetOdid(std::string &odid) const
4304 {
4305 odid = odid_;
4306 }
4307
AddAllowedAcls(const std::vector<std::string> & allowedAcls)4308 void InnerBundleInfo::AddAllowedAcls(const std::vector<std::string> &allowedAcls)
4309 {
4310 for (const auto &acl : allowedAcls) {
4311 if (!acl.empty() && (std::find(allowedAcls_.begin(), allowedAcls_.end(), acl) == allowedAcls_.end())) {
4312 allowedAcls_.emplace_back(acl);
4313 }
4314 }
4315 }
4316
IsAsanEnabled() const4317 bool InnerBundleInfo::IsAsanEnabled() const
4318 {
4319 for (const auto &item : innerModuleInfos_) {
4320 if (item.second.asanEnabled) {
4321 return true;
4322 }
4323 }
4324 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4325 for (const auto &module : modules) {
4326 if (module.asanEnabled) {
4327 return true;
4328 }
4329 }
4330 }
4331 return false;
4332 }
4333
IsGwpAsanEnabled() const4334 bool InnerBundleInfo::IsGwpAsanEnabled() const
4335 {
4336 for (const auto &item : innerModuleInfos_) {
4337 if (item.second.gwpAsanEnabled) {
4338 return true;
4339 }
4340 }
4341 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4342 for (const auto &module : modules) {
4343 if (module.gwpAsanEnabled) {
4344 return true;
4345 }
4346 }
4347 }
4348 return false;
4349 }
4350
IsTsanEnabled() const4351 bool InnerBundleInfo::IsTsanEnabled() const
4352 {
4353 for (const auto &item : innerModuleInfos_) {
4354 if (item.second.tsanEnabled) {
4355 return true;
4356 }
4357 }
4358 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4359 for (const auto &module : modules) {
4360 if (module.tsanEnabled) {
4361 return true;
4362 }
4363 }
4364 }
4365 return false;
4366 }
4367
IsHwasanEnabled() const4368 bool InnerBundleInfo::IsHwasanEnabled() const
4369 {
4370 bool hwasanEnabled = false;
4371 for (const auto &item : innerModuleInfos_) {
4372 hwasanEnabled = static_cast<bool>(item.second.innerModuleInfoFlag &
4373 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4374 if (hwasanEnabled) {
4375 return true;
4376 }
4377 }
4378 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
4379 for (const auto &module : modules) {
4380 hwasanEnabled = static_cast<bool>(module.innerModuleInfoFlag &
4381 GetSanitizerFlag(GetInnerModuleInfoFlag::GET_INNER_MODULE_INFO_WITH_HWASANENABLED));
4382 if (hwasanEnabled) {
4383 return true;
4384 }
4385 }
4386 }
4387 return false;
4388 }
4389
NeedCreateEl5Dir() const4390 bool InnerBundleInfo::NeedCreateEl5Dir() const
4391 {
4392 std::vector<RequestPermission> reqPermissions = GetAllRequestPermissions();
4393 auto it = std::find_if(reqPermissions.begin(), reqPermissions.end(), [](const RequestPermission& permission) {
4394 return permission.name == ServiceConstants::PERMISSION_PROTECT_SCREEN_LOCK_DATA;
4395 });
4396 return it != reqPermissions.end();
4397 }
4398
GetUninstallState() const4399 bool InnerBundleInfo::GetUninstallState() const
4400 {
4401 return uninstallState_;
4402 }
4403
SetUninstallState(const bool & uninstallState)4404 void InnerBundleInfo::SetUninstallState(const bool &uninstallState)
4405 {
4406 uninstallState_ = uninstallState;
4407 }
4408
IsNeedSendNotify() const4409 bool InnerBundleInfo::IsNeedSendNotify() const
4410 {
4411 return isNeedSendNotify_;
4412 }
4413
SetNeedSendNotify(const bool needStatus)4414 void InnerBundleInfo::SetNeedSendNotify(const bool needStatus)
4415 {
4416 isNeedSendNotify_ = needStatus;
4417 }
4418
GetAllExtensionDirsInSpecifiedModule(const std::string & moduleName) const4419 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirsInSpecifiedModule(const std::string &moduleName) const
4420 {
4421 std::vector<std::string> dirVec;
4422 auto extensionInfoMap = GetInnerExtensionInfos();
4423 for (auto item : extensionInfoMap) {
4424 if (item.second.moduleName != moduleName || !item.second.needCreateSandbox) {
4425 continue;
4426 }
4427 std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4428 ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4429 ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4430 dirVec.emplace_back(dir);
4431 }
4432 return dirVec;
4433 }
4434
GetAllExtensionDirs() const4435 std::vector<std::string> InnerBundleInfo::GetAllExtensionDirs() const
4436 {
4437 std::vector<std::string> dirVec;
4438 auto extensionInfoMap = GetInnerExtensionInfos();
4439 for (auto item : extensionInfoMap) {
4440 if (!item.second.needCreateSandbox) {
4441 continue;
4442 }
4443 // eg: +extension-entry-inputMethodExtAbility+com.example.myapplication
4444 std::string dir = ServiceConstants::EXTENSION_DIR + item.second.moduleName +
4445 ServiceConstants::FILE_SEPARATOR_LINE + item.second.name +
4446 ServiceConstants::FILE_SEPARATOR_PLUS + item.second.bundleName;
4447 dirVec.emplace_back(dir);
4448 }
4449 return dirVec;
4450 }
4451
SetApplicationFlags(ApplicationInfoFlag flag)4452 void InnerBundleInfo::SetApplicationFlags(ApplicationInfoFlag flag)
4453 {
4454 uint32_t applicationFlags = static_cast<uint32_t>(baseApplicationInfo_->applicationFlags);
4455 uint32_t installSourceFlag = static_cast<uint32_t>(flag);
4456 baseApplicationInfo_->applicationFlags =
4457 static_cast<int32_t>((applicationFlags & PREINSTALL_SOURCE_CLEAN_MASK) | installSourceFlag);
4458 }
4459
UpdateExtensionSandboxInfo(const std::vector<std::string> & typeList)4460 void InnerBundleInfo::UpdateExtensionSandboxInfo(const std::vector<std::string> &typeList)
4461 {
4462 for (auto &extensionItem : baseExtensionInfos_) {
4463 extensionItem.second.needCreateSandbox = false;
4464 std::string typeName = extensionItem.second.extensionTypeName;
4465 auto it = std::find(typeList.begin(), typeList.end(), typeName);
4466 if (it != typeList.end()) {
4467 extensionItem.second.needCreateSandbox = true;
4468 }
4469 }
4470 }
4471
UpdateExtensionDataGroupInfo(const std::string & key,const std::vector<std::string> & dataGroupIds)4472 void InnerBundleInfo::UpdateExtensionDataGroupInfo(
4473 const std::string &key, const std::vector<std::string>& dataGroupIds)
4474 {
4475 auto it = baseExtensionInfos_.find(key);
4476 if (it == baseExtensionInfos_.end()) {
4477 APP_LOGW("UpdateExtensionDataGroupInfo not find key: %{public}s", key.c_str());
4478 return;
4479 }
4480 it->second.validDataGroupIds = dataGroupIds;
4481 }
4482
AddDataGroupInfo(const std::string & dataGroupId,const DataGroupInfo & info)4483 void InnerBundleInfo::AddDataGroupInfo(const std::string &dataGroupId, const DataGroupInfo &info)
4484 {
4485 APP_LOGD("AddDataGroupInfo, dataGroupId: %{public}s, dataGroupInfo: %{public}s",
4486 dataGroupId.c_str(), info.ToString().c_str());
4487 auto dataGroupInfosItem = dataGroupInfos_.find(dataGroupId);
4488 if (dataGroupInfosItem == dataGroupInfos_.end()) {
4489 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for dataGroupId: %{public}s", dataGroupId.c_str());
4490 dataGroupInfos_[dataGroupId] = std::vector<DataGroupInfo> { info };
4491 return;
4492 }
4493 int32_t userId = info.userId;
4494 auto iter = std::find_if(std::begin(dataGroupInfos_[dataGroupId]), std::end(dataGroupInfos_[dataGroupId]),
4495 [userId](const DataGroupInfo &dataGroupinfo) { return dataGroupinfo.userId == userId; });
4496 if (iter != std::end(dataGroupInfos_[dataGroupId])) {
4497 if ((iter->uid == info.uid) && (iter->uuid == info.uuid)) {
4498 return;
4499 }
4500 APP_LOGW("uid or uuid not same, dataGroupId: %{public}s", dataGroupId.c_str());
4501 dataGroupInfos_[dataGroupId].erase(iter);
4502 }
4503 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for user: %{public}d", info.userId);
4504 dataGroupInfos_[dataGroupId].emplace_back(info);
4505 }
4506
AddCloneBundle(const InnerBundleCloneInfo & attr)4507 ErrCode InnerBundleInfo::AddCloneBundle(const InnerBundleCloneInfo &attr)
4508 {
4509 int32_t userId = attr.userId;
4510 int32_t appIndex = attr.appIndex;
4511 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4512 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4513 APP_LOGE("Add Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4514 userId, GetBundleName().c_str());
4515 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4516 }
4517 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4518 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4519
4520 if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4521 APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4522 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4523 }
4524 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4525 if (cloneInfos.find(appIndexKey) != cloneInfos.end()) {
4526 APP_LOGE("Add Clone Bundle Fail, appIndex: %{public}d existed", appIndex);
4527 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
4528 }
4529
4530 InnerBundleCloneInfo cloneInfo;
4531 cloneInfo.userId = userId;
4532 cloneInfo.appIndex = appIndex;
4533 // copy from user
4534 cloneInfo.enabled = userInfo.bundleUserInfo.enabled;
4535 cloneInfo.disabledAbilities = userInfo.bundleUserInfo.disabledAbilities;
4536 cloneInfo.accessTokenId = attr.accessTokenId;
4537 cloneInfo.accessTokenIdEx = attr.accessTokenIdEx;
4538 cloneInfo.uid = attr.uid;
4539 cloneInfo.gids = attr.gids;
4540 int64_t now = BundleUtil::GetCurrentTimeMs();
4541 cloneInfo.installTime = now;
4542
4543 cloneInfos[appIndexKey] = cloneInfo;
4544 APP_LOGD("Add clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4545 userId, appIndex, GetBundleName().c_str());
4546 return ERR_OK;
4547 }
4548
RemoveCloneBundle(const int32_t userId,const int32_t appIndex)4549 ErrCode InnerBundleInfo::RemoveCloneBundle(const int32_t userId, const int32_t appIndex)
4550 {
4551 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4552 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4553 APP_LOGE("Remove Clone Bundle Fail, userId: %{public}d not found in bundleName: %{public}s",
4554 userId, GetBundleName().c_str());
4555 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4556 }
4557 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4558 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4559
4560 if (appIndex < ServiceConstants::CLONE_APP_INDEX_MIN || appIndex > ServiceConstants::CLONE_APP_INDEX_MAX) {
4561 APP_LOGE("Remove Clone Bundle Fail, appIndex: %{public}d not in valid range", appIndex);
4562 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4563 }
4564 std::string appIndexKey = InnerBundleUserInfo::AppIndexToKey(appIndex);
4565 if (cloneInfos.find(appIndexKey) == cloneInfos.end()) {
4566 APP_LOGD("appIndex: %{public}d not found", appIndex);
4567 return ERR_OK;
4568 }
4569 cloneInfos.erase(appIndexKey);
4570 APP_LOGD("Remove clone app userId: %{public}d appIndex: %{public}d in bundle: %{public}s",
4571 userId, appIndex, GetBundleName().c_str());
4572 return ERR_OK;
4573 }
4574
GetAvailableCloneAppIndex(const int32_t userId,int32_t & appIndex)4575 ErrCode InnerBundleInfo::GetAvailableCloneAppIndex(const int32_t userId, int32_t &appIndex)
4576 {
4577 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4578 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4579 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4580 }
4581 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4582 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4583
4584 int32_t candidateAppIndex = 1;
4585 while (cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(candidateAppIndex)) != cloneInfos.end()) {
4586 candidateAppIndex++;
4587 }
4588 appIndex = candidateAppIndex;
4589 return ERR_OK;
4590 }
4591
IsCloneAppIndexExisted(const int32_t userId,const int32_t appIndex,bool & res)4592 ErrCode InnerBundleInfo::IsCloneAppIndexExisted(const int32_t userId, const int32_t appIndex, bool &res)
4593 {
4594 const std::string key = NameAndUserIdToKey(GetBundleName(), userId);
4595 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
4596 return ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST;
4597 }
4598 InnerBundleUserInfo &userInfo = innerBundleUserInfos_.find(key)->second;
4599 std::map<std::string, InnerBundleCloneInfo> &cloneInfos = userInfo.cloneInfos;
4600
4601 res = cloneInfos.find(InnerBundleUserInfo::AppIndexToKey(appIndex)) != cloneInfos.end();
4602 return ERR_OK;
4603 }
4604
GetApplicationInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,ApplicationInfo & appInfo) const4605 bool InnerBundleInfo::GetApplicationInfoAdaptBundleClone(
4606 const InnerBundleUserInfo &innerBundleUserInfo,
4607 int32_t appIndex,
4608 ApplicationInfo &appInfo) const
4609 {
4610 if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4611 if (appInfo.removable && !innerBundleUserInfo.isRemovable) {
4612 appInfo.removable = false;
4613 }
4614
4615 appInfo.accessTokenId = innerBundleUserInfo.accessTokenId;
4616 appInfo.accessTokenIdEx = innerBundleUserInfo.accessTokenIdEx;
4617 appInfo.enabled = innerBundleUserInfo.bundleUserInfo.enabled;
4618 appInfo.uid = innerBundleUserInfo.uid;
4619 return true;
4620 }
4621 APP_LOGD("start appIndex: %{public}d", appIndex);
4622 auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4623 if (iter == innerBundleUserInfo.cloneInfos.end()) {
4624 APP_LOGE("appIndex %{public}d not exist", appIndex);
4625 return false;
4626 }
4627 appInfo.accessTokenId = iter->second.accessTokenId;
4628 appInfo.accessTokenIdEx = iter->second.accessTokenIdEx;
4629 appInfo.enabled = iter->second.enabled;
4630 appInfo.uid = iter->second.uid;
4631 appInfo.appIndex = iter->second.appIndex;
4632 return true;
4633 }
4634
GetBundleInfoAdaptBundleClone(const InnerBundleUserInfo & innerBundleUserInfo,int32_t appIndex,BundleInfo & bundleInfo) const4635 bool InnerBundleInfo::GetBundleInfoAdaptBundleClone(
4636 const InnerBundleUserInfo &innerBundleUserInfo,
4637 int32_t appIndex,
4638 BundleInfo &bundleInfo) const
4639 {
4640 if (appIndex == 0 || appIndex > Constants::INITIAL_SANDBOX_APP_INDEX) {
4641 bundleInfo.uid = innerBundleUserInfo.uid;
4642 if (!innerBundleUserInfo.gids.empty()) {
4643 bundleInfo.gid = innerBundleUserInfo.gids[0];
4644 }
4645 bundleInfo.installTime = innerBundleUserInfo.installTime;
4646 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4647 bundleInfo.appIndex = appIndex_;
4648 return true;
4649 }
4650 APP_LOGD("start appIndex: %{public}d", appIndex);
4651 auto iter = innerBundleUserInfo.cloneInfos.find(std::to_string(appIndex));
4652 if (iter == innerBundleUserInfo.cloneInfos.end()) {
4653 APP_LOGE("appIndex %{public}d not exist", appIndex);
4654 return false;
4655 }
4656 bundleInfo.uid = iter->second.uid;
4657 bundleInfo.gid = iter->second.uid; // no gids, need add
4658 bundleInfo.installTime = iter->second.installTime;
4659 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
4660 bundleInfo.appIndex = appIndex;
4661 return true;
4662 }
4663
VerifyAndAckCloneAppIndex(int32_t userId,int32_t & appIndex)4664 ErrCode InnerBundleInfo::VerifyAndAckCloneAppIndex(int32_t userId, int32_t &appIndex)
4665 {
4666 auto multiAppModeData = this->baseApplicationInfo_->multiAppMode;
4667 if (multiAppModeData.multiAppModeType != MultiAppModeType::APP_CLONE) {
4668 APP_LOGE("bundleName:%{public}s is not clone app", GetBundleName().c_str());
4669 return ERR_APPEXECFWK_CLONE_INSTALL_APP_NOT_SUPPORTED_MULTI_TYPE;
4670 }
4671
4672 if (appIndex < 0) {
4673 APP_LOGE("appIndex:%{public}d not in valid range", appIndex);
4674 return ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX;
4675 }
4676 if (appIndex == 0) {
4677 ErrCode availableRes = GetAvailableCloneAppIndex(userId, appIndex);
4678 if (availableRes != ERR_OK) {
4679 APP_LOGE("Get Available Clone AppIndex Fail for, errCode: %{public}d", availableRes);
4680 return availableRes;
4681 }
4682 } else {
4683 bool found = false;
4684 ErrCode isExistedRes = IsCloneAppIndexExisted(userId, appIndex, found);
4685 if (isExistedRes != ERR_OK) {
4686 return isExistedRes;
4687 }
4688 if (found) {
4689 APP_LOGE("AppIndex %{public}d existed in userId %{public}d", appIndex, userId);
4690 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED;
4691 }
4692 }
4693 int32_t maxCount = std::min(multiAppModeData.maxCount, ServiceConstants::CLONE_APP_INDEX_MAX);
4694 if (appIndex > maxCount) {
4695 APP_LOGE("AppIndex %{public}d exceed max limit %{public}d in userId: %{public}d",
4696 appIndex, maxCount, userId);
4697 return ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXCEED_MAX_NUMBER;
4698 }
4699 return ERR_OK;
4700 }
4701
UpdateMultiAppMode(const InnerBundleInfo & newInfo)4702 void InnerBundleInfo::UpdateMultiAppMode(const InnerBundleInfo &newInfo)
4703 {
4704 std::string moduleType = newInfo.GetModuleTypeByPackage(newInfo.GetCurrentModulePackage());
4705 if (moduleType == Profile::MODULE_TYPE_ENTRY || moduleType == Profile::MODULE_TYPE_FEATURE) {
4706 baseApplicationInfo_->multiAppMode = newInfo.GetBaseApplicationInfo().multiAppMode;
4707 }
4708 }
4709
UpdateReleaseType(const InnerBundleInfo & newInfo)4710 void InnerBundleInfo::UpdateReleaseType(const InnerBundleInfo &newInfo)
4711 {
4712 if (baseBundleInfo_->releaseType.empty() ||
4713 baseApplicationInfo_->apiReleaseType.empty() ||
4714 !newInfo.IsHsp()) {
4715 baseBundleInfo_->releaseType = newInfo.GetBaseBundleInfo().releaseType;
4716 baseApplicationInfo_->apiReleaseType = newInfo.GetBaseApplicationInfo().apiReleaseType;
4717 }
4718 }
4719
AdaptMainLauncherResourceInfo(ApplicationInfo & applicationInfo) const4720 void InnerBundleInfo::AdaptMainLauncherResourceInfo(ApplicationInfo &applicationInfo) const
4721 {
4722 if (ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.find(GetBundleName()) !=
4723 ServiceConstants::ALLOW_MULTI_ICON_BUNDLE.end()) {
4724 return;
4725 }
4726 AbilityInfo mainAbilityInfo;
4727 GetMainAbilityInfo(mainAbilityInfo);
4728 if ((mainAbilityInfo.labelId != 0) && (mainAbilityInfo.iconId != 0)) {
4729 applicationInfo.labelId = mainAbilityInfo.labelId ;
4730 applicationInfo.labelResource.id = mainAbilityInfo.labelId;
4731 applicationInfo.labelResource.moduleName = mainAbilityInfo.moduleName;
4732 applicationInfo.labelResource.bundleName = mainAbilityInfo.bundleName;
4733
4734 applicationInfo.iconId = mainAbilityInfo.iconId ;
4735 applicationInfo.iconResource.id = mainAbilityInfo.iconId;
4736 applicationInfo.iconResource.moduleName = mainAbilityInfo.moduleName;
4737 applicationInfo.iconResource.bundleName = mainAbilityInfo.bundleName;
4738 }
4739 }
4740
GetCloneBundleAppIndexes() const4741 std::set<int32_t> InnerBundleInfo::GetCloneBundleAppIndexes() const
4742 {
4743 std::set<int32_t> appIndexes;
4744 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
4745 for (const auto &cloneInfo : innerBundleUserInfo.second.cloneInfos) {
4746 appIndexes.insert(cloneInfo.second.appIndex);
4747 }
4748 }
4749 return appIndexes;
4750 }
4751
GetSanitizerFlag(GetInnerModuleInfoFlag flag)4752 uint8_t InnerBundleInfo::GetSanitizerFlag(GetInnerModuleInfoFlag flag)
4753 {
4754 return 1 << (static_cast<uint8_t>(flag) - 1);
4755 }
4756
PrintSetEnabledInfo(bool isEnabled,int32_t userId,int32_t appIndex,const std::string & bundleName,const std::string & caller) const4757 void InnerBundleInfo::PrintSetEnabledInfo(bool isEnabled, int32_t userId, int32_t appIndex,
4758 const std::string &bundleName, const std::string &caller) const
4759 {
4760 if (!isEnabled) {
4761 APP_LOGW_NOFUNC("-n %{public}s -u %{public}d -i %{public}d disabled caller is %{public}s",
4762 bundleName.c_str(), userId, appIndex, caller.c_str());
4763 }
4764 }
4765 } // namespace AppExecFwk
4766 } // namespace OHOS
4767