1 /*
2 * Copyright (c) 2022 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 #include "checker/checker_manager.h"
16 namespace OHOS {
17 namespace DistributedData {
GetInstance()18 CheckerManager &CheckerManager::GetInstance()
19 {
20 static CheckerManager instance;
21 return instance;
22 }
23
LoadCheckers(std::vector<std::string> & checkers)24 void CheckerManager::LoadCheckers(std::vector<std::string> &checkers)
25 {
26 for (const auto &checker : checkers) {
27 if (checkers_.find(checker) != checkers_.end()) {
28 continue;
29 }
30 auto it = getters_.Find(checker);
31 if (!it.first || it.second == nullptr) {
32 continue;
33 }
34 auto *bundleChecker = it.second();
35 if (bundleChecker == nullptr) {
36 continue;
37 }
38 bundleChecker->Initialize();
39 checkers_[checker] = bundleChecker;
40 }
41 }
42
RegisterPlugin(const std::string & checker,std::function<Checker * ()> getter)43 void CheckerManager::RegisterPlugin(const std::string &checker, std::function<Checker *()> getter)
44 {
45 getters_.ComputeIfAbsent(checker, [&getter](const auto &) mutable {
46 return std::move(getter);
47 });
48 }
49
DeleteCache(const std::string & bundleName,int32_t user,int32_t index)50 void CheckerManager::DeleteCache(const std::string &bundleName, int32_t user, int32_t index)
51 {
52 for (auto &[name, checker] : checkers_) {
53 if (checker == nullptr) {
54 continue;
55 }
56 checker->DeleteCache(bundleName, user, index);
57 }
58 }
59
ClearCache()60 void CheckerManager::ClearCache()
61 {
62 for (auto &[name, checker] : checkers_) {
63 if (checker == nullptr) {
64 continue;
65 }
66 checker->ClearCache();
67 }
68 }
69
GetAppId(const StoreInfo & info)70 std::string CheckerManager::GetAppId(const StoreInfo &info)
71 {
72 for (auto &[name, checker] : checkers_) {
73 if (checker == nullptr) {
74 continue;
75 }
76 auto appId = checker->GetAppId(info);
77 if (appId.empty()) {
78 continue;
79 }
80 return appId;
81 }
82 return "";
83 }
84
IsValid(const StoreInfo & info)85 bool CheckerManager::IsValid(const StoreInfo &info)
86 {
87 for (auto &[name, checker] : checkers_) {
88 if (checker == nullptr) {
89 continue;
90 }
91 if (!checker->IsValid(info)) {
92 continue;
93 }
94 return true;
95 }
96 return false;
97 }
98
IsDistrust(const StoreInfo & info)99 bool CheckerManager::IsDistrust(const StoreInfo &info)
100 {
101 for (auto &[name, checker] : checkers_) {
102 if (checker == nullptr) {
103 continue;
104 }
105 if (!checker->IsDistrust(info)) {
106 continue;
107 }
108 return true;
109 }
110 return false;
111 }
112
IsSwitches(const StoreInfo & info)113 bool CheckerManager::IsSwitches(const StoreInfo &info)
114 {
115 for (auto &[name, checker] : checkers_) {
116 if (checker == nullptr) {
117 continue;
118 }
119 if (checker->IsSwitches(info)) {
120 return true;
121 }
122 }
123 return false;
124 }
125
GetChecker(const std::string & checker)126 CheckerManager::Checker *CheckerManager::GetChecker(const std::string &checker)
127 {
128 auto it = checkers_.find(checker);
129 if (it == checkers_.end()) {
130 return nullptr;
131 }
132 return it->second;
133 }
134
GetDynamicStores()135 std::vector<CheckerManager::StoreInfo> CheckerManager::GetDynamicStores()
136 {
137 std::vector<CheckerManager::StoreInfo> res;
138 for (auto &[name, checker] : checkers_) {
139 if (checker == nullptr) {
140 continue;
141 }
142 res = checker->GetDynamicStores();
143 if (!res.empty()) {
144 return res;
145 }
146 }
147 return res;
148 }
GetStaticStores()149 std::vector<CheckerManager::StoreInfo> CheckerManager::GetStaticStores()
150 {
151 std::vector<CheckerManager::StoreInfo> res;
152 for (auto &[name, checker] : checkers_) {
153 if (checker == nullptr) {
154 continue;
155 }
156 res = checker->GetStaticStores();
157 if (!res.empty()) {
158 return res;
159 }
160 }
161 return res;
162 }
IsDynamic(const CheckerManager::StoreInfo & info)163 bool CheckerManager::IsDynamic(const CheckerManager::StoreInfo &info)
164 {
165 for (auto &[name, checker] : checkers_) {
166 if (checker == nullptr) {
167 continue;
168 }
169 if (checker->IsDynamic(info)) {
170 return true;
171 }
172 }
173 return false;
174 }
IsStatic(const CheckerManager::StoreInfo & info)175 bool CheckerManager::IsStatic(const CheckerManager::StoreInfo &info)
176 {
177 for (auto &[name, checker] : checkers_) {
178 if (checker == nullptr) {
179 continue;
180 }
181 if (checker->IsStatic(info)) {
182 return true;
183 }
184 }
185 return false;
186 }
187 } // namespace DistributedData
188 } // namespace OHOS