1 /*
2 * Copyright (C) 2023-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 #include "wifi_app_parser.h"
16 #include <unordered_map>
17 #include "wifi_common_def.h"
18 #include "wifi_config_file_impl.h"
19 #include "wifi_logger.h"
20
21 namespace OHOS {
22 namespace Wifi {
23 DEFINE_WIFILOG_LABEL("WifiAppXmlParser");
24
25 constexpr auto WIFI_MONITOR_APP_FILE_PATH = "/system/etc/wifi/wifi_monitor_apps.xml";
26 constexpr auto WIFI_NETWORK_CONTROL_APP_FILE_PATH = "/system/etc/wifi/wifi_network_control_apps.xml";
27 constexpr auto XML_TAG_SECTION_HEADER_MONITOR_APP = "MonitorAPP";
28 constexpr auto XML_TAG_SECTION_HEADER_NETWORK_CONTROL_APP = "NetworkControlAPP";
29 constexpr auto XML_TAG_SECTION_HEADER_GAME_INFO = "GameInfo";
30 constexpr auto XML_TAG_SECTION_HEADER_APP_WHITE_LIST = "AppWhiteList";
31 constexpr auto XML_TAG_SECTION_HEADER_APP_BLACK_LIST = "AppBlackList";
32 constexpr auto XML_TAG_SECTION_HEADER_MULTILINK_BLACK_LIST = "MultiLinkBlackList";
33 constexpr auto XML_TAG_SECTION_HEADER_CHARIOT_APP = "ChariotApp";
34 constexpr auto XML_TAG_SECTION_HEADER_HIGH_TEMP_LIMIT_SPEED_APP = "HighTempLimitSpeedApp";
35 constexpr auto XML_TAG_SECTION_HEADER_APP_KEY_FOREGROUND_LIST = "KeyAppForegroundList";
36 constexpr auto XML_TAG_SECTION_HEADER_APP_KEY_BACKGROUND_LIMIT_LIST = "KeyBackgroundLimitListApp";
37 constexpr auto XML_TAG_SECTION_HEADER_APP_LIVE_STREAM_LIST = "AppLiveStream";
38 constexpr auto XML_TAG_SECTION_HEADER_APP_GAME_BACKGROUND_LIMIT_LIST = "GameBackgroundLimitListApp";
39 constexpr auto XML_TAG_SECTION_HEADER_ASYNC_DELAY_TIME = "AsyncDelayTime";
40 constexpr auto XML_TAG_SECTION_KEY_GAME_RTT = "mGameRtt";
41 constexpr auto XML_TAG_SECTION_KEY_GAME_NAME = "gameName";
42 constexpr auto XML_TAG_SECTION_KEY_PACKAGE_NAME = "packageName";
43 constexpr auto XML_TAG_SECTION_KEY_DELAY_TIME = "delayTime";
44 constexpr auto XML_VERSION_NODE_NAME = "HighTempLimitSpeedAppVersionInfo";
45
46 const std::unordered_map<std::string, AppType> appTypeMap = {
47 { XML_TAG_SECTION_HEADER_GAME_INFO, AppType::LOW_LATENCY_APP },
48 { XML_TAG_SECTION_HEADER_APP_WHITE_LIST, AppType::WHITE_LIST_APP },
49 { XML_TAG_SECTION_HEADER_APP_BLACK_LIST, AppType::BLACK_LIST_APP },
50 { XML_TAG_SECTION_HEADER_MULTILINK_BLACK_LIST, AppType::MULTILINK_BLACK_LIST_APP },
51 { XML_TAG_SECTION_HEADER_CHARIOT_APP, AppType::CHARIOT_APP },
52 {XML_TAG_SECTION_HEADER_HIGH_TEMP_LIMIT_SPEED_APP, AppType::HIGH_TEMP_LIMIT_SPEED_APP},
53 { XML_TAG_SECTION_HEADER_APP_KEY_FOREGROUND_LIST, AppType::KEY_FOREGROUND_LIST_APP},
54 { XML_TAG_SECTION_HEADER_APP_KEY_BACKGROUND_LIMIT_LIST, AppType::KEY_BACKGROUND_LIMIT_LIST_APP},
55 { XML_TAG_SECTION_HEADER_ASYNC_DELAY_TIME, AppType::ASYNC_DELAY_TIME},
56 { XML_TAG_SECTION_HEADER_APP_LIVE_STREAM_LIST, AppType::LIVE_STREAM_APP},
57 { XML_TAG_SECTION_HEADER_APP_GAME_BACKGROUND_LIMIT_LIST, AppType::GAME_BACKGROUND_LIMIT_LIST_APP},
58 { XML_TAG_SECTION_KEY_GAME_RTT, AppType::GAME_RTT},
59 };
60
AppParserInner()61 AppParserInner::AppParserInner()
62 {
63 WIFI_LOGI("%{public}s enter", __FUNCTION__);
64 }
65
~AppParserInner()66 AppParserInner::~AppParserInner()
67 {
68 WIFI_LOGI("%{public}s enter", __FUNCTION__);
69 }
70
Init(AppParserResult & result,std::vector<const char * > appFileList)71 bool AppParserInner::Init(AppParserResult &result, std::vector<const char*> appFileList)
72 {
73 if (!initFlag_) {
74 bool parserRet = true;
75 for (auto filePath: appFileList) {
76 bool ret = InitAppParser(filePath);
77 WIFI_LOGI("%{public}s InitAppParser result %{public}s : %{public}d",
78 __FUNCTION__, filePath, static_cast<int>(ret));
79 parserRet &= ret;
80 }
81 if (parserRet) {
82 initFlag_ = true;
83 result = result_;
84 WIFI_LOGD("%{public}s InitAppParser successful", __FUNCTION__);
85 } else {
86 WIFI_LOGE("%{public}s InitAppParser fail", __FUNCTION__);
87 };
88 }
89 return initFlag_;
90 }
91
92
InitAppParser(const char * appXmlFilePath)93 bool AppParserInner::InitAppParser(const char *appXmlFilePath)
94 {
95 if (appXmlFilePath == nullptr) {
96 WIFI_LOGE("%{public}s appXmlFilePath is null", __FUNCTION__);
97 return false;
98 }
99 std::string xmlPath(appXmlFilePath);
100 std::filesystem::path pathName = xmlPath;
101 std::error_code code;
102 if (!std::filesystem::exists(pathName, code)) {
103 WIFI_LOGE("%{public}s %{public}s not exists", __FUNCTION__, appXmlFilePath);
104 return false;
105 }
106 bool ret = LoadConfiguration(appXmlFilePath);
107 if (!ret) {
108 WIFI_LOGE("%{public}s load failed", __FUNCTION__);
109 return ret;
110 }
111 ret = Parse();
112 if (!ret) {
113 WIFI_LOGE("%{public}s parse failed", __FUNCTION__);
114 return ret;
115 }
116 WIFI_LOGD("%{public}s, wifi monitor app xml parsed successfully", __FUNCTION__);
117 return ret;
118 }
119
ParseInternal(xmlNodePtr node)120 bool AppParserInner::ParseInternal(xmlNodePtr node)
121 {
122 if (node == nullptr) {
123 WIFI_LOGE("%{public}s node is null", __FUNCTION__);
124 return false;
125 }
126 ParseAppList(node);
127 ParseNetworkControlAppList(node);
128 return true;
129 }
130
ParseAppList(const xmlNodePtr & innode)131 void AppParserInner::ParseAppList(const xmlNodePtr &innode)
132 {
133 if (innode == nullptr) {
134 return;
135 }
136 if (innode->name == nullptr || xmlStrcmp(innode->name, BAD_CAST(XML_TAG_SECTION_HEADER_MONITOR_APP)) != 0) {
137 WIFI_LOGE("innode name=%{public}s not equal MonitorAPP", innode->name);
138 return;
139 }
140 result_.m_lowLatencyAppVec.clear();
141 result_.m_whiteAppVec.clear();
142 result_.m_multilinkAppVec.clear();
143 result_.m_chariotAppVec.clear();
144 result_.m_blackAppVec.clear();
145 result_.m_highTempLimitSpeedAppVec.clear();
146 xmlNodePtr nodeVersion = innode->children;
147 if (nodeVersion != nullptr) {
148 GetLocalFileVersion(nodeVersion);
149 }
150 for (xmlNodePtr node = innode->children; node != nullptr; node = node->next) {
151 switch (GetAppTypeAsInt(node)) {
152 case AppType::LOW_LATENCY_APP:
153 result_.m_lowLatencyAppVec.push_back(ParseLowLatencyAppInfo(node));
154 break;
155 case AppType::WHITE_LIST_APP:
156 result_.m_whiteAppVec.push_back(ParseWhiteAppInfo(node));
157 break;
158 case AppType::MULTILINK_BLACK_LIST_APP:
159 result_.m_multilinkAppVec.push_back(ParseMultiLinkAppInfo(node));
160 break;
161 case AppType::BLACK_LIST_APP:
162 result_.m_blackAppVec.push_back(ParseBlackAppInfo(node));
163 break;
164 case AppType::CHARIOT_APP:
165 result_.m_chariotAppVec.push_back(ParseChariotAppInfo(node));
166 break;
167 case AppType::HIGH_TEMP_LIMIT_SPEED_APP:
168 result_.m_highTempLimitSpeedAppVec.push_back(ParseHighTempLimitSpeedAppInfo(node));
169 break;
170 default:
171 WIFI_LOGD("app type: %{public}s is not monitored", GetNodeValue(node).c_str());
172 break;
173 }
174 }
175 WIFI_LOGI("%{public}s out,result_.m_highTempLimitSpeedAppVec count:%{public}d!",
176 __FUNCTION__, (int)result_.m_highTempLimitSpeedAppVec.size());
177 WIFI_LOGI("%{public}s out,result_.m_multilinkAppVec count:%{public}d!",
178 __FUNCTION__, (int)result_.m_multilinkAppVec.size());
179 }
180
ParseNetworkControlAppList(const xmlNodePtr & innode)181 void AppParserInner::ParseNetworkControlAppList(const xmlNodePtr &innode)
182 {
183 if (innode == nullptr || innode->name == nullptr) {
184 return;
185 }
186 if (xmlStrcmp(innode->name, BAD_CAST(XML_TAG_SECTION_HEADER_NETWORK_CONTROL_APP)) != 0) {
187 WIFI_LOGE("innode name=%{public}s not equal NetworkControlAPP", innode->name);
188 return;
189 }
190 result_.m_keyForegroundListAppVec.clear();
191 result_.m_keyBackgroundLimitListAppVec.clear();
192 result_.m_liveStreamAppVec.clear();
193 result_.m_gameBackgroundLimitListAppVec.clear();
194
195 for (xmlNodePtr node = innode->children; node != nullptr; node = node->next) {
196 switch (GetAppTypeAsInt(node)) {
197 case AppType::KEY_FOREGROUND_LIST_APP:
198 result_.m_keyForegroundListAppVec.push_back(ParseKeyForegroundListAppInfo(node));
199 break;
200 case AppType::KEY_BACKGROUND_LIMIT_LIST_APP:
201 result_.m_keyBackgroundLimitListAppVec.push_back(ParseKeyBackgroundLimitListAppInfo(node));
202 break;
203 case AppType::GAME_BACKGROUND_LIMIT_LIST_APP:
204 result_.m_gameBackgroundLimitListAppVec.push_back(ParseGameBackgroundLimitListAppInfo(node));
205 break;
206 case AppType::LIVE_STREAM_APP:
207 result_.m_liveStreamAppVec.push_back(ParseLiveStreamAppInfo(node));
208 break;
209 case AppType::ASYNC_DELAY_TIME:
210 ParseAsyncLimitSpeedDelayTime(node);
211 break;
212 default:
213 WIFI_LOGD("app type: %{public}s is not limited", GetNodeValue(node).c_str());
214 break;
215 }
216 }
217 WIFI_LOGI("%{public}s out,result_.m_keyForegroundListAppVec count:%{public}d!",
218 __FUNCTION__, (int)result_.m_keyForegroundListAppVec.size());
219 WIFI_LOGI("%{public}s out,result_.m_keyBackgroundLimitListAppVec count:%{public}d!",
220 __FUNCTION__, (int)result_.m_keyBackgroundLimitListAppVec.size());
221 }
222
ParseLowLatencyAppInfo(const xmlNodePtr & innode)223 LowLatencyAppInfo AppParserInner::ParseLowLatencyAppInfo(const xmlNodePtr &innode)
224 {
225 LowLatencyAppInfo appInfo{};
226 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_GAME_NAME));
227 if (value == NULL) {
228 WIFI_LOGE("%{public}s xml parser low latency app info error.", __FUNCTION__);
229 return appInfo;
230 }
231 std::string gameName = std::string(reinterpret_cast<char *>(value));
232 appInfo.packageName = gameName;
233 xmlFree(value);
234 for (xmlNodePtr node = innode->children; node != nullptr; node = node->next) {
235 if (GetAppTypeAsInt(node) == AppType::GAME_RTT) {
236 xmlChar *rttValue = xmlNodeGetContent(node);
237 if (rttValue == NULL) {
238 WIFI_LOGE("%{public}s xml parser game rtt info error.", __FUNCTION__);
239 break;
240 }
241 std::string rtt = std::string(reinterpret_cast<char *>(rttValue));
242 result_.m_gameRtt[gameName] = CheckDataLegal(rtt);
243 xmlFree(rttValue);
244 }
245 }
246 return appInfo;
247 }
248
ParseWhiteAppInfo(const xmlNodePtr & innode)249 WhiteListAppInfo AppParserInner::ParseWhiteAppInfo(const xmlNodePtr &innode)
250 {
251 WhiteListAppInfo appInfo;
252 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
253 if (value == NULL) {
254 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
255 return appInfo;
256 }
257 std::string packageName = std::string(reinterpret_cast<char *>(value));
258 appInfo.packageName = packageName;
259 xmlFree(value);
260 return appInfo;
261 }
262
ParseBlackAppInfo(const xmlNodePtr & innode)263 BlackListAppInfo AppParserInner::ParseBlackAppInfo(const xmlNodePtr &innode)
264 {
265 BlackListAppInfo appInfo;
266 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
267 if (value == NULL) {
268 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
269 return appInfo;
270 }
271 std::string packageName = std::string(reinterpret_cast<char *>(value));
272 appInfo.packageName = packageName;
273 xmlFree(value);
274 return appInfo;
275 }
276
ParseMultiLinkAppInfo(const xmlNodePtr & innode)277 MultiLinkAppInfo AppParserInner::ParseMultiLinkAppInfo(const xmlNodePtr &innode)
278 {
279 MultiLinkAppInfo appInfo;
280 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
281 if (value == NULL) {
282 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
283 return appInfo;
284 }
285 std::string packageName = std::string(reinterpret_cast<char *>(value));
286 appInfo.packageName = packageName;
287 WIFI_LOGD("%{public}s packageName:%{public}s", __FUNCTION__, packageName.c_str());
288 xmlFree(value);
289 return appInfo;
290 }
291
ParseChariotAppInfo(const xmlNodePtr & innode)292 ChariotAppInfo AppParserInner::ParseChariotAppInfo(const xmlNodePtr &innode)
293 {
294 ChariotAppInfo appInfo;
295 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
296 if (value == NULL) {
297 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
298 return appInfo;
299 }
300 std::string packageName = std::string(reinterpret_cast<char *>(value));
301 appInfo.packageName = packageName;
302 xmlFree(value);
303 return appInfo;
304 }
305
ParseHighTempLimitSpeedAppInfo(const xmlNodePtr & innode)306 HighTempLimitSpeedAppInfo AppParserInner::ParseHighTempLimitSpeedAppInfo(const xmlNodePtr &innode)
307 {
308 HighTempLimitSpeedAppInfo appInfo;
309 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
310 if (value == NULL) {
311 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
312 return appInfo;
313 }
314 std::string packageName = std::string(reinterpret_cast<char *>(value));
315 appInfo.packageName = packageName;
316 xmlFree(value);
317 return appInfo;
318 }
319
ParseKeyForegroundListAppInfo(const xmlNodePtr & innode)320 KeyForegroundListAppInfo AppParserInner::ParseKeyForegroundListAppInfo(const xmlNodePtr &innode)
321 {
322 KeyForegroundListAppInfo appInfo;
323 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
324 if (value == NULL) {
325 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
326 return appInfo;
327 }
328 std::string packageName = std::string(reinterpret_cast<char *>(value));
329 appInfo.packageName = packageName;
330 xmlFree(value);
331 return appInfo;
332 }
333
ParseKeyBackgroundLimitListAppInfo(const xmlNodePtr & innode)334 KeyBackgroundLimitListAppInfo AppParserInner::ParseKeyBackgroundLimitListAppInfo(const xmlNodePtr &innode)
335 {
336 KeyBackgroundLimitListAppInfo appInfo;
337 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
338 if (value == NULL) {
339 WIFI_LOGE("%{public}s xml parser app info error.", __FUNCTION__);
340 return appInfo;
341 }
342 std::string packageName = std::string(reinterpret_cast<char *>(value));
343 appInfo.packageName = packageName;
344 xmlFree(value);
345 return appInfo;
346 }
347
ParseLiveStreamAppInfo(const xmlNodePtr & innode)348 LiveStreamAppInfo AppParserInner::ParseLiveStreamAppInfo(const xmlNodePtr &innode)
349 {
350 LiveStreamAppInfo appInfo{};
351 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
352 if (value == NULL) {
353 WIFI_LOGE("%{public}s xml parser live stream app info error.", __FUNCTION__);
354 return appInfo;
355 }
356 std::string packageName = std::string(reinterpret_cast<char *>(value));
357 appInfo.packageName = packageName;
358 xmlFree(value);
359 return appInfo;
360 }
361
ParseGameBackgroundLimitListAppInfo(const xmlNodePtr & innode)362 GameBackgroundLimitListAppInfo AppParserInner::ParseGameBackgroundLimitListAppInfo(const xmlNodePtr &innode)
363 {
364 GameBackgroundLimitListAppInfo appInfo{};
365 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_PACKAGE_NAME));
366 if (value == NULL) {
367 WIFI_LOGE("%{public}s xml parser game background limit app info error.", __FUNCTION__);
368 return appInfo;
369 }
370 std::string packageName = std::string(reinterpret_cast<char *>(value));
371 appInfo.packageName = packageName;
372 xmlFree(value);
373 return appInfo;
374 }
375
ParseAsyncLimitSpeedDelayTime(const xmlNodePtr & innode)376 void AppParserInner::ParseAsyncLimitSpeedDelayTime(const xmlNodePtr &innode)
377 {
378 xmlChar *value = xmlGetProp(innode, BAD_CAST(XML_TAG_SECTION_KEY_DELAY_TIME));
379 if (value == NULL) {
380 WIFI_LOGE("%{public}s xml parser info error.", __FUNCTION__);
381 return;
382 }
383 result_.m_delayTime = std::string(reinterpret_cast<char *>(value));
384 if (result_.m_delayTime.empty()) {
385 WIFI_LOGE("%{public}s delay time is null, will set 0.", __FUNCTION__);
386 result_.m_delayTime = "0";
387 }
388 }
389
GetAppTypeAsInt(const xmlNodePtr & innode)390 AppType AppParserInner::GetAppTypeAsInt(const xmlNodePtr &innode)
391 {
392 std::string tagName = GetNodeValue(innode);
393 if (appTypeMap.find(tagName) != appTypeMap.end()) {
394 return appTypeMap.at(tagName);
395 }
396 WIFI_LOGD("%{public}s not find targName:%{public}s in appTypeMap", __FUNCTION__, tagName.c_str());
397 return AppType::OTHER_APP;
398 }
399
GetLocalFileVersion(const xmlNodePtr & innode)400 std::string AppParserInner::GetLocalFileVersion(const xmlNodePtr &innode)
401 {
402 if (innode == nullptr || innode->name == nullptr) {
403 return "";
404 }
405 if (xmlStrcmp(innode->name, BAD_CAST(XML_VERSION_NODE_NAME)) != 0) {
406 WIFI_LOGE("innode name=%{public}s not equal version", innode->name);
407 return "";
408 }
409 std::string fileVersion = GetStringValue(innode);
410 WIFI_LOGI("%{public}s name=%{public}s", __FUNCTION__, fileVersion.c_str());
411 return fileVersion;
412 }
413
414 /* below: AppParser is used for judge whether application in certain list*/
415
AppParser()416 AppParser::AppParser()
417 {
418 WIFI_LOGI("%{public}s enter", __FUNCTION__);
419 }
420
~AppParser()421 AppParser::~AppParser()
422 {
423 WIFI_LOGI("%{public}s enter", __FUNCTION__);
424 }
425
GetInstance()426 AppParser &AppParser::GetInstance()
427 {
428 static AppParser instance;
429 return instance;
430 }
431
Init()432 bool AppParser::Init()
433 {
434 std::unique_lock<std::shared_mutex> lock(appParserMutex_);
435 if (!initFlag_) {
436 appParserInner_ = std::make_unique<AppParserInner>();
437 std::vector<const char*> appFileList = {WIFI_MONITOR_APP_FILE_PATH, WIFI_NETWORK_CONTROL_APP_FILE_PATH};
438 initFlag_ = appParserInner_->Init(result_, appFileList);
439 appParserInner_ = nullptr; // release memory after use
440 }
441 return initFlag_;
442 }
443
IsLowLatencyApp(const std::string & bundleName) const444 bool AppParser::IsLowLatencyApp(const std::string &bundleName) const
445 {
446 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
447 return std::any_of(result_.m_lowLatencyAppVec.begin(), result_.m_lowLatencyAppVec.end(),
448 [bundleName](const LowLatencyAppInfo &app) { return app.packageName == bundleName; });
449 }
450
IsWhiteListApp(const std::string & bundleName) const451 bool AppParser::IsWhiteListApp(const std::string &bundleName) const
452 {
453 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
454 return std::any_of(result_.m_whiteAppVec.begin(), result_.m_whiteAppVec.end(),
455 [bundleName](const WhiteListAppInfo &app) { return app.packageName == bundleName; });
456 }
457
IsBlackListApp(const std::string & bundleName) const458 bool AppParser::IsBlackListApp(const std::string &bundleName) const
459 {
460 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
461 return std::any_of(result_.m_blackAppVec.begin(), result_.m_blackAppVec.end(),
462 [bundleName](const BlackListAppInfo &app) { return app.packageName == bundleName; });
463 }
464
IsMultiLinkApp(const std::string & bundleName) const465 bool AppParser::IsMultiLinkApp(const std::string &bundleName) const
466 {
467 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
468 return std::any_of(result_.m_multilinkAppVec.begin(), result_.m_multilinkAppVec.end(),
469 [bundleName](const MultiLinkAppInfo &app) { return app.packageName == bundleName; });
470 }
471
IsChariotApp(const std::string & bundleName) const472 bool AppParser::IsChariotApp(const std::string &bundleName) const
473 {
474 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
475 return std::any_of(result_.m_chariotAppVec.begin(), result_.m_chariotAppVec.end(),
476 [bundleName](const ChariotAppInfo &app) { return app.packageName == bundleName; });
477 }
478
IsHighTempLimitSpeedApp(const std::string & bundleName) const479 bool AppParser::IsHighTempLimitSpeedApp(const std::string &bundleName) const
480 {
481 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
482 return std::any_of(result_.m_highTempLimitSpeedAppVec.begin(), result_.m_highTempLimitSpeedAppVec.end(),
483 [bundleName](const HighTempLimitSpeedAppInfo &app) { return app.packageName == bundleName; });
484 }
485
IsKeyForegroundApp(const std::string & bundleName) const486 bool AppParser::IsKeyForegroundApp(const std::string &bundleName) const
487 {
488 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
489 return std::any_of(result_.m_keyForegroundListAppVec.begin(), result_.m_keyForegroundListAppVec.end(),
490 [bundleName](const KeyForegroundListAppInfo &app) { return app.packageName == bundleName; });
491 }
492
IsKeyBackgroundLimitApp(const std::string & bundleName) const493 bool AppParser::IsKeyBackgroundLimitApp(const std::string &bundleName) const
494 {
495 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
496 return std::any_of(result_.m_keyBackgroundLimitListAppVec.begin(), result_.m_keyBackgroundLimitListAppVec.end(),
497 [bundleName](const KeyBackgroundLimitListAppInfo &app) { return app.packageName == bundleName; });
498 }
499
IsLiveStreamApp(const std::string & bundleName) const500 bool AppParser::IsLiveStreamApp(const std::string &bundleName) const
501 {
502 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
503 return std::any_of(result_.m_liveStreamAppVec.begin(), result_.m_liveStreamAppVec.end(),
504 [bundleName](const LiveStreamAppInfo &app) { return app.packageName == bundleName; });
505 }
506
IsGameBackgroundLimitApp(const std::string & bundleName) const507 bool AppParser::IsGameBackgroundLimitApp(const std::string &bundleName) const
508 {
509 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
510 return std::any_of(result_.m_gameBackgroundLimitListAppVec.begin(), result_.m_gameBackgroundLimitListAppVec.end(),
511 [bundleName](const GameBackgroundLimitListAppInfo &app) { return app.packageName == bundleName; });
512 }
513
IsOverGameRtt(const std::string & bundleName,const int gameRtt) const514 bool AppParser::IsOverGameRtt(const std::string &bundleName, const int gameRtt) const
515 {
516 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
517 if (result_.m_gameRtt.find(bundleName) == result_.m_gameRtt.end()) {
518 return false;
519 }
520 return result_.m_gameRtt.at(bundleName) <= gameRtt;
521 }
522
GetAsyncLimitSpeedDelayTime() const523 std::string AppParser::GetAsyncLimitSpeedDelayTime() const
524 {
525 std::shared_lock<std::shared_mutex> lock(appParserMutex_);
526 return result_.m_delayTime;
527 }
528 } // namespace Wifi
529 } // namespace OHOS