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 <algorithm>
19 #include <deque>
20 #include <unistd.h>
21 #include "string_ex.h"
22
23 #ifdef BUNDLE_FRAMEWORK_APP_CONTROL
24 #include "app_control_constants.h"
25 #include "app_control_manager.h"
26 #endif
27 #include "bundle_mgr_client.h"
28 #include "bundle_permission_mgr.h"
29 #include "common_profile.h"
30 #include "distributed_module_info.h"
31 #include "distributed_ability_info.h"
32 #include "free_install_params.h"
33 #include "mime_type_mgr.h"
34 #include "parameters.h"
35
36 namespace OHOS {
37 namespace AppExecFwk {
38 namespace {
39 const std::string APP_TYPE = "appType";
40 const std::string UID = "uid";
41 const std::string GID = "gid";
42 const std::string BUNDLE_STATUS = "bundleStatus";
43 const std::string BASE_APPLICATION_INFO = "baseApplicationInfo";
44 const std::string BASE_BUNDLE_INFO = "baseBundleInfo";
45 const std::string BASE_ABILITY_INFO = "baseAbilityInfos";
46 const std::string INNER_MODULE_INFO = "innerModuleInfos";
47 const std::string SKILL_INFOS = "skillInfos";
48 const std::string USER_ID = "userId_";
49 const std::string APP_FEATURE = "appFeature";
50 const std::string NAME = "name";
51 const std::string MODULE_FORMS = "formInfos";
52 const std::string MODULE_SHORTCUT = "shortcutInfos";
53 const std::string MODULE_COMMON_EVENT = "commonEvents";
54 const std::string PORT_SEPARATOR = ":";
55 const std::string PATH_SEPARATOR = "/";
56 const std::string IS_PREINSTALL_APP = "isPreInstallApp";
57 const std::string INSTALL_MARK = "installMark";
58 const std::string INNER_BUNDLE_USER_INFOS = "innerBundleUserInfos";
59 const std::string BUNDLE_IS_NEW_VERSION = "isNewVersion";
60 const std::string BUNDLE_BASE_EXTENSION_INFOS = "baseExtensionInfos";
61 const std::string BUNDLE_EXTENSION_SKILL_INFOS = "extensionSkillInfos";
62 const std::string BUNDLE_PACK_INFO = "bundlePackInfo";
63 const std::string ALLOWED_ACLS = "allowedAcls";
64 const std::string META_DATA_SHORTCUTS_NAME = "ohos.ability.shortcuts";
65 const std::string APP_INDEX = "appIndex";
66 const std::string BUNDLE_IS_SANDBOX_APP = "isSandboxApp";
67 const std::string BUNDLE_HQF_INFOS = "hqfInfos";
68 const std::string OVERLAY_BUNDLE_INFO = "overlayBundleInfo";
69 const std::string OVERLAY_TYPE = "overlayType";
70 const std::string APPLY_QUICK_FIX_FREQUENCY = "applyQuickFixFrequency";
71 const std::string INNER_SHARED_MODULE_INFO = "innerSharedModuleInfos";
72 const std::string DATA_GROUP_INFOS = "dataGroupInfos";
73 const std::string NATIVE_LIBRARY_PATH_SYMBOL = "!/";
74 const int32_t SINGLE_HSP_VERSION = 1;
75 const std::map<std::string, IsolationMode> ISOLATION_MODE_MAP = {
76 {"isolationOnly", IsolationMode::ISOLATION_ONLY},
77 {"nonisolationOnly", IsolationMode::NONISOLATION_ONLY},
78 {"isolationFirst", IsolationMode::ISOLATION_FIRST},
79 };
80
ConvertCompileMode(const std::string & compileMode)81 inline CompileMode ConvertCompileMode(const std::string& compileMode)
82 {
83 if (compileMode == Profile::COMPILE_MODE_ES_MODULE) {
84 return CompileMode::ES_MODULE;
85 } else {
86 return CompileMode::JS_BUNDLE;
87 }
88 }
89
NameAndUserIdToKey(const std::string & bundleName,int32_t userId)90 const std::string NameAndUserIdToKey(const std::string &bundleName, int32_t userId)
91 {
92 return bundleName + Constants::FILE_UNDERLINE + std::to_string(userId);
93 }
94 } // namespace
95
SetAOTCompileStatus(const std::string & moduleName,AOTCompileStatus aotCompileStatus)96 void InnerBundleInfo::SetAOTCompileStatus(const std::string &moduleName, AOTCompileStatus aotCompileStatus)
97 {
98 auto item = innerModuleInfos_.find(moduleName);
99 if (item == innerModuleInfos_.end()) {
100 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
101 return;
102 }
103 item->second.aotCompileStatus = aotCompileStatus;
104 }
105
GetAOTCompileStatus(const std::string & moduleName) const106 AOTCompileStatus InnerBundleInfo::GetAOTCompileStatus(const std::string &moduleName) const
107 {
108 auto item = innerModuleInfos_.find(moduleName);
109 if (item == innerModuleInfos_.end()) {
110 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
111 return AOTCompileStatus::NOT_COMPILED;
112 }
113 return item->second.aotCompileStatus;
114 }
115
ResetAOTFlags()116 void InnerBundleInfo::ResetAOTFlags()
117 {
118 baseApplicationInfo_->arkNativeFilePath.clear();
119 baseApplicationInfo_->arkNativeFileAbi.clear();
120 std::for_each(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](auto &item) {
121 item.second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
122 });
123 }
124
ResetAOTCompileStatus(const std::string & moduleName)125 ErrCode InnerBundleInfo::ResetAOTCompileStatus(const std::string &moduleName)
126 {
127 auto item = innerModuleInfos_.find(moduleName);
128 if (item == innerModuleInfos_.end()) {
129 APP_LOGE("moduleName %{public}s not exist", moduleName.c_str());
130 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
131 }
132 item->second.aotCompileStatus = AOTCompileStatus::NOT_COMPILED;
133 return ERR_OK;
134 }
135
GetInternalDependentHspInfo(const std::string & moduleName,std::vector<HspInfo> & hspInfoVector) const136 void InnerBundleInfo::GetInternalDependentHspInfo(
137 const std::string &moduleName, std::vector<HspInfo> &hspInfoVector) const
138 {
139 std::vector<std::string> dependentModuleNames;
140 if (!GetAllDependentModuleNames(moduleName, dependentModuleNames)) {
141 return;
142 }
143 for (const auto &name : dependentModuleNames) {
144 auto item = innerModuleInfos_.find(name);
145 if (item == innerModuleInfos_.end()) {
146 continue;
147 }
148 HspInfo hspInfo;
149 hspInfo.bundleName = baseApplicationInfo_->bundleName;
150 hspInfo.moduleName = item->second.moduleName;
151 hspInfo.hapPath = item->second.hapPath;
152 hspInfoVector.emplace_back(hspInfo);
153 }
154 }
155
InnerBundleInfo()156 InnerBundleInfo::InnerBundleInfo()
157 {
158 baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
159 if (baseApplicationInfo_ == nullptr) {
160 APP_LOGE("baseApplicationInfo_ is nullptr, create failed");
161 }
162 baseBundleInfo_ = std::make_shared<BundleInfo>();
163 if (baseBundleInfo_ == nullptr) {
164 APP_LOGE("baseBundleInfo_ is nullptr, create failed");
165 }
166 bundlePackInfo_ = std::make_shared<BundlePackInfo>();
167 if (bundlePackInfo_ == nullptr) {
168 APP_LOGE("bundlePackInfo_ is nullptr, create failed");
169 }
170 APP_LOGD("inner bundle info instance is created");
171 }
172
operator =(const InnerBundleInfo & info)173 InnerBundleInfo &InnerBundleInfo::operator=(const InnerBundleInfo &info)
174 {
175 if (this == &info) {
176 return *this;
177 }
178 this->appType_ = info.appType_;
179 this->userId_ = info.userId_;
180 this->bundleStatus_ = info.bundleStatus_;
181 this->appFeature_ = info.appFeature_;
182 this->allowedAcls_ = info.allowedAcls_;
183 this->mark_ = info.mark_;
184 this->appIndex_ = info.appIndex_;
185 this->isSandboxApp_ = info.isSandboxApp_;
186 this->currentPackage_ = info.currentPackage_;
187 this->onlyCreateBundleUser_ = info.onlyCreateBundleUser_;
188 this->innerModuleInfos_ = info.innerModuleInfos_;
189 this->innerSharedModuleInfos_ = info.innerSharedModuleInfos_;
190 this->formInfos_ = info.formInfos_;
191 this->commonEvents_ = info.commonEvents_;
192 this->shortcutInfos_ = info.shortcutInfos_;
193 this->baseAbilityInfos_ = info.baseAbilityInfos_;
194 this->skillInfos_ = info.skillInfos_;
195 this->innerBundleUserInfos_ = info.innerBundleUserInfos_;
196 this->bundlePackInfo_ = std::make_shared<BundlePackInfo>();
197 if (info.bundlePackInfo_ != nullptr) {
198 *(this->bundlePackInfo_) = *(info.bundlePackInfo_);
199 }
200 this->isNewVersion_ = info.isNewVersion_;
201 this->baseExtensionInfos_= info.baseExtensionInfos_;
202 this->extensionSkillInfos_ = info.extensionSkillInfos_;
203 this->baseApplicationInfo_ = std::make_shared<ApplicationInfo>();
204 if (info.baseApplicationInfo_ != nullptr) {
205 *(this->baseApplicationInfo_) = *(info.baseApplicationInfo_);
206 }
207 this->baseBundleInfo_ = std::make_shared<BundleInfo>();
208 if (info.baseBundleInfo_ != nullptr) {
209 *(this->baseBundleInfo_) = *(info.baseBundleInfo_);
210 }
211 this->hqfInfos_ = info.hqfInfos_;
212 this->overlayBundleInfo_ = info.overlayBundleInfo_;
213 this->overlayType_ = info.overlayType_;
214 this->applyQuickFixFrequency_ = info.applyQuickFixFrequency_;
215 this->provisionMetadatas_ = info.provisionMetadatas_;
216 this->dataGroupInfos_ = info.dataGroupInfos_;
217 return *this;
218 }
219
~InnerBundleInfo()220 InnerBundleInfo::~InnerBundleInfo()
221 {
222 APP_LOGD("inner bundle info instance is destroyed");
223 }
224
ToJson(nlohmann::json & jsonObject) const225 void InnerBundleInfo::ToJson(nlohmann::json &jsonObject) const
226 {
227 jsonObject[APP_TYPE] = appType_;
228 jsonObject[BUNDLE_STATUS] = bundleStatus_;
229 jsonObject[ALLOWED_ACLS] = allowedAcls_;
230 jsonObject[BASE_APPLICATION_INFO] = *baseApplicationInfo_;
231 jsonObject[BASE_BUNDLE_INFO] = *baseBundleInfo_;
232 jsonObject[BASE_ABILITY_INFO] = baseAbilityInfos_;
233 jsonObject[INNER_MODULE_INFO] = innerModuleInfos_;
234 jsonObject[INNER_SHARED_MODULE_INFO] = innerSharedModuleInfos_;
235 jsonObject[SKILL_INFOS] = skillInfos_;
236 jsonObject[USER_ID] = userId_;
237 jsonObject[APP_FEATURE] = appFeature_;
238 jsonObject[MODULE_FORMS] = formInfos_;
239 jsonObject[MODULE_SHORTCUT] = shortcutInfos_;
240 jsonObject[MODULE_COMMON_EVENT] = commonEvents_;
241 jsonObject[INSTALL_MARK] = mark_;
242 jsonObject[INNER_BUNDLE_USER_INFOS] = innerBundleUserInfos_;
243 jsonObject[BUNDLE_IS_NEW_VERSION] = isNewVersion_;
244 jsonObject[BUNDLE_BASE_EXTENSION_INFOS] = baseExtensionInfos_;
245 jsonObject[BUNDLE_EXTENSION_SKILL_INFOS] = extensionSkillInfos_;
246 jsonObject[BUNDLE_PACK_INFO] = *bundlePackInfo_;
247 jsonObject[APP_INDEX] = appIndex_;
248 jsonObject[BUNDLE_IS_SANDBOX_APP] = isSandboxApp_;
249 jsonObject[BUNDLE_HQF_INFOS] = hqfInfos_;
250 jsonObject[OVERLAY_BUNDLE_INFO] = overlayBundleInfo_;
251 jsonObject[OVERLAY_TYPE] = overlayType_;
252 jsonObject[APPLY_QUICK_FIX_FREQUENCY] = applyQuickFixFrequency_;
253 jsonObject[DATA_GROUP_INFOS] = dataGroupInfos_;
254 }
255
FromJson(const nlohmann::json & jsonObject)256 int32_t InnerBundleInfo::FromJson(const nlohmann::json &jsonObject)
257 {
258 const auto &jsonObjectEnd = jsonObject.end();
259 int32_t parseResult = ERR_OK;
260 GetValueIfFindKey<Constants::AppType>(jsonObject,
261 jsonObjectEnd,
262 APP_TYPE,
263 appType_,
264 JsonType::NUMBER,
265 true,
266 parseResult,
267 ArrayType::NOT_ARRAY);
268 GetValueIfFindKey<std::vector<std::string>>(jsonObject,
269 jsonObjectEnd,
270 ALLOWED_ACLS,
271 allowedAcls_,
272 JsonType::ARRAY,
273 false,
274 parseResult,
275 ArrayType::STRING);
276 GetValueIfFindKey<BundleStatus>(jsonObject,
277 jsonObjectEnd,
278 BUNDLE_STATUS,
279 bundleStatus_,
280 JsonType::NUMBER,
281 true,
282 parseResult,
283 ArrayType::NOT_ARRAY);
284 GetValueIfFindKey<BundleInfo>(jsonObject,
285 jsonObjectEnd,
286 BASE_BUNDLE_INFO,
287 *baseBundleInfo_,
288 JsonType::OBJECT,
289 true,
290 parseResult,
291 ArrayType::NOT_ARRAY);
292 GetValueIfFindKey<ApplicationInfo>(jsonObject,
293 jsonObjectEnd,
294 BASE_APPLICATION_INFO,
295 *baseApplicationInfo_,
296 JsonType::OBJECT,
297 true,
298 parseResult,
299 ArrayType::NOT_ARRAY);
300 GetValueIfFindKey<std::map<std::string, AbilityInfo>>(jsonObject,
301 jsonObjectEnd,
302 BASE_ABILITY_INFO,
303 baseAbilityInfos_,
304 JsonType::OBJECT,
305 true,
306 parseResult,
307 ArrayType::NOT_ARRAY);
308 GetValueIfFindKey<std::map<std::string, InnerModuleInfo>>(jsonObject,
309 jsonObjectEnd,
310 INNER_MODULE_INFO,
311 innerModuleInfos_,
312 JsonType::OBJECT,
313 true,
314 parseResult,
315 ArrayType::NOT_ARRAY);
316 GetValueIfFindKey<std::map<std::string, std::vector<InnerModuleInfo>>>(jsonObject,
317 jsonObjectEnd,
318 INNER_SHARED_MODULE_INFO,
319 innerSharedModuleInfos_,
320 JsonType::OBJECT,
321 false,
322 parseResult,
323 ArrayType::NOT_ARRAY);
324 GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
325 jsonObjectEnd,
326 SKILL_INFOS,
327 skillInfos_,
328 JsonType::OBJECT,
329 true,
330 parseResult,
331 ArrayType::NOT_ARRAY);
332 GetValueIfFindKey<int>(jsonObject,
333 jsonObjectEnd,
334 USER_ID,
335 userId_,
336 JsonType::NUMBER,
337 true,
338 parseResult,
339 ArrayType::NOT_ARRAY);
340 GetValueIfFindKey<std::string>(jsonObject,
341 jsonObjectEnd,
342 APP_FEATURE,
343 appFeature_,
344 JsonType::STRING,
345 true,
346 parseResult,
347 ArrayType::NOT_ARRAY);
348 GetValueIfFindKey<std::map<std::string, std::vector<FormInfo>>>(jsonObject,
349 jsonObjectEnd,
350 MODULE_FORMS,
351 formInfos_,
352 JsonType::OBJECT,
353 true,
354 parseResult,
355 ArrayType::NOT_ARRAY);
356 GetValueIfFindKey<std::map<std::string, ShortcutInfo>>(jsonObject,
357 jsonObjectEnd,
358 MODULE_SHORTCUT,
359 shortcutInfos_,
360 JsonType::OBJECT,
361 true,
362 parseResult,
363 ArrayType::NOT_ARRAY);
364 GetValueIfFindKey<std::map<std::string, CommonEventInfo>>(jsonObject,
365 jsonObjectEnd,
366 MODULE_COMMON_EVENT,
367 commonEvents_,
368 JsonType::OBJECT,
369 true,
370 parseResult,
371 ArrayType::NOT_ARRAY);
372 GetValueIfFindKey<InstallMark>(jsonObject,
373 jsonObjectEnd,
374 INSTALL_MARK,
375 mark_,
376 JsonType::OBJECT,
377 false,
378 parseResult,
379 ArrayType::NOT_ARRAY);
380 int32_t isOldVersion = ERR_OK;
381 GetValueIfFindKey<std::map<std::string, InnerBundleUserInfo>>(jsonObject,
382 jsonObjectEnd,
383 INNER_BUNDLE_USER_INFOS,
384 innerBundleUserInfos_,
385 JsonType::OBJECT,
386 true,
387 isOldVersion,
388 ArrayType::NOT_ARRAY);
389 GetValueIfFindKey<bool>(jsonObject,
390 jsonObjectEnd,
391 BUNDLE_IS_NEW_VERSION,
392 isNewVersion_,
393 JsonType::BOOLEAN,
394 false,
395 parseResult,
396 ArrayType::NOT_ARRAY);
397 GetValueIfFindKey<std::map<std::string, ExtensionAbilityInfo>>(jsonObject,
398 jsonObjectEnd,
399 BUNDLE_BASE_EXTENSION_INFOS,
400 baseExtensionInfos_,
401 JsonType::OBJECT,
402 false,
403 parseResult,
404 ArrayType::NOT_ARRAY);
405 GetValueIfFindKey<std::map<std::string, std::vector<Skill>>>(jsonObject,
406 jsonObjectEnd,
407 BUNDLE_EXTENSION_SKILL_INFOS,
408 extensionSkillInfos_,
409 JsonType::OBJECT,
410 false,
411 parseResult,
412 ArrayType::NOT_ARRAY);
413 GetValueIfFindKey<BundlePackInfo>(jsonObject,
414 jsonObjectEnd,
415 BUNDLE_PACK_INFO,
416 *bundlePackInfo_,
417 JsonType::OBJECT,
418 false,
419 parseResult,
420 ArrayType::NOT_ARRAY);
421 GetValueIfFindKey<int>(jsonObject,
422 jsonObjectEnd,
423 APP_INDEX,
424 appIndex_,
425 JsonType::NUMBER,
426 false,
427 parseResult,
428 ArrayType::NOT_ARRAY);
429 GetValueIfFindKey<bool>(jsonObject,
430 jsonObjectEnd,
431 BUNDLE_IS_SANDBOX_APP,
432 isSandboxApp_,
433 JsonType::BOOLEAN,
434 false,
435 parseResult,
436 ArrayType::NOT_ARRAY);
437 GetValueIfFindKey<std::vector<HqfInfo>>(jsonObject,
438 jsonObjectEnd,
439 BUNDLE_HQF_INFOS,
440 hqfInfos_,
441 JsonType::ARRAY,
442 false,
443 parseResult,
444 ArrayType::OBJECT);
445 GetValueIfFindKey<std::vector<OverlayBundleInfo>>(jsonObject,
446 jsonObjectEnd,
447 OVERLAY_BUNDLE_INFO,
448 overlayBundleInfo_,
449 JsonType::ARRAY,
450 false,
451 parseResult,
452 ArrayType::OBJECT);
453 GetValueIfFindKey<int32_t>(jsonObject,
454 jsonObjectEnd,
455 OVERLAY_TYPE,
456 overlayType_,
457 JsonType::NUMBER,
458 false,
459 parseResult,
460 ArrayType::NOT_ARRAY);
461 GetValueIfFindKey<int32_t>(jsonObject,
462 jsonObjectEnd,
463 APPLY_QUICK_FIX_FREQUENCY,
464 applyQuickFixFrequency_,
465 JsonType::NUMBER,
466 false,
467 parseResult,
468 ArrayType::NOT_ARRAY);
469 GetValueIfFindKey<std::unordered_map<std::string, std::vector<DataGroupInfo>>>(jsonObject,
470 jsonObjectEnd,
471 DATA_GROUP_INFOS,
472 dataGroupInfos_,
473 JsonType::OBJECT,
474 false,
475 parseResult,
476 ArrayType::NOT_ARRAY);
477 if (parseResult != ERR_OK) {
478 APP_LOGE("read InnerBundleInfo from database error, error code : %{public}d", parseResult);
479 }
480 return parseResult;
481 }
482
FindHapModuleInfo(const std::string & modulePackage,int32_t userId) const483 std::optional<HapModuleInfo> InnerBundleInfo::FindHapModuleInfo(const std::string &modulePackage, int32_t userId) const
484 {
485 auto it = innerModuleInfos_.find(modulePackage);
486 if (it == innerModuleInfos_.end()) {
487 APP_LOGE("can not find module %{public}s", modulePackage.c_str());
488 return std::nullopt;
489 }
490 HapModuleInfo hapInfo;
491 hapInfo.name = it->second.name;
492 hapInfo.package = it->second.modulePackage;
493 hapInfo.moduleName = it->second.moduleName;
494 hapInfo.description = it->second.description;
495 hapInfo.descriptionId = it->second.descriptionId;
496 hapInfo.label = it->second.label;
497 hapInfo.labelId = it->second.labelId;
498 hapInfo.iconPath = it->second.icon;
499 hapInfo.iconId = it->second.iconId;
500 hapInfo.mainAbility = it->second.mainAbility;
501 hapInfo.srcPath = it->second.srcPath;
502 hapInfo.hapPath = it->second.hapPath;
503 hapInfo.supportedModes = baseApplicationInfo_->supportedModes;
504 hapInfo.reqCapabilities = it->second.reqCapabilities;
505 hapInfo.colorMode = it->second.colorMode;
506 hapInfo.isRemovable = it->second.isRemovable;
507 hapInfo.upgradeFlag = it->second.upgradeFlag;
508 hapInfo.isLibIsolated = it->second.isLibIsolated;
509 hapInfo.nativeLibraryPath = it->second.nativeLibraryPath;
510 hapInfo.cpuAbi = it->second.cpuAbi;
511
512 hapInfo.bundleName = baseApplicationInfo_->bundleName;
513 hapInfo.mainElementName = it->second.mainAbility;
514 hapInfo.pages = it->second.pages;
515 hapInfo.process = it->second.process;
516 hapInfo.resourcePath = it->second.moduleResPath;
517 hapInfo.srcEntrance = it->second.srcEntrance;
518 hapInfo.uiSyntax = it->second.uiSyntax;
519 hapInfo.virtualMachine = it->second.virtualMachine;
520 hapInfo.deliveryWithInstall = it->second.distro.deliveryWithInstall;
521 hapInfo.installationFree = it->second.distro.installationFree;
522 hapInfo.isModuleJson = it->second.isModuleJson;
523 hapInfo.isStageBasedModel = it->second.isStageBasedModel;
524 std::string moduleType = it->second.distro.moduleType;
525 if (moduleType == Profile::MODULE_TYPE_ENTRY) {
526 hapInfo.moduleType = ModuleType::ENTRY;
527 } else if (moduleType == Profile::MODULE_TYPE_FEATURE) {
528 hapInfo.moduleType = ModuleType::FEATURE;
529 } else if (moduleType == Profile::MODULE_TYPE_SHARED) {
530 hapInfo.moduleType = ModuleType::SHARED;
531 } else {
532 hapInfo.moduleType = ModuleType::UNKNOWN;
533 }
534 std::string key;
535 key.append(".").append(modulePackage).append(".");
536 for (const auto &extension : baseExtensionInfos_) {
537 if (extension.first.find(key) != std::string::npos) {
538 hapInfo.extensionInfos.emplace_back(extension.second);
539 }
540 }
541 hapInfo.metadata = it->second.metadata;
542 bool first = false;
543 for (auto &ability : baseAbilityInfos_) {
544 if (ability.second.name == Constants::APP_DETAIL_ABILITY) {
545 continue;
546 }
547 if (ability.first.find(key) != std::string::npos) {
548 if (!first) {
549 hapInfo.deviceTypes = ability.second.deviceTypes;
550 first = true;
551 }
552 auto &abilityInfo = hapInfo.abilityInfos.emplace_back(ability.second);
553 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
554 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
555 abilityInfo.applicationInfo);
556 }
557 }
558 hapInfo.dependencies = it->second.dependencies;
559 hapInfo.compileMode = ConvertCompileMode(it->second.compileMode);
560 for (const auto &hqf : hqfInfos_) {
561 if (hqf.moduleName == it->second.moduleName) {
562 hapInfo.hqfInfo = hqf;
563 break;
564 }
565 }
566 for (const auto &item : it->second.preloads) {
567 PreloadItem preload(item);
568 hapInfo.preloads.emplace_back(preload);
569 }
570 for (const auto &item : it->second.proxyDatas) {
571 ProxyData proxyData(item);
572 hapInfo.proxyDatas.emplace_back(proxyData);
573 }
574 hapInfo.buildHash = it->second.buildHash;
575 hapInfo.isolationMode = GetIsolationMode(it->second.isolationMode);
576 hapInfo.compressNativeLibs = it->second.compressNativeLibs;
577 hapInfo.nativeLibraryFileNames = it->second.nativeLibraryFileNames;
578 hapInfo.aotCompileStatus = it->second.aotCompileStatus;
579 hapInfo.fileContextMenu = it->second.fileContextMenu;
580 return hapInfo;
581 }
582
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,int32_t userId) const583 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfo(
584 const std::string &moduleName,
585 const std::string &abilityName,
586 int32_t userId) const
587 {
588 for (const auto &ability : baseAbilityInfos_) {
589 auto abilityInfo = ability.second;
590 if ((abilityInfo.name == abilityName) &&
591 (moduleName.empty() || (abilityInfo.moduleName == moduleName))) {
592 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
593 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
594 abilityInfo.applicationInfo);
595 return abilityInfo;
596 }
597 }
598
599 return std::nullopt;
600 }
601
FindAbilityInfoV9(const std::string & moduleName,const std::string & abilityName) const602 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfoV9(
603 const std::string &moduleName, const std::string &abilityName) const
604 {
605 for (const auto &ability : baseAbilityInfos_) {
606 auto abilityInfo = ability.second;
607 if ((abilityInfo.name == abilityName) &&
608 (moduleName.empty() || (abilityInfo.moduleName == moduleName))) {
609 return abilityInfo;
610 }
611 }
612 APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s",
613 GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str());
614 return std::nullopt;
615 }
616
FindAbilityInfo(const std::string & moduleName,const std::string & abilityName,AbilityInfo & info) const617 ErrCode InnerBundleInfo::FindAbilityInfo(
618 const std::string &moduleName, const std::string &abilityName, AbilityInfo &info) const
619 {
620 bool isModuleFind = false;
621 for (const auto &ability : baseAbilityInfos_) {
622 auto abilityInfo = ability.second;
623 if ((abilityInfo.moduleName == moduleName)) {
624 isModuleFind = true;
625 if (abilityInfo.name == abilityName) {
626 info = abilityInfo;
627 return ERR_OK;
628 }
629 }
630 }
631 APP_LOGE("bundleName: %{public}s not find moduleName:%{public}s, abilityName:%{public}s, isModuleFind:%{public}d",
632 GetBundleName().c_str(), moduleName.c_str(), abilityName.c_str(), isModuleFind);
633 if (isModuleFind) {
634 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
635 } else {
636 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
637 }
638 }
639
FindAbilityInfos(int32_t userId) const640 std::optional<std::vector<AbilityInfo>> InnerBundleInfo::FindAbilityInfos(int32_t userId) const
641 {
642 if (!HasInnerBundleUserInfo(userId)) {
643 return std::nullopt;
644 }
645
646 std::vector<AbilityInfo> abilitys;
647 for (const auto &ability : baseAbilityInfos_) {
648 if (ability.second.name == Constants::APP_DETAIL_ABILITY) {
649 continue;
650 }
651 auto abilityInfo = ability.second;
652 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION |
653 ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
654 abilityInfo.applicationInfo);
655 abilitys.emplace_back(abilityInfo);
656 }
657
658 if (abilitys.empty()) {
659 return std::nullopt;
660 }
661 return abilitys;
662 }
663
FindExtensionInfo(const std::string & moduleName,const std::string & extensionName) const664 std::optional<ExtensionAbilityInfo> InnerBundleInfo::FindExtensionInfo(
665 const std::string &moduleName, const std::string &extensionName) const
666 {
667 for (const auto &extension : baseExtensionInfos_) {
668 if ((extension.second.name == extensionName) &&
669 (moduleName.empty() || (extension.second.moduleName == moduleName))) {
670 return extension.second;
671 }
672 }
673
674 return std::nullopt;
675 }
676
FindExtensionInfos() const677 std::optional<std::vector<ExtensionAbilityInfo>> InnerBundleInfo::FindExtensionInfos() const
678 {
679 std::vector<ExtensionAbilityInfo> extensions;
680 for (const auto &extension : baseExtensionInfos_) {
681 extensions.emplace_back(extension.second);
682 }
683
684 if (extensions.empty()) {
685 return std::nullopt;
686 }
687
688 return extensions;
689 }
690
AddModuleInfo(const InnerBundleInfo & newInfo)691 bool InnerBundleInfo::AddModuleInfo(const InnerBundleInfo &newInfo)
692 {
693 if (newInfo.currentPackage_.empty()) {
694 APP_LOGE("current package is empty");
695 return false;
696 }
697 if (FindModule(newInfo.currentPackage_)) {
698 APP_LOGE("current package %{public}s is exist", currentPackage_.c_str());
699 return false;
700 }
701 AddInnerModuleInfo(newInfo.innerModuleInfos_);
702 AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
703 AddModuleSkillInfo(newInfo.skillInfos_);
704 AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
705 AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
706 AddModuleFormInfo(newInfo.formInfos_);
707 AddModuleShortcutInfo(newInfo.shortcutInfos_);
708 AddModuleCommonEvent(newInfo.commonEvents_);
709 UpdateIsCompressNativeLibs();
710 return true;
711 }
712
UpdateBaseBundleInfo(const BundleInfo & bundleInfo,bool isEntry)713 void InnerBundleInfo::UpdateBaseBundleInfo(const BundleInfo &bundleInfo, bool isEntry)
714 {
715 baseBundleInfo_->name = bundleInfo.name;
716
717 baseBundleInfo_->versionCode = bundleInfo.versionCode;
718 baseBundleInfo_->versionName = bundleInfo.versionName;
719 baseBundleInfo_->minCompatibleVersionCode = bundleInfo.minCompatibleVersionCode;
720
721 baseBundleInfo_->compatibleVersion = bundleInfo.compatibleVersion;
722 baseBundleInfo_->targetVersion = bundleInfo.targetVersion;
723
724 baseBundleInfo_->isKeepAlive = bundleInfo.isKeepAlive;
725 baseBundleInfo_->singleton = bundleInfo.singleton;
726 if (!baseBundleInfo_->isPreInstallApp) {
727 baseBundleInfo_->isPreInstallApp = bundleInfo.isPreInstallApp;
728 }
729
730 baseBundleInfo_->vendor = bundleInfo.vendor;
731 baseBundleInfo_->releaseType = bundleInfo.releaseType;
732 if (!baseBundleInfo_->isNativeApp) {
733 baseBundleInfo_->isNativeApp = bundleInfo.isNativeApp;
734 }
735
736 if (isEntry) {
737 baseBundleInfo_->mainEntry = bundleInfo.mainEntry;
738 baseBundleInfo_->entryModuleName = bundleInfo.entryModuleName;
739 }
740 }
741
UpdateBaseApplicationInfo(const ApplicationInfo & applicationInfo,bool isEntry)742 void InnerBundleInfo::UpdateBaseApplicationInfo(
743 const ApplicationInfo &applicationInfo, bool isEntry)
744 {
745 baseApplicationInfo_->name = applicationInfo.name;
746 baseApplicationInfo_->bundleName = applicationInfo.bundleName;
747
748 baseApplicationInfo_->versionCode = applicationInfo.versionCode;
749 baseApplicationInfo_->versionName = applicationInfo.versionName;
750 baseApplicationInfo_->minCompatibleVersionCode = applicationInfo.minCompatibleVersionCode;
751
752 baseApplicationInfo_->apiCompatibleVersion = applicationInfo.apiCompatibleVersion;
753 baseApplicationInfo_->apiTargetVersion = applicationInfo.apiTargetVersion;
754
755 baseApplicationInfo_->iconPath = applicationInfo.iconPath;
756 baseApplicationInfo_->iconId = applicationInfo.iconId;
757 baseApplicationInfo_->label = applicationInfo.label;
758 baseApplicationInfo_->labelId = applicationInfo.labelId;
759 baseApplicationInfo_->description = applicationInfo.description;
760 baseApplicationInfo_->descriptionId = applicationInfo.descriptionId;
761 baseApplicationInfo_->iconResource = applicationInfo.iconResource;
762 baseApplicationInfo_->labelResource = applicationInfo.labelResource;
763 baseApplicationInfo_->descriptionResource = applicationInfo.descriptionResource;
764 baseApplicationInfo_->singleton = applicationInfo.singleton;
765 baseApplicationInfo_->userDataClearable = applicationInfo.userDataClearable;
766 baseApplicationInfo_->accessible = applicationInfo.accessible;
767
768 if (!baseApplicationInfo_->isSystemApp) {
769 baseApplicationInfo_->isSystemApp = applicationInfo.isSystemApp;
770 }
771 if (!baseApplicationInfo_->isLauncherApp) {
772 baseApplicationInfo_->isLauncherApp = applicationInfo.isLauncherApp;
773 }
774
775 baseApplicationInfo_->apiReleaseType = applicationInfo.apiReleaseType;
776 baseApplicationInfo_->deviceId = applicationInfo.deviceId;
777 baseApplicationInfo_->distributedNotificationEnabled = applicationInfo.distributedNotificationEnabled;
778 baseApplicationInfo_->entityType = applicationInfo.entityType;
779 baseApplicationInfo_->process = applicationInfo.process;
780 baseApplicationInfo_->supportedModes = applicationInfo.supportedModes;
781 baseApplicationInfo_->vendor = applicationInfo.vendor;
782 baseApplicationInfo_->appDistributionType = applicationInfo.appDistributionType;
783 baseApplicationInfo_->appProvisionType = applicationInfo.appProvisionType;
784 baseApplicationInfo_->formVisibleNotify = applicationInfo.formVisibleNotify;
785 baseApplicationInfo_->needAppDetail = applicationInfo.needAppDetail;
786 baseApplicationInfo_->appDetailAbilityLibraryPath = applicationInfo.appDetailAbilityLibraryPath;
787 baseApplicationInfo_->bundleType = applicationInfo.bundleType;
788 UpdatePrivilegeCapability(applicationInfo);
789 SetHideDesktopIcon(applicationInfo.hideDesktopIcon);
790 #ifdef BUNDLE_FRAMEWORK_OVERLAY_INSTALLATION
791 baseApplicationInfo_->targetBundleName = applicationInfo.targetBundleName;
792 baseApplicationInfo_->targetPriority = applicationInfo.targetPriority;
793 #endif
794 UpdateDebug(applicationInfo.debug, isEntry);
795 }
796
UpdateAppDetailAbilityAttrs()797 void InnerBundleInfo::UpdateAppDetailAbilityAttrs()
798 {
799 if (IsExistLauncherAbility()) {
800 baseApplicationInfo_->needAppDetail = false;
801 baseApplicationInfo_->appDetailAbilityLibraryPath = Constants::EMPTY_STRING;
802 }
803 for (auto iter = baseAbilityInfos_.begin(); iter != baseAbilityInfos_.end(); ++iter) {
804 if (iter->second.name == Constants::APP_DETAIL_ABILITY) {
805 if (!baseApplicationInfo_->needAppDetail) {
806 baseAbilityInfos_.erase(iter);
807 return;
808 }
809 if (isNewVersion_) {
810 iter->second.labelId = baseApplicationInfo_->labelId;
811 iter->second.iconId =
812 (baseApplicationInfo_->iconId == 0) ? iter->second.iconId : baseApplicationInfo_->iconId;
813 }
814 return;
815 }
816 }
817 }
818
IsHideDesktopIcon() const819 bool InnerBundleInfo::IsHideDesktopIcon() const
820 {
821 return baseApplicationInfo_->hideDesktopIcon ? true : !IsExistLauncherAbility();
822 }
823
IsExistLauncherAbility() const824 bool InnerBundleInfo::IsExistLauncherAbility() const
825 {
826 bool isExistLauncherAbility = false;
827 OHOS::AAFwk::Want want;
828 want.SetAction(OHOS::AAFwk::Want::ACTION_HOME);
829 want.AddEntity(OHOS::AAFwk::Want::ENTITY_HOME);
830 for (const auto& abilityInfoPair : baseAbilityInfos_) {
831 auto skillsPair = skillInfos_.find(abilityInfoPair.first);
832 if (skillsPair == skillInfos_.end()) {
833 continue;
834 }
835 for (const Skill& skill : skillsPair->second) {
836 if (skill.MatchLauncher(want) && (abilityInfoPair.second.type == AbilityType::PAGE)) {
837 isExistLauncherAbility = true;
838 break;
839 }
840 }
841 }
842 return isExistLauncherAbility;
843 }
844
UpdateNativeLibAttrs(const ApplicationInfo & applicationInfo)845 void InnerBundleInfo::UpdateNativeLibAttrs(const ApplicationInfo &applicationInfo)
846 {
847 baseApplicationInfo_->cpuAbi = applicationInfo.cpuAbi;
848 baseApplicationInfo_->nativeLibraryPath = applicationInfo.nativeLibraryPath;
849 }
850
UpdateArkNativeAttrs(const ApplicationInfo & applicationInfo)851 void InnerBundleInfo::UpdateArkNativeAttrs(const ApplicationInfo &applicationInfo)
852 {
853 baseApplicationInfo_->arkNativeFileAbi = applicationInfo.arkNativeFileAbi;
854 baseApplicationInfo_->arkNativeFilePath = applicationInfo.arkNativeFilePath;
855 }
856
UpdatePrivilegeCapability(const ApplicationInfo & applicationInfo)857 void InnerBundleInfo::UpdatePrivilegeCapability(const ApplicationInfo &applicationInfo)
858 {
859 SetKeepAlive(applicationInfo.keepAlive);
860 baseApplicationInfo_->runningResourcesApply = applicationInfo.runningResourcesApply;
861 baseApplicationInfo_->associatedWakeUp = applicationInfo.associatedWakeUp;
862 SetAllowCommonEvent(applicationInfo.allowCommonEvent);
863 baseApplicationInfo_->resourcesApply = applicationInfo.resourcesApply;
864 }
865
UpdateRemovable(bool isPreInstall,bool removable)866 void InnerBundleInfo::UpdateRemovable(bool isPreInstall, bool removable)
867 {
868 #ifdef USE_PRE_BUNDLE_PROFILE
869 if (!isPreInstall) {
870 return;
871 }
872 #endif
873
874 baseApplicationInfo_->removable = removable;
875 }
876
UpdateModuleInfo(const InnerBundleInfo & newInfo)877 void InnerBundleInfo::UpdateModuleInfo(const InnerBundleInfo &newInfo)
878 {
879 if (newInfo.currentPackage_.empty()) {
880 APP_LOGE("no package in new info");
881 return;
882 }
883
884 RemoveModuleInfo(newInfo.currentPackage_);
885 AddInnerModuleInfo(newInfo.innerModuleInfos_);
886 AddModuleAbilityInfo(newInfo.baseAbilityInfos_);
887 AddModuleSkillInfo(newInfo.skillInfos_);
888 AddModuleExtensionInfos(newInfo.baseExtensionInfos_);
889 AddModuleExtensionSkillInfos(newInfo.extensionSkillInfos_);
890 AddModuleFormInfo(newInfo.formInfos_);
891 AddModuleShortcutInfo(newInfo.shortcutInfos_);
892 AddModuleCommonEvent(newInfo.commonEvents_);
893 UpdateIsCompressNativeLibs();
894 }
895
GetMaxVerBaseSharedBundleInfo(const std::string & moduleName,BaseSharedBundleInfo & baseSharedBundleInfo) const896 bool InnerBundleInfo::GetMaxVerBaseSharedBundleInfo(const std::string &moduleName,
897 BaseSharedBundleInfo &baseSharedBundleInfo) const
898 {
899 auto it = innerSharedModuleInfos_.find(moduleName);
900 if (it == innerSharedModuleInfos_.end()) {
901 APP_LOGE("The shared module(%{public}s) infomation does not exist", moduleName.c_str());
902 return false;
903 }
904 auto sharedModuleInfoVector = it->second;
905 if (sharedModuleInfoVector.empty()) {
906 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
907 return false;
908 }
909 InnerModuleInfo innerModuleInfo = sharedModuleInfoVector.front();
910 if (innerModuleInfo.bundleType != BundleType::SHARED) {
911 APP_LOGE("GetMaxVerBaseSharedBundleInfo failed, bundleType is invalid!");
912 return false;
913 }
914 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
915 baseSharedBundleInfo.moduleName = innerModuleInfo.moduleName;
916 baseSharedBundleInfo.versionCode = innerModuleInfo.versionCode;
917 baseSharedBundleInfo.nativeLibraryPath = innerModuleInfo.nativeLibraryPath;
918 baseSharedBundleInfo.hapPath = innerModuleInfo.hapPath;
919 baseSharedBundleInfo.compressNativeLibs = innerModuleInfo.compressNativeLibs;
920 baseSharedBundleInfo.nativeLibraryFileNames = innerModuleInfo.nativeLibraryFileNames;
921 return true;
922 }
923
GetBaseSharedBundleInfo(const std::string & moduleName,uint32_t versionCode,BaseSharedBundleInfo & baseSharedBundleInfo) const924 bool InnerBundleInfo::GetBaseSharedBundleInfo(const std::string &moduleName, uint32_t versionCode,
925 BaseSharedBundleInfo &baseSharedBundleInfo) const
926 {
927 auto it = innerSharedModuleInfos_.find(moduleName);
928 if (it == innerSharedModuleInfos_.end()) {
929 APP_LOGE("The shared module(%{public}s) infomation does not exist", moduleName.c_str());
930 return false;
931 }
932 auto sharedModuleInfoVector = it->second;
933 if (sharedModuleInfoVector.empty()) {
934 APP_LOGE("No version exists for the shared module(%{public}s)", moduleName.c_str());
935 return false;
936 }
937 for (const auto &item : sharedModuleInfoVector) {
938 if (item.bundleType != BundleType::SHARED) {
939 APP_LOGE("GetBaseSharedBundleInfo failed, bundleType is invalid!");
940 return false;
941 }
942 if (item.versionCode == versionCode) {
943 baseSharedBundleInfo.bundleName = baseBundleInfo_->name;
944 baseSharedBundleInfo.moduleName = item.moduleName;
945 baseSharedBundleInfo.versionCode = item.versionCode;
946 baseSharedBundleInfo.nativeLibraryPath = item.nativeLibraryPath;
947 baseSharedBundleInfo.hapPath = item.hapPath;
948 baseSharedBundleInfo.compressNativeLibs = item.compressNativeLibs;
949 baseSharedBundleInfo.nativeLibraryFileNames = item.nativeLibraryFileNames;
950 return true;
951 }
952 }
953 APP_LOGE("GetBaseSharedBundleInfo failed, the version(%{public}d) is not exists for this module(%{public}s)",
954 versionCode, moduleName.c_str());
955 return false;
956 }
957
InsertInnerSharedModuleInfo(const std::string & moduleName,const InnerModuleInfo & innerModuleInfo)958 void InnerBundleInfo::InsertInnerSharedModuleInfo(const std::string &moduleName,
959 const InnerModuleInfo &innerModuleInfo)
960 {
961 auto iterator = innerSharedModuleInfos_.find(moduleName);
962 if (iterator != innerSharedModuleInfos_.end()) {
963 auto innerModuleInfoVector = iterator->second;
964 bool insertFlag = false;
965 for (unsigned long i = 0; i < innerModuleInfoVector.size(); i++) {
966 if (innerModuleInfo.versionCode == innerModuleInfoVector.at(i).versionCode) {
967 // if the inserted versionCode same as the existing one, replace old innerModuleInfo.
968 innerModuleInfoVector.at(i) = innerModuleInfo;
969 insertFlag = true;
970 break;
971 } else if (innerModuleInfo.versionCode > innerModuleInfoVector.at(i).versionCode) {
972 // if the inserted versionCode bigger then the existing one, insert the specified location.
973 innerModuleInfoVector.emplace(innerModuleInfoVector.begin() + i, innerModuleInfo);
974 insertFlag = true;
975 break;
976 } else {
977 continue;
978 }
979 }
980 if (!insertFlag) {
981 // insert innerModuleInfo in last location.
982 innerModuleInfoVector.emplace(innerModuleInfoVector.end(), innerModuleInfo);
983 }
984 innerSharedModuleInfos_[moduleName] = innerModuleInfoVector;
985 } else {
986 std::vector<InnerModuleInfo> newInnerModuleInfoVector;
987 newInnerModuleInfoVector.emplace_back(innerModuleInfo);
988 innerSharedModuleInfos_.try_emplace(moduleName, newInnerModuleInfoVector);
989 }
990 }
991
SetSharedModuleNativeLibraryPath(const std::string & nativeLibraryPath)992 void InnerBundleInfo::SetSharedModuleNativeLibraryPath(const std::string &nativeLibraryPath)
993 {
994 auto sharedModuleInfoIterator = innerSharedModuleInfos_.find(currentPackage_);
995 auto moduleInfoIterator = innerModuleInfos_.find(currentPackage_);
996 if ((sharedModuleInfoIterator == innerSharedModuleInfos_.end()) ||
997 (moduleInfoIterator == innerModuleInfos_.end())) {
998 APP_LOGE("The shared module(%{public}s) infomation does not exist", currentPackage_.c_str());
999 return;
1000 }
1001 auto &innerModuleInfoVector = sharedModuleInfoIterator->second;
1002 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
1003 if (iter->versionCode == moduleInfoIterator->second.versionCode) {
1004 iter->nativeLibraryPath = nativeLibraryPath;
1005 return;
1006 }
1007 }
1008 }
1009
GetSharedBundleInfo(SharedBundleInfo & sharedBundleInfo) const1010 bool InnerBundleInfo::GetSharedBundleInfo(SharedBundleInfo &sharedBundleInfo) const
1011 {
1012 sharedBundleInfo.name = GetBundleName();
1013 sharedBundleInfo.compatiblePolicy = CompatiblePolicy::BACKWARD_COMPATIBILITY;
1014 std::vector<SharedModuleInfo> sharedModuleInfos;
1015 for (const auto &infoVector : innerSharedModuleInfos_) {
1016 for (const auto &info : infoVector.second) {
1017 SharedModuleInfo sharedModuleInfo;
1018 sharedModuleInfo.name = info.name;
1019 sharedModuleInfo.versionCode = info.versionCode;
1020 sharedModuleInfo.versionName = info.versionName;
1021 sharedModuleInfo.description = info.description;
1022 sharedModuleInfo.descriptionId = info.descriptionId;
1023 sharedModuleInfo.compressNativeLibs = info.compressNativeLibs;
1024 sharedModuleInfo.hapPath = info.hapPath;
1025 sharedModuleInfo.cpuAbi = info.cpuAbi;
1026 sharedModuleInfo.nativeLibraryPath = info.nativeLibraryPath;
1027 sharedModuleInfo.nativeLibraryFileNames = info.nativeLibraryFileNames;
1028 sharedModuleInfos.emplace_back(sharedModuleInfo);
1029 }
1030 }
1031 sharedBundleInfo.sharedModuleInfos = sharedModuleInfos;
1032 return true;
1033 }
1034
GetSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const1035 bool InnerBundleInfo::GetSharedDependencies(const std::string &moduleName,
1036 std::vector<Dependency> &dependencies) const
1037 {
1038 if (innerModuleInfos_.find(moduleName) != innerModuleInfos_.end()) {
1039 dependencies = innerModuleInfos_.at(moduleName).dependencies;
1040 return true;
1041 }
1042 APP_LOGE("GetSharedDependencies can not find module %{public}s", moduleName.c_str());
1043 return false;
1044 }
1045
GetAllSharedDependencies(const std::string & moduleName,std::vector<Dependency> & dependencies) const1046 bool InnerBundleInfo::GetAllSharedDependencies(const std::string &moduleName,
1047 std::vector<Dependency> &dependencies) const
1048 {
1049 if (!GetSharedDependencies(moduleName, dependencies)) {
1050 return false;
1051 }
1052 std::deque<Dependency> dependenciesDeque;
1053 std::copy(dependencies.begin(), dependencies.end(), std::back_inserter(dependenciesDeque));
1054 dependencies.clear();
1055 while (!dependenciesDeque.empty()) {
1056 bool isAdd = true;
1057 Dependency itemDependency = dependenciesDeque.front();
1058 dependenciesDeque.pop_front();
1059 for (const auto &item : dependencies) {
1060 if (item.bundleName == itemDependency.bundleName && item.moduleName == itemDependency.moduleName &&
1061 item.versionCode == itemDependency.versionCode) {
1062 isAdd = false;
1063 break;
1064 }
1065 }
1066 if (isAdd) {
1067 dependencies.push_back(itemDependency);
1068 std::vector<Dependency> tempDependencies;
1069 if (GetSharedDependencies(itemDependency.moduleName, tempDependencies)) {
1070 std::copy(tempDependencies.begin(), tempDependencies.end(), std::back_inserter(dependenciesDeque));
1071 }
1072 }
1073 }
1074 return true;
1075 }
1076
RemoveModuleInfo(const std::string & modulePackage)1077 void InnerBundleInfo::RemoveModuleInfo(const std::string &modulePackage)
1078 {
1079 auto it = innerModuleInfos_.find(modulePackage);
1080 if (it == innerModuleInfos_.end()) {
1081 APP_LOGE("The module(%{public}s) infomation does not exist", modulePackage.c_str());
1082 return;
1083 }
1084
1085 auto oldModuleInfo = it->second;
1086 if (oldModuleInfo.isEntry) {
1087 baseBundleInfo_->mainEntry.clear();
1088 baseBundleInfo_->entryModuleName.clear();
1089 }
1090 innerModuleInfos_.erase(it);
1091 std::string key;
1092 key.append(".").append(modulePackage).append(".");
1093 for (auto iter = shortcutInfos_.begin(); iter != shortcutInfos_.end();) {
1094 if (iter->first.find(key) != std::string::npos) {
1095 shortcutInfos_.erase(iter++);
1096 } else {
1097 ++iter;
1098 }
1099 }
1100
1101 for (auto iter = commonEvents_.begin(); iter != commonEvents_.end();) {
1102 if (iter->first.find(key) != std::string::npos) {
1103 commonEvents_.erase(iter++);
1104 } else {
1105 ++iter;
1106 }
1107 }
1108
1109 // delete old abilityInfos
1110 for (auto abilityKey : oldModuleInfo.abilityKeys) {
1111 auto abilityItem = baseAbilityInfos_.find(abilityKey);
1112 if (abilityItem == baseAbilityInfos_.end()) {
1113 continue;
1114 }
1115
1116 baseAbilityInfos_.erase(abilityItem);
1117 formInfos_.erase(abilityKey);
1118 }
1119
1120 // delete old skillInfos
1121 for (auto skillKey : oldModuleInfo.skillKeys) {
1122 auto skillItem = skillInfos_.find(skillKey);
1123 if (skillItem == skillInfos_.end()) {
1124 continue;
1125 }
1126
1127 skillInfos_.erase(skillItem);
1128 }
1129
1130 // delete old extensionInfos
1131 for (auto extensionKey : oldModuleInfo.extensionKeys) {
1132 auto extensionItem = baseExtensionInfos_.find(extensionKey);
1133 if (extensionItem == baseExtensionInfos_.end()) {
1134 continue;
1135 }
1136
1137 baseExtensionInfos_.erase(extensionItem);
1138 }
1139
1140 // delete old extensionSkillInfos
1141 for (auto extensionSkillKey : oldModuleInfo.extensionSkillKeys) {
1142 auto extensionSkillItem = extensionSkillInfos_.find(extensionSkillKey);
1143 if (extensionSkillItem == extensionSkillInfos_.end()) {
1144 continue;
1145 }
1146
1147 extensionSkillInfos_.erase(extensionSkillItem);
1148 }
1149 }
1150
ToString() const1151 std::string InnerBundleInfo::ToString() const
1152 {
1153 nlohmann::json j;
1154 ToJson(j);
1155 return j.dump();
1156 }
1157
GetApplicationInfo(int32_t flags,int32_t userId,ApplicationInfo & appInfo) const1158 void InnerBundleInfo::GetApplicationInfo(int32_t flags, int32_t userId, ApplicationInfo &appInfo) const
1159 {
1160 InnerBundleUserInfo innerBundleUserInfo;
1161 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1162 APP_LOGE("can not find userId %{public}d when get applicationInfo", userId);
1163 return;
1164 }
1165
1166 appInfo = *baseApplicationInfo_;
1167 if (appInfo.removable && !innerBundleUserInfo.isRemovable) {
1168 appInfo.removable = false;
1169 }
1170
1171 appInfo.accessTokenId = innerBundleUserInfo.accessTokenId;
1172 appInfo.accessTokenIdEx = innerBundleUserInfo.accessTokenIdEx;
1173 appInfo.enabled = innerBundleUserInfo.bundleUserInfo.enabled;
1174 appInfo.uid = innerBundleUserInfo.uid;
1175
1176 for (const auto &info : innerModuleInfos_) {
1177 bool deCompress = info.second.hapPath.empty();
1178 ModuleInfo moduleInfo;
1179 moduleInfo.moduleName = info.second.moduleName;
1180 if (deCompress) {
1181 moduleInfo.moduleSourceDir = info.second.modulePath;
1182 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
1183 }
1184 moduleInfo.preloads = info.second.preloads;
1185 appInfo.moduleInfos.emplace_back(moduleInfo);
1186 if (deCompress && info.second.isEntry) {
1187 appInfo.entryDir = info.second.modulePath;
1188 }
1189 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_PERMISSION) ==
1190 GET_APPLICATION_INFO_WITH_PERMISSION) {
1191 for (const auto &item : info.second.requestPermissions) {
1192 appInfo.permissions.push_back(item.name);
1193 }
1194 }
1195 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_METADATA) == GET_APPLICATION_INFO_WITH_METADATA) {
1196 bool isModuleJson = info.second.isModuleJson;
1197 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
1198 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
1199 }
1200 if (isModuleJson && info.second.metadata.size() > 0) {
1201 appInfo.metadata[info.second.moduleName] = info.second.metadata;
1202 }
1203 }
1204 if ((static_cast<uint32_t>(flags) & GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) !=
1205 GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT) {
1206 appInfo.fingerprint.clear();
1207 }
1208 }
1209 if (!appInfo.permissions.empty()) {
1210 RemoveDuplicateName(appInfo.permissions);
1211 }
1212 }
1213
GetApplicationInfoV9(int32_t flags,int32_t userId,ApplicationInfo & appInfo) const1214 ErrCode InnerBundleInfo::GetApplicationInfoV9(int32_t flags, int32_t userId, ApplicationInfo &appInfo) const
1215 {
1216 InnerBundleUserInfo innerBundleUserInfo;
1217 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1218 APP_LOGE("can not find userId %{public}d when get applicationInfo", userId);
1219 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
1220 }
1221
1222 appInfo = *baseApplicationInfo_;
1223 if (appInfo.removable && !innerBundleUserInfo.isRemovable) {
1224 appInfo.removable = false;
1225 }
1226
1227 appInfo.accessTokenId = innerBundleUserInfo.accessTokenId;
1228 appInfo.accessTokenIdEx = innerBundleUserInfo.accessTokenIdEx;
1229 appInfo.enabled = innerBundleUserInfo.bundleUserInfo.enabled;
1230 appInfo.uid = innerBundleUserInfo.uid;
1231
1232 for (const auto &info : innerModuleInfos_) {
1233 bool deCompress = info.second.hapPath.empty();
1234 ModuleInfo moduleInfo;
1235 moduleInfo.moduleName = info.second.moduleName;
1236 if (deCompress) {
1237 moduleInfo.moduleSourceDir = info.second.modulePath;
1238 appInfo.moduleSourceDirs.emplace_back(info.second.modulePath);
1239 }
1240 moduleInfo.preloads = info.second.preloads;
1241 appInfo.moduleInfos.emplace_back(moduleInfo);
1242 if (deCompress && info.second.isEntry) {
1243 appInfo.entryDir = info.second.modulePath;
1244 }
1245 if ((static_cast<uint32_t>(flags) &
1246 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) ==
1247 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION)) {
1248 for (const auto &item : info.second.requestPermissions) {
1249 appInfo.permissions.push_back(item.name);
1250 }
1251 }
1252 if ((static_cast<uint32_t>(flags) &
1253 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) ==
1254 static_cast<uint32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA)) {
1255 bool isModuleJson = info.second.isModuleJson;
1256 if (!isModuleJson && info.second.metaData.customizeData.size() > 0) {
1257 appInfo.metaData[info.second.moduleName] = info.second.metaData.customizeData;
1258 }
1259 if (isModuleJson && info.second.metadata.size() > 0) {
1260 appInfo.metadata[info.second.moduleName] = info.second.metadata;
1261 }
1262 }
1263 }
1264 if (!appInfo.permissions.empty()) {
1265 RemoveDuplicateName(appInfo.permissions);
1266 }
1267 return ERR_OK;
1268 }
1269
GetBundleInfo(int32_t flags,BundleInfo & bundleInfo,int32_t userId) const1270 bool InnerBundleInfo::GetBundleInfo(int32_t flags, BundleInfo &bundleInfo, int32_t userId) const
1271 {
1272 InnerBundleUserInfo innerBundleUserInfo;
1273 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1274 APP_LOGE("can not find userId %{public}d when GetBundleInfo bundleName:%{public}s",
1275 userId, GetBundleName().c_str());
1276 return false;
1277 }
1278
1279 bundleInfo = *baseBundleInfo_;
1280
1281 bundleInfo.uid = innerBundleUserInfo.uid;
1282 if (!innerBundleUserInfo.gids.empty()) {
1283 bundleInfo.gid = innerBundleUserInfo.gids[0];
1284 }
1285 bundleInfo.installTime = innerBundleUserInfo.installTime;
1286 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
1287 bundleInfo.appIndex = appIndex_;
1288 bundleInfo.overlayType = overlayType_;
1289
1290 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_CERTIFICATE_FINGERPRINT, userId,
1291 bundleInfo.applicationInfo);
1292 for (const auto &info : innerModuleInfos_) {
1293 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
1294 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
1295 for (const auto &item : info.second.requestPermissions) {
1296 bundleInfo.reqPermissions.push_back(item.name);
1297 }
1298 for (const auto &item : info.second.definePermissions) {
1299 bundleInfo.defPermissions.push_back(item.name);
1300 }
1301 }
1302 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
1303 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
1304 if (hapmoduleinfo) {
1305 GetModuleWithHashValue(flags, info.second.modulePackage, *hapmoduleinfo);
1306 bundleInfo.hapModuleInfos.emplace_back(*hapmoduleinfo);
1307 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
1308 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
1309 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
1310 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
1311 } else {
1312 APP_LOGE("can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
1313 }
1314 }
1315 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_REQUESTED_PERMISSION)
1316 == GET_BUNDLE_WITH_REQUESTED_PERMISSION) {
1317 if (!bundleInfo.reqPermissions.empty()) {
1318 RemoveDuplicateName(bundleInfo.reqPermissions);
1319 }
1320 if (!bundleInfo.defPermissions.empty()) {
1321 RemoveDuplicateName(bundleInfo.defPermissions);
1322 }
1323 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo,
1324 bundleInfo.applicationInfo.accessTokenId, bundleInfo.applicationInfo.deviceId)) {
1325 APP_LOGE("get request permission state failed");
1326 }
1327 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
1328 }
1329 GetBundleWithAbilities(flags, bundleInfo, userId);
1330 GetBundleWithExtension(flags, bundleInfo, userId);
1331 return true;
1332 }
1333
GetBundleInfoV9(int32_t flags,BundleInfo & bundleInfo,int32_t userId) const1334 ErrCode InnerBundleInfo::GetBundleInfoV9(int32_t flags, BundleInfo &bundleInfo, int32_t userId) const
1335 {
1336 InnerBundleUserInfo innerBundleUserInfo;
1337 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1338 APP_LOGE("can not find userId %{public}d when GetBundleInfo", userId);
1339 return ERR_BUNDLE_MANAGER_INTERNAL_ERROR;
1340 }
1341
1342 bundleInfo = *baseBundleInfo_;
1343
1344 bundleInfo.uid = innerBundleUserInfo.uid;
1345 if (!innerBundleUserInfo.gids.empty()) {
1346 bundleInfo.gid = innerBundleUserInfo.gids[0];
1347 }
1348 bundleInfo.installTime = innerBundleUserInfo.installTime;
1349 bundleInfo.updateTime = innerBundleUserInfo.updateTime;
1350 bundleInfo.appIndex = appIndex_;
1351
1352 for (const auto &info : innerModuleInfos_) {
1353 bundleInfo.hapModuleNames.emplace_back(info.second.modulePackage);
1354 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
1355 if (hapmoduleinfo) {
1356 bundleInfo.moduleNames.emplace_back(info.second.moduleName);
1357 bundleInfo.moduleDirs.emplace_back(info.second.modulePath);
1358 bundleInfo.modulePublicDirs.emplace_back(info.second.moduleDataDir);
1359 bundleInfo.moduleResPaths.emplace_back(info.second.moduleResPath);
1360 } else {
1361 APP_LOGE("can not find hapmoduleinfo %{public}s", info.second.moduleName.c_str());
1362 }
1363 }
1364 ProcessBundleFlags(flags, userId, bundleInfo);
1365 return ERR_OK;
1366 }
1367
GetSharedBundleInfo(int32_t flags,BundleInfo & bundleInfo) const1368 bool InnerBundleInfo::GetSharedBundleInfo(int32_t flags, BundleInfo &bundleInfo) const
1369 {
1370 bundleInfo = *baseBundleInfo_;
1371 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, Constants::ALL_USERID);
1372 bundleInfo.applicationInfo = *baseApplicationInfo_;
1373 return true;
1374 }
1375
ProcessBundleFlags(int32_t flags,int32_t userId,BundleInfo & bundleInfo) const1376 void InnerBundleInfo::ProcessBundleFlags(
1377 int32_t flags, int32_t userId, BundleInfo &bundleInfo) const
1378 {
1379 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
1380 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
1381 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
1382 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
1383 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_WITH_METADATA), userId,
1384 bundleInfo.applicationInfo);
1385 } else {
1386 GetApplicationInfoV9(static_cast<int32_t>(GetApplicationFlag::GET_APPLICATION_INFO_DEFAULT), userId,
1387 bundleInfo.applicationInfo);
1388 }
1389 }
1390 GetBundleWithReqPermissionsV9(flags, userId, bundleInfo);
1391 ProcessBundleWithHapModuleInfoFlag(flags, bundleInfo, userId);
1392 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
1393 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
1394 bundleInfo.signatureInfo.appId = baseBundleInfo_->appId;
1395 bundleInfo.signatureInfo.fingerprint = baseApplicationInfo_->fingerprint;
1396 }
1397 }
1398
GetBundleWithReqPermissionsV9(int32_t flags,int32_t userId,BundleInfo & bundleInfo) const1399 void InnerBundleInfo::GetBundleWithReqPermissionsV9(int32_t flags, int32_t userId, BundleInfo &bundleInfo) const
1400 {
1401 if ((static_cast<uint32_t>(flags) &
1402 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION))
1403 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION)) {
1404 return;
1405 }
1406 for (const auto &info : innerModuleInfos_) {
1407 for (const auto &item : info.second.requestPermissions) {
1408 bundleInfo.reqPermissions.push_back(item.name);
1409 }
1410 for (const auto &item : info.second.definePermissions) {
1411 bundleInfo.defPermissions.push_back(item.name);
1412 }
1413 }
1414 if (!bundleInfo.reqPermissions.empty()) {
1415 RemoveDuplicateName(bundleInfo.reqPermissions);
1416 }
1417 if (!bundleInfo.defPermissions.empty()) {
1418 RemoveDuplicateName(bundleInfo.defPermissions);
1419 }
1420 InnerBundleUserInfo innerBundleUserInfo;
1421 if (!GetInnerBundleUserInfo(userId, innerBundleUserInfo)) {
1422 APP_LOGE("can not find userId %{public}d when get applicationInfo", userId);
1423 return;
1424 }
1425 uint32_t tokenId = innerBundleUserInfo.accessTokenId;
1426 std::string deviceId = baseApplicationInfo_->deviceId;
1427 if (!BundlePermissionMgr::GetRequestPermissionStates(bundleInfo, tokenId, deviceId)) {
1428 APP_LOGE("get request permission state failed");
1429 }
1430 bundleInfo.reqPermissionDetails = GetAllRequestPermissions();
1431 }
1432
GetModuleWithHashValue(int32_t flags,const std::string & modulePackage,HapModuleInfo & hapModuleInfo) const1433 void InnerBundleInfo::GetModuleWithHashValue(
1434 int32_t flags, const std::string &modulePackage, HapModuleInfo &hapModuleInfo) const
1435 {
1436 if (!(static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_HASH_VALUE)) {
1437 return;
1438 }
1439
1440 auto it = innerModuleInfos_.find(modulePackage);
1441 if (it == innerModuleInfos_.end()) {
1442 APP_LOGE("can not find module %{public}s", modulePackage.c_str());
1443 return;
1444 }
1445
1446 hapModuleInfo.hashValue = it->second.hashValue;
1447 }
1448
ProcessBundleWithHapModuleInfoFlag(int32_t flags,BundleInfo & bundleInfo,int32_t userId) const1449 void InnerBundleInfo::ProcessBundleWithHapModuleInfoFlag(int32_t flags, BundleInfo &bundleInfo, int32_t userId) const
1450 {
1451 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE))
1452 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_HAP_MODULE)) {
1453 bundleInfo.hapModuleInfos.clear();
1454 return;
1455 }
1456 for (const auto &info : innerModuleInfos_) {
1457 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, userId);
1458 if (hapmoduleinfo) {
1459 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
1460 auto it = innerModuleInfos_.find(info.second.modulePackage);
1461 if (it == innerModuleInfos_.end()) {
1462 APP_LOGE("can not find module %{public}s", info.second.modulePackage.c_str());
1463 } else {
1464 hapModuleInfo.hashValue = it->second.hashValue;
1465 }
1466 if (hapModuleInfo.hapPath.empty()) {
1467 hapModuleInfo.moduleSourceDir = info.second.modulePath;
1468 }
1469 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
1470 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
1471 hapModuleInfo.metadata.clear();
1472 }
1473
1474 GetBundleWithAbilitiesV9(flags, hapModuleInfo, userId);
1475 GetBundleWithExtensionAbilitiesV9(flags, hapModuleInfo);
1476 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
1477 }
1478 }
1479 }
1480
GetBundleWithAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo,int32_t userId) const1481 void InnerBundleInfo::GetBundleWithAbilitiesV9(int32_t flags, HapModuleInfo &hapModuleInfo, int32_t userId) const
1482 {
1483 hapModuleInfo.abilityInfos.clear();
1484 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY))
1485 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_ABILITY)) {
1486 return;
1487 }
1488 APP_LOGD("Get bundleInfo with abilities.");
1489 for (auto &ability : baseAbilityInfos_) {
1490 if ((ability.second.moduleName != hapModuleInfo.moduleName) ||
1491 (ability.second.name == Constants::APP_DETAIL_ABILITY)) {
1492 continue;
1493 }
1494 bool isEnabled = IsAbilityEnabled(ability.second, userId);
1495 if (!(static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_DISABLE))
1496 && !isEnabled) {
1497 APP_LOGW("%{public}s is disabled,", ability.second.name.c_str());
1498 continue;
1499 }
1500 AbilityInfo abilityInfo = ability.second;
1501 abilityInfo.enabled = isEnabled;
1502
1503 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
1504 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
1505 abilityInfo.metaData.customizeData.clear();
1506 abilityInfo.metadata.clear();
1507 }
1508 hapModuleInfo.abilityInfos.emplace_back(abilityInfo);
1509 }
1510 }
1511
GetBundleWithExtensionAbilitiesV9(int32_t flags,HapModuleInfo & hapModuleInfo) const1512 void InnerBundleInfo::GetBundleWithExtensionAbilitiesV9(int32_t flags, HapModuleInfo &hapModuleInfo) const
1513 {
1514 hapModuleInfo.extensionInfos.clear();
1515 if ((static_cast<uint32_t>(flags) &
1516 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY))
1517 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_EXTENSION_ABILITY)) {
1518 return;
1519 }
1520 APP_LOGD("Get bundleInfo with extensionAbilities.");
1521 for (const auto &extensionInfo : baseExtensionInfos_) {
1522 if (extensionInfo.second.moduleName != hapModuleInfo.moduleName || !extensionInfo.second.enabled) {
1523 continue;
1524 }
1525 ExtensionAbilityInfo info = extensionInfo.second;
1526
1527 if ((static_cast<uint32_t>(flags) & static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA))
1528 != static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_METADATA)) {
1529 info.metadata.clear();
1530 }
1531 hapModuleInfo.extensionInfos.emplace_back(info);
1532 }
1533 }
1534
GetBundleWithAbilities(int32_t flags,BundleInfo & bundleInfo,int32_t userId) const1535 void InnerBundleInfo::GetBundleWithAbilities(int32_t flags, BundleInfo &bundleInfo, int32_t userId) const
1536 {
1537 APP_LOGD("bundleName:%{public}s userid:%{public}d", bundleInfo.name.c_str(), userId);
1538 if (static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_ABILITIES) {
1539 for (auto &ability : baseAbilityInfos_) {
1540 if (ability.second.name == Constants::APP_DETAIL_ABILITY) {
1541 continue;
1542 }
1543 bool isEnabled = IsAbilityEnabled(ability.second, userId);
1544 if (!(static_cast<uint32_t>(flags) & GET_ABILITY_INFO_WITH_DISABLE)
1545 && !isEnabled) {
1546 APP_LOGW("%{public}s is disabled,", ability.second.name.c_str());
1547 continue;
1548 }
1549 AbilityInfo abilityInfo = ability.second;
1550 abilityInfo.enabled = isEnabled;
1551 bundleInfo.abilityInfos.emplace_back(abilityInfo);
1552 }
1553 }
1554 }
1555
GetBundleWithExtension(int32_t flags,BundleInfo & bundleInfo,int32_t userId) const1556 void InnerBundleInfo::GetBundleWithExtension(int32_t flags, BundleInfo &bundleInfo, int32_t userId) const
1557 {
1558 APP_LOGD("get bundleInfo with extensionInfo begin");
1559 if ((static_cast<uint32_t>(flags) & GET_BUNDLE_WITH_EXTENSION_INFO) == GET_BUNDLE_WITH_EXTENSION_INFO) {
1560 for (const auto &extensionInfo : baseExtensionInfos_) {
1561 if (!extensionInfo.second.enabled) {
1562 continue;
1563 }
1564 ExtensionAbilityInfo info = extensionInfo.second;
1565 bundleInfo.extensionInfos.emplace_back(info);
1566 }
1567 }
1568 APP_LOGD("get bundleInfo with extensionInfo end");
1569 }
1570
CheckSpecialMetaData(const std::string & metaData) const1571 bool InnerBundleInfo::CheckSpecialMetaData(const std::string &metaData) const
1572 {
1573 if (isNewVersion_) {
1574 for (const auto &moduleInfo : innerModuleInfos_) {
1575 for (const auto &data : moduleInfo.second.metadata) {
1576 if (metaData == data.name) {
1577 return true;
1578 }
1579 }
1580 }
1581 return false;
1582 }
1583 // old version
1584 for (const auto &moduleInfo : innerModuleInfos_) {
1585 for (const auto &data : moduleInfo.second.metaData.customizeData) {
1586 if (metaData == data.name) {
1587 return true;
1588 }
1589 }
1590 }
1591 return false;
1592 }
1593
GetFormsInfoByModule(const std::string & moduleName,std::vector<FormInfo> & formInfos) const1594 void InnerBundleInfo::GetFormsInfoByModule(const std::string &moduleName, std::vector<FormInfo> &formInfos) const
1595 {
1596 for (const auto &data : formInfos_) {
1597 for (auto &form : data.second) {
1598 if (form.moduleName == moduleName) {
1599 formInfos.emplace_back(form);
1600 }
1601 }
1602 }
1603 }
1604
GetFormsInfoByApp(std::vector<FormInfo> & formInfos) const1605 void InnerBundleInfo::GetFormsInfoByApp(std::vector<FormInfo> &formInfos) const
1606 {
1607 for (const auto &data : formInfos_) {
1608 std::copy(data.second.begin(), data.second.end(), std::back_inserter(formInfos));
1609 }
1610 }
1611
GetShortcutInfos(std::vector<ShortcutInfo> & shortcutInfos) const1612 void InnerBundleInfo::GetShortcutInfos(std::vector<ShortcutInfo> &shortcutInfos) const
1613 {
1614 if (isNewVersion_) {
1615 AbilityInfo abilityInfo;
1616 GetMainAbilityInfo(abilityInfo);
1617 if ((!abilityInfo.resourcePath.empty() || !abilityInfo.hapPath.empty())
1618 && abilityInfo.metadata.size() > 0) {
1619 std::vector<std::string> rawJson;
1620 BundleMgrClient bundleMgrClient;
1621 bool ret = bundleMgrClient.GetResConfigFile(abilityInfo, META_DATA_SHORTCUTS_NAME, rawJson);
1622 if (!ret) {
1623 APP_LOGD("GetResConfigFile return false");
1624 return;
1625 }
1626 if (rawJson.size() == 0) {
1627 APP_LOGD("rawJson size 0. skip.");
1628 return;
1629 }
1630 nlohmann::json jsonObject = nlohmann::json::parse(rawJson[0], nullptr, false);
1631 if (jsonObject.is_discarded()) {
1632 APP_LOGE("shortcuts json invalid");
1633 return;
1634 }
1635 ShortcutJson shortcutJson = jsonObject.get<ShortcutJson>();
1636 for (const Shortcut &item : shortcutJson.shortcuts) {
1637 ShortcutInfo shortcutInfo;
1638 shortcutInfo.bundleName = abilityInfo.bundleName;
1639 shortcutInfo.moduleName = abilityInfo.moduleName;
1640 InnerProcessShortcut(item, shortcutInfo);
1641 shortcutInfos.emplace_back(shortcutInfo);
1642 }
1643 }
1644 return;
1645 }
1646 for (const auto &shortcut : shortcutInfos_) {
1647 shortcutInfos.emplace_back(shortcut.second);
1648 }
1649 }
1650
GetCommonEvents(const std::string & eventKey,std::vector<CommonEventInfo> & commonEvents) const1651 void InnerBundleInfo::GetCommonEvents(const std::string &eventKey, std::vector<CommonEventInfo> &commonEvents) const
1652 {
1653 CommonEventInfo item;
1654 for (const auto &commonEvent : commonEvents_) {
1655 for (const auto &event : commonEvent.second.events) {
1656 if (event == eventKey) {
1657 item = commonEvent.second;
1658 item.uid = GetUid(GetUserId());
1659 commonEvents.emplace_back(item);
1660 break;
1661 }
1662 }
1663 }
1664 }
1665
GetInnerModuleInfoByModuleName(const std::string & moduleName) const1666 std::optional<InnerModuleInfo> InnerBundleInfo::GetInnerModuleInfoByModuleName(const std::string &moduleName) const
1667 {
1668 for (const auto &innerModuleInfo : innerModuleInfos_) {
1669 APP_LOGD("info.moduleName = %{public}s, moduleName= %{public}s",
1670 innerModuleInfo.second.moduleName.c_str(), moduleName.c_str());
1671 if (innerModuleInfo.second.moduleName == moduleName) {
1672 return innerModuleInfo.second;
1673 }
1674 }
1675 return std::nullopt;
1676 }
1677
GetModuleNames(std::vector<std::string> & moduleNames) const1678 void InnerBundleInfo::GetModuleNames(std::vector<std::string> &moduleNames) const
1679 {
1680 for (const auto &innerModuleInfo : innerModuleInfos_) {
1681 moduleNames.emplace_back(innerModuleInfo.second.moduleName);
1682 }
1683 }
1684
ResetBundleState(int32_t userId)1685 void InnerBundleInfo::ResetBundleState(int32_t userId)
1686 {
1687 if (userId == Constants::ALL_USERID) {
1688 for (auto& innerBundleUserInfo : innerBundleUserInfos_) {
1689 innerBundleUserInfo.second.bundleUserInfo.Reset();
1690 }
1691
1692 return;
1693 }
1694
1695 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1696 if (innerBundleUserInfos_.find(key) == innerBundleUserInfos_.end()) {
1697 APP_LOGD("no this user %{public}s", key.c_str());
1698 return;
1699 }
1700
1701 innerBundleUserInfos_.at(key).bundleUserInfo.Reset();
1702 }
1703
RemoveInnerBundleUserInfo(int32_t userId)1704 void InnerBundleInfo::RemoveInnerBundleUserInfo(int32_t userId)
1705 {
1706 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1707 auto infoItem = innerBundleUserInfos_.find(key);
1708 if (infoItem == innerBundleUserInfos_.end()) {
1709 return;
1710 }
1711
1712 auto result = innerBundleUserInfos_.erase(key);
1713 if (result == 0) {
1714 APP_LOGE("remove userId:%{public}d key:%{public}s info failed", userId, key.c_str());
1715 }
1716 for (auto &innerModuleInfo : innerModuleInfos_) {
1717 DeleteModuleRemovable(innerModuleInfo.second.moduleName, userId);
1718 }
1719 }
1720
AddInnerBundleUserInfo(const InnerBundleUserInfo & innerBundleUserInfo)1721 void InnerBundleInfo::AddInnerBundleUserInfo(
1722 const InnerBundleUserInfo& innerBundleUserInfo)
1723 {
1724 auto& key = NameAndUserIdToKey(
1725 GetBundleName(), innerBundleUserInfo.bundleUserInfo.userId);
1726 auto infoItem = innerBundleUserInfos_.find(key);
1727 if (infoItem == innerBundleUserInfos_.end()) {
1728 innerBundleUserInfos_.emplace(key, innerBundleUserInfo);
1729 return;
1730 }
1731
1732 innerBundleUserInfos_[key] = innerBundleUserInfo;
1733 }
1734
GetInnerBundleUserInfo(int32_t userId,InnerBundleUserInfo & innerBundleUserInfo) const1735 bool InnerBundleInfo::GetInnerBundleUserInfo(
1736 int32_t userId, InnerBundleUserInfo& innerBundleUserInfo) const
1737 {
1738 if (userId == Constants::NOT_EXIST_USERID) {
1739 return true;
1740 }
1741
1742 if (userId == Constants::ALL_USERID) {
1743 if (innerBundleUserInfos_.empty()) {
1744 return false;
1745 }
1746
1747 innerBundleUserInfo = innerBundleUserInfos_.begin()->second;
1748 return true;
1749 }
1750
1751 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1752 auto infoItem = innerBundleUserInfos_.find(key);
1753 if (infoItem == innerBundleUserInfos_.end()) {
1754 return false;
1755 }
1756
1757 innerBundleUserInfo = infoItem->second;
1758 return true;
1759 }
1760
HasInnerBundleUserInfo(int32_t userId) const1761 bool InnerBundleInfo::HasInnerBundleUserInfo(int32_t userId) const
1762 {
1763 if (userId == Constants::ALL_USERID || userId == Constants::ANY_USERID) {
1764 return !innerBundleUserInfos_.empty();
1765 }
1766
1767 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1768 auto infoItem = innerBundleUserInfos_.find(key);
1769 return infoItem != innerBundleUserInfos_.end();
1770 }
1771
SetBundleInstallTime(const int64_t time,int32_t userId)1772 void InnerBundleInfo::SetBundleInstallTime(const int64_t time, int32_t userId)
1773 {
1774 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1775 auto infoItem = innerBundleUserInfos_.find(key);
1776 if (infoItem == innerBundleUserInfos_.end()) {
1777 return;
1778 }
1779
1780 infoItem->second.installTime = time;
1781 infoItem->second.updateTime = time;
1782 }
1783
SetAccessTokenId(uint32_t accessToken,const int32_t userId)1784 void InnerBundleInfo::SetAccessTokenId(uint32_t accessToken, const int32_t userId)
1785 {
1786 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1787 auto infoItem = innerBundleUserInfos_.find(key);
1788 if (infoItem == innerBundleUserInfos_.end()) {
1789 return;
1790 }
1791
1792 infoItem->second.accessTokenId = accessToken;
1793 }
1794
SetAccessTokenIdEx(const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,const int32_t userId)1795 void InnerBundleInfo::SetAccessTokenIdEx(
1796 const Security::AccessToken::AccessTokenIDEx accessTokenIdEx,
1797 const int32_t userId)
1798 {
1799 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1800 auto infoItem = innerBundleUserInfos_.find(key);
1801 if (infoItem == innerBundleUserInfos_.end()) {
1802 return;
1803 }
1804
1805 infoItem->second.accessTokenId = accessTokenIdEx.tokenIdExStruct.tokenID;
1806 infoItem->second.accessTokenIdEx = accessTokenIdEx.tokenIDEx;
1807 }
1808
SetBundleUpdateTime(const int64_t time,int32_t userId)1809 void InnerBundleInfo::SetBundleUpdateTime(const int64_t time, int32_t userId)
1810 {
1811 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1812 auto infoItem = innerBundleUserInfos_.find(key);
1813 if (infoItem == innerBundleUserInfos_.end()) {
1814 return;
1815 }
1816
1817 infoItem->second.updateTime = time;
1818 }
1819
IsAbilityEnabled(const AbilityInfo & abilityInfo,int32_t userId) const1820 bool InnerBundleInfo::IsAbilityEnabled(const AbilityInfo &abilityInfo, int32_t userId) const
1821 {
1822 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
1823 if (userId == Constants::NOT_EXIST_USERID) {
1824 return true;
1825 }
1826 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
1827 auto infoItem = innerBundleUserInfos_.find(key);
1828 if (infoItem == innerBundleUserInfos_.end()) {
1829 APP_LOGE("innerBundleUserInfos find key:%{public}s, error", key.c_str());
1830 return false;
1831 }
1832 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
1833 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name) != disabledAbilities.end()) {
1834 return false;
1835 } else {
1836 return true;
1837 }
1838 }
1839
SetOverlayModuleState(const std::string & moduleName,int32_t state,int32_t userId)1840 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state, int32_t userId)
1841 {
1842 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
1843 if (overlayType_ == NON_OVERLAY_TYPE) {
1844 APP_LOGW("no overlay module");
1845 return;
1846 }
1847 for (auto &innerUserInfo : innerBundleUserInfos_) {
1848 if (innerUserInfo.second.bundleUserInfo.userId != userId) {
1849 continue;
1850 }
1851
1852 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
1853 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
1854 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
1855 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
1856 return true;
1857 }
1858 return false;
1859 });
1860 if (!isSetSucc) {
1861 APP_LOGD("no overlay module state info under user %{public}d", userId);
1862 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
1863 }
1864 }
1865 }
1866
SetOverlayModuleState(const std::string & moduleName,int32_t state)1867 void InnerBundleInfo::SetOverlayModuleState(const std::string &moduleName, int32_t state)
1868 {
1869 APP_LOGD("start to set overlay moduleInfo state of module %{public}s", moduleName.c_str());
1870 if (overlayType_ == NON_OVERLAY_TYPE) {
1871 APP_LOGW("no overlay module");
1872 return;
1873 }
1874 for (auto &innerUserInfo : innerBundleUserInfos_) {
1875 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
1876 bool isSetSucc = std::any_of(overlayStates.begin(), overlayStates.end(), [&moduleName, &state](auto &item) {
1877 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
1878 item = moduleName + Constants::FILE_UNDERLINE + std::to_string(state);
1879 return true;
1880 }
1881 return false;
1882 });
1883 if (!isSetSucc) {
1884 overlayStates.emplace_back(moduleName + Constants::FILE_UNDERLINE + std::to_string(state));
1885 }
1886 }
1887 }
1888
GetOverlayModuleState(const std::string & moduleName,int32_t userId,int32_t & state) const1889 bool InnerBundleInfo::GetOverlayModuleState(const std::string &moduleName, int32_t userId, int32_t &state) const
1890 {
1891 APP_LOGD("start to get overlay state of moduleName:%{public}s, userId:%{public}d", moduleName.c_str(), userId);
1892 if (userId == Constants::NOT_EXIST_USERID) {
1893 APP_LOGE("invalid userId %{public}d", userId);
1894 return false;
1895 }
1896 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
1897 auto infoItem = innerBundleUserInfos_.find(key);
1898 if (infoItem == innerBundleUserInfos_.end()) {
1899 APP_LOGE("no userInfo under userId %{public}d", userId);
1900 return false;
1901 }
1902
1903 auto overlayModulesState = infoItem->second.bundleUserInfo.overlayModulesState;
1904 if (overlayModulesState.empty()) {
1905 APP_LOGE("no overlay module installed under userId %{public}d", userId);
1906 return false;
1907 }
1908 for (const auto &item : overlayModulesState) {
1909 auto pos = item.find(moduleName + Constants::FILE_UNDERLINE);
1910 if (pos == std::string::npos) {
1911 continue;
1912 }
1913 return OHOS::StrToInt(item.substr(moduleName.length() + 1), state);
1914 }
1915 APP_LOGE("no overlay module installed under userId %{public}d", userId);
1916 return false;
1917 }
1918
ClearOverlayModuleStates(const std::string & moduleName)1919 void InnerBundleInfo::ClearOverlayModuleStates(const std::string &moduleName)
1920 {
1921 // delete overlay module state
1922 for (auto &innerUserInfo : innerBundleUserInfos_) {
1923 auto &overlayStates = innerUserInfo.second.bundleUserInfo.overlayModulesState;
1924 auto iter = std::find_if(overlayStates.begin(), overlayStates.end(), [&moduleName](const auto &item) {
1925 if (item.find(moduleName + Constants::FILE_UNDERLINE) != std::string::npos) {
1926 return true;
1927 }
1928 return false;
1929 });
1930 if (iter != overlayStates.end()) {
1931 overlayStates.erase(iter);
1932 }
1933 }
1934 }
1935
IsAbilityEnabledV9(const AbilityInfo & abilityInfo,int32_t userId,bool & isEnable) const1936 ErrCode InnerBundleInfo::IsAbilityEnabledV9(const AbilityInfo &abilityInfo, int32_t userId, bool &isEnable) const
1937 {
1938 APP_LOGD("IsAbilityEnabled bundleName:%{public}s, userId:%{public}d", abilityInfo.bundleName.c_str(), userId);
1939 if (userId == Constants::NOT_EXIST_USERID) {
1940 isEnable = true;
1941 return ERR_OK;
1942 }
1943 auto& key = NameAndUserIdToKey(abilityInfo.bundleName, userId);
1944 auto infoItem = innerBundleUserInfos_.find(key);
1945 if (infoItem == innerBundleUserInfos_.end()) {
1946 APP_LOGE("innerBundleUserInfos find key:%{public}s, error", key.c_str());
1947 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1948 }
1949 auto disabledAbilities = infoItem->second.bundleUserInfo.disabledAbilities;
1950 if (std::find(disabledAbilities.begin(), disabledAbilities.end(), abilityInfo.name) != disabledAbilities.end()) {
1951 isEnable = false;
1952 } else {
1953 isEnable = true;
1954 }
1955 return ERR_OK;
1956 }
1957
SetAbilityEnabled(const std::string & moduleName,const std::string & abilityName,bool isEnabled,int32_t userId)1958 ErrCode InnerBundleInfo::SetAbilityEnabled(
1959 const std::string &moduleName, const std::string &abilityName, bool isEnabled, int32_t userId)
1960 {
1961 APP_LOGD("SetAbilityEnabled : %{public}s, %{public}s, %{public}d",
1962 moduleName.c_str(), abilityName.c_str(), userId);
1963 for (const auto &ability : baseAbilityInfos_) {
1964 if ((ability.second.name == abilityName) &&
1965 (moduleName.empty() || (ability.second.moduleName == moduleName))) {
1966 auto &key = NameAndUserIdToKey(GetBundleName(), userId);
1967 auto infoItem = innerBundleUserInfos_.find(key);
1968 if (infoItem == innerBundleUserInfos_.end()) {
1969 APP_LOGE("SetAbilityEnabled find innerBundleUserInfo failed");
1970 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
1971 }
1972
1973 auto iter = std::find(infoItem->second.bundleUserInfo.disabledAbilities.begin(),
1974 infoItem->second.bundleUserInfo.disabledAbilities.end(),
1975 abilityName);
1976 if (iter != infoItem->second.bundleUserInfo.disabledAbilities.end()) {
1977 if (isEnabled) {
1978 infoItem->second.bundleUserInfo.disabledAbilities.erase(iter);
1979 }
1980 } else {
1981 if (!isEnabled) {
1982 infoItem->second.bundleUserInfo.disabledAbilities.push_back(abilityName);
1983 }
1984 }
1985 return ERR_OK;
1986 }
1987 }
1988 APP_LOGE("SetAbilityEnabled find abilityInfo failed");
1989 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
1990 }
1991
RemoveDuplicateName(std::vector<std::string> & name) const1992 void InnerBundleInfo::RemoveDuplicateName(std::vector<std::string> &name) const
1993 {
1994 std::sort(name.begin(), name.end());
1995 auto iter = std::unique(name.begin(), name.end());
1996 name.erase(iter, name.end());
1997 }
1998
GetAllDefinePermissions() const1999 std::vector<DefinePermission> InnerBundleInfo::GetAllDefinePermissions() const
2000 {
2001 std::vector<DefinePermission> definePermissions;
2002 for (const auto &info : innerModuleInfos_) {
2003 std::transform(info.second.definePermissions.begin(),
2004 info.second.definePermissions.end(),
2005 std::back_inserter(definePermissions),
2006 [](const auto &p) { return p; });
2007 }
2008 if (!definePermissions.empty()) {
2009 std::sort(definePermissions.begin(), definePermissions.end(),
2010 [](DefinePermission defPermA, DefinePermission defPermB) {
2011 return defPermA.name < defPermB.name;
2012 });
2013 auto iter = std::unique(definePermissions.begin(), definePermissions.end(),
2014 [](DefinePermission defPermA, DefinePermission defPermB) {
2015 return defPermA.name == defPermB.name;
2016 });
2017 definePermissions.erase(iter, definePermissions.end());
2018 }
2019 return definePermissions;
2020 }
2021
GetAllRequestPermissions() const2022 std::vector<RequestPermission> InnerBundleInfo::GetAllRequestPermissions() const
2023 {
2024 std::vector<RequestPermission> requestPermissions;
2025 for (const auto &info : innerModuleInfos_) {
2026 for (auto item : info.second.requestPermissions) {
2027 item.moduleName = info.second.moduleName;
2028 requestPermissions.push_back(item);
2029 }
2030 }
2031 if (!requestPermissions.empty()) {
2032 std::sort(requestPermissions.begin(), requestPermissions.end(),
2033 [](RequestPermission reqPermA, RequestPermission reqPermB) {
2034 if (reqPermA.name == reqPermB.name) {
2035 return reqPermA.reasonId > reqPermB.reasonId;
2036 }
2037 return reqPermA.name < reqPermB.name;
2038 });
2039 auto iter = std::unique(requestPermissions.begin(), requestPermissions.end(),
2040 [](RequestPermission reqPermA, RequestPermission reqPermB) {
2041 return reqPermA.name == reqPermB.name;
2042 });
2043 requestPermissions.erase(iter, requestPermissions.end());
2044 }
2045 return requestPermissions;
2046 }
2047
SetApplicationEnabled(bool enabled,int32_t userId)2048 ErrCode InnerBundleInfo::SetApplicationEnabled(bool enabled, int32_t userId)
2049 {
2050 auto& key = NameAndUserIdToKey(GetBundleName(), userId);
2051 auto infoItem = innerBundleUserInfos_.find(key);
2052 if (infoItem == innerBundleUserInfos_.end()) {
2053 APP_LOGE("SetApplicationEnabled can not find:%{public}s bundleUserInfo in userId: %{public}d",
2054 GetBundleName().c_str(), userId);
2055 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
2056 }
2057
2058 infoItem->second.bundleUserInfo.enabled = enabled;
2059 return ERR_OK;
2060 }
2061
GetCurModuleName() const2062 const std::string &InnerBundleInfo::GetCurModuleName() const
2063 {
2064 if (innerModuleInfos_.find(currentPackage_) != innerModuleInfos_.end()) {
2065 return innerModuleInfos_.at(currentPackage_).moduleName;
2066 }
2067
2068 return Constants::EMPTY_STRING;
2069 }
2070
IsBundleRemovable() const2071 bool InnerBundleInfo::IsBundleRemovable() const
2072 {
2073 if (GetIsPreInstallApp()) {
2074 APP_LOGE("PreInstallApp should not be cleaned");
2075 return false;
2076 }
2077
2078 for (const auto &innerModuleInfo : innerModuleInfos_) {
2079 if (!innerModuleInfo.second.installationFree) {
2080 return false;
2081 }
2082
2083 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
2084 if (!stateIter.second) {
2085 return false;
2086 }
2087 }
2088 }
2089
2090 return true;
2091 }
2092
GetLastInstallationTime() const2093 int64_t InnerBundleInfo::GetLastInstallationTime() const
2094 {
2095 int64_t installTime = 0;
2096 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
2097 installTime = innerBundleUserInfo.second.updateTime > installTime ?
2098 innerBundleUserInfo.second.updateTime : installTime;
2099 }
2100
2101 return installTime;
2102 }
2103
GetRemovableModules(std::vector<std::string> & moduleToDelete) const2104 bool InnerBundleInfo::GetRemovableModules(std::vector<std::string> &moduleToDelete) const
2105 {
2106 for (const auto &innerModuleInfo : innerModuleInfos_) {
2107 if (!innerModuleInfo.second.installationFree) {
2108 continue;
2109 }
2110
2111 bool canDelete = true;
2112 for (const auto &stateIter : innerModuleInfo.second.isRemovable) {
2113 if (!stateIter.second) {
2114 canDelete = false;
2115 break;
2116 }
2117 }
2118
2119 if (canDelete) {
2120 moduleToDelete.emplace_back(innerModuleInfo.second.moduleName);
2121 }
2122 }
2123
2124 return !moduleToDelete.empty();
2125 }
2126
GetFreeInstallModules(std::vector<std::string> & freeInstallModule) const2127 bool InnerBundleInfo::GetFreeInstallModules(std::vector<std::string> &freeInstallModule) const
2128 {
2129 for (const auto &innerModuleInfo : innerModuleInfos_) {
2130 if (!innerModuleInfo.second.installationFree) {
2131 continue;
2132 }
2133
2134 freeInstallModule.emplace_back(innerModuleInfo.second.moduleName);
2135 }
2136
2137 return !freeInstallModule.empty();
2138 }
2139
IsUserExistModule(const std::string & moduleName,int32_t userId) const2140 bool InnerBundleInfo::IsUserExistModule(const std::string &moduleName, int32_t userId) const
2141 {
2142 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
2143 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
2144 if (!modInfoItem) {
2145 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
2146 return false;
2147 }
2148
2149 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
2150 if (item == modInfoItem->isRemovable.end()) {
2151 APP_LOGE("userId:%{public}d has not moduleName:%{public}s", userId, moduleName.c_str());
2152 return false;
2153 }
2154
2155 APP_LOGD("userId:%{public}d exist moduleName:%{public}s", userId, moduleName.c_str());
2156 return true;
2157 }
2158
IsModuleRemovable(const std::string & moduleName,int32_t userId,bool & isRemovable) const2159 ErrCode InnerBundleInfo::IsModuleRemovable(
2160 const std::string &moduleName, int32_t userId, bool &isRemovable) const
2161 {
2162 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
2163 auto modInfoItem = GetInnerModuleInfoByModuleName(moduleName);
2164 if (!modInfoItem) {
2165 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
2166 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2167 }
2168
2169 auto item = modInfoItem->isRemovable.find(std::to_string(userId));
2170 if (item == modInfoItem->isRemovable.end()) {
2171 APP_LOGW("userId:%{public}d has not moduleName:%{public}s", userId, moduleName.c_str());
2172 isRemovable = false;
2173 return ERR_OK;
2174 }
2175
2176 isRemovable = item->second;
2177 APP_LOGD("userId:%{public}d, moduleName:%{public}s, isRemovable:%{public}d,",
2178 userId, moduleName.c_str(), isRemovable);
2179 return ERR_OK;
2180 }
2181
AddModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId,bool isEnable) const2182 bool InnerBundleInfo::AddModuleRemovableInfo(
2183 InnerModuleInfo &info, const std::string &stringUserId, bool isEnable) const
2184 {
2185 auto item = info.isRemovable.find(stringUserId);
2186 if (item == info.isRemovable.end()) {
2187 auto result = info.isRemovable.try_emplace(stringUserId, isEnable);
2188 if (!result.second) {
2189 APP_LOGE("add userId:%{public}s isRemovable:%{public}d failed", stringUserId.c_str(), isEnable);
2190 return false;
2191 }
2192
2193 APP_LOGD("add userId:%{public}s isRemovable:%{public}d into map", stringUserId.c_str(), isEnable);
2194 return true;
2195 }
2196
2197 item->second = isEnable;
2198 APP_LOGD("set userId:%{public}s isEnable:%{public}d ok", stringUserId.c_str(), isEnable);
2199 return true;
2200 }
2201
SetModuleRemovable(const std::string & moduleName,bool isEnable,int32_t userId)2202 bool InnerBundleInfo::SetModuleRemovable(const std::string &moduleName, bool isEnable, int32_t userId)
2203 {
2204 std::string stringUserId = std::to_string(userId);
2205 APP_LOGD("userId:%{public}d moduleName:%{public}s isEnable:%{public}d", userId, moduleName.c_str(), isEnable);
2206 for (auto &innerModuleInfo : innerModuleInfos_) {
2207 if (innerModuleInfo.second.moduleName == moduleName) {
2208 return AddModuleRemovableInfo(innerModuleInfo.second, stringUserId, isEnable);
2209 }
2210 }
2211
2212 return false;
2213 }
2214
DeleteModuleRemovableInfo(InnerModuleInfo & info,const std::string & stringUserId)2215 void InnerBundleInfo::DeleteModuleRemovableInfo(InnerModuleInfo &info, const std::string &stringUserId)
2216 {
2217 auto item = info.isRemovable.find(stringUserId);
2218 if (item == info.isRemovable.end()) {
2219 return;
2220 }
2221
2222 info.isRemovable.erase(stringUserId);
2223 }
2224
DeleteModuleRemovable(const std::string & moduleName,int32_t userId)2225 void InnerBundleInfo::DeleteModuleRemovable(const std::string &moduleName, int32_t userId)
2226 {
2227 std::string stringUserId = std::to_string(userId);
2228 APP_LOGD("userId:%{public}d moduleName:%{public}s", userId, moduleName.c_str());
2229 for (auto &innerModuleInfo : innerModuleInfos_) {
2230 if (innerModuleInfo.second.moduleName == moduleName) {
2231 DeleteModuleRemovableInfo(innerModuleInfo.second, stringUserId);
2232 return;
2233 }
2234 }
2235 }
2236
SetModuleUpgradeFlag(std::string moduleName,int32_t upgradeFlag)2237 ErrCode InnerBundleInfo::SetModuleUpgradeFlag(std::string moduleName, int32_t upgradeFlag)
2238 {
2239 APP_LOGD("moduleName= %{public}s, upgradeFlag = %{public}d", moduleName.c_str(), upgradeFlag);
2240 for (auto &innerModuleInfo : innerModuleInfos_) {
2241 if (innerModuleInfo.second.moduleName == moduleName) {
2242 innerModuleInfo.second.upgradeFlag = upgradeFlag;
2243 return ERR_OK;
2244 }
2245 }
2246 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2247 }
2248
GetModuleUpgradeFlag(std::string moduleName) const2249 int32_t InnerBundleInfo::GetModuleUpgradeFlag(std::string moduleName) const
2250 {
2251 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
2252 if (!moduleInfo) {
2253 APP_LOGE("get InnerModuleInfo by moduleName(%{public}s) failed", moduleName.c_str());
2254 return UpgradeFlag::NOT_UPGRADE;
2255 }
2256 APP_LOGD("innerModuleInfo.upgradeFlag : %{public}d", moduleInfo->upgradeFlag);
2257 return moduleInfo->upgradeFlag;
2258 }
2259
GetResponseUserId(int32_t requestUserId) const2260 int32_t InnerBundleInfo::GetResponseUserId(int32_t requestUserId) const
2261 {
2262 if (innerBundleUserInfos_.empty()) {
2263 APP_LOGE("Get responseUserId failed due to user map is empty.");
2264 return Constants::INVALID_USERID;
2265 }
2266
2267 if (requestUserId == Constants::ANY_USERID) {
2268 return innerBundleUserInfos_.begin()->second.bundleUserInfo.userId;
2269 }
2270
2271 if (HasInnerBundleUserInfo(requestUserId)) {
2272 return requestUserId;
2273 }
2274
2275 if (requestUserId < Constants::START_USERID) {
2276 APP_LOGD("requestUserId(%{public}d) less than start userId.", requestUserId);
2277 return Constants::INVALID_USERID;
2278 }
2279
2280 int32_t responseUserId = Constants::INVALID_USERID;
2281 for (const auto &innerBundleUserInfo : innerBundleUserInfos_) {
2282 if (innerBundleUserInfo.second.bundleUserInfo.userId < Constants::START_USERID) {
2283 responseUserId = innerBundleUserInfo.second.bundleUserInfo.userId;
2284 break;
2285 }
2286 }
2287
2288 APP_LOGD("requestUserId(%{public}d) and responseUserId(%{public}d).", requestUserId, responseUserId);
2289 return responseUserId;
2290 }
2291
GetDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const2292 bool InnerBundleInfo::GetDependentModuleNames(const std::string &moduleName,
2293 std::vector<std::string> &dependentModuleNames) const
2294 {
2295 for (auto iter = innerModuleInfos_.begin(); iter != innerModuleInfos_.end(); ++iter) {
2296 if (iter->second.moduleName == moduleName) {
2297 for (const auto &dependency : iter->second.dependencies) {
2298 dependentModuleNames.push_back(dependency.moduleName);
2299 }
2300 return true;
2301 }
2302 }
2303 APP_LOGE("GetDependentModuleNames can not find module %{public}s", moduleName.c_str());
2304 return false;
2305 }
2306
GetAllDependentModuleNames(const std::string & moduleName,std::vector<std::string> & dependentModuleNames) const2307 bool InnerBundleInfo::GetAllDependentModuleNames(const std::string &moduleName,
2308 std::vector<std::string> &dependentModuleNames) const
2309 {
2310 if (!GetDependentModuleNames(moduleName, dependentModuleNames)) {
2311 return false;
2312 }
2313 std::deque<std::string> moduleDeque;
2314 std::copy(dependentModuleNames.begin(), dependentModuleNames.end(), std::back_inserter(moduleDeque));
2315 dependentModuleNames.clear();
2316 while (!moduleDeque.empty()) {
2317 std::string name = moduleDeque.front();
2318 moduleDeque.pop_front();
2319 if (std::find(dependentModuleNames.begin(), dependentModuleNames.end(), name) == dependentModuleNames.end()) {
2320 dependentModuleNames.push_back(name);
2321 std::vector<std::string> tempModuleNames;
2322 if (GetDependentModuleNames(name, tempModuleNames)) {
2323 std::copy(tempModuleNames.begin(), tempModuleNames.end(), std::back_inserter(moduleDeque));
2324 }
2325 }
2326 }
2327 return true;
2328 }
2329
GetMainAbility() const2330 std::string InnerBundleInfo::GetMainAbility() const
2331 {
2332 AbilityInfo abilityInfo;
2333 GetMainAbilityInfo(abilityInfo);
2334 return abilityInfo.name;
2335 }
2336
GetMainAbilityInfo(AbilityInfo & abilityInfo) const2337 void InnerBundleInfo::GetMainAbilityInfo(AbilityInfo &abilityInfo) const
2338 {
2339 for (const auto& item : innerModuleInfos_) {
2340 const std::string& key = item.second.entryAbilityKey;
2341 if (!key.empty() && (baseAbilityInfos_.count(key) != 0)) {
2342 abilityInfo = baseAbilityInfos_.at(key);
2343 if (item.second.isEntry) {
2344 return;
2345 }
2346 }
2347 }
2348 }
2349
HasEntry() const2350 bool InnerBundleInfo::HasEntry() const
2351 {
2352 return std::any_of(innerModuleInfos_.begin(), innerModuleInfos_.end(), [](const auto &item) {
2353 return item.second.isEntry;
2354 });
2355 }
2356
SetAppDistributionType(const std::string & appDistributionType)2357 void InnerBundleInfo::SetAppDistributionType(const std::string &appDistributionType)
2358 {
2359 baseApplicationInfo_->appDistributionType = appDistributionType;
2360 }
2361
GetAppDistributionType() const2362 std::string InnerBundleInfo::GetAppDistributionType() const
2363 {
2364 return baseApplicationInfo_->appDistributionType;
2365 }
2366
SetAppProvisionType(const std::string & appProvisionType)2367 void InnerBundleInfo::SetAppProvisionType(const std::string &appProvisionType)
2368 {
2369 baseApplicationInfo_->appProvisionType = appProvisionType;
2370 }
2371
GetAppProvisionType() const2372 std::string InnerBundleInfo::GetAppProvisionType() const
2373 {
2374 return baseApplicationInfo_->appProvisionType;
2375 }
2376
SetAppCrowdtestDeadline(int64_t crowdtestDeadline)2377 void InnerBundleInfo::SetAppCrowdtestDeadline(int64_t crowdtestDeadline)
2378 {
2379 baseApplicationInfo_->crowdtestDeadline = crowdtestDeadline;
2380 }
2381
GetAppCrowdtestDeadline() const2382 int64_t InnerBundleInfo::GetAppCrowdtestDeadline() const
2383 {
2384 return baseApplicationInfo_->crowdtestDeadline;
2385 }
2386
GetDistroModuleName() const2387 std::vector<std::string> InnerBundleInfo::GetDistroModuleName() const
2388 {
2389 std::vector<std::string> moduleVec;
2390 for (const auto &item : innerModuleInfos_) {
2391 moduleVec.push_back(item.second.moduleName);
2392 }
2393 return moduleVec;
2394 }
2395
GetModuleNameByPackage(const std::string & packageName) const2396 std::string InnerBundleInfo::GetModuleNameByPackage(const std::string &packageName) const
2397 {
2398 auto it = innerModuleInfos_.find(packageName);
2399 if (it == innerModuleInfos_.end()) {
2400 return Constants::EMPTY_STRING;
2401 }
2402 return it->second.moduleName;
2403 }
2404
GetModuleTypeByPackage(const std::string & packageName) const2405 std::string InnerBundleInfo::GetModuleTypeByPackage(const std::string &packageName) const
2406 {
2407 auto it = innerModuleInfos_.find(packageName);
2408 if (it == innerModuleInfos_.end()) {
2409 return Constants::EMPTY_STRING;
2410 }
2411 return it->second.distro.moduleType;
2412 }
2413
GetAppQuickFix() const2414 AppQuickFix InnerBundleInfo::GetAppQuickFix() const
2415 {
2416 return baseApplicationInfo_->appQuickFix;
2417 }
2418
SetAppQuickFix(const AppQuickFix & appQuickFix)2419 void InnerBundleInfo::SetAppQuickFix(const AppQuickFix &appQuickFix)
2420 {
2421 baseApplicationInfo_->appQuickFix = appQuickFix;
2422 if (appQuickFix.deployedAppqfInfo.hqfInfos.empty() && appQuickFix.deployingAppqfInfo.hqfInfos.empty()) {
2423 baseApplicationInfo_->appQuickFix.bundleName = Constants::EMPTY_STRING;
2424 baseApplicationInfo_->appQuickFix.versionCode = 0;
2425 baseApplicationInfo_->appQuickFix.versionName = Constants::EMPTY_STRING;
2426 }
2427 SetQuickFixHqfInfos(appQuickFix.deployedAppqfInfo.hqfInfos);
2428 }
2429
GetQuickFixHqfInfos() const2430 std::vector<HqfInfo> InnerBundleInfo::GetQuickFixHqfInfos() const
2431 {
2432 return hqfInfos_;
2433 }
2434
SetQuickFixHqfInfos(const std::vector<HqfInfo> & hqfInfos)2435 void InnerBundleInfo::SetQuickFixHqfInfos(const std::vector<HqfInfo> &hqfInfos)
2436 {
2437 hqfInfos_ = hqfInfos;
2438 }
2439
FetchNativeSoAttrs(const std::string & requestPackage,std::string & cpuAbi,std::string & nativeLibraryPath) const2440 bool InnerBundleInfo::FetchNativeSoAttrs(
2441 const std::string &requestPackage, std::string &cpuAbi, std::string &nativeLibraryPath) const
2442 {
2443 auto moduleIter = innerModuleInfos_.find(requestPackage);
2444 if (moduleIter == innerModuleInfos_.end()) {
2445 APP_LOGE("requestPackage(%{public}s) is not exist", requestPackage.c_str());
2446 return false;
2447 }
2448
2449 auto &moduleInfo = moduleIter->second;
2450 if (!moduleInfo.compressNativeLibs) {
2451 cpuAbi = moduleInfo.cpuAbi;
2452 nativeLibraryPath = moduleInfo.nativeLibraryPath;
2453 return !nativeLibraryPath.empty();
2454 }
2455
2456 if (moduleInfo.isLibIsolated) {
2457 cpuAbi = moduleInfo.cpuAbi;
2458 nativeLibraryPath = moduleInfo.nativeLibraryPath;
2459 } else {
2460 cpuAbi = baseApplicationInfo_->cpuAbi;
2461 nativeLibraryPath = baseApplicationInfo_->nativeLibraryPath;
2462 }
2463
2464 return !nativeLibraryPath.empty();
2465 }
2466
IsLibIsolated(const std::string & moduleName) const2467 bool InnerBundleInfo::IsLibIsolated(const std::string &moduleName) const
2468 {
2469 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
2470 if (!moduleInfo) {
2471 APP_LOGE("Get moduleInfo(%{public}s) failed.", moduleName.c_str());
2472 return false;
2473 }
2474
2475 return moduleInfo->isLibIsolated;
2476 }
2477
GetDeviceType(const std::string & packageName) const2478 std::vector<std::string> InnerBundleInfo::GetDeviceType(const std::string &packageName) const
2479 {
2480 auto it = innerModuleInfos_.find(packageName);
2481 if (it == innerModuleInfos_.end()) {
2482 APP_LOGW("%{public}s is not existed", packageName.c_str());
2483 return std::vector<std::string>();
2484 }
2485 return innerModuleInfos_.at(packageName).deviceTypes;
2486 }
2487
AddApplyQuickFixFrequency()2488 void InnerBundleInfo::AddApplyQuickFixFrequency()
2489 {
2490 ++applyQuickFixFrequency_;
2491 }
2492
GetApplyQuickFixFrequency() const2493 int32_t InnerBundleInfo::GetApplyQuickFixFrequency() const
2494 {
2495 return applyQuickFixFrequency_;
2496 }
2497
ResetApplyQuickFixFrequency()2498 void InnerBundleInfo::ResetApplyQuickFixFrequency()
2499 {
2500 applyQuickFixFrequency_ = 0;
2501 }
2502
GetAllHspVersion() const2503 std::vector<uint32_t> InnerBundleInfo::GetAllHspVersion() const
2504 {
2505 std::vector<uint32_t> versionCodes;
2506 for (const auto &[moduleName, modules] : innerSharedModuleInfos_) {
2507 for (const auto &module : modules) {
2508 if (std::find(versionCodes.begin(), versionCodes.end(), module.versionCode) == versionCodes.end()) {
2509 versionCodes.emplace_back(module.versionCode);
2510 }
2511 }
2512 }
2513 return versionCodes;
2514 }
2515
DeleteHspModuleByVersion(int32_t versionCode)2516 void InnerBundleInfo::DeleteHspModuleByVersion(int32_t versionCode)
2517 {
2518 for (auto modulesIt = innerSharedModuleInfos_.begin(); modulesIt != innerSharedModuleInfos_.end();) {
2519 if (modulesIt->second.size() == SINGLE_HSP_VERSION &&
2520 modulesIt->second.front().versionCode == static_cast<uint32_t>(versionCode)) {
2521 modulesIt = innerSharedModuleInfos_.erase(modulesIt);
2522 } else {
2523 modulesIt->second.erase(
2524 std::remove_if(modulesIt->second.begin(), modulesIt->second.end(),
2525 [versionCode] (InnerModuleInfo &module) {
2526 return module.versionCode == static_cast<uint32_t>(versionCode);
2527 }));
2528 ++modulesIt;
2529 }
2530 }
2531 }
2532
GetProxyDataInfos(const std::string & moduleName,std::vector<ProxyData> & proxyDatas) const2533 ErrCode InnerBundleInfo::GetProxyDataInfos(
2534 const std::string &moduleName, std::vector<ProxyData> &proxyDatas) const
2535 {
2536 if (moduleName == Constants::EMPTY_STRING) {
2537 GetAllProxyDataInfos(proxyDatas);
2538 return ERR_OK;
2539 }
2540 auto moduleIt = std::find_if(innerModuleInfos_.begin(), innerModuleInfos_.end(), [&moduleName](const auto &info) {
2541 return info.second.moduleName == moduleName;
2542 });
2543 if (moduleIt != innerModuleInfos_.end()) {
2544 proxyDatas.insert(
2545 proxyDatas.end(), moduleIt->second.proxyDatas.begin(), moduleIt->second.proxyDatas.end());
2546 } else {
2547 APP_LOGE("moduleName %{public}s not found", moduleName.c_str());
2548 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2549 }
2550 if (proxyDatas.empty()) {
2551 APP_LOGW("proxyDatas is empty");
2552 }
2553 return ERR_OK;
2554 }
2555
GetAllProxyDataInfos(std::vector<ProxyData> & proxyDatas) const2556 void InnerBundleInfo::GetAllProxyDataInfos(std::vector<ProxyData> &proxyDatas) const
2557 {
2558 for (const auto &innerModuleInfo : innerModuleInfos_) {
2559 proxyDatas.insert(
2560 proxyDatas.end(), innerModuleInfo.second.proxyDatas.begin(), innerModuleInfo.second.proxyDatas.end());
2561 }
2562 }
2563
GetIsolationMode(const std::string & isolationMode) const2564 IsolationMode InnerBundleInfo::GetIsolationMode(const std::string &isolationMode) const
2565 {
2566 auto isolationModeRes = ISOLATION_MODE_MAP.find(isolationMode);
2567 if (isolationModeRes != ISOLATION_MODE_MAP.end()) {
2568 return isolationModeRes->second;
2569 } else {
2570 return IsolationMode::NONISOLATION_FIRST;
2571 }
2572 }
2573
SetModuleHapPath(const std::string & hapPath)2574 void InnerBundleInfo::SetModuleHapPath(const std::string &hapPath)
2575 {
2576 if (innerModuleInfos_.count(currentPackage_) == 1) {
2577 innerModuleInfos_.at(currentPackage_).hapPath = hapPath;
2578 for (auto &abilityInfo : baseAbilityInfos_) {
2579 abilityInfo.second.hapPath = hapPath;
2580 }
2581 for (auto &extensionInfo : baseExtensionInfos_) {
2582 extensionInfo.second.hapPath = hapPath;
2583 }
2584 if (!innerModuleInfos_.at(currentPackage_).compressNativeLibs &&
2585 !innerModuleInfos_.at(currentPackage_).nativeLibraryPath.empty()) {
2586 auto pos = hapPath.rfind(Constants::PATH_SEPARATOR);
2587 if (pos != std::string::npos) {
2588 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
2589 hapPath.substr(pos + 1, hapPath.length() - pos - 1) + NATIVE_LIBRARY_PATH_SYMBOL +
2590 innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
2591 return;
2592 }
2593 innerModuleInfos_.at(currentPackage_).nativeLibraryPath =
2594 hapPath + NATIVE_LIBRARY_PATH_SYMBOL + innerModuleInfos_.at(currentPackage_).nativeLibraryPath;
2595 }
2596 }
2597 }
2598
IsCompressNativeLibs(const std::string & moduleName) const2599 bool InnerBundleInfo::IsCompressNativeLibs(const std::string &moduleName) const
2600 {
2601 auto moduleInfo = GetInnerModuleInfoByModuleName(moduleName);
2602 if (!moduleInfo) {
2603 APP_LOGE("Get moduleInfo(%{public}s) failed.", moduleName.c_str());
2604 return true; // compressNativeLibs default true
2605 }
2606
2607 return moduleInfo->compressNativeLibs;
2608 }
2609
SetNativeLibraryFileNames(const std::string & moduleName,const std::vector<std::string> & fileNames)2610 void InnerBundleInfo::SetNativeLibraryFileNames(const std::string &moduleName,
2611 const std::vector<std::string> &fileNames)
2612 {
2613 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
2614 APP_LOGE("innerBundleInfo does not contain the module: %{public}s.", moduleName.c_str());
2615 return;
2616 }
2617 innerModuleInfos_.at(moduleName).nativeLibraryFileNames = fileNames;
2618 }
2619
UpdateSharedModuleInfo()2620 void InnerBundleInfo::UpdateSharedModuleInfo()
2621 {
2622 auto sharedModuleInfoIter = innerSharedModuleInfos_.find(currentPackage_);
2623 auto moduleInfoIter = innerModuleInfos_.find(currentPackage_);
2624 if ((sharedModuleInfoIter == innerSharedModuleInfos_.end()) ||
2625 (moduleInfoIter == innerModuleInfos_.end())) {
2626 APP_LOGE("The shared module(%{public}s) infomation does not exist", currentPackage_.c_str());
2627 return;
2628 }
2629 auto &innerModuleInfoVector = sharedModuleInfoIter->second;
2630 for (auto iter = innerModuleInfoVector.begin(); iter != innerModuleInfoVector.end(); ++iter) {
2631 if (iter->versionCode == moduleInfoIter->second.versionCode) {
2632 iter->hapPath = moduleInfoIter->second.hapPath;
2633 iter->compressNativeLibs = moduleInfoIter->second.compressNativeLibs;
2634 iter->cpuAbi = moduleInfoIter->second.cpuAbi;
2635 iter->nativeLibraryPath = moduleInfoIter->second.nativeLibraryPath;
2636 iter->nativeLibraryFileNames = moduleInfoIter->second.nativeLibraryFileNames;
2637 return;
2638 }
2639 }
2640 }
2641
SetExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)2642 ErrCode InnerBundleInfo::SetExtName(
2643 const std::string &moduleName, const std::string &abilityName, const std::string extName)
2644 {
2645 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
2646 if (abilityInfoPair == baseAbilityInfos_.end()) {
2647 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
2648 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
2649 }
2650 if (moduleName != abilityInfoPair->second.moduleName) {
2651 APP_LOGE("module %{public}s not exists", moduleName.c_str());
2652 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2653 }
2654 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
2655 bool duplicated = std::any_of(supportExtNames.begin(), supportExtNames.end(), [&extName](const auto &name) {
2656 return extName == name;
2657 });
2658 if (duplicated) {
2659 APP_LOGW("extName %{public}s already exist in ability %{public}s", extName.c_str(), abilityName.c_str());
2660 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
2661 }
2662 supportExtNames.emplace_back(extName);
2663 return ERR_OK;
2664 }
2665
SetMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)2666 ErrCode InnerBundleInfo::SetMimeType(
2667 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
2668 {
2669 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
2670 if (abilityInfoPair == baseAbilityInfos_.end()) {
2671 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
2672 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
2673 }
2674 if (moduleName != abilityInfoPair->second.moduleName) {
2675 APP_LOGE("module %{public}s not exists", moduleName.c_str());
2676 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2677 }
2678 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
2679 bool duplicated = std::any_of(supportMimeTypes.begin(), supportMimeTypes.end(), [&mimeType](const auto &type) {
2680 return mimeType == type;
2681 });
2682 if (duplicated) {
2683 APP_LOGW("MIME type %{public}s already exist in ability %{public}s", mimeType.c_str(), abilityName.c_str());
2684 return ERR_BUNDLE_MANAGER_DUPLICATED_EXT_OR_TYPE;
2685 }
2686 abilityInfoPair->second.supportMimeTypes.emplace_back(mimeType);
2687 return ERR_OK;
2688 }
2689
DelExtName(const std::string & moduleName,const std::string & abilityName,const std::string extName)2690 ErrCode InnerBundleInfo::DelExtName(
2691 const std::string &moduleName, const std::string &abilityName, const std::string extName)
2692 {
2693 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
2694 if (abilityInfoPair == baseAbilityInfos_.end()) {
2695 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
2696 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
2697 }
2698 if (moduleName != abilityInfoPair->second.moduleName) {
2699 APP_LOGE("module %{public}s not exists", moduleName.c_str());
2700 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2701 }
2702 auto &supportExtNames = abilityInfoPair->second.supportExtNames;
2703 supportExtNames.erase(std::remove(supportExtNames.begin(), supportExtNames.end(), extName), supportExtNames.end());
2704 return ERR_OK;
2705 }
2706
DelMimeType(const std::string & moduleName,const std::string & abilityName,const std::string mimeType)2707 ErrCode InnerBundleInfo::DelMimeType(
2708 const std::string &moduleName, const std::string &abilityName, const std::string mimeType)
2709 {
2710 auto abilityInfoPair = baseAbilityInfos_.find(abilityName);
2711 if (abilityInfoPair == baseAbilityInfos_.end()) {
2712 APP_LOGE("ability %{public}s not exists", abilityName.c_str());
2713 return ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST;
2714 }
2715 if (moduleName != abilityInfoPair->second.moduleName) {
2716 APP_LOGE("module %{public}s not exists", moduleName.c_str());
2717 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2718 }
2719 auto &supportMimeTypes = abilityInfoPair->second.supportMimeTypes;
2720 supportMimeTypes.erase(
2721 std::remove(supportMimeTypes.begin(), supportMimeTypes.end(), mimeType), supportMimeTypes.end());
2722 return ERR_OK;
2723 }
2724
GetAppServiceHspInfo(BundleInfo & bundleInfo) const2725 ErrCode InnerBundleInfo::GetAppServiceHspInfo(BundleInfo &bundleInfo) const
2726 {
2727 if (baseApplicationInfo_->bundleType != BundleType::APP_SERVICE_FWK) {
2728 APP_LOGD("bundle is not app service hsp.");
2729 return ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST;
2730 }
2731 bundleInfo = *baseBundleInfo_;
2732 bundleInfo.applicationInfo = *baseApplicationInfo_;
2733 for (const auto &info : innerModuleInfos_) {
2734 if (info.second.distro.moduleType == Profile::MODULE_TYPE_SHARED) {
2735 auto hapmoduleinfo = FindHapModuleInfo(info.second.modulePackage, Constants::ALL_USERID);
2736 if (hapmoduleinfo) {
2737 HapModuleInfo hapModuleInfo = *hapmoduleinfo;
2738 hapModuleInfo.moduleSourceDir = hapModuleInfo.hapPath.empty() ?
2739 info.second.modulePath : hapModuleInfo.moduleSourceDir;
2740 bundleInfo.hapModuleInfos.emplace_back(hapModuleInfo);
2741 }
2742 }
2743 }
2744 if (bundleInfo.hapModuleInfos.empty()) {
2745 APP_LOGE("bundleName:%{public}s has no hsp module info", baseApplicationInfo_->bundleName.c_str());
2746 return ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST;
2747 }
2748 return ERR_OK;
2749 }
2750
UpdateIsCompressNativeLibs()2751 void InnerBundleInfo::UpdateIsCompressNativeLibs()
2752 {
2753 if (innerModuleInfos_.empty()) {
2754 baseApplicationInfo_->isCompressNativeLibs = true;
2755 return;
2756 }
2757 baseApplicationInfo_->isCompressNativeLibs = false;
2758 for (const auto &info : innerModuleInfos_) {
2759 baseApplicationInfo_->isCompressNativeLibs =
2760 (baseApplicationInfo_->isCompressNativeLibs || info.second.compressNativeLibs) ? true : false;
2761 }
2762 }
2763
SetResourcesApply(const std::vector<int32_t> & resourcesApply)2764 void InnerBundleInfo::SetResourcesApply(const std::vector<int32_t> &resourcesApply)
2765 {
2766 baseApplicationInfo_->resourcesApply = resourcesApply;
2767 }
2768
InnerProcessShortcut(const Shortcut & oldShortcut,ShortcutInfo & shortcutInfo) const2769 void InnerBundleInfo::InnerProcessShortcut(const Shortcut &oldShortcut, ShortcutInfo &shortcutInfo) const
2770 {
2771 shortcutInfo.id = oldShortcut.shortcutId;
2772 shortcutInfo.icon = oldShortcut.icon;
2773 shortcutInfo.label = oldShortcut.label;
2774 shortcutInfo.iconId = oldShortcut.iconId;
2775 if (shortcutInfo.iconId == 0) {
2776 auto iter = oldShortcut.icon.find(PORT_SEPARATOR);
2777 if (iter != std::string::npos) {
2778 shortcutInfo.iconId = atoi(oldShortcut.icon.substr(iter + 1).c_str());
2779 }
2780 }
2781 shortcutInfo.labelId = oldShortcut.labelId;
2782 if (shortcutInfo.labelId == 0) {
2783 auto iter = oldShortcut.label.find(PORT_SEPARATOR);
2784 if (iter != std::string::npos) {
2785 shortcutInfo.labelId = atoi(oldShortcut.label.substr(iter + 1).c_str());
2786 }
2787 }
2788 for (const ShortcutWant &shortcutWant : oldShortcut.wants) {
2789 ShortcutIntent shortcutIntent;
2790 shortcutIntent.targetBundle = shortcutWant.bundleName;
2791 shortcutIntent.targetModule = shortcutWant.moduleName;
2792 shortcutIntent.targetClass = shortcutWant.abilityName;
2793 shortcutInfo.intents.emplace_back(shortcutIntent);
2794 }
2795 }
2796
GetEntryModuleName() const2797 std::string InnerBundleInfo::GetEntryModuleName() const
2798 {
2799 for (const auto &item : innerModuleInfos_) {
2800 if (item.second.isEntry) {
2801 return item.second.modulePackage;
2802 }
2803 }
2804 return Constants::EMPTY_STRING;
2805 }
2806
SetMoudleIsEncrpted(const std::string & packageName,bool isEncrypted)2807 void InnerBundleInfo::SetMoudleIsEncrpted(const std::string &packageName, bool isEncrypted)
2808 {
2809 auto it = innerModuleInfos_.find(packageName);
2810 if (it == innerModuleInfos_.end()) {
2811 return;
2812 }
2813 it->second.isEncrypted = isEncrypted;
2814 }
2815
IsEncryptedMoudle(const std::string & packageName) const2816 bool InnerBundleInfo::IsEncryptedMoudle(const std::string &packageName) const
2817 {
2818 auto it = innerModuleInfos_.find(packageName);
2819 if (it == innerModuleInfos_.end()) {
2820 return false;
2821 }
2822 return it->second.isEncrypted;
2823 }
2824
IsContainEncryptedModule() const2825 bool InnerBundleInfo::IsContainEncryptedModule() const
2826 {
2827 for (const auto &info : innerModuleInfos_) {
2828 if (info.second.isEncrypted) {
2829 return true;
2830 }
2831 }
2832 return false;
2833 }
2834
GetAppIdentifier() const2835 std::string InnerBundleInfo::GetAppIdentifier() const
2836 {
2837 return baseBundleInfo_->signatureInfo.appIdentifier;
2838 }
2839
SetAppIdentifier(const std::string & appIdentifier)2840 void InnerBundleInfo::SetAppIdentifier(const std::string &appIdentifier)
2841 {
2842 baseBundleInfo_->signatureInfo.appIdentifier = appIdentifier;
2843 }
2844
UpdateDebug(bool debug,bool isEntry)2845 void InnerBundleInfo::UpdateDebug(bool debug, bool isEntry)
2846 {
2847 if (isEntry) {
2848 baseApplicationInfo_->debug = debug;
2849 } else if (!HasEntry() && debug) {
2850 baseApplicationInfo_->debug = debug;
2851 }
2852 }
2853
AddOldAppId(const std::string & appId)2854 void InnerBundleInfo::AddOldAppId(const std::string &appId)
2855 {
2856 auto appIds = baseBundleInfo_->oldAppIds;
2857 if (std::find(appIds.begin(), appIds.end(), appId) == appIds.end()) {
2858 baseBundleInfo_->oldAppIds.emplace_back(appId);
2859 }
2860 }
2861
GetOldAppIds() const2862 std::vector<std::string> InnerBundleInfo::GetOldAppIds() const
2863 {
2864 return baseBundleInfo_->oldAppIds;
2865 }
2866
AddOverlayModuleInfo(const OverlayModuleInfo & overlayModuleInfo)2867 void InnerBundleInfo::AddOverlayModuleInfo(const OverlayModuleInfo &overlayModuleInfo)
2868 {
2869 auto iterator = innerModuleInfos_.find(overlayModuleInfo.targetModuleName);
2870 if (iterator == innerModuleInfos_.end()) {
2871 return;
2872 }
2873 auto innerModuleInfo = iterator->second;
2874 auto overlayModuleInfoIt = std::find_if(innerModuleInfo.overlayModuleInfo.begin(),
2875 innerModuleInfo.overlayModuleInfo.end(), [&overlayModuleInfo](const auto &overlayInfo) {
2876 return (overlayInfo.moduleName == overlayModuleInfo.moduleName) &&
2877 (overlayInfo.bundleName == overlayModuleInfo.bundleName);
2878 });
2879 if (overlayModuleInfoIt != innerModuleInfo.overlayModuleInfo.end()) {
2880 innerModuleInfo.overlayModuleInfo.erase(overlayModuleInfoIt);
2881 }
2882 innerModuleInfo.overlayModuleInfo.emplace_back(overlayModuleInfo);
2883 innerModuleInfos_.erase(iterator);
2884 innerModuleInfos_.try_emplace(overlayModuleInfo.targetModuleName, innerModuleInfo);
2885 }
2886
RemoveOverlayModuleInfo(const std::string & targetModuleName,const std::string & bundleName,const std::string & moduleName)2887 void InnerBundleInfo::RemoveOverlayModuleInfo(const std::string &targetModuleName,
2888 const std::string &bundleName, const std::string &moduleName)
2889 {
2890 auto iterator = innerModuleInfos_.find(targetModuleName);
2891 if (iterator == innerModuleInfos_.end()) {
2892 return;
2893 }
2894 auto innerModuleInfo = iterator->second;
2895 auto overlayModuleInfoIt = std::find_if(innerModuleInfo.overlayModuleInfo.begin(),
2896 innerModuleInfo.overlayModuleInfo.end(), [&moduleName, &bundleName](const auto &overlayInfo) {
2897 return (overlayInfo.moduleName == moduleName) && (overlayInfo.bundleName == bundleName);
2898 });
2899 if (overlayModuleInfoIt == innerModuleInfo.overlayModuleInfo.end()) {
2900 return;
2901 }
2902 innerModuleInfo.overlayModuleInfo.erase(overlayModuleInfoIt);
2903 innerModuleInfos_.erase(iterator);
2904 innerModuleInfos_.try_emplace(targetModuleName, innerModuleInfo);
2905 }
2906
RemoveAllOverlayModuleInfo(const std::string & bundleName)2907 void InnerBundleInfo::RemoveAllOverlayModuleInfo(const std::string &bundleName)
2908 {
2909 for (auto &innerModuleInfo : innerModuleInfos_) {
2910 innerModuleInfo.second.overlayModuleInfo.erase(std::remove_if(
2911 innerModuleInfo.second.overlayModuleInfo.begin(),
2912 innerModuleInfo.second.overlayModuleInfo.end(),
2913 [&bundleName](const auto &overlayInfo) {
2914 return overlayInfo.bundleName == bundleName;
2915 }), innerModuleInfo.second.overlayModuleInfo.end());
2916 }
2917 }
2918
CleanAllOverlayModuleInfo()2919 void InnerBundleInfo::CleanAllOverlayModuleInfo()
2920 {
2921 for (auto &innerModuleInfo : innerModuleInfos_) {
2922 innerModuleInfo.second.overlayModuleInfo.clear();
2923 }
2924 }
2925
isOverlayModule(const std::string & moduleName) const2926 bool InnerBundleInfo::isOverlayModule(const std::string &moduleName) const
2927 {
2928 if (innerModuleInfos_.find(moduleName) == innerModuleInfos_.end()) {
2929 return true;
2930 }
2931 return !innerModuleInfos_.at(moduleName).targetModuleName.empty();
2932 }
2933
isExistedOverlayModule() const2934 bool InnerBundleInfo::isExistedOverlayModule() const
2935 {
2936 for (const auto &innerModuleInfo : innerModuleInfos_) {
2937 if (!innerModuleInfo.second.targetModuleName.empty()) {
2938 return true;
2939 }
2940 }
2941 return false;
2942 }
2943
KeepOldOverlayConnection(InnerBundleInfo & info)2944 void InnerBundleInfo::KeepOldOverlayConnection(InnerBundleInfo &info)
2945 {
2946 auto &newInnerModuleInfos = info.FetchInnerModuleInfos();
2947 for (const auto &innerModuleInfo : innerModuleInfos_) {
2948 if ((!innerModuleInfo.second.overlayModuleInfo.empty()) &&
2949 (newInnerModuleInfos.find(innerModuleInfo.second.moduleName) != newInnerModuleInfos.end())) {
2950 newInnerModuleInfos[innerModuleInfo.second.moduleName].overlayModuleInfo =
2951 innerModuleInfo.second.overlayModuleInfo;
2952 return;
2953 }
2954 }
2955 }
2956
FindAbilityInfoByUri(const std::string & abilityUri) const2957 std::optional<AbilityInfo> InnerBundleInfo::FindAbilityInfoByUri(const std::string &abilityUri) const
2958 {
2959 APP_LOGD("Uri is %{public}s", abilityUri.c_str());
2960 for (const auto &ability : baseAbilityInfos_) {
2961 auto abilityInfo = ability.second;
2962 if (abilityInfo.uri.size() < strlen(Constants::DATA_ABILITY_URI_PREFIX)) {
2963 continue;
2964 }
2965
2966 auto configUri = abilityInfo.uri.substr(strlen(Constants::DATA_ABILITY_URI_PREFIX));
2967 APP_LOGD("configUri is %{public}s", configUri.c_str());
2968 if (configUri == abilityUri) {
2969 return abilityInfo;
2970 }
2971 }
2972 return std::nullopt;
2973 }
2974
FindExtensionAbilityInfoByUri(const std::string & uri,ExtensionAbilityInfo & extensionAbilityInfo) const2975 bool InnerBundleInfo::FindExtensionAbilityInfoByUri(
2976 const std::string &uri, ExtensionAbilityInfo &extensionAbilityInfo) const
2977 {
2978 for (const auto &item : baseExtensionInfos_) {
2979 if (uri == item.second.uri) {
2980 extensionAbilityInfo = item.second;
2981 APP_LOGD("find target extension, bundle: %{public}s, module: %{public}s, name: %{public}s",
2982 extensionAbilityInfo.bundleName.c_str(), extensionAbilityInfo.moduleName.c_str(),
2983 extensionAbilityInfo.name.c_str());
2984 return true;
2985 }
2986 }
2987 return false;
2988 }
2989
FindAbilityInfosByUri(const std::string & abilityUri,std::vector<AbilityInfo> & abilityInfos,int32_t userId)2990 void InnerBundleInfo::FindAbilityInfosByUri(
2991 const std::string &abilityUri, std::vector<AbilityInfo> &abilityInfos, int32_t userId)
2992 {
2993 APP_LOGI("Uri is %{public}s", abilityUri.c_str());
2994 for (auto &ability : baseAbilityInfos_) {
2995 auto abilityInfo = ability.second;
2996 if (abilityInfo.uri.size() < strlen(Constants::DATA_ABILITY_URI_PREFIX)) {
2997 continue;
2998 }
2999
3000 auto configUri = abilityInfo.uri.substr(strlen(Constants::DATA_ABILITY_URI_PREFIX));
3001 APP_LOGI("configUri is %{public}s", configUri.c_str());
3002 if (configUri == abilityUri) {
3003 GetApplicationInfo(ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION,
3004 userId, abilityInfo.applicationInfo);
3005 abilityInfos.emplace_back(abilityInfo);
3006 }
3007 }
3008 return;
3009 }
3010
AddDataGroupInfo(const std::string & dataGroupId,const DataGroupInfo & info)3011 void InnerBundleInfo::AddDataGroupInfo(const std::string &dataGroupId, const DataGroupInfo &info)
3012 {
3013 APP_LOGD("AddDataGroupInfo, dataGroupId: %{public}s, dataGroupInfo: %{public}s",
3014 dataGroupId.c_str(), info.ToString().c_str());
3015 auto dataGroupInfosItem = dataGroupInfos_.find(dataGroupId);
3016 if (dataGroupInfosItem == dataGroupInfos_.end()) {
3017 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for dataGroupId: %{public}s",
3018 dataGroupId.c_str());
3019 dataGroupInfos_[dataGroupId] = std::vector<DataGroupInfo> { info };
3020 return;
3021 }
3022
3023 int32_t userId = info.userId;
3024 auto iter = std::find_if(
3025 std::begin(dataGroupInfos_[dataGroupId]), std::end(dataGroupInfos_[dataGroupId]),
3026 [userId](const DataGroupInfo &dataGroupinfo) { return dataGroupinfo.userId == userId; });
3027 if (iter != std::end(dataGroupInfos_[dataGroupId])) {
3028 return;
3029 }
3030
3031 APP_LOGD("AddDataGroupInfo add new dataGroupInfo for user: %{public}d", info.userId);
3032 dataGroupInfos_[dataGroupId].emplace_back(info);
3033 }
3034
RemoveGroupInfos(int32_t userId,const std::string & dataGroupId)3035 void InnerBundleInfo::RemoveGroupInfos(int32_t userId, const std::string &dataGroupId)
3036 {
3037 auto iter = dataGroupInfos_.find(dataGroupId);
3038 if (iter == dataGroupInfos_.end()) {
3039 return;
3040 }
3041 for (auto dataGroupIter = iter->second.begin();dataGroupIter != iter->second.end(); dataGroupIter++) {
3042 if (dataGroupIter->userId == userId) {
3043 iter->second.erase(dataGroupIter);
3044 return;
3045 }
3046 }
3047 }
3048
UpdateDataGroupInfos(const std::unordered_map<std::string,std::vector<DataGroupInfo>> & dataGroupInfos)3049 void InnerBundleInfo::UpdateDataGroupInfos(
3050 const std::unordered_map<std::string, std::vector<DataGroupInfo>> &dataGroupInfos)
3051 {
3052 std::set<int32_t> userIdList;
3053 for (auto item = dataGroupInfos.begin(); item != dataGroupInfos.end(); item++) {
3054 for (const DataGroupInfo &info : item->second) {
3055 userIdList.insert(info.userId);
3056 }
3057 }
3058
3059 std::vector<std::string> deletedGroupIds;
3060 for (auto &item : dataGroupInfos_) {
3061 if (dataGroupInfos.find(item.first) == dataGroupInfos.end()) {
3062 for (int32_t userId : userIdList) {
3063 RemoveGroupInfos(userId, item.first);
3064 }
3065 }
3066 if (item.second.empty()) {
3067 deletedGroupIds.emplace_back(item.first);
3068 }
3069 }
3070 for (std::string groupId : deletedGroupIds) {
3071 dataGroupInfos_.erase(groupId);
3072 }
3073 for (auto item = dataGroupInfos.begin(); item != dataGroupInfos.end(); item++) {
3074 std::string dataGroupId = item->first;
3075 for (const DataGroupInfo &info : item->second) {
3076 AddDataGroupInfo(dataGroupId, info);
3077 }
3078 }
3079 }
3080 } // namespace AppExecFwk
3081 } // namespace OHOS
3082