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 "net_stats_service.h"
17
18 #include <dlfcn.h>
19 #include <net/if.h>
20 #include <sys/time.h>
21 #include <unistd.h>
22 #include <chrono>
23 #include <format>
24 #include <regex>
25
26 #include <cinttypes>
27
28 #include <initializer_list>
29
30 #include "bpf_stats.h"
31 #include "bpf_path.h"
32 #include "bpf_def.h"
33 #include "broadcast_manager.h"
34 #include "common_event_manager.h"
35 #include "common_event_support.h"
36 #include "ffrt_inner.h"
37 #include "net_bundle.h"
38 #include "net_manager_center.h"
39 #include "net_manager_constants.h"
40 #include "net_mgr_log_wrapper.h"
41 #include "net_stats_constants.h"
42 #include "net_stats_database_defines.h"
43 #include "net_stats_service_common.h"
44 #include "netmanager_base_common_utils.h"
45 #include "netmanager_base_permission.h"
46 #include "netmanager_hitrace.h"
47 #include "netsys_controller.h"
48 #include "system_ability_definition.h"
49 #ifdef SUPPORT_TRAFFIC_STATISTIC
50 #include "cellular_data_client.h"
51 #include "core_service_client.h"
52 #include "net_conn_client.h"
53 #include "cellular_data_types.h"
54 #include "net_stats_utils.h"
55 #include "net_stats_notification.h"
56 #include "net_stats_rdb.h"
57 #endif // SUPPORT_TRAFFIC_STATISTIC
58 #include "iptables_wrapper.h"
59 #ifdef SUPPORT_NETWORK_SHARE
60 #include "networkshare_client.h"
61 #include "networkshare_constants.h"
62 #endif // SUPPORT_NETWORK_SHARE
63 #include "system_timer.h"
64 #include "net_stats_subscriber.h"
65
66 namespace OHOS {
67 namespace NetManagerStandard {
68 using namespace NetStatsDatabaseDefines;
69 namespace {
70 constexpr std::initializer_list<NetBearType> BEAR_TYPE_LIST = {
71 NetBearType::BEARER_CELLULAR, NetBearType::BEARER_WIFI, NetBearType::BEARER_BLUETOOTH,
72 NetBearType::BEARER_ETHERNET, NetBearType::BEARER_VPN, NetBearType::BEARER_WIFI_AWARE,
73 };
74 constexpr uint32_t DEFAULT_UPDATE_TRAFFIC_INFO_CYCLE_MS = 30 * 60 * 1000;
75 constexpr uint32_t DAY_SECONDS = 2 * 24 * 60 * 60;
76 constexpr uint32_t DAY_MILLISECONDS = 24 * 60 * 60 * 1000;
77 constexpr int32_t TRAFFIC_NOTIFY_TYPE = 3;
78 constexpr const char* UID = "uid";
79 const std::string LIB_NET_BUNDLE_UTILS_PATH = "libnet_bundle_utils.z.so";
80 constexpr uint64_t DELAY_US = 35 * 1000 * 1000;
81 constexpr const char* COMMON_EVENT_STATUS = "usual.event.RGM_STATUS_CHANGED";
82 constexpr const char* STATUS_FIELD = "rgmStatus";
83 const std::string STATUS_UNLOCKED = "rgm_user_unlocked";
84
85 enum NetStatusType : uint8_t {
86 WIFI_TYPE = 0,
87 CELLULAR_TYPE = 1,
88 };
89
90 enum NetStatusConn : uint8_t {
91 NON_CONNECTED = 0,
92 CONNECTED = 1,
93 };
94 } // namespace
95 const bool REGISTER_LOCAL_RESULT =
96 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<NetStatsService>::GetInstance().get());
97
NetStatsService()98 NetStatsService::NetStatsService()
99 : SystemAbility(COMM_NET_STATS_MANAGER_SYS_ABILITY_ID, true), registerToService_(false), state_(STATE_STOPPED)
100 {
101 netStatsCallback_ = std::make_shared<NetStatsCallback>();
102 netStatsCached_ = std::make_unique<NetStatsCached>();
103 #ifdef SUPPORT_TRAFFIC_STATISTIC
104 trafficObserver_ = std::make_unique<TrafficObserver>().release();
105 trafficPlanFfrtQueue_ = std::make_shared<ffrt::queue>("TrafficPlanStatistic");
106 #endif // SUPPORT_TRAFFIC_STATISTIC
107 }
108
109 NetStatsService::~NetStatsService() = default;
110
OnStart()111 void NetStatsService::OnStart()
112 {
113 if (state_ == STATE_RUNNING) {
114 NETMGR_LOG_D("the state is already running");
115 return;
116 }
117 if (!Init()) {
118 NETMGR_LOG_E("init failed");
119 return;
120 }
121 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
122 AddSystemAbilityListener(TIME_SERVICE_ID);
123 #ifdef SUPPORT_TRAFFIC_STATISTIC
124 AddSystemAbilityListener(COMM_NETSYS_NATIVE_SYS_ABILITY_ID);
125 #endif // SUPPORT_TRAFFIC_STATISTIC
126 AddSystemAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN);
127 state_ = STATE_RUNNING;
128 sptr<NetStatsBaseService> baseService = new (std::nothrow) NetStatsServiceCommon();
129 if (baseService == nullptr) {
130 NETMGR_LOG_E("Net stats base service instance create failed");
131 return;
132 }
133 NetManagerCenter::GetInstance().RegisterStatsService(baseService);
134 }
135
StartSysTimer()136 void NetStatsService::StartSysTimer()
137 {
138 NETMGR_LOG_I("NetStatsService StartSysTimer");
139 std::lock_guard<std::mutex> lock(timerMutex_);
140 if (netStatsSysTimerId_ != 0) {
141 NETMGR_LOG_E("netStatsSysTimerId_ is not zero, value is %{public}" PRIu64, netStatsSysTimerId_);
142 return;
143 }
144 std::shared_ptr<NetmanagerSysTimer> netStatsSysTimer =
145 std::make_unique<NetmanagerSysTimer>(true, DAY_MILLISECONDS, true);
146 std::function<void()> callback = [this]() {
147 #ifdef SUPPORT_TRAFFIC_STATISTIC
148 NetStatsRDB netStats;
149 netStats.BackUpNetStatsFreqDB(NOTICE_DATABASE_NAME, NOTICE_DATABASE_BACK_NAME);
150 #endif // SUPPORT_TRAFFIC_STATISTIC
151 UpdateStatsDataInner();
152 };
153 netStatsSysTimer->SetCallbackInfo(callback);
154 netStatsSysTimer->SetName("netstats_data_persistence_timer");
155 netStatsSysTimerId_ = MiscServices::TimeServiceClient::GetInstance()->CreateTimer(netStatsSysTimer);
156 uint64_t todayStartTime = static_cast<uint64_t>(CommonUtils::GetTodayMidnightTimestamp(23, 59, 55)) * 1000;
157 MiscServices::TimeServiceClient::GetInstance()->StartTimer(netStatsSysTimerId_, todayStartTime);
158 NETMGR_LOG_I("netStatsSysTimerId_ success. value is %{public}" PRIu64, netStatsSysTimerId_);
159 }
160
StopSysTimer()161 void NetStatsService::StopSysTimer()
162 {
163 std::lock_guard<std::mutex> lock(timerMutex_);
164 if (netStatsSysTimerId_ == 0) {
165 NETMGR_LOG_W("netStatsSysTimerId_ is zero");
166 return;
167 }
168 MiscServices::TimeServiceClient::GetInstance()->StopTimer(netStatsSysTimerId_);
169 MiscServices::TimeServiceClient::GetInstance()->DestroyTimer(netStatsSysTimerId_);
170 netStatsSysTimerId_ = 0;
171 NETMGR_LOG_I("stop netStatsSysTimerId_ success");
172 }
173
ModifySysTimer()174 int32_t NetStatsService::ModifySysTimer()
175 {
176 std::lock_guard<std::mutex> lock(timerMutex_);
177 if (netStatsSysTimerId_ == 0) {
178 NETMGR_LOG_E("netStatsSysTimerId_ is zero");
179 return NETMANAGER_ERROR;
180 }
181 MiscServices::TimeServiceClient::GetInstance()->StopTimer(netStatsSysTimerId_);
182 uint64_t todayStartTime = static_cast<uint64_t>(CommonUtils::GetTodayMidnightTimestamp(23, 59, 55)) * 1000;
183 MiscServices::TimeServiceClient::GetInstance()->StartTimer(netStatsSysTimerId_, todayStartTime);
184 NETMGR_LOG_I("ModifySysTimer netStatsSysTimerId_ success. timer: %{public}" PRIu64, todayStartTime);
185 return NETMANAGER_SUCCESS;
186 }
187
OnStop()188 void NetStatsService::OnStop()
189 {
190 state_ = STATE_STOPPED;
191 registerToService_ = true;
192 }
193
Dump(int32_t fd,const std::vector<std::u16string> & args)194 int32_t NetStatsService::Dump(int32_t fd, const std::vector<std::u16string> &args)
195 {
196 NETMGR_LOG_D("Start Dump, fd: %{public}d", fd);
197 std::string result;
198 GetDumpMessage(result);
199 int32_t ret = dprintf(fd, "%s\n", result.c_str());
200 return ret < 0 ? STATS_DUMP_MESSAGE_FAIL : NETMANAGER_SUCCESS;
201 }
202
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)203 void NetStatsService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
204 {
205 NETMGR_LOG_I("OnAddSystemAbility: systemAbilityId:%{public}d", systemAbilityId);
206 #ifdef SUPPORT_TRAFFIC_STATISTIC
207 if (systemAbilityId == COMM_NETSYS_NATIVE_SYS_ABILITY_ID) {
208 StartTrafficOvserver();
209 return;
210 }
211 #endif // SUPPORT_TRAFFIC_STATISTIC
212 if (systemAbilityId == BUNDLE_MGR_SERVICE_SYS_ABILITY_ID) {
213 RefreshUidStatsFlag(DELAY_US);
214 return;
215 }
216 if (systemAbilityId == TIME_SERVICE_ID) {
217 StartSysTimer();
218 return;
219 }
220
221 if (systemAbilityId == SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN) {
222 InitPrivateUserId();
223 StartAccountObserver();
224 return;
225 }
226 RegisterCommonEvent();
227 }
228
RegisterCommonEvent()229 void NetStatsService::RegisterCommonEvent()
230 {
231 EventFwk::MatchingSkills matchingSkills;
232 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
233 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED);
234 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN);
235 #ifdef SUPPORT_TRAFFIC_STATISTIC
236 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED); // 监听卡状态
237 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CELLULAR_DATA_STATE_CHANGED);
238 #endif // SUPPORT_TRAFFIC_STATISTIC
239 matchingSkills.AddEvent(COMMON_EVENT_STATUS);
240 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_TIME_CHANGED);
241 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED);
242 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE);
243 EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
244 subscriber_ = std::make_shared<NetStatsListener>(subscribeInfo);
245 subscriber_->RegisterStatsCallback(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN,
246 [this](const EventFwk::Want &want) {
247 NETMGR_LOG_I("Net stats shutdown event");
248 return UpdateStatsData();
249 });
250 subscriber_->RegisterStatsCallback(
251 EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED, [this](const EventFwk::Want &want) {
252 uint32_t uid = want.GetIntParam(UID, 0);
253 NETMGR_LOG_D("Net Manager delete uid, uid:[%{public}d]", uid);
254 return CommonEventPackageRemoved(uid);
255 });
256 subscriber_->RegisterStatsCallback(
257 EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_ADDED, [this](const EventFwk::Want &want) {
258 uint32_t uid = want.GetIntParam(UID, 0);
259 NETMGR_LOG_D("Net Manager add uid, uid:[%{public}d]", uid);
260 return CommonEventPackageAdded(uid);
261 });
262 subscriber_->RegisterStatsCallback(COMMON_EVENT_STATUS, [this](const EventFwk::Want &want) -> bool {
263 std::string status = want.GetStringParam(STATUS_FIELD);
264 NETMGR_LOG_I("Net Manager status changed, status:[%{public}s]", status.c_str());
265 if (status == STATUS_UNLOCKED) {
266 RefreshUidStatsFlag(0);
267 }
268 return true;
269 });
270 RegisterCommonTelephonyEvent();
271 RegisterCommonTimeEvent();
272 RegisterCommonNetStatusEvent();
273 EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
274 }
275
RegisterCommonNetStatusEvent()276 void NetStatsService::RegisterCommonNetStatusEvent()
277 {
278 subscriber_->RegisterStatsCallbackData(
279 EventFwk::CommonEventSupport::COMMON_EVENT_WIFI_CONN_STATE, [this](const EventFwk::CommonEventData& eventData) {
280 int32_t state = eventData.GetCode();
281 NETMGR_LOG_I("COMMON_EVENT_WIFI_CONN_STATE: %{public}d", state);
282 if (state == 4) { // 4:OHOS::Wifi::ConnState::CONNECTED
283 return UpdateNetStatusMap(0, 1);
284 } else {
285 return UpdateNetStatusMap(0, 0);
286 }
287 return false;
288 });
289 }
290
RegisterCommonTelephonyEvent()291 void NetStatsService::RegisterCommonTelephonyEvent()
292 {
293 #ifdef SUPPORT_TRAFFIC_STATISTIC
294 subscriber_->RegisterStatsCallback(
295 EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED, [this](const EventFwk::Want &want) {
296 int32_t slotId = want.GetIntParam("slotId", -1);
297 int32_t simStatus = want.GetIntParam("state", -1);
298 return CommonEventSimStateChanged(slotId, simStatus);
299 });
300 subscriber_->RegisterStatsCallback(
301 EventFwk::CommonEventSupport::COMMON_EVENT_CELLULAR_DATA_STATE_CHANGED, [this](const EventFwk::Want &want) {
302 int32_t slotId = want.GetIntParam("slotId", -1);
303 int32_t dataState = want.GetIntParam("dataState", -1);
304 return CommonEventCellularDataStateChanged(slotId, dataState);
305 });
306 #endif // SUPPORT_TRAFFIC_STATISTIC
307 }
308
RegisterCommonTimeEvent()309 void NetStatsService::RegisterCommonTimeEvent()
310 {
311 subscriber_->RegisterStatsCallback(
312 EventFwk::CommonEventSupport::COMMON_EVENT_TIME_CHANGED, [this](const EventFwk::Want &want) {
313 NETMGR_LOG_I("COMMON_EVENT_TIME_CHANGED");
314 return ModifySysTimer();
315 });
316 subscriber_->RegisterStatsCallback(
317 EventFwk::CommonEventSupport::COMMON_EVENT_TIMEZONE_CHANGED, [this](const EventFwk::Want &want) -> bool {
318 NETMGR_LOG_I("COMMON_EVENT_TIMEZONE_CHANGED");
319 return ModifySysTimer();
320 });
321 }
322
UpdateNetStatusMap(uint8_t type,uint8_t value)323 bool NetStatsService::UpdateNetStatusMap(uint8_t type, uint8_t value)
324 {
325 int32_t ret = NetsysController::GetInstance().SetNetStatusMap(type, value);
326 if (ret != NETMANAGER_SUCCESS) {
327 return false;
328 }
329 return true;
330 }
331
InitPrivateUserId()332 void NetStatsService::InitPrivateUserId()
333 {
334 std::vector<AccountSA::OsAccountInfo> osAccountInfos;
335 AccountSA::OsAccountManager::QueryAllCreatedOsAccounts(osAccountInfos);
336 for (auto info : osAccountInfos) {
337 AccountSA::OsAccountType accountType;
338 AccountSA::OsAccountManager::GetOsAccountType(info.GetLocalId(), accountType);
339 NETMGR_LOG_I("InitPrivateUserId, info: %{public}d", info.GetLocalId());
340 if (accountType == AccountSA::OsAccountType::PRIVATE) {
341 netStatsCached_->SetCurPrivateUserId(info.GetLocalId());
342 }
343 }
344 int32_t defaultUserId = -1;
345 int32_t ret = AccountSA::OsAccountManager::GetDefaultActivatedOsAccount(defaultUserId);
346 NETMGR_LOG_I("default userId: %{public}d", defaultUserId);
347 netStatsCached_->SetCurDefaultUserId(defaultUserId);
348 }
349
ProcessOsAccountChanged(int32_t userId,AccountSA::OsAccountState state)350 int32_t NetStatsService::ProcessOsAccountChanged(int32_t userId, AccountSA::OsAccountState state)
351 {
352 NETMGR_LOG_I("OsAccountChanged toId: %{public}d, state:%{public}d", userId, state);
353 if (state == AccountSA::OsAccountState::CREATED) {
354 AccountSA::OsAccountType accountType;
355 AccountSA::OsAccountManager::GetOsAccountType(userId, accountType);
356 if (accountType == AccountSA::OsAccountType::PRIVATE) {
357 netStatsCached_->SetCurPrivateUserId(userId);
358 }
359 return 0;
360 }
361 if (state == AccountSA::OsAccountState::STOPPING || state == AccountSA::OsAccountState::STOPPED ||
362 state == AccountSA::OsAccountState::REMOVED) {
363 if (netStatsCached_->GetCurPrivateUserId() != userId) {
364 return 0;
365 }
366 netStatsCached_->SetCurPrivateUserId(-1); // -1:invalid userID
367 auto handler = std::make_unique<NetStatsDataHandler>();
368 if (handler == nullptr) {
369 NETMGR_LOG_E("handler is nullptr");
370 return static_cast<int32_t>(NETMANAGER_ERR_INTERNAL);
371 }
372 auto ret1 = handler->UpdateStatsFlagByUserId(userId, STATS_DATA_FLAG_UNINSTALLED);
373 if (ret1 != NETMANAGER_SUCCESS) {
374 NETMGR_LOG_E("update stats flag failed, uid:[%{public}d]", userId);
375 }
376 auto ret2 = handler->UpdateSimStatsFlagByUserId(userId, STATS_DATA_FLAG_UNINSTALLED);
377 if (ret2 != NETMANAGER_SUCCESS) {
378 NETMGR_LOG_E("update sim stats flag failed, uid:[%{public}d]", userId);
379 }
380 UpdateStatsData();
381 }
382 return 0;
383 }
384
GetDumpMessage(std::string & message)385 void NetStatsService::GetDumpMessage(std::string &message)
386 {
387 message.append("Net Stats Info:\n");
388 uint64_t rxBytes = 0;
389 uint64_t txBytes = 0;
390 uint64_t rxPackets = 0;
391 uint64_t txPackets = 0;
392 NetsysController::GetInstance().GetTotalStats(rxBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
393 NetsysController::GetInstance().GetTotalStats(txBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
394 NetsysController::GetInstance().GetTotalStats(rxPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_PACKETS));
395 NetsysController::GetInstance().GetTotalStats(txPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_PACKETS));
396
397 message.append("\tRxBytes: " + std::to_string(rxBytes) + "\n");
398 message.append("\tTxBytes: " + std::to_string(txBytes) + "\n");
399 message.append("\tRxPackets: " + std::to_string(rxPackets) + "\n");
400 message.append("\tTxPackets: " + std::to_string(txPackets) + "\n");
401 std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [&message, this](const auto &bearType) {
402 std::list<std::string> ifaceNames;
403 if (NetManagerCenter::GetInstance().GetIfaceNames(bearType, ifaceNames)) {
404 return;
405 }
406 uint64_t rx = 0;
407 uint64_t tx = 0;
408 for (const auto &name : ifaceNames) {
409 GetIfaceRxBytes(rx, name);
410 GetIfaceTxBytes(tx, name);
411 message.append("\t" + name + "-TxBytes: " + std::to_string(tx));
412 message.append("\t" + name + "-RxBytes: " + std::to_string(rx));
413 }
414 });
415 }
416
Init()417 bool NetStatsService::Init()
418 {
419 if (!REGISTER_LOCAL_RESULT) {
420 NETMGR_LOG_E("Register to local sa manager failed");
421 registerToService_ = false;
422 return false;
423 }
424 if (!registerToService_) {
425 #ifndef NETMANAGER_TEST
426 if (!Publish(DelayedSingleton<NetStatsService>::GetInstance().get())) {
427 NETMGR_LOG_E("Register to sa manager failed");
428 return false;
429 }
430 #endif
431 registerToService_ = true;
432 }
433 if (nullptr == netStatsCached_) {
434 return false;
435 }
436 netStatsCached_->SetCallbackManager(netStatsCallback_);
437 auto ret = netStatsCached_->StartCached();
438 if (ret != NETMANAGER_SUCCESS) {
439 NETMGR_LOG_E("Start cached failed");
440 return false;
441 }
442 AddSystemAbilityListener(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
443 uint64_t delay = DELAY_US / 2;
444 RefreshUidStatsFlag(delay);
445
446 #ifdef SUPPORT_TRAFFIC_STATISTIC
447 #ifndef UNITTEST_FORBID_FFRT
448 trafficTimer_ = std::make_unique<FfrtTimer>();
449 trafficTimer_->Start(DEFAULT_UPDATE_TRAFFIC_INFO_CYCLE_MS, [this]() { UpdateBpfMapTimer(); });
450 #endif
451 NetStatsRDB netStats;
452 netStats.InitRdbStore();
453 #endif // SUPPORT_TRAFFIC_STATISTIC
454 return true;
455 }
456
RegisterNetStatsCallback(const sptr<INetStatsCallback> & callback)457 int32_t NetStatsService::RegisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
458 {
459 NETMGR_LOG_I("Enter RegisterNetStatsCallback");
460 int32_t checkPermission = CheckNetManagerAvailable();
461 if (checkPermission != NETMANAGER_SUCCESS) {
462 return checkPermission;
463 }
464 if (callback == nullptr) {
465 NETMGR_LOG_E("RegisterNetStatsCallback parameter callback is null");
466 return NETMANAGER_ERR_PARAMETER_ERROR;
467 }
468 netStatsCallback_->RegisterNetStatsCallback(callback);
469 return NETMANAGER_SUCCESS;
470 }
471
UnregisterNetStatsCallback(const sptr<INetStatsCallback> & callback)472 int32_t NetStatsService::UnregisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
473 {
474 NETMGR_LOG_I("Enter UnregisterNetStatsCallback");
475 int32_t checkPermission = CheckNetManagerAvailable();
476 if (checkPermission != NETMANAGER_SUCCESS) {
477 return checkPermission;
478 }
479 if (callback == nullptr) {
480 NETMGR_LOG_E("UnregisterNetStatsCallback parameter callback is null");
481 return NETMANAGER_ERR_PARAMETER_ERROR;
482 }
483 netStatsCallback_->UnregisterNetStatsCallback(callback);
484 return NETMANAGER_SUCCESS;
485 }
486
GetIfaceRxBytes(uint64_t & stats,const std::string & interfaceName)487 int32_t NetStatsService::GetIfaceRxBytes(uint64_t &stats, const std::string &interfaceName)
488 {
489 return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
490 interfaceName);
491 }
492
GetIfaceTxBytes(uint64_t & stats,const std::string & interfaceName)493 int32_t NetStatsService::GetIfaceTxBytes(uint64_t &stats, const std::string &interfaceName)
494 {
495 return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
496 interfaceName);
497 }
498
GetCellularRxBytes(uint64_t & stats)499 int32_t NetStatsService::GetCellularRxBytes(uint64_t &stats)
500 {
501 std::list<std::string> ifaceNames;
502 if (!GetIfaceNamesFromManager(ifaceNames)) {
503 return STATS_ERR_GET_IFACE_NAME_FAILED;
504 }
505
506 for (const auto &name : ifaceNames) {
507 uint64_t totalCellular = 0;
508 auto ret = NetsysController::GetInstance().GetIfaceStats(
509 totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES), name);
510 if (ret != NETMANAGER_SUCCESS) {
511 NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
512 return ret;
513 }
514 stats += totalCellular;
515 }
516 return NETMANAGER_SUCCESS;
517 }
518
GetCellularTxBytes(uint64_t & stats)519 int32_t NetStatsService::GetCellularTxBytes(uint64_t &stats)
520 {
521 std::list<std::string> ifaceNames;
522 if (!GetIfaceNamesFromManager(ifaceNames)) {
523 return STATS_ERR_GET_IFACE_NAME_FAILED;
524 }
525
526 uint64_t totalCellular = 0;
527 for (const auto &name : ifaceNames) {
528 auto ret = NetsysController::GetInstance().GetIfaceStats(
529 totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES), name);
530 if (ret != NETMANAGER_SUCCESS) {
531 NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
532 return ret;
533 }
534 stats += totalCellular;
535 }
536 return NETMANAGER_SUCCESS;
537 }
538
GetAllRxBytes(uint64_t & stats)539 int32_t NetStatsService::GetAllRxBytes(uint64_t &stats)
540 {
541 NETMGR_LOG_D("Enter GetAllRxBytes");
542 return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
543 }
544
GetAllTxBytes(uint64_t & stats)545 int32_t NetStatsService::GetAllTxBytes(uint64_t &stats)
546 {
547 NETMGR_LOG_D("Enter GetAllTxBytes");
548 return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
549 }
550
GetUidRxBytes(uint64_t & stats,uint32_t uid)551 int32_t NetStatsService::GetUidRxBytes(uint64_t &stats, uint32_t uid)
552 {
553 NETMGR_LOG_D("Enter GetUidRxBytes, uid is %{public}d", uid);
554 return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
555 uid);
556 }
557
GetUidTxBytes(uint64_t & stats,uint32_t uid)558 int32_t NetStatsService::GetUidTxBytes(uint64_t &stats, uint32_t uid)
559 {
560 NETMGR_LOG_D("Enter GetUidTxBytes,uid is %{public}d", uid);
561 return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
562 uid);
563 }
564
GetIfaceStatsDetail(const std::string & iface,uint64_t start,uint64_t end,NetStatsInfo & statsInfo)565 int32_t NetStatsService::GetIfaceStatsDetail(const std::string &iface, uint64_t start, uint64_t end,
566 NetStatsInfo &statsInfo)
567 {
568 // Start of get traffic data by interface name.
569 NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s", iface.c_str());
570 int32_t checkPermission = CheckNetManagerAvailable();
571 if (checkPermission != NETMANAGER_SUCCESS) {
572 return checkPermission;
573 }
574 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail start");
575 if (start > end) {
576 NETMGR_LOG_E("start is after end.");
577 return NETMANAGER_ERR_INVALID_PARAMETER;
578 }
579 std::vector<NetStatsInfo> allInfo;
580 auto history = std::make_unique<NetStatsHistory>();
581 int32_t ret = history->GetHistory(allInfo, iface, start, end);
582
583 if (netStatsCached_ == nullptr) {
584 NETMGR_LOG_E("netStatsCached_ is fail");
585 return NETMANAGER_ERR_LOCAL_PTR_NULL;
586 }
587 netStatsCached_->GetIfaceStatsCached(allInfo);
588 if (ret != NETMANAGER_SUCCESS) {
589 NETMGR_LOG_E("Get traffic stats data failed");
590 return ret;
591 }
592 std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &start, &end](const auto &info) {
593 if (info.iface_ == iface && info.date_ >= start && info.date_ <= end) {
594 statsInfo += info;
595 }
596 });
597 statsInfo.iface_ = iface;
598 statsInfo.date_ = end;
599 // End of get traffic data by interface name.
600 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail end");
601 return NETMANAGER_SUCCESS;
602 }
603
GetUidStatsDetail(const std::string & iface,uint32_t uid,uint64_t start,uint64_t end,NetStatsInfo & statsInfo)604 int32_t NetStatsService::GetUidStatsDetail(const std::string &iface, uint32_t uid, uint64_t start, uint64_t end,
605 NetStatsInfo &statsInfo)
606 {
607 // Start of get traffic data by usr id.
608 NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s uid= %{public}d", iface.c_str(), uid);
609 int32_t checkPermission = CheckNetManagerAvailable();
610 if (checkPermission != NETMANAGER_SUCCESS) {
611 return checkPermission;
612 }
613 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetUidStatsDetail start");
614 if (start > end) {
615 NETMGR_LOG_E("start is after end.");
616 return NETMANAGER_ERR_INVALID_PARAMETER;
617 }
618 std::vector<NetStatsInfo> allInfo;
619 auto history = std::make_unique<NetStatsHistory>();
620 int32_t ret = history->GetHistory(allInfo, iface, uid, start, end);
621 if (netStatsCached_ == nullptr) {
622 NETMGR_LOG_E("netStatsCached_ is fail");
623 return NETMANAGER_ERR_LOCAL_PTR_NULL;
624 }
625 netStatsCached_->GetUidStatsCached(allInfo);
626 if (ret != NETMANAGER_SUCCESS) {
627 NETMGR_LOG_E("Get traffic stats data failed");
628 return ret;
629 }
630 std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &uid, &start, &end](const auto &info) {
631 if (info.iface_ == iface && info.uid_ == uid && info.date_ >= start && info.date_ <= end) {
632 statsInfo += info;
633 }
634 });
635 statsInfo.uid_ = uid;
636 statsInfo.iface_ = iface;
637 statsInfo.date_ = end;
638 // End of get traffic data by usr id.
639 NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService GetUidStatsDetail end");
640 return NETMANAGER_SUCCESS;
641 }
642
UpdateIfacesStats(const std::string & iface,uint64_t start,uint64_t end,const NetStatsInfo & stats)643 int32_t NetStatsService::UpdateIfacesStats(const std::string &iface, uint64_t start, uint64_t end,
644 const NetStatsInfo &stats)
645 {
646 // Start of update traffic data by date.
647 NETMGR_LOG_I("UpdateIfacesStats ifaces is %{public}s", iface.c_str());
648 int32_t checkPermission = CheckNetManagerAvailable();
649 if (checkPermission != NETMANAGER_SUCCESS) {
650 return checkPermission;
651 }
652 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService UpdateIfacesStats start");
653 if (start > end) {
654 NETMGR_LOG_E("start is after end.");
655 return NETMANAGER_ERR_INVALID_PARAMETER;
656 }
657 std::vector<NetStatsInfo> infos;
658 infos.push_back(stats);
659 auto handler = std::make_unique<NetStatsDataHandler>();
660 auto ret = handler->DeleteByDate(IFACE_TABLE, start, end);
661 if (ret != NETMANAGER_SUCCESS) {
662 NETMGR_LOG_E("Update ifaces stats failed");
663 }
664 ret = handler->WriteStatsData(infos, IFACE_TABLE);
665 if (ret != NETMANAGER_SUCCESS) {
666 NETMGR_LOG_E("Update ifaces stats failed");
667 return STATS_ERR_WRITE_DATA_FAIL;
668 }
669 // End of update traffic data by date.
670 NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService UpdateIfacesStats end");
671 return ret;
672 }
673
UpdateStatsData()674 int32_t NetStatsService::UpdateStatsData()
675 {
676 NETMGR_LOG_I("Enter UpdateStatsData.");
677 if (!NetManagerPermission::IsSystemCaller()) {
678 return NETMANAGER_ERR_NOT_SYSTEM_CALL;
679 }
680 if (!NetManagerPermission::CheckPermission(Permission::CONNECTIVITY_INTERNAL)) {
681 return NETMANAGER_ERR_PERMISSION_DENIED;
682 }
683 if (netStatsCached_ == nullptr) {
684 NETMGR_LOG_E("Cached is nullptr");
685 return NETMANAGER_ERR_LOCAL_PTR_NULL;
686 }
687 netStatsCached_->ForceUpdateStats();
688 NETMGR_LOG_D("End UpdateStatsData.");
689 return NETMANAGER_SUCCESS;
690 }
691
UpdateStatsDataInner()692 int32_t NetStatsService::UpdateStatsDataInner()
693 {
694 NETMGR_LOG_I("Enter UpdateStatsDataInner.");
695 if (netStatsCached_ == nullptr) {
696 NETMGR_LOG_E("Cached is nullptr");
697 return NETMANAGER_ERR_LOCAL_PTR_NULL;
698 }
699 netStatsCached_->ForceUpdateStats();
700 NETMGR_LOG_I("End UpdateStatsDataInner.");
701 return NETMANAGER_SUCCESS;
702 }
703
ResetFactory()704 int32_t NetStatsService::ResetFactory()
705 {
706 int32_t checkPermission = CheckNetManagerAvailable();
707 if (checkPermission != NETMANAGER_SUCCESS) {
708 return checkPermission;
709 }
710 auto handler = std::make_unique<NetStatsDataHandler>();
711 return handler->ClearData();
712 }
713
GetAllStatsInfo(std::vector<NetStatsInfo> & infos)714 int32_t NetStatsService::GetAllStatsInfo(std::vector<NetStatsInfo> &infos)
715 {
716 NETMGR_LOG_D("Enter GetAllStatsInfo.");
717 int32_t checkPermission = CheckNetManagerAvailable();
718 if (checkPermission != NETMANAGER_SUCCESS) {
719 return checkPermission;
720 }
721 if (netStatsCached_ != nullptr) {
722 netStatsCached_->GetUidPushStatsCached(infos);
723 netStatsCached_->GetAllPushStatsCached(infos);
724 } else {
725 NETMGR_LOG_E("Cached is nullptr");
726 }
727 return NetsysController::GetInstance().GetAllStatsInfo(infos);
728 }
729
GetAllSimStatsInfo(std::vector<NetStatsInfo> & infos)730 int32_t NetStatsService::GetAllSimStatsInfo(std::vector<NetStatsInfo> &infos)
731 {
732 NETMGR_LOG_D("Enter GetAllSimStatsInfo.");
733 int32_t checkPermission = CheckNetManagerAvailable();
734 if (checkPermission != NETMANAGER_SUCCESS) {
735 return checkPermission;
736 }
737 return NetsysController::GetInstance().GetAllSimStatsInfo(infos);
738 }
739
740 #ifdef SUPPORT_NETWORK_SHARE
IsSharingOn()741 bool NetStatsService::IsSharingOn()
742 {
743 int32_t share = 0;
744 int ret = DelayedSingleton<NetManagerStandard::NetworkShareClient>::GetInstance()->IsSharing(share);
745 if (ret != NETMANAGER_EXT_SUCCESS) {
746 NETMGR_LOG_E("get sharing state res: %{public}d, isSharing: %{public}d", ret, share);
747 return false;
748 }
749 return share == NetManagerStandard::NETWORKSHARE_IS_SHARING;
750 }
751
GetSharingStats(std::vector<NetStatsInfo> & sharingStats,uint32_t endtime)752 void NetStatsService::GetSharingStats(std::vector<NetStatsInfo> &sharingStats, uint32_t endtime)
753 {
754 if (endtime > netStatsCached_->GetWriteDateTime()) {
755 // 跑在非ipc线程防止鉴权失败
756 bool isSharingOn = false;
757 auto task = ffrt::submit_h([&isSharingOn, this]() { isSharingOn = NetStatsService::IsSharingOn(); }, {}, {},
758 ffrt::task_attr().name("isSharingOn"));
759 ffrt::wait({task});
760 if (isSharingOn) {
761 NETMGR_LOG_D("GetSharingStats enter");
762 netStatsCached_->GetIptablesStatsCached(sharingStats);
763 }
764 }
765 }
766 #endif
767
GetTrafficStatsByNetwork(std::unordered_map<uint32_t,NetStatsInfo> & infos,const NetStatsNetwork & networkIpc)768 int32_t NetStatsService::GetTrafficStatsByNetwork(std::unordered_map<uint32_t, NetStatsInfo> &infos,
769 const NetStatsNetwork &networkIpc)
770 {
771 NETMGR_LOG_D("Enter GetTrafficStatsByNetwork.");
772 int32_t checkPermission = CheckNetManagerAvailable();
773 if (checkPermission != NETMANAGER_SUCCESS) {
774 return checkPermission;
775 }
776 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork start");
777 if (netStatsCached_ == nullptr) {
778 return NETMANAGER_ERR_LOCAL_PTR_NULL;
779 }
780 sptr<NetStatsNetwork> network = new (std::nothrow) NetStatsNetwork(networkIpc);
781 if (network == nullptr) {
782 NETMGR_LOG_E("param network is nullptr");
783 return NETMANAGER_ERR_LOCAL_PTR_NULL;
784 }
785 std::string ident;
786 if (network->type_ == 0) {
787 ident = std::to_string(network->simId_);
788 }
789 uint32_t start = network->startTime_;
790 uint32_t end = network->endTime_;
791 NETMGR_LOG_D("param: ident=%{public}s, start=%{public}u, end=%{public}u", ident.c_str(), start, end);
792 auto history = std::make_unique<NetStatsHistory>();
793 if (history == nullptr) {
794 NETMGR_LOG_E("history is null");
795 return NETMANAGER_ERR_INTERNAL;
796 }
797 std::vector<NetStatsInfo> allInfo;
798 int32_t ret = history->GetHistoryByIdent(allInfo, ident, start, end);
799 if (ret != NETMANAGER_SUCCESS) {
800 NETMGR_LOG_E("get history by ident failed, err code=%{public}d", ret);
801 return ret;
802 }
803 netStatsCached_->GetKernelStats(allInfo);
804 netStatsCached_->GetUidPushStatsCached(allInfo);
805 netStatsCached_->GetUidStatsCached(allInfo);
806 netStatsCached_->GetUidSimStatsCached(allInfo);
807 #ifdef SUPPORT_NETWORK_SHARE
808 GetSharingStats(allInfo, end);
809 #endif
810 MergeTrafficStatsByAccount(allInfo);
811 FilterTrafficStatsByNetwork(allInfo, infos, ident, start, end);
812 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork end");
813 return NETMANAGER_SUCCESS;
814 }
815
FilterTrafficStatsByNetwork(std::vector<NetStatsInfo> & allInfo,std::unordered_map<uint32_t,NetStatsInfo> & infos,const std::string ident,uint32_t startTime,uint32_t endTime)816 void NetStatsService::FilterTrafficStatsByNetwork(std::vector<NetStatsInfo> &allInfo,
817 std::unordered_map<uint32_t, NetStatsInfo> &infos,
818 const std::string ident, uint32_t startTime, uint32_t endTime)
819 {
820 std::for_each(allInfo.begin(), allInfo.end(), [&infos, &ident, &startTime, &endTime](NetStatsInfo &info) {
821 if (ident != info.ident_ || startTime > info.date_ || endTime < info.date_) {
822 return;
823 }
824 if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
825 info.uid_ = UNINSTALLED_UID;
826 }
827 auto item = infos.find(info.uid_);
828 if (item == infos.end()) {
829 infos.emplace(info.uid_, info);
830 } else {
831 item->second += info;
832 }
833 });
834 }
835
MergeTrafficStatsByAccount(std::vector<NetStatsInfo> & infos)836 void NetStatsService::MergeTrafficStatsByAccount(std::vector<NetStatsInfo> &infos)
837 {
838 int32_t curUserId = -1;
839 int32_t ret = AccountSA::OsAccountManager::GetForegroundOsAccountLocalId(curUserId);
840 int32_t defaultUserId = netStatsCached_->GetCurDefaultUserId();
841 if (ret != 0) {
842 NETMGR_LOG_E("get userId error. ret1: %{public}d", ret);
843 }
844
845 if (curUserId == defaultUserId) {
846 for (auto &info : infos) {
847 if (info.userId_ == netStatsCached_->GetCurPrivateUserId()) {
848 info.uid_ = OTHER_ACCOUNT_UID;
849 }
850 }
851 } else if (curUserId == netStatsCached_->GetCurPrivateUserId()) {
852 for (auto &info : infos) {
853 if (info.userId_ != curUserId) {
854 info.uid_ = DEFAULT_ACCOUNT_UID;
855 }
856 }
857 } else {
858 NETMGR_LOG_W("curUserId:%{public}d, defaultUserId:%{public}d", curUserId, defaultUserId);
859 }
860 }
861
GetHistoryData(std::vector<NetStatsInfo> & infos,std::string ident,uint32_t uid,uint32_t start,uint32_t end)862 int32_t NetStatsService::GetHistoryData(std::vector<NetStatsInfo> &infos, std::string ident,
863 uint32_t uid, uint32_t start, uint32_t end)
864 {
865 auto history = std::make_unique<NetStatsHistory>();
866 if (history == nullptr) {
867 NETMGR_LOG_E("history is null");
868 return NETMANAGER_ERR_INTERNAL;
869 }
870 if (uid != DEFAULT_ACCOUNT_UID && uid != OTHER_ACCOUNT_UID) {
871 int32_t ret = history->GetHistory(infos, uid, ident, start, end);
872 return ret;
873 }
874 int32_t userId = -1;
875 if (uid == DEFAULT_ACCOUNT_UID) {
876 userId = netStatsCached_->GetCurDefaultUserId();
877 std::vector<NetStatsInfo> infos1;
878 std::vector<NetStatsInfo> infos2;
879 history->GetHistoryByIdentAndUserId(infos1, ident, userId, start, end);
880 history->GetHistoryByIdentAndUserId(infos2, ident, SYSTEM_DEFAULT_USERID, start, end);
881 infos.insert(infos.end(), infos1.begin(), infos1.end());
882 infos.insert(infos.end(), infos2.begin(), infos2.end());
883 } else if (netStatsCached_->GetCurPrivateUserId() != -1) {
884 userId = netStatsCached_->GetCurPrivateUserId();
885 history->GetHistoryByIdentAndUserId(infos, ident, userId, start, end);
886 }
887 if (userId == -1) {
888 NETMGR_LOG_E("GetHistoryData error. uid:%{public}u, curPrivateUserId: %{public}d",
889 uid, netStatsCached_->GetCurPrivateUserId());
890 return NETMANAGER_ERROR;
891 }
892 return NETMANAGER_SUCCESS;
893 }
894
GetTrafficStatsByUidNetwork(std::vector<NetStatsInfoSequence> & infos,uint32_t uid,const NetStatsNetwork & networkIpc)895 int32_t NetStatsService::GetTrafficStatsByUidNetwork(std::vector<NetStatsInfoSequence> &infos, uint32_t uid,
896 const NetStatsNetwork &networkIpc)
897 {
898 NETMGR_LOG_D("Enter GetTrafficStatsByUidNetwork.");
899 int32_t checkPermission = CheckNetManagerAvailable();
900 if (checkPermission != NETMANAGER_SUCCESS) {
901 return checkPermission;
902 }
903 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork start");
904 if (netStatsCached_ == nullptr) {
905 NETMGR_LOG_E("Cached is nullptr");
906 return NETMANAGER_ERR_LOCAL_PTR_NULL;
907 }
908 sptr<NetStatsNetwork> network = new (std::nothrow) NetStatsNetwork(networkIpc);
909 if (network == nullptr) {
910 NETMGR_LOG_E("param network is nullptr");
911 return NETMANAGER_ERR_LOCAL_PTR_NULL;
912 }
913 std::string ident;
914 if (network->type_ == 0) {
915 ident = std::to_string(network->simId_);
916 }
917 uint32_t start = network->startTime_;
918 uint32_t end = network->endTime_;
919 NETMGR_LOG_D("GetTrafficStatsByUidNetwork param: "
920 "uid=%{public}u, ident=%{public}s, start=%{public}u, end=%{public}u", uid, ident.c_str(), start, end);
921
922 std::vector<NetStatsInfo> allInfo;
923 int32_t ret = GetHistoryData(allInfo, ident, uid, start, end);
924 if (ret != NETMANAGER_SUCCESS) {
925 NETMGR_LOG_E("get history by uid and ident failed, err code=%{public}d", ret);
926 return ret;
927 }
928
929 netStatsCached_->GetKernelStats(allInfo);
930 netStatsCached_->GetUidPushStatsCached(allInfo);
931 netStatsCached_->GetUidStatsCached(allInfo);
932 netStatsCached_->GetUidSimStatsCached(allInfo);
933 #ifdef SUPPORT_NETWORK_SHARE
934 if (uid == IPTABLES_UID) {
935 GetSharingStats(allInfo, end);
936 }
937 #endif
938 FilterTrafficStatsByUidNetwork(allInfo, infos, uid, ident, start, end);
939 DeleteTrafficStatsByAccount(infos, uid);
940 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork end");
941 return NETMANAGER_SUCCESS;
942 }
943
DeleteTrafficStatsByAccount(std::vector<NetStatsInfoSequence> & infos,uint32_t uid)944 void NetStatsService::DeleteTrafficStatsByAccount(std::vector<NetStatsInfoSequence> &infos, uint32_t uid)
945 {
946 int32_t defaultUserId = netStatsCached_->GetCurDefaultUserId();
947 if (uid == DEFAULT_ACCOUNT_UID) {
948 for (auto it = infos.begin(); it != infos.end();) {
949 if (it->info_.userId_ != defaultUserId && it->info_.userId_ != SYSTEM_DEFAULT_USERID) {
950 it = infos.erase(it);
951 } else {
952 ++it;
953 }
954 }
955 } else if (uid == OTHER_ACCOUNT_UID) {
956 for (auto it = infos.begin(); it != infos.end();) {
957 if (it->info_.userId_ == defaultUserId || it->info_.userId_ == SYSTEM_DEFAULT_USERID) {
958 it = infos.erase(it);
959 } else {
960 ++it;
961 }
962 }
963 }
964 }
965
FilterTrafficStatsByUidNetwork(std::vector<NetStatsInfo> & allInfo,std::vector<NetStatsInfoSequence> & infos,const uint32_t uid,const std::string ident,uint32_t startTime,uint32_t endTime)966 void NetStatsService::FilterTrafficStatsByUidNetwork(std::vector<NetStatsInfo> &allInfo,
967 std::vector<NetStatsInfoSequence> &infos, const uint32_t uid,
968 const std::string ident, uint32_t startTime, uint32_t endTime)
969 {
970 std::for_each(allInfo.begin(), allInfo.end(),
971 [this, &infos, &uid, &ident, &startTime, &endTime](const NetStatsInfo &info) {
972 if (uid != DEFAULT_ACCOUNT_UID && uid != OTHER_ACCOUNT_UID && uid != info.uid_) {
973 return;
974 }
975
976 if (ident != info.ident_ || startTime > info.date_ || endTime < info.date_) {
977 return;
978 }
979 if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
980 return;
981 }
982 MergeTrafficStats(infos, info, endTime);
983 });
984 }
985
SetAppStats(const PushStatsInfo & info)986 int32_t NetStatsService::SetAppStats(const PushStatsInfo &info)
987 {
988 NETMGR_LOG_D("Enter SetAppStats.");
989 int32_t checkPermission = CheckNetManagerAvailable();
990 if (checkPermission != NETMANAGER_SUCCESS) {
991 return checkPermission;
992 }
993 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats start");
994 if (netStatsCached_ == nullptr) {
995 NETMGR_LOG_E("Cached is nullptr");
996 return NETMANAGER_ERR_LOCAL_PTR_NULL;
997 }
998 netStatsCached_->SetAppStats(info);
999 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats end");
1000 return NETMANAGER_SUCCESS;
1001 }
1002
SaveSharingTraffic(const NetStatsInfo & infos)1003 int32_t NetStatsService::SaveSharingTraffic(const NetStatsInfo &infos)
1004 {
1005 NETMGR_LOG_D("Enter SaveSharingTraffic");
1006 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SaveSharingTraffic start");
1007 if (netStatsCached_ == nullptr) {
1008 NETMGR_LOG_E("Cached is nullptr");
1009 return NETMANAGER_ERR_LOCAL_PTR_NULL;
1010 }
1011 netStatsCached_->SaveSharingTraffic(infos);
1012 NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SaveSharingTraffic end");
1013 return NETMANAGER_SUCCESS;
1014 }
1015
GetCookieRxBytes(uint64_t & stats,uint64_t cookie)1016 int32_t NetStatsService::GetCookieRxBytes(uint64_t &stats, uint64_t cookie)
1017 {
1018 return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
1019 cookie);
1020 }
1021
GetCookieTxBytes(uint64_t & stats,uint64_t cookie)1022 int32_t NetStatsService::GetCookieTxBytes(uint64_t &stats, uint64_t cookie)
1023 {
1024 return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
1025 cookie);
1026 }
1027
MergeTrafficStats(std::vector<NetStatsInfoSequence> & statsInfoSequences,const NetStatsInfo & info,uint32_t currentTimestamp)1028 void NetStatsService::MergeTrafficStats(std::vector<NetStatsInfoSequence> &statsInfoSequences, const NetStatsInfo &info,
1029 uint32_t currentTimestamp)
1030 {
1031 NetStatsInfoSequence tmp;
1032 tmp.startTime_ = info.date_;
1033 tmp.endTime_ = info.date_;
1034 tmp.info_ = info;
1035 uint32_t previousTimestamp = currentTimestamp > DAY_SECONDS ? currentTimestamp - DAY_SECONDS : 0;
1036 if (info.date_ > previousTimestamp) {
1037 statsInfoSequences.push_back(std::move(tmp));
1038 return;
1039 }
1040 auto findRet = std::find_if(
1041 statsInfoSequences.begin(), statsInfoSequences.end(), [&info, previousTimestamp](const auto &item) {
1042 return item.endTime_ < previousTimestamp && CommonUtils::IsSameNaturalDay(info.date_, item.endTime_);
1043 });
1044 if (findRet == statsInfoSequences.end()) {
1045 statsInfoSequences.push_back(std::move(tmp));
1046 return;
1047 }
1048 (*findRet).info_ += info;
1049 }
1050
GetIfaceNamesFromManager(std::list<std::string> & ifaceNames)1051 bool NetStatsService::GetIfaceNamesFromManager(std::list<std::string> &ifaceNames)
1052 {
1053 int32_t ret = NetManagerCenter::GetInstance().GetIfaceNames(BEARER_CELLULAR, ifaceNames);
1054 if (ret != NETMANAGER_SUCCESS || ifaceNames.empty()) {
1055 NETMGR_LOG_D("Iface list is empty, ret = %{public}d", ret);
1056 return false;
1057 }
1058 ifaceNames.sort();
1059 ifaceNames.erase(std::unique(ifaceNames.begin(), ifaceNames.end()), ifaceNames.end());
1060 return true;
1061 }
1062
GetSampleBundleInfosForActiveUser()1063 std::unordered_map<uint32_t, SampleBundleInfo> NetStatsService::GetSampleBundleInfosForActiveUser()
1064 {
1065 void *handler = dlopen(LIB_NET_BUNDLE_UTILS_PATH.c_str(), RTLD_LAZY | RTLD_NODELETE);
1066 if (handler == nullptr) {
1067 NETMGR_LOG_E("load lib failed, reason : %{public}s", dlerror());
1068 return std::unordered_map<uint32_t, SampleBundleInfo>{};
1069 }
1070 using GetNetBundleClass = INetBundle *(*)();
1071 auto getNetBundle = (GetNetBundleClass)dlsym(handler, "GetNetBundle");
1072 if (getNetBundle == nullptr) {
1073 NETMGR_LOG_E("GetNetBundle failed, reason : %{public}s", dlerror());
1074 dlclose(handler);
1075 return std::unordered_map<uint32_t, SampleBundleInfo>{};
1076 }
1077 auto netBundle = getNetBundle();
1078 if (netBundle == nullptr) {
1079 NETMGR_LOG_E("netBundle is nullptr");
1080 dlclose(handler);
1081 return std::unordered_map<uint32_t, SampleBundleInfo>{};
1082 }
1083 std::optional<std::unordered_map<uint32_t, SampleBundleInfo>> result = netBundle->ObtainBundleInfoForActive();
1084 dlclose(handler);
1085 if (!result.has_value()) {
1086 NETMGR_LOG_W("ObtainBundleInfoForActive is nullopt");
1087 return std::unordered_map<uint32_t, SampleBundleInfo>{};
1088 }
1089 return result.value();
1090 }
1091
GetSampleBundleInfoForUid(uint32_t uid)1092 SampleBundleInfo NetStatsService::GetSampleBundleInfoForUid(uint32_t uid)
1093 {
1094 void *handler = dlopen(LIB_NET_BUNDLE_UTILS_PATH.c_str(), RTLD_LAZY | RTLD_NODELETE);
1095 if (handler == nullptr) {
1096 NETMGR_LOG_E("load lib failed, reason : %{public}s", dlerror());
1097 return SampleBundleInfo{};
1098 }
1099 using GetNetBundleClass = INetBundle *(*)();
1100 auto getNetBundle = (GetNetBundleClass)dlsym(handler, "GetNetBundle");
1101 if (getNetBundle == nullptr) {
1102 NETMGR_LOG_E("GetNetBundle failed, reason : %{public}s", dlerror());
1103 dlclose(handler);
1104 return SampleBundleInfo{};
1105 }
1106 auto netBundle = getNetBundle();
1107 if (netBundle == nullptr) {
1108 NETMGR_LOG_E("netBundle is nullptr");
1109 dlclose(handler);
1110 return SampleBundleInfo{};
1111 }
1112 std::optional<SampleBundleInfo> result = netBundle->ObtainBundleInfoForUid(uid);
1113 dlclose(handler);
1114 if (!result.has_value()) {
1115 NETMGR_LOG_W("ObtainBundleInfoForUid is nullopt");
1116 return SampleBundleInfo{};
1117 }
1118 return result.value();
1119 }
1120
RefreshUidStatsFlag(uint64_t delay)1121 void NetStatsService::RefreshUidStatsFlag(uint64_t delay)
1122 {
1123 std::function<void()> uidInstallSourceFunc = [this]() {
1124 auto tmp = GetSampleBundleInfosForActiveUser();
1125 for (auto iter = tmp.begin(); iter != tmp.end(); ++iter) {
1126 if (CommonUtils::IsSim(iter->second.bundleName_) ||
1127 CommonUtils::IsSim2(iter->second.bundleName_)) {
1128 netStatsCached_->SetUidSimSampleBundle(iter->first, iter->second);
1129 }
1130 }
1131 netStatsCached_->ClearUidStatsFlag();
1132 netStatsCached_->SetUidStatsFlag(tmp);
1133 };
1134 ffrt::submit(std::move(uidInstallSourceFunc), {}, {}, ffrt::task_attr().name("RefreshUidStatsFlag").delay(delay));
1135 }
1136
CommonEventPackageAdded(uint32_t uid)1137 bool NetStatsService::CommonEventPackageAdded(uint32_t uid)
1138 {
1139 SampleBundleInfo sampleBundleInfo = GetSampleBundleInfoForUid(uid);
1140 if (CommonUtils::IsSim(sampleBundleInfo.bundleName_) ||
1141 CommonUtils::IsSim2(sampleBundleInfo.bundleName_)) {
1142 uint64_t delay = 0;
1143 if (netStatsCached_->GetUidSimSampleBundlesSize() == 0) {
1144 delay = DELAY_US;
1145 netStatsCached_->ForceCachedStats();
1146 }
1147 RefreshUidStatsFlag(delay);
1148 } else {
1149 std::unordered_map<uint32_t, SampleBundleInfo> tmp{{uid, sampleBundleInfo}};
1150 netStatsCached_->SetUidStatsFlag(tmp);
1151 }
1152 return true;
1153 }
1154
CommonEventPackageRemoved(uint32_t uid)1155 bool NetStatsService::CommonEventPackageRemoved(uint32_t uid)
1156 {
1157 if (static_cast<int32_t>(uid / USER_ID_DIVIDOR) != netStatsCached_->GetCurDefaultUserId() &&
1158 uid / USER_ID_DIVIDOR != SYSTEM_DEFAULT_USERID &&
1159 static_cast<int32_t>(uid / USER_ID_DIVIDOR) != netStatsCached_->GetCurPrivateUserId()) {
1160 NETMGR_LOG_E("CommonEventPackageRemoved uid:%{public}d", uid);
1161 return true;
1162 }
1163 auto handler = std::make_unique<NetStatsDataHandler>();
1164 if (handler == nullptr) {
1165 NETMGR_LOG_E("Net Manager package removed, get db handler failed. uid:[%{public}d]", uid);
1166 return static_cast<int32_t>(NETMANAGER_ERR_INTERNAL);
1167 }
1168 auto ret1 = handler->UpdateStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
1169 if (ret1 != NETMANAGER_SUCCESS) {
1170 NETMGR_LOG_E("Net Manager update stats flag failed, uid:[%{public}d]", uid);
1171 }
1172 auto ret2 = handler->UpdateSimStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
1173 if (ret2 != NETMANAGER_SUCCESS) {
1174 NETMGR_LOG_E("Net Manager update sim stats flag failed, uid:[%{public}d]", uid);
1175 }
1176 auto ffrtHandle = netStatsCached_->ForceArchiveStats(uid);
1177 if (netStatsCached_->GetUidSimSampleBundle(uid).has_value()) {
1178 ffrt::wait({ffrtHandle});
1179 RefreshUidStatsFlag(0);
1180 }
1181 return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
1182 }
1183
CheckNetManagerAvailable()1184 int32_t NetStatsService::CheckNetManagerAvailable()
1185 {
1186 if (!NetManagerPermission::IsSystemCaller()) {
1187 NETMGR_LOG_E("Permission check failed.");
1188 return NETMANAGER_ERR_NOT_SYSTEM_CALL;
1189 }
1190 if (!NetManagerPermission::CheckPermission(Permission::GET_NETWORK_STATS)) {
1191 return NETMANAGER_ERR_PERMISSION_DENIED;
1192 }
1193 return NETMANAGER_SUCCESS;
1194 }
1195
StartAccountObserver()1196 void NetStatsService::StartAccountObserver()
1197 {
1198 NETMGR_LOG_I("StartAccountObserver start");
1199 std::set<AccountSA::OsAccountState> states = {
1200 AccountSA::OsAccountState::STOPPING, AccountSA::OsAccountState::CREATED,
1201 AccountSA::OsAccountState::SWITCHING, AccountSA::OsAccountState::SWITCHED, AccountSA::OsAccountState::UNLOCKED,
1202 AccountSA::OsAccountState::STOPPED, AccountSA::OsAccountState::REMOVED };
1203 bool withHandShake = false;
1204 AccountSA::OsAccountSubscribeInfo subscribeInfo(states, withHandShake);
1205 accountSubscriber_ = std::make_shared<NetStatsAccountSubscriber>(subscribeInfo);
1206 ErrCode errCode = AccountSA::OsAccountManager::SubscribeOsAccount(accountSubscriber_);
1207 if (errCode != 0) {
1208 NETMGR_LOG_E("SubscribeOsAccount error. errCode:%{public}d", errCode);
1209 }
1210 NETMGR_LOG_I("StartAccountObserver end");
1211 }
1212
1213 #ifdef SUPPORT_TRAFFIC_STATISTIC
UpdateBpfMapTimer()1214 void NetStatsService::UpdateBpfMapTimer()
1215 {
1216 NETMGR_LOG_I("UpdateBpfMapTimer start");
1217 if (!trafficPlanFfrtQueue_) {
1218 NETMGR_LOG_E("FFRT Init Fail");
1219 return;
1220 }
1221 #ifndef UNITTEST_FORBID_FFRT
1222 trafficPlanFfrtQueue_->submit([this]() {
1223 #endif
1224 int32_t primarySlotId = NetStatsUtils::GetPrimarySlotId();
1225 int32_t primarySimId = Telephony::CoreServiceClient::GetInstance().GetSimId(primarySlotId);
1226 int slaveSlotId = primarySlotId == 0 ? 1 : 0;
1227 int32_t slaveSimId = Telephony::CoreServiceClient::GetInstance().GetSimId(slaveSlotId);
1228 UpdateBpfMap(primarySimId);
1229 UpdateBpfMap(slaveSimId);
1230 #ifndef UNITTEST_FORBID_FFRT
1231 });
1232 #endif
1233 }
1234
CommonEventSimStateChanged(int32_t slotId,int32_t simState)1235 bool NetStatsService::CommonEventSimStateChanged(int32_t slotId, int32_t simState)
1236 {
1237 if (!trafficPlanFfrtQueue_) {
1238 NETMGR_LOG_E("FFRT Init Fail");
1239 return false;
1240 }
1241 #ifndef UNITTEST_FORBID_FFRT
1242 trafficPlanFfrtQueue_->submit([this, slotId, simState]() {
1243 #endif
1244 CommonEventSimStateChangedFfrt(slotId, simState);
1245 #ifndef UNITTEST_FORBID_FFRT
1246 });
1247 #endif
1248 return true;
1249 }
1250
CommonEventSimStateChangedFfrt(int32_t slotId,int32_t simState)1251 bool NetStatsService::CommonEventSimStateChangedFfrt(int32_t slotId, int32_t simState)
1252 {
1253 int32_t simId = Telephony::CoreServiceClient::GetInstance().GetSimId(slotId);
1254 NETMGR_LOG_I("CommonEventSimStateChanged simId: %{public}d, slotId:%{public}d, simState:%{public}d",
1255 simId, slotId, simState);
1256 if (simId < 0) {
1257 NETMGR_LOG_E("get simId error");
1258 return false;
1259 }
1260
1261 if (simState == static_cast<int32_t>(Telephony::SimState::SIM_STATE_LOADED)) {
1262 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1263 ObserverPtr trafficDataObserver = std::make_shared<TrafficDataObserver>(simId);
1264 SettingsInfoPtr trafficSettingsInfo = std::make_shared<TrafficSettingsInfo>();
1265 trafficDataObserver->ReadTrafficDataSettings(trafficSettingsInfo);
1266 settingsTrafficMap_.insert(
1267 std::make_pair(simId, std::make_pair(trafficDataObserver, trafficSettingsInfo)));
1268 UpdateNetStatsToMapFromDB(simId);
1269 NETMGR_LOG_I("settingsTrafficMap_.insert(simId). simId:%{public}d", simId);
1270 trafficDataObserver->RegisterTrafficDataSettingObserver();
1271 }
1272 } else if (simState != static_cast<int32_t>(Telephony::SimState::SIM_STATE_READY)) {
1273 if (settingsTrafficMap_.find(simId) != settingsTrafficMap_.end()) {
1274 settingsTrafficMap_[simId].first->UnRegisterTrafficDataSettingObserver();
1275 NETMGR_LOG_I("settingsTrafficMap_.erase(simId). simId:%{public}d", simId);
1276 settingsTrafficMap_.erase(simId);
1277 }
1278 }
1279 return true;
1280 }
1281
CommonEventCellularDataStateChanged(int32_t slotId,int32_t dataState)1282 bool NetStatsService::CommonEventCellularDataStateChanged(int32_t slotId, int32_t dataState)
1283 {
1284 UpdateNetStatusMapCellular(dataState);
1285 if (!trafficPlanFfrtQueue_) {
1286 NETMGR_LOG_E("FFRT Init Fail");
1287 return false;
1288 }
1289 #ifndef UNITTEST_FORBID_FFRT
1290 trafficPlanFfrtQueue_->submit([this, slotId, dataState]() {
1291 #endif
1292 CellularDataStateChangedFfrt(slotId, dataState);
1293 #ifndef UNITTEST_FORBID_FFRT
1294 });
1295 #endif
1296 return true;
1297 }
1298
UpdateNetStatusMapCellular(int32_t dataState)1299 void NetStatsService::UpdateNetStatusMapCellular(int32_t dataState)
1300 {
1301 if (dataState == static_cast<int32_t>(Telephony::DataConnectState::DATA_STATE_CONNECTED)) {
1302 UpdateNetStatusMap(NetStatusType::CELLULAR_TYPE, NetStatusConn::CONNECTED);
1303 } else {
1304 UpdateNetStatusMap(NetStatusType::CELLULAR_TYPE, NetStatusConn::NON_CONNECTED);
1305 }
1306 }
1307
CellularDataStateChangedFfrt(int32_t slotId,int32_t dataState)1308 bool NetStatsService::CellularDataStateChangedFfrt(int32_t slotId, int32_t dataState)
1309 {
1310 NETMGR_LOG_I("slotId:%{public}d, dateState:%{public}d", slotId, dataState);
1311 int32_t simId = Telephony::CoreServiceClient::GetInstance().GetSimId(slotId);
1312
1313 if (dataState != static_cast<int32_t>(Telephony::DataConnectState::DATA_STATE_CONNECTED)) {
1314 if (simIdToIfIndexMap_.find(simId) != simIdToIfIndexMap_.end()) {
1315 NETMGR_LOG_E("simIdToIfIndexMap erase, simId: %{public}d", simId);
1316 ClearTrafficMapBySlotId(slotId, simIdToIfIndexMap_[simId]);
1317 simIdToIfIndexMap_.erase(simId);
1318 }
1319 return true;
1320 }
1321 int32_t ret = NetConnClient::GetInstance().GetIfaceNameIdentMaps(
1322 NetBearType::BEARER_CELLULAR, ifaceNameIdentMap_);
1323 if (ret != NETMANAGER_SUCCESS || ifaceNameIdentMap_.IsEmpty()) {
1324 NETMGR_LOG_E("error or empty.ret: %{public}d, ifaceNameIdentMap size: %{public}u",
1325 ret, ifaceNameIdentMap_.Size());
1326 return false;
1327 }
1328 NETMGR_LOG_I("ifaceNameIdentMap size: %{public}d", ifaceNameIdentMap_.Size());
1329 uint64_t ifIndex = UINT64_MAX;
1330 ifaceNameIdentMap_.Iterate([this, simId, &ifIndex](const std::string &k, const std::string &v) {
1331 if (v == std::to_string(simId)) {
1332 ifIndex = if_nametoindex(k.c_str());
1333 NETMGR_LOG_E("curIfIndex_:%{public}" PRIu64, ifIndex);
1334 }
1335 });
1336 if (simIdToIfIndexMap_.find(simId) != simIdToIfIndexMap_.end() && simIdToIfIndexMap_[simId] == ifIndex) {
1337 NETMGR_LOG_E("not need process");
1338 return true;
1339 }
1340 UpdateCurActiviteSimChanged(simId, ifIndex);
1341 return true;
1342 }
1343
StartTrafficOvserver()1344 void NetStatsService::StartTrafficOvserver()
1345 {
1346 NETMGR_LOG_I("StartTrafficOvserver start");
1347 if (trafficObserver_ == nullptr) {
1348 trafficObserver_ = std::make_unique<TrafficObserver>().release();
1349 }
1350 if (trafficObserver_ == nullptr) {
1351 return;
1352 }
1353 int32_t ret = NetsysController::GetInstance().RegisterNetsysTrafficCallback(trafficObserver_);
1354 if (ret != 0) {
1355 NETMGR_LOG_E("StartTrafficOvserver fail, ret = %{public}d", ret);
1356 return;
1357 }
1358 }
1359
StopTrafficOvserver()1360 void NetStatsService::StopTrafficOvserver()
1361 {
1362 NETMGR_LOG_I("StopTrafficOvserver start");
1363 if (trafficObserver_ == nullptr) {
1364 trafficObserver_ = std::make_unique<TrafficObserver>().release();
1365 }
1366 if (trafficObserver_ == nullptr) {
1367 return;
1368 }
1369 int32_t ret = NetsysController::GetInstance().UnRegisterNetsysTrafficCallback(trafficObserver_);
1370 if (ret != 0) {
1371 NETMGR_LOG_E("StopTrafficOvserver fail, ret = %{public}d", ret);
1372 return;
1373 }
1374 }
1375
1376
UpdateCurActiviteSimChanged(int32_t simId,uint64_t ifIndex)1377 void NetStatsService::UpdateCurActiviteSimChanged(int32_t simId, uint64_t ifIndex)
1378 {
1379 AddSimIdInTwoMap(simId, ifIndex);
1380 int32_t slotId = Telephony::CoreServiceClient::GetInstance().GetSlotId(simId);
1381 if (settingsTrafficMap_[simId].second->monthlyLimit == UINT64_MAX ||
1382 settingsTrafficMap_[simId].second->unLimitedDataEnable == 1) {
1383 SetTrafficMapMaxValue(slotId);
1384 } else {
1385 UpdateBpfMap(simId);
1386 }
1387 }
1388
IsSameStateInTwoMap(int32_t simId)1389 bool NetStatsService::IsSameStateInTwoMap(int32_t simId)
1390 {
1391 auto ifIndexItem = simIdToIfIndexMap_.find(simId);
1392 auto settingsItem = settingsTrafficMap_.find(simId);
1393 if (ifIndexItem == simIdToIfIndexMap_.end() &&
1394 settingsItem == settingsTrafficMap_.end()) {
1395 return true;
1396 }
1397 if (ifIndexItem != simIdToIfIndexMap_.end() &&
1398 settingsItem != settingsTrafficMap_.end()) {
1399 return true;
1400 }
1401 return false;
1402 }
1403
DeleteSimIdInTwoMap(int32_t simId)1404 void NetStatsService::DeleteSimIdInTwoMap(int32_t simId)
1405 {
1406 if (simIdToIfIndexMap_.find(simId) != simIdToIfIndexMap_.end() &&
1407 settingsTrafficMap_.find(simId) != settingsTrafficMap_.end()) {
1408 simIdToIfIndexMap_.erase(simId);
1409 settingsTrafficMap_.erase(simId);
1410 }
1411 }
1412
AddSimIdInTwoMap(int32_t simId,uint64_t ifIndex)1413 void NetStatsService::AddSimIdInTwoMap(int32_t simId, uint64_t ifIndex)
1414 {
1415 NETMGR_LOG_I("AddSimIdInTwoMap. simId:%{public}d, ifIndex:%{public}" PRIu64, simId, ifIndex);
1416 if (simIdToIfIndexMap_.find(simId) != simIdToIfIndexMap_.end()) {
1417 int32_t slotId = Telephony::CoreServiceClient::GetInstance().GetSlotId(simId);
1418 if (slotId != 0 && slotId != 1) {
1419 NETMGR_LOG_I("SetTrafficMapMaxValue error. slotId: %{public}d", slotId);
1420 return;
1421 }
1422 ClearTrafficMapBySlotId(slotId, simIdToIfIndexMap_[simId]);
1423 }
1424 simIdToIfIndexMap_[simId] = ifIndex;
1425
1426 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1427 NETMGR_LOG_E("settingsTrafficMap_ not find simId: %{public}d", simId);
1428 std::shared_ptr<TrafficDataObserver> observer = std::make_shared<TrafficDataObserver>(simId);
1429
1430 std::shared_ptr<TrafficSettingsInfo> settingsInfo = std::make_shared<TrafficSettingsInfo>();
1431 observer->ReadTrafficDataSettings(settingsInfo);
1432
1433 observer->RegisterTrafficDataSettingObserver();
1434 settingsTrafficMap_.insert(std::make_pair(simId, std::make_pair(observer, settingsInfo)));
1435 UpdateNetStatsToMapFromDB(simId);
1436 NETMGR_LOG_I("AddSimIdInTwoMap insert settingsInfo beginDate:%{public}d,\
1437 unLimitedDataEnable:%{public}d, monthlyLimitdNotifyType:%{public}d,\
1438 monthlyLimit:%{public}" PRIu64 ", monthlyMark:%{public}u, dailyMark:%{public}u",
1439 settingsInfo->beginDate, settingsInfo->unLimitedDataEnable, settingsInfo->monthlyLimitdNotifyType,
1440 settingsInfo->monthlyLimit, settingsInfo->monthlyMark, settingsInfo->dailyMark);
1441 }
1442 }
1443
ClearTrafficMapBySlotId(int32_t slotId,uint64_t ifIndex)1444 void NetStatsService::ClearTrafficMapBySlotId(int32_t slotId, uint64_t ifIndex)
1445 {
1446 NETMGR_LOG_I("ClearTrafficMapBySlotId slotId:%{public}d, ifIndex: %{public}lu", slotId, ifIndex);
1447 NetsysController::GetInstance().DeleteIncreaseTrafficMap(ifIndex);
1448 NetsysController::GetInstance().UpdateIfIndexMap(slotId, UINT64_MAX);
1449 SetTrafficMapMaxValue(slotId);
1450 }
1451
1452
GetAllUsedTrafficStatsByNetwork(const sptr<NetStatsNetwork> & network,uint64_t & allUsedTraffic)1453 int32_t NetStatsService::GetAllUsedTrafficStatsByNetwork(const sptr<NetStatsNetwork> &network, uint64_t &allUsedTraffic)
1454 {
1455 std::unordered_map<uint32_t, NetStatsInfo> infos;
1456 int32_t ret = GetTrafficStatsByNetwork(infos, *network);
1457 if (ret != NETMANAGER_SUCCESS) {
1458 return ret;
1459 }
1460
1461 allUsedTraffic = 0;
1462 NETMGR_LOG_I("NetStatsInfo size: %{public}zu", infos.size());
1463 for (auto it = infos.begin(); it != infos.end(); ++it) {
1464 allUsedTraffic += it->second.rxBytes_;
1465 allUsedTraffic += it->second.txBytes_;
1466 }
1467 return NETMANAGER_SUCCESS;
1468 }
1469
UpdateBpfMap(int32_t simId)1470 void NetStatsService::UpdateBpfMap(int32_t simId)
1471 {
1472 NETMGR_LOG_I("UpdateBpfMap start. simId:%{public}d", simId);
1473 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end() ||
1474 simIdToIfIndexMap_.find(simId) == simIdToIfIndexMap_.end()) {
1475 NETMGR_LOG_E("simId: %{public}d error", simId);
1476 return;
1477 }
1478
1479 int32_t slotId = Telephony::CoreServiceClient::GetInstance().GetSlotId(simId);
1480 if (slotId != 0 && slotId != 1) {
1481 NETMGR_LOG_I("SetTrafficMapMaxValue error. slotId: %{public}d", slotId);
1482 return;
1483 }
1484
1485 NetsysController::GetInstance().DeleteIncreaseTrafficMap(simIdToIfIndexMap_[simId]);
1486 NetsysController::GetInstance().UpdateIfIndexMap(slotId, simIdToIfIndexMap_[simId]);
1487
1488 PrintTrafficSettingsMapInfo(simId);
1489
1490 uint64_t monthlyAvailable = UINT64_MAX;
1491 uint64_t monthlyMarkAvailable = UINT64_MAX;
1492 uint64_t dailyMarkAvailable = UINT64_MAX;
1493 bool ret = CalculateTrafficAvailable(simId, monthlyAvailable, monthlyMarkAvailable, dailyMarkAvailable);
1494 if (!ret) {
1495 NETMGR_LOG_E("CalculateTrafficAvailable error or open unlimit");
1496 return;
1497 }
1498
1499 NETMGR_LOG_I("GetTrafficMap before write. monthlyAvailable:%{public}" PRIu64", \
1500 monthlyMarkAvailable:%{public}" PRIu64", dailyMarkAvailable:%{public}" PRIu64,
1501 monthlyAvailable, monthlyMarkAvailable, dailyMarkAvailable);
1502 NetsysController::GetInstance().SetNetStateTrafficMap(
1503 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_LIMIT, monthlyAvailable);
1504 NetsysController::GetInstance().SetNetStateTrafficMap(
1505 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_MARK, monthlyMarkAvailable);
1506 NetsysController::GetInstance().SetNetStateTrafficMap(
1507 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_DAILY_MARK, dailyMarkAvailable);
1508
1509 PrintTrafficBpfMapInfo(slotId);
1510
1511 if (settingsTrafficMap_[simId].second->monthlyLimit == UINT64_MAX) {
1512 return;
1513 }
1514
1515 if (monthlyAvailable == UINT64_MAX) {
1516 NotifyTrafficAlert(simId, NET_STATS_MONTHLY_LIMIT);
1517 } else if (monthlyMarkAvailable == UINT64_MAX) {
1518 NotifyTrafficAlert(simId, NET_STATS_MONTHLY_MARK);
1519 } else if (dailyMarkAvailable == UINT64_MAX) {
1520 NotifyTrafficAlert(simId, NET_STATS_DAILY_MARK);
1521 }
1522 }
1523
PrintTrafficSettingsMapInfo(int32_t simId)1524 void NetStatsService::PrintTrafficSettingsMapInfo(int32_t simId)
1525 {
1526 SettingsInfoPtr info = settingsTrafficMap_[simId].second;
1527 if (info != nullptr) {
1528 NETMGR_LOG_I("settingsInfo-> simId:%{public}d, beginDate:%{public}d, unLimitedDataEnable:%{public}d,\
1529 monthlyLimitdNotifyType:%{public}d, monthlyLimit:%{public}" PRIu64 ", monthlyMark:%{public}u,\
1530 dailyMark:%{public}u",
1531 simId, info->beginDate, info->unLimitedDataEnable, info->monthlyLimitdNotifyType,
1532 info->monthlyLimit, info->monthlyMark, info->dailyMark);
1533 }
1534 }
1535
PrintTrafficBpfMapInfo(int32_t slotId)1536 void NetStatsService::PrintTrafficBpfMapInfo(int32_t slotId)
1537 {
1538 uint64_t monthlyAvailableMap = UINT64_MAX;
1539 uint64_t monthlyMarkAvailableMap = UINT64_MAX;
1540 uint64_t dailyMarkAvailableMap = UINT64_MAX;
1541 NetsysController::GetInstance().GetNetStateTrafficMap(
1542 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_LIMIT, monthlyAvailableMap);
1543 NetsysController::GetInstance().GetNetStateTrafficMap(
1544 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_MARK, monthlyMarkAvailableMap);
1545 NetsysController::GetInstance().GetNetStateTrafficMap(
1546 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_DAILY_MARK, dailyMarkAvailableMap);
1547 NETMGR_LOG_I("GetTrafficMap after write. monthlyAvailable:%{public}" PRIu64", \
1548 monthlyMarkAvailable:%{public}" PRIu64", dailyMarkAvailable:%{public}" PRIu64,
1549 monthlyAvailableMap, monthlyMarkAvailableMap, dailyMarkAvailableMap);
1550 }
1551
CalculateTrafficAvailable(int32_t simId,uint64_t & monthlyAvailable,uint64_t & monthlyMarkAvailable,uint64_t & dailyMarkAvailable)1552 bool NetStatsService::CalculateTrafficAvailable(int32_t simId, uint64_t &monthlyAvailable,
1553 uint64_t &monthlyMarkAvailable, uint64_t &dailyMarkAvailable)
1554 {
1555 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1556 NETMGR_LOG_E("settingsTrafficMap not find simId, simId is %{public}d", simId);
1557 return false;
1558 }
1559
1560 if (settingsTrafficMap_[simId].second->monthlyLimit == UINT64_MAX) {
1561 return true;
1562 }
1563 sptr<NetStatsNetwork> network = (std::make_unique<NetStatsNetwork>()).release();
1564 network->startTime_ =
1565 static_cast<uint64_t>(NetStatsUtils::GetStartTimestamp(settingsTrafficMap_[simId].second->beginDate));
1566 network->endTime_ = NetStatsUtils::GetNowTimestamp();
1567 NETMGR_LOG_I("endTime: %{public}lu. simId: %{public}d", network->endTime_, simId);
1568 network->type_ = 0;
1569 network->simId_ = static_cast<uint32_t>(simId);
1570 uint64_t allUsedTraffic = 0;
1571 int ret = GetAllUsedTrafficStatsByNetwork(network, allUsedTraffic);
1572 if (ret != NETMANAGER_SUCCESS) {
1573 NETMGR_LOG_E("GetAllUsedTrafficStatsByNetwork err. ret: %{public}d", ret);
1574 return false;
1575 }
1576
1577 NETMGR_LOG_I("GetAllUsedTrafficStatsByNetwork allUsedTraffic: %{public}" PRIu64, allUsedTraffic);
1578 if (settingsTrafficMap_[simId].second->unLimitedDataEnable != 1) {
1579 if (settingsTrafficMap_[simId].second->monthlyLimit > allUsedTraffic) {
1580 monthlyAvailable = settingsTrafficMap_[simId].second->monthlyLimit - allUsedTraffic;
1581 }
1582
1583 uint64_t monthTmp = (settingsTrafficMap_[simId].second->monthlyLimit / 100.0) *
1584 settingsTrafficMap_[simId].second->monthlyMark;
1585 if (monthTmp > allUsedTraffic) {
1586 monthlyMarkAvailable = monthTmp - allUsedTraffic;
1587 }
1588 uint64_t todayStartTime = static_cast<uint64_t>(NetStatsUtils::GetTodayStartTimestamp());
1589 network->startTime_ = todayStartTime;
1590 uint64_t allTodayUsedTraffix = 0;
1591 ret = GetAllUsedTrafficStatsByNetwork(network, allTodayUsedTraffix);
1592 if (ret != NETMANAGER_SUCCESS) {
1593 NETMGR_LOG_E("GetAllUsedTrafficStatsByNetwork err. ret: %{public}d", ret);
1594 return false;
1595 }
1596
1597 uint64_t dayTmp = (settingsTrafficMap_[simId].second->monthlyLimit / 100.0) *
1598 settingsTrafficMap_[simId].second->dailyMark;
1599 NETMGR_LOG_I("dayTmp:%{public}" PRIu64 ", allTodayUsedTraffix:%{public}" PRIu64, dayTmp, allTodayUsedTraffix);
1600 if (dayTmp > allTodayUsedTraffix) {
1601 dailyMarkAvailable = dayTmp - allTodayUsedTraffix;
1602 }
1603 return true;
1604 }
1605 return false;
1606 }
1607
SetTrafficMapMaxValue()1608 void NetStatsService::SetTrafficMapMaxValue()
1609 {
1610 NETMGR_LOG_I("SetTrafficMapMaxValue");
1611 NetsysController::GetInstance().SetNetStateTrafficMap(NET_STATS_MONTHLY_LIMIT, UINT64_MAX);
1612 NetsysController::GetInstance().SetNetStateTrafficMap(NET_STATS_MONTHLY_MARK, UINT64_MAX);
1613 NetsysController::GetInstance().SetNetStateTrafficMap(NET_STATS_DAILY_MARK, UINT64_MAX);
1614 }
1615
SetTrafficMapMaxValue(int32_t slotId)1616 void NetStatsService::SetTrafficMapMaxValue(int32_t slotId)
1617 {
1618 NETMGR_LOG_I("SetTrafficMapMaxValue");
1619 if (slotId != 0 && slotId != 1) {
1620 NETMGR_LOG_E("SetTrafficMapMaxValue error. slotId: %{public}d", slotId);
1621 return;
1622 }
1623 NetsysController::GetInstance().SetNetStateTrafficMap(
1624 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_LIMIT, UINT64_MAX);
1625 NetsysController::GetInstance().SetNetStateTrafficMap(
1626 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_MONTHLY_MARK, UINT64_MAX);
1627 NetsysController::GetInstance().SetNetStateTrafficMap(
1628 slotId * TRAFFIC_NOTIFY_TYPE + NET_STATS_DAILY_MARK, UINT64_MAX);
1629 }
1630
UpdataSettingsdata(int32_t simId,uint8_t flag,uint64_t value)1631 void NetStatsService::UpdataSettingsdata(int32_t simId, uint8_t flag, uint64_t value)
1632 {
1633 if (!trafficPlanFfrtQueue_) {
1634 NETMGR_LOG_E("FFRT Init Fail");
1635 return;
1636 }
1637 #ifndef UNITTEST_FORBID_FFRT
1638 trafficPlanFfrtQueue_->submit([this, simId, flag, value]() {
1639 #endif
1640 UpdataSettingsdataFfrt(simId, flag, value);
1641 #ifndef UNITTEST_FORBID_FFRT
1642 });
1643 #endif
1644 }
1645
UpdataSettingsdataFfrt(int32_t simId,uint8_t flag,uint64_t value)1646 int32_t NetStatsService::UpdataSettingsdataFfrt(int32_t simId, uint8_t flag, uint64_t value)
1647 {
1648 NETMGR_LOG_I("UpdataSettingsdata. simId: %{public}d, flag: %{public}d, value: %{public}lu", simId, flag, value);
1649 auto iter = settingsTrafficMap_.find(simId);
1650 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1651 NETMGR_LOG_I("iter is nullptr.");
1652 return NETMANAGER_ERR_PARAMETER_ERROR;
1653 }
1654 switch (flag) {
1655 case NET_STATS_NO_LIMIT_ENABLE:
1656 if (value == 0 || value == 1) {
1657 iter->second.second->unLimitedDataEnable = static_cast<int8_t>(value);
1658 }
1659 break;
1660 case NET_STATS_MONTHLY_LIMIT:
1661 iter->second.second->monthlyLimit = value;
1662 iter->second.second->isCanNotifyMonthlyLimit = true;
1663 iter->second.second->isCanNotifyMonthlyMark = true;
1664 iter->second.second->isCanNotifyDailyMark = true;
1665 UpdateTrafficLimitDate(simId);
1666 break;
1667 case NET_STATS_BEGIN_DATE:
1668 if (value >= 1 && value <= 31) { // 31: 每月日期数最大值
1669 iter->second.second->beginDate = static_cast<int32_t>(value);
1670 }
1671 break;
1672 case NET_STATS_NOTIFY_TYPE:
1673 if (value == 0 || value == 1) {
1674 iter->second.second->monthlyLimitdNotifyType = static_cast<int8_t>(value);
1675 }
1676 break;
1677 case NET_STATS_MONTHLY_MARK:
1678 if (value >= 0 && value <= 100) { // 100: 百分比最大值
1679 iter->second.second->monthlyMark = value;
1680 iter->second.second->isCanNotifyMonthlyMark = true;
1681 UpdateTrafficLimitDate(simId);
1682 }
1683 break;
1684 case NET_STATS_DAILY_MARK:
1685 if (value >= 0 && value <= 100) { // 100: 百分比最大值
1686 iter->second.second->dailyMark = value;
1687 }
1688 break;
1689 default:
1690 break;
1691 }
1692
1693 if (simIdToIfIndexMap_.find(simId) != simIdToIfIndexMap_.end()) {
1694 UpdateBpfMap(simId);
1695 }
1696 return NETMANAGER_SUCCESS;
1697 }
1698
TrafficObserver()1699 TrafficObserver::TrafficObserver() {}
~TrafficObserver()1700 TrafficObserver::~TrafficObserver() {}
1701
OnExceedTrafficLimits(int8_t & flag)1702 int32_t TrafficObserver::OnExceedTrafficLimits(int8_t &flag)
1703 {
1704 NETMGR_LOG_I("OnExceedTrafficLimits flag: %{public}d", flag);
1705 if (flag < NET_STATS_MONTHLY_LIMIT || flag > NET_STATS_DAILY_MARK + TRAFFIC_NOTIFY_TYPE * 1) {
1706 NETMGR_LOG_E("OnExceedTrafficLimits flag error. value: %{public}d", flag);
1707 return -1;
1708 }
1709
1710 int8_t slotId = -1;
1711 if (flag == 0) {
1712 slotId = 0;
1713 } else {
1714 slotId = flag / TRAFFIC_NOTIFY_TYPE;
1715 }
1716 int8_t trafficFlag = flag - TRAFFIC_NOTIFY_TYPE * slotId;
1717 int32_t simId = Telephony::CoreServiceClient::GetInstance().GetSimId(slotId);
1718 if (simId < 0) {
1719 NETMGR_LOG_E("get simId error");
1720 return -1;
1721 }
1722
1723 DelayedSingleton<NetStatsService>::GetInstance()->NotifyTrafficAlert(simId, trafficFlag);
1724 return 0;
1725 }
1726
UpdateNetStatsToMapFromDB(int32_t simId)1727 void NetStatsService::UpdateNetStatsToMapFromDB(int32_t simId)
1728 {
1729 NETMGR_LOG_I("UpdateNetStatsToMapFromDB enter.");
1730 NetStatsRDB netStats;
1731
1732 std::vector<NetStatsData> result = netStats.QueryAll();
1733 for (size_t i = 0; i < result.size(); i++) {
1734 int32_t curSumId = result[i].simId;
1735 if (simId == curSumId && settingsTrafficMap_.find(simId) != settingsTrafficMap_.end()) {
1736 settingsTrafficMap_[curSumId].second->lastMonAlertTime = result[i].monWarningDate;
1737 settingsTrafficMap_[curSumId].second->lastMonNotifyTime = result[i].dayNoticeDate;
1738 settingsTrafficMap_[curSumId].second->lastDayNotifyTime = result[i].monNoticeDate;
1739 settingsTrafficMap_[curSumId].second->isCanNotifyMonthlyLimit =
1740 static_cast<bool>(result[i].monWarningState);
1741 settingsTrafficMap_[curSumId].second->isCanNotifyMonthlyMark = static_cast<bool>(result[i].monNoticeState);
1742 settingsTrafficMap_[curSumId].second->isCanNotifyDailyMark = static_cast<bool>(result[i].dayNoticeState);
1743 }
1744 }
1745 }
1746
NotifyTrafficAlert(int32_t simId,uint8_t flag)1747 int32_t NetStatsService::NotifyTrafficAlert(int32_t simId, uint8_t flag)
1748 {
1749 if (simIdToIfIndexMap_.find(simId) == simIdToIfIndexMap_.end()) {
1750 NETMGR_LOG_E("simIdToIfIndexMap not find simId: %{public}d", simId);
1751 return -1;
1752 }
1753
1754 if (NetStatsUtils::IsMobileDataEnabled() && GetNotifyStats(simId, flag)) {
1755 DealNotificaiton(simId, flag);
1756 } else {
1757 NETMGR_LOG_I("There is no need to pop up trafficLimit notification.");
1758 }
1759 return NETMANAGER_SUCCESS;
1760 }
1761
GetNotifyStats(int32_t simId,uint8_t flag)1762 bool NetStatsService::GetNotifyStats(int32_t simId, uint8_t flag)
1763 {
1764 NETMGR_LOG_I("Enter GetNotifyStats.");
1765 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1766 return false;
1767 }
1768 if (settingsTrafficMap_[simId].second->unLimitedDataEnable == 1) {
1769 NETMGR_LOG_I("simId: %{public}d, setting unLimitedDataEnable: true.", simId);
1770 return false;
1771 }
1772
1773 switch (flag) {
1774 case NET_STATS_MONTHLY_LIMIT:
1775 return GetMonAlertStatus(simId);
1776 case NET_STATS_MONTHLY_MARK:
1777 return GetMonNotifyStatus(simId);
1778 case NET_STATS_DAILY_MARK:
1779 return GetDayNotifyStatus(simId);
1780 default:
1781 NETMGR_LOG_E("unknown notification type");
1782 return false;
1783 }
1784 return false;
1785 }
1786
GetMonNotifyStatus(int32_t simId)1787 bool NetStatsService::GetMonNotifyStatus(int32_t simId)
1788 {
1789 NETMGR_LOG_I("Enter GetMonNotifyStatus.");
1790 auto iter = settingsTrafficMap_.find(simId);
1791 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1792 NETMGR_LOG_E("iter is nullptr.");
1793 return false;
1794 }
1795 if (iter->second.second->isCanNotifyMonthlyMark) {
1796 iter->second.second->isCanNotifyMonthlyMark = false;
1797 return true;
1798 }
1799
1800 int32_t currentTime = NetStatsUtils::GetNowTimestamp();
1801 int32_t currentStartTime =
1802 NetStatsUtils::GetStartTimestamp(iter->second.second->beginDate);
1803 NETMGR_LOG_I("Enter currentTime:%{public}d, currentDayStartTime:%{public}d, lastMonNotifyTime: %{public}d",
1804 currentTime, currentStartTime, iter->second.second->lastMonNotifyTime);
1805 if (iter->second.second->lastMonNotifyTime < currentStartTime) {
1806 return true;
1807 }
1808 return false;
1809 }
1810
GetDayNotifyStatus(int32_t simId)1811 bool NetStatsService::GetDayNotifyStatus(int32_t simId)
1812 {
1813 NETMGR_LOG_I("Enter GetDayNotifyStatus.");
1814 auto iter = settingsTrafficMap_.find(simId);
1815 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1816 NETMGR_LOG_I("iter is nullptr.");
1817 return false;
1818 }
1819 if (iter->second.second->isCanNotifyDailyMark) {
1820 iter->second.second->isCanNotifyDailyMark = false;
1821 return true;
1822 }
1823 int32_t currentDayStartTime = NetStatsUtils::GetTodayStartTimestamp();
1824 NETMGR_LOG_I("Enter currentDayStartTime:%{public}d, lastDayNotifyTime: %{public}d",
1825 currentDayStartTime, iter->second.second->lastDayNotifyTime);
1826 if (iter->second.second->lastDayNotifyTime < currentDayStartTime) {
1827 return true;
1828 }
1829 return false;
1830 }
1831
GetMonAlertStatus(int32_t simId)1832 bool NetStatsService::GetMonAlertStatus(int32_t simId)
1833 {
1834 NETMGR_LOG_I("Enter GetMonAlertStatus.");
1835 auto iter = settingsTrafficMap_.find(simId);
1836 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1837 NETMGR_LOG_I("iter is nullptr.");
1838 return false;
1839 }
1840 if (iter->second.second->isCanNotifyMonthlyLimit) {
1841 NETMGR_LOG_I("isCanNotify true : states changed caused.");
1842 iter->second.second->isCanNotifyMonthlyLimit = false;
1843 iter->second.second->isCanNotifyMonthlyMark = false;
1844 iter->second.second->isCanNotifyDailyMark = false;
1845 return true;
1846 }
1847
1848 int currentTime = NetStatsUtils::GetNowTimestamp();
1849 int currentStartTime = NetStatsUtils::GetStartTimestamp(iter->second.second->beginDate);
1850 NETMGR_LOG_I("Enter currentTime:%{public}d, currentDayStartTime:%{public}d, lastMonAlertTime: %{public}d",
1851 currentTime, currentStartTime, iter->second.second->lastMonAlertTime);
1852 if (iter->second.second->lastMonAlertTime < currentStartTime) {
1853 return true;
1854 }
1855 return false;
1856 }
1857
DealNotificaiton(int32_t simId,uint8_t flag)1858 void NetStatsService::DealNotificaiton(int32_t simId, uint8_t flag)
1859 {
1860 NETMGR_LOG_I("Enter DealDayNotification.");
1861 int simNum = NetStatsUtils::IsDualCardEnabled();
1862 bool isDualCard = false;
1863 if (simNum == 0) {
1864 return;
1865 } else if (simNum == DUAL_CARD) {
1866 isDualCard = true;
1867 }
1868
1869 switch (flag) {
1870 case NET_STATS_MONTHLY_LIMIT:
1871 return DealMonAlert(simId, isDualCard);
1872 case NET_STATS_MONTHLY_MARK:
1873 return DealMonNotification(simId, isDualCard);
1874 case NET_STATS_DAILY_MARK:
1875 return DealDayNotification(simId, isDualCard);
1876 default:
1877 NETMGR_LOG_I("unknown notificationdeal type");
1878 }
1879 }
1880
DealDayNotification(int32_t simId,bool isDualCard)1881 void NetStatsService::DealDayNotification(int32_t simId, bool isDualCard)
1882 {
1883 NETMGR_LOG_I("Enter DealDayNotification.");
1884 auto iter = settingsTrafficMap_.find(simId);
1885 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1886 NETMGR_LOG_I("iter is nullptr.");
1887 return;
1888 }
1889 NetMgrNetStatsLimitNotification::GetInstance().PublishNetStatsLimitNotification(NETMGR_STATS_LIMIT_DAY,
1890 simId, isDualCard);
1891 iter->second.second->lastDayNotifyTime = NetStatsUtils::GetNowTimestamp();
1892 UpdateTrafficLimitDate(simId);
1893 NETMGR_LOG_I("update DayNotification time:%{public}d", iter->second.second->lastDayNotifyTime);
1894 }
1895
DealMonNotification(int32_t simId,bool isDualCard)1896 void NetStatsService::DealMonNotification(int32_t simId, bool isDualCard)
1897 {
1898 NETMGR_LOG_I("Enter DealMonNotification.");
1899 auto iter = settingsTrafficMap_.find(simId);
1900 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1901 NETMGR_LOG_I("iter is nullptr.");
1902 return;
1903 }
1904 NetMgrNetStatsLimitNotification::GetInstance().PublishNetStatsLimitNotification(NETMGR_STATS_LIMIT_MONTH,
1905 simId, isDualCard);
1906 iter->second.second->lastMonNotifyTime = NetStatsUtils::GetNowTimestamp();
1907 UpdateTrafficLimitDate(simId);
1908 NETMGR_LOG_I("update MonNotification time:%{public}d", iter->second.second->lastMonNotifyTime);
1909 }
1910
DealMonAlert(int32_t simId,bool isDualCard)1911 void NetStatsService::DealMonAlert(int32_t simId, bool isDualCard)
1912 {
1913 NETMGR_LOG_I("Enter DealMonAlert.");
1914 if (dialog_ == nullptr) {
1915 dialog_ = std::make_shared<TrafficLimitDialog>();
1916 }
1917
1918 auto iter = settingsTrafficMap_.find(simId);
1919 if (iter == settingsTrafficMap_.end() || iter->second.second == nullptr) {
1920 NETMGR_LOG_I("iter is nullptr.");
1921 return;
1922 }
1923
1924 NetMgrNetStatsLimitNotification::GetInstance().PublishNetStatsLimitNotification(NETMGR_STATS_ALERT_MONTH,
1925 simId, isDualCard);
1926 if (iter->second.second->monthlyLimitdNotifyType) {
1927 dialog_->PopUpTrafficLimitDialog(simId);
1928 }
1929 iter->second.second->lastMonAlertTime = NetStatsUtils::GetNowTimestamp();
1930 UpdateTrafficLimitDate(simId);
1931 NETMGR_LOG_I("update MonAlert time:%{public}d", iter->second.second->lastMonAlertTime);
1932 }
1933
GetSettingsObserverMap()1934 std::map<int32_t, std::pair<ObserverPtr, SettingsInfoPtr>> NetStatsService::GetSettingsObserverMap()
1935 {
1936 return settingsTrafficMap_;
1937 }
1938
UpdateTrafficLimitDate(int32_t simId)1939 void NetStatsService::UpdateTrafficLimitDate(int32_t simId)
1940 {
1941 NETMGR_LOG_I("UpdateTrafficLimitDate start");
1942 NetStatsRDB netStats;
1943 NetStatsData statsData;
1944 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1945 NETMGR_LOG_E("UpdateTrafficLimitDate err. Not find simId:%{public}d", simId);
1946 return;
1947 }
1948 auto info = settingsTrafficMap_[simId];
1949 statsData.simId = simId;
1950 statsData.monWarningDate = info.second->lastMonAlertTime;
1951 statsData.dayNoticeDate = info.second->lastDayNotifyTime;
1952 statsData.monNoticeDate = info.second->lastMonNotifyTime;
1953 statsData.monWarningState = info.second->isCanNotifyMonthlyLimit;
1954 statsData.dayNoticeState = info.second->isCanNotifyDailyMark;
1955 statsData.monNoticeState = info.second->isCanNotifyMonthlyMark;
1956
1957 netStats.InsertData(statsData);
1958 }
1959
GetMonthlyLimitBySimId(int32_t simId,uint64_t & monthlyLimit)1960 bool NetStatsService::GetMonthlyLimitBySimId(int32_t simId, uint64_t &monthlyLimit)
1961 {
1962 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1963 return false;
1964 }
1965 monthlyLimit = settingsTrafficMap_[simId].second->monthlyLimit;
1966 return true;
1967 }
1968
GetMonthlyMarkBySimId(int32_t simId,uint16_t & monthlyMark)1969 bool NetStatsService::GetMonthlyMarkBySimId(int32_t simId, uint16_t &monthlyMark)
1970 {
1971 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1972 return false;
1973 }
1974 monthlyMark = settingsTrafficMap_[simId].second->monthlyMark;
1975 return true;
1976 }
1977
GetdailyMarkBySimId(int32_t simId,uint16_t & dailyMark)1978 bool NetStatsService::GetdailyMarkBySimId(int32_t simId, uint16_t &dailyMark)
1979 {
1980 if (settingsTrafficMap_.find(simId) == settingsTrafficMap_.end()) {
1981 return false;
1982 }
1983 dailyMark = settingsTrafficMap_[simId].second->dailyMark;
1984 return true;
1985 }
1986 #endif //SUPPORT_TRAFFIC_STATISTIC
1987 } // namespace NetManagerStandard
1988 } // namespace OHOS
1989