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 <net/if.h>
19#include <sys/time.h>
20#include <unistd.h>
21
22#include <cinttypes>
23#include <initializer_list>
24
25#include "bpf_stats.h"
26#include "broadcast_manager.h"
27#include "common_event_manager.h"
28#include "common_event_support.h"
29#include "net_manager_center.h"
30#include "net_manager_constants.h"
31#include "net_mgr_log_wrapper.h"
32#include "net_stats_constants.h"
33#include "net_stats_database_defines.h"
34#include "net_stats_service_common.h"
35#include "netmanager_base_common_utils.h"
36#include "netmanager_base_permission.h"
37#include "netmanager_hitrace.h"
38#include "netsys_controller.h"
39#include "system_ability_definition.h"
40
41namespace OHOS {
42namespace NetManagerStandard {
43using namespace NetStatsDatabaseDefines;
44namespace {
45constexpr std::initializer_list<NetBearType> BEAR_TYPE_LIST = {
46    NetBearType::BEARER_CELLULAR, NetBearType::BEARER_WIFI, NetBearType::BEARER_BLUETOOTH,
47    NetBearType::BEARER_ETHERNET, NetBearType::BEARER_VPN,  NetBearType::BEARER_WIFI_AWARE,
48};
49constexpr uint32_t DAY_SECONDS = 2 * 24 * 60 * 60;
50constexpr const char* UID = "uid";
51} // namespace
52const bool REGISTER_LOCAL_RESULT =
53    SystemAbility::MakeAndRegisterAbility(DelayedSingleton<NetStatsService>::GetInstance().get());
54
55NetStatsService::NetStatsService()
56    : SystemAbility(COMM_NET_STATS_MANAGER_SYS_ABILITY_ID, true), registerToService_(false), state_(STATE_STOPPED)
57{
58    netStatsCallback_ = std::make_shared<NetStatsCallback>();
59    netStatsCached_ = std::make_unique<NetStatsCached>();
60}
61
62NetStatsService::~NetStatsService() = default;
63
64void NetStatsService::OnStart()
65{
66    if (state_ == STATE_RUNNING) {
67        NETMGR_LOG_D("the state is already running");
68        return;
69    }
70    if (!Init()) {
71        NETMGR_LOG_E("init failed");
72        return;
73    }
74    AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
75    state_ = STATE_RUNNING;
76    sptr<NetStatsBaseService> baseService = new (std::nothrow) NetStatsServiceCommon();
77    if (baseService == nullptr) {
78        NETMGR_LOG_E("Net stats base service instance create failed");
79        return;
80    }
81    NetManagerCenter::GetInstance().RegisterStatsService(baseService);
82}
83
84void NetStatsService::OnStop()
85{
86    state_ = STATE_STOPPED;
87    registerToService_ = true;
88}
89
90int32_t NetStatsService::Dump(int32_t fd, const std::vector<std::u16string> &args)
91{
92    NETMGR_LOG_D("Start Dump, fd: %{public}d", fd);
93    std::string result;
94    GetDumpMessage(result);
95    int32_t ret = dprintf(fd, "%s\n", result.c_str());
96    return ret < 0 ? STATS_DUMP_MESSAGE_FAIL : NETMANAGER_SUCCESS;
97}
98
99void NetStatsService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
100{
101    EventFwk::MatchingSkills matchingSkills;
102    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED);
103    matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN);
104    EventFwk::CommonEventSubscribeInfo subscribeInfo(matchingSkills);
105    subscribeInfo.SetPriority(1);
106    subscriber_ = std::make_shared<NetStatsListener>(subscribeInfo);
107    subscriber_->RegisterStatsCallback(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN,
108                                       [this](const EventFwk::Want &want) { return UpdateStatsData(); });
109    subscriber_->RegisterStatsCallback(
110        EventFwk::CommonEventSupport::COMMON_EVENT_PACKAGE_REMOVED,
111        [this](const EventFwk::Want &want) {
112            uint32_t uid = want.GetIntParam(UID, 0);
113            NETMGR_LOG_D("Net Manager delete uid, uid:[%{public}d]", uid);
114            auto handler = std::make_unique<NetStatsDataHandler>();
115            if (handler == nullptr) {
116                NETMGR_LOG_E("Net Manager package removed, get db handler failed. uid:[%{public}d]", uid);
117                return static_cast<int32_t>(NETMANAGER_ERR_INTERNAL);
118            }
119            auto ret1 = handler->UpdateStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
120            if (ret1 != NETMANAGER_SUCCESS) {
121                NETMGR_LOG_E("Net Manager update stats flag failed, uid:[%{public}d]", uid);
122            }
123            auto ret2 = handler->UpdateSimStatsFlag(uid, STATS_DATA_FLAG_UNINSTALLED);
124            if (ret2 != NETMANAGER_SUCCESS) {
125                NETMGR_LOG_E("Net Manager update sim stats flag failed, uid:[%{public}d]", uid);
126            }
127            netStatsCached_->ForceArchiveStats(uid);
128            return ret1 != NETMANAGER_SUCCESS ? ret1 : ret2;
129        });
130    EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber_);
131}
132
133void NetStatsService::GetDumpMessage(std::string &message)
134{
135    message.append("Net Stats Info:\n");
136    uint64_t rxBytes = 0;
137    uint64_t txBytes = 0;
138    uint64_t rxPackets = 0;
139    uint64_t txPackets = 0;
140    NetsysController::GetInstance().GetTotalStats(rxBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
141    NetsysController::GetInstance().GetTotalStats(txBytes, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
142    NetsysController::GetInstance().GetTotalStats(rxPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_PACKETS));
143    NetsysController::GetInstance().GetTotalStats(txPackets, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_PACKETS));
144
145    message.append("\tRxBytes: " + std::to_string(rxBytes) + "\n");
146    message.append("\tTxBytes: " + std::to_string(txBytes) + "\n");
147    message.append("\tRxPackets: " + std::to_string(rxPackets) + "\n");
148    message.append("\tTxPackets: " + std::to_string(txPackets) + "\n");
149    std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [&message, this](const auto &bearType) {
150        std::list<std::string> ifaceNames;
151        if (NetManagerCenter::GetInstance().GetIfaceNames(bearType, ifaceNames)) {
152            return;
153        }
154        uint64_t rx = 0;
155        uint64_t tx = 0;
156        for (const auto &name : ifaceNames) {
157            GetIfaceRxBytes(rx, name);
158            GetIfaceTxBytes(tx, name);
159            message.append("\t" + name + "-TxBytes: " + std::to_string(tx));
160            message.append("\t" + name + "-RxBytes: " + std::to_string(rx));
161        }
162    });
163}
164
165bool NetStatsService::Init()
166{
167    if (!REGISTER_LOCAL_RESULT) {
168        NETMGR_LOG_E("Register to local sa manager failed");
169        registerToService_ = false;
170        return false;
171    }
172    if (!registerToService_) {
173        if (!Publish(DelayedSingleton<NetStatsService>::GetInstance().get())) {
174            NETMGR_LOG_E("Register to sa manager failed");
175            return false;
176        }
177        registerToService_ = true;
178    }
179    if (nullptr == netStatsCached_) {
180        return false;
181    }
182    netStatsCached_->SetCallbackManager(netStatsCallback_);
183    auto ret = netStatsCached_->StartCached();
184    if (ret != NETMANAGER_SUCCESS) {
185        NETMGR_LOG_E("Start cached failed");
186        return false;
187    }
188
189    return true;
190}
191
192int32_t NetStatsService::RegisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
193{
194    NETMGR_LOG_I("Enter RegisterNetStatsCallback");
195    if (callback == nullptr) {
196        NETMGR_LOG_E("RegisterNetStatsCallback parameter callback is null");
197        return NETMANAGER_ERR_PARAMETER_ERROR;
198    }
199    netStatsCallback_->RegisterNetStatsCallback(callback);
200    return NETMANAGER_SUCCESS;
201}
202
203int32_t NetStatsService::UnregisterNetStatsCallback(const sptr<INetStatsCallback> &callback)
204{
205    NETMGR_LOG_I("Enter UnregisterNetStatsCallback");
206    if (callback == nullptr) {
207        NETMGR_LOG_E("UnregisterNetStatsCallback parameter callback is null");
208        return NETMANAGER_ERR_PARAMETER_ERROR;
209    }
210    netStatsCallback_->UnregisterNetStatsCallback(callback);
211    return NETMANAGER_SUCCESS;
212}
213
214int32_t NetStatsService::GetIfaceRxBytes(uint64_t &stats, const std::string &interfaceName)
215{
216    return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
217                                                         interfaceName);
218}
219
220int32_t NetStatsService::GetIfaceTxBytes(uint64_t &stats, const std::string &interfaceName)
221{
222    return NetsysController::GetInstance().GetIfaceStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
223                                                         interfaceName);
224}
225
226int32_t NetStatsService::GetCellularRxBytes(uint64_t &stats)
227{
228    std::list<std::string> ifaceNames;
229    if (!GetIfaceNamesFromManager(ifaceNames)) {
230        return STATS_ERR_GET_IFACE_NAME_FAILED;
231    }
232
233    for (const auto &name : ifaceNames) {
234        uint64_t totalCellular = 0;
235        auto ret = NetsysController::GetInstance().GetIfaceStats(
236            totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES), name);
237        if (ret != NETMANAGER_SUCCESS) {
238            NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
239            return ret;
240        }
241        stats += totalCellular;
242    }
243    return NETMANAGER_SUCCESS;
244}
245
246int32_t NetStatsService::GetCellularTxBytes(uint64_t &stats)
247{
248    std::list<std::string> ifaceNames;
249    if (!GetIfaceNamesFromManager(ifaceNames)) {
250        return STATS_ERR_GET_IFACE_NAME_FAILED;
251    }
252
253    uint64_t totalCellular = 0;
254    for (const auto &name : ifaceNames) {
255        auto ret = NetsysController::GetInstance().GetIfaceStats(
256            totalCellular, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES), name);
257        if (ret != NETMANAGER_SUCCESS) {
258            NETMGR_LOG_E("Get iface stats failed result: %{public}d", ret);
259            return ret;
260        }
261        stats += totalCellular;
262    }
263    return NETMANAGER_SUCCESS;
264}
265
266int32_t NetStatsService::GetAllRxBytes(uint64_t &stats)
267{
268    NETMGR_LOG_D("Enter GetAllRxBytes");
269    return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES));
270}
271
272int32_t NetStatsService::GetAllTxBytes(uint64_t &stats)
273{
274    NETMGR_LOG_D("Enter GetAllTxBytes");
275    return NetsysController::GetInstance().GetTotalStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES));
276}
277
278int32_t NetStatsService::GetUidRxBytes(uint64_t &stats, uint32_t uid)
279{
280    NETMGR_LOG_D("Enter GetUidRxBytes, uid is %{public}d", uid);
281    return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
282                                                       uid);
283}
284
285int32_t NetStatsService::GetUidTxBytes(uint64_t &stats, uint32_t uid)
286{
287    NETMGR_LOG_D("Enter GetUidTxBytes,uid is %{public}d", uid);
288    return NetsysController::GetInstance().GetUidStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
289                                                       uid);
290}
291
292int32_t NetStatsService::GetIfaceStatsDetail(const std::string &iface, uint64_t start, uint64_t end,
293                                             NetStatsInfo &statsInfo)
294{
295    // Start of get traffic data by interface name.
296    NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s", iface.c_str());
297    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail start");
298    if (start > end) {
299        NETMGR_LOG_E("start is after end.");
300        return NETMANAGER_ERR_INVALID_PARAMETER;
301    }
302    std::vector<NetStatsInfo> allInfo;
303    auto history = std::make_unique<NetStatsHistory>();
304    int32_t ret = history->GetHistory(allInfo, iface, start, end);
305
306    if (netStatsCached_ == nullptr) {
307        NETMGR_LOG_E("netStatsCached_ is fail");
308        return NETMANAGER_ERR_LOCAL_PTR_NULL;
309    }
310    netStatsCached_->GetIfaceStatsCached(allInfo);
311    if (ret != NETMANAGER_SUCCESS) {
312        NETMGR_LOG_E("Get traffic stats data failed");
313        return ret;
314    }
315    std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &start, &end](const auto &info) {
316        if (info.iface_ == iface && info.date_ >= start && info.date_ <= end) {
317            statsInfo += info;
318        }
319    });
320    statsInfo.iface_ = iface;
321    statsInfo.date_ = end;
322    // End of get traffic data by interface name.
323    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetIfaceStatsDetail end");
324    return NETMANAGER_SUCCESS;
325}
326
327int32_t NetStatsService::GetUidStatsDetail(const std::string &iface, uint32_t uid, uint64_t start, uint64_t end,
328                                           NetStatsInfo &statsInfo)
329{
330    // Start of get traffic data by usr id.
331    NETMGR_LOG_D("Enter GetIfaceStatsDetail, iface= %{public}s uid= %{public}d", iface.c_str(), uid);
332    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetUidStatsDetail start");
333    if (start > end) {
334        NETMGR_LOG_E("start is after end.");
335        return NETMANAGER_ERR_INVALID_PARAMETER;
336    }
337    std::vector<NetStatsInfo> allInfo;
338    auto history = std::make_unique<NetStatsHistory>();
339    int32_t ret = history->GetHistory(allInfo, iface, uid, start, end);
340    if (netStatsCached_ == nullptr) {
341        NETMGR_LOG_E("netStatsCached_ is fail");
342        return NETMANAGER_ERR_LOCAL_PTR_NULL;
343    }
344    netStatsCached_->GetUidStatsCached(allInfo);
345    if (ret != NETMANAGER_SUCCESS) {
346        NETMGR_LOG_E("Get traffic stats data failed");
347        return ret;
348    }
349    std::for_each(allInfo.begin(), allInfo.end(), [&statsInfo, &iface, &uid, &start, &end](const auto &info) {
350        if (info.iface_ == iface && info.uid_ == uid && info.date_ >= start && info.date_ <= end) {
351            statsInfo += info;
352        }
353    });
354    statsInfo.uid_ = uid;
355    statsInfo.iface_ = iface;
356    statsInfo.date_ = end;
357    // End of get traffic data by usr id.
358    NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService GetUidStatsDetail end");
359    return NETMANAGER_SUCCESS;
360}
361
362int32_t NetStatsService::UpdateIfacesStats(const std::string &iface, uint64_t start, uint64_t end,
363                                           const NetStatsInfo &stats)
364{
365    // Start of update traffic data by date.
366    NETMGR_LOG_I("UpdateIfacesStats ifaces is %{public}s", iface.c_str());
367    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService UpdateIfacesStats start");
368    if (start > end) {
369        NETMGR_LOG_E("start is after end.");
370        return NETMANAGER_ERR_INVALID_PARAMETER;
371    }
372    std::vector<NetStatsInfo> infos;
373    infos.push_back(stats);
374    auto handler = std::make_unique<NetStatsDataHandler>();
375    auto ret = handler->DeleteByDate(IFACE_TABLE, start, end);
376    if (ret != NETMANAGER_SUCCESS) {
377        NETMGR_LOG_E("Update ifaces stats failed");
378    }
379    ret = handler->WriteStatsData(infos, IFACE_TABLE);
380    if (ret != NETMANAGER_SUCCESS) {
381        NETMGR_LOG_E("Update ifaces stats failed");
382        return STATS_ERR_WRITE_DATA_FAIL;
383    }
384    // End of update traffic data by date.
385    NetmanagerHiTrace::NetmanagerFinishSyncTrace("NetStatsService UpdateIfacesStats end");
386    return ret;
387}
388
389int32_t NetStatsService::UpdateStatsData()
390{
391    NETMGR_LOG_D("Enter UpdateStatsData.");
392    if (netStatsCached_ == nullptr) {
393        NETMGR_LOG_E("Cached is nullptr");
394        return NETMANAGER_ERR_LOCAL_PTR_NULL;
395    }
396    netStatsCached_->ForceUpdateStats();
397    NETMGR_LOG_D("End UpdateStatsData.");
398    return NETMANAGER_SUCCESS;
399}
400
401int32_t NetStatsService::ResetFactory()
402{
403    auto handler = std::make_unique<NetStatsDataHandler>();
404    return handler->ClearData();
405}
406
407int32_t NetStatsService::GetAllStatsInfo(std::vector<NetStatsInfo> &infos)
408{
409    NETMGR_LOG_D("Enter GetAllStatsInfo.");
410    if (netStatsCached_ != nullptr) {
411        netStatsCached_->GetUidPushStatsCached(infos);
412        netStatsCached_->GetAllPushStatsCached(infos);
413    } else {
414        NETMGR_LOG_E("Cached is nullptr");
415    }
416    return NetsysController::GetInstance().GetAllStatsInfo(infos);
417}
418
419int32_t NetStatsService::GetAllSimStatsInfo(std::vector<NetStatsInfo> &infos)
420{
421    NETMGR_LOG_D("Enter GetAllSimStatsInfo.");
422    return NetsysController::GetInstance().GetAllSimStatsInfo(infos);
423}
424
425int32_t NetStatsService::GetTrafficStatsByNetwork(std::unordered_map<uint32_t, NetStatsInfo> &infos,
426                                                  const sptr<NetStatsNetwork> &network)
427{
428    NETMGR_LOG_D("Enter GetTrafficStatsByNetwork.");
429    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork start");
430    if (netStatsCached_ == nullptr) {
431        return NETMANAGER_ERR_LOCAL_PTR_NULL;
432    }
433    if (network == nullptr || network->startTime_ > network->endTime_) {
434        NETMGR_LOG_E("param network is invalid");
435        return NETMANAGER_ERR_INVALID_PARAMETER;
436    }
437    std::string ident;
438    if (network->type_ == 0) {
439        ident = std::to_string(network->simId_);
440    }
441    uint32_t start = network->startTime_;
442    uint32_t end = network->endTime_;
443    NETMGR_LOG_D("param: ident=%{public}s, start=%{public}u, end=%{public}u", ident.c_str(), start, end);
444    auto history = std::make_unique<NetStatsHistory>();
445    if (history == nullptr) {
446        NETMGR_LOG_E("history is null");
447        return NETMANAGER_ERR_INTERNAL;
448    }
449    std::vector<NetStatsInfo> allInfo;
450    int32_t ret = history->GetHistoryByIdent(allInfo, ident, start, end);
451    if (ret != NETMANAGER_SUCCESS) {
452        NETMGR_LOG_E("get history by ident failed, err code=%{public}d", ret);
453        return ret;
454    }
455    netStatsCached_->GetKernelStats(allInfo);
456    netStatsCached_->GetUidPushStatsCached(allInfo);
457    netStatsCached_->GetUidStatsCached(allInfo);
458    netStatsCached_->GetUidSimStatsCached(allInfo);
459    std::for_each(allInfo.begin(), allInfo.end(), [&infos, &ident, &start, &end](NetStatsInfo &info) {
460        if (ident != info.ident_ || start > info.date_ || end < info.date_) {
461            return;
462        }
463        if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
464            info.uid_ = UNINSTALLED_UID;
465        }
466        auto item = infos.find(info.uid_);
467        if (item == infos.end()) {
468            infos.emplace(info.uid_, info);
469        } else {
470            item->second += info;
471        }
472    });
473    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByNetwork end");
474    return NETMANAGER_SUCCESS;
475}
476
477int32_t NetStatsService::GetTrafficStatsByUidNetwork(std::vector<NetStatsInfoSequence> &infos, uint32_t uid,
478                                                     const sptr<NetStatsNetwork> &network)
479{
480    NETMGR_LOG_D("Enter GetTrafficStatsByUidNetwork.");
481    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork start");
482    if (netStatsCached_ == nullptr) {
483        NETMGR_LOG_E("Cached is nullptr");
484        return NETMANAGER_ERR_LOCAL_PTR_NULL;
485    }
486    if (network == nullptr || network->startTime_ > network->endTime_) {
487        NETMGR_LOG_E("param network is invalid");
488        return NETMANAGER_ERR_INVALID_PARAMETER;
489    }
490    std::string ident;
491    if (network->type_ == 0) {
492        ident = std::to_string(network->simId_);
493    }
494    uint32_t start = network->startTime_;
495    uint32_t end = network->endTime_;
496    NETMGR_LOG_D("GetTrafficStatsByUidNetwork param: "
497        "uid=%{public}u, ident=%{public}s, start=%{public}u, end=%{public}u", uid, ident.c_str(), start, end);
498    auto history = std::make_unique<NetStatsHistory>();
499    if (history == nullptr) {
500        NETMGR_LOG_E("history is null");
501        return NETMANAGER_ERR_INTERNAL;
502    }
503    std::vector<NetStatsInfo> allInfo;
504    int32_t ret = history->GetHistory(allInfo, uid, ident, start, end);
505    if (ret != NETMANAGER_SUCCESS) {
506        NETMGR_LOG_E("get history by uid and ident failed, err code=%{public}d", ret);
507        return ret;
508    }
509    netStatsCached_->GetKernelStats(allInfo);
510    netStatsCached_->GetUidPushStatsCached(allInfo);
511    netStatsCached_->GetUidStatsCached(allInfo);
512    netStatsCached_->GetUidSimStatsCached(allInfo);
513    std::for_each(allInfo.begin(), allInfo.end(), [this, &infos, &uid, &ident, &start, &end](const NetStatsInfo &info) {
514        if (uid != info.uid_ || ident != info.ident_ || start > info.date_ || end < info.date_) {
515            return;
516        }
517        if (info.flag_ == STATS_DATA_FLAG_UNINSTALLED) {
518            return;
519        }
520        MergeTrafficStats(infos, info, end);
521    });
522    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService GetTrafficStatsByUidNetwork end");
523    return NETMANAGER_SUCCESS;
524}
525
526int32_t NetStatsService::SetAppStats(const PushStatsInfo &info)
527{
528    NETMGR_LOG_D("Enter GetTrafficStatsByUidNetwork.");
529    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats start");
530    if (netStatsCached_ == nullptr) {
531        NETMGR_LOG_E("Cached is nullptr");
532        return NETMANAGER_ERR_LOCAL_PTR_NULL;
533    }
534    netStatsCached_->SetAppStats(info);
535    NetmanagerHiTrace::NetmanagerStartSyncTrace("NetStatsService SetAppStats end");
536    return NETMANAGER_SUCCESS;
537}
538
539int32_t NetStatsService::GetCookieRxBytes(uint64_t &stats, uint64_t cookie)
540{
541    return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_RX_BYTES),
542                                                          cookie);
543}
544
545int32_t NetStatsService::GetCookieTxBytes(uint64_t &stats, uint64_t cookie)
546{
547    return NetsysController::GetInstance().GetCookieStats(stats, static_cast<uint32_t>(StatsType::STATS_TYPE_TX_BYTES),
548                                                          cookie);
549}
550
551void NetStatsService::MergeTrafficStats(std::vector<NetStatsInfoSequence> &statsInfoSequences, const NetStatsInfo &info,
552                                        uint32_t currentTimestamp)
553{
554    NetStatsInfoSequence tmp;
555    tmp.startTime_ = info.date_;
556    tmp.endTime_ = info.date_;
557    tmp.info_ = info;
558    uint32_t previousTimestamp = currentTimestamp > DAY_SECONDS ? currentTimestamp - DAY_SECONDS : 0;
559    if (info.date_ > previousTimestamp) {
560        statsInfoSequences.push_back(std::move(tmp));
561        return;
562    }
563    auto findRet = std::find_if(
564        statsInfoSequences.begin(), statsInfoSequences.end(), [&info, previousTimestamp](const auto &item) {
565            return item.endTime_ < previousTimestamp && CommonUtils::IsSameNaturalDay(info.date_, item.endTime_);
566        });
567    if (findRet == statsInfoSequences.end()) {
568        statsInfoSequences.push_back(std::move(tmp));
569        return;
570    }
571    (*findRet).info_ += info;
572}
573
574bool NetStatsService::GetIfaceNamesFromManager(std::list<std::string> &ifaceNames)
575{
576    int32_t ret = NetManagerCenter::GetInstance().GetIfaceNames(BEARER_CELLULAR, ifaceNames);
577    if (ret != NETMANAGER_SUCCESS || ifaceNames.empty()) {
578        NETMGR_LOG_D("Iface list is empty, ret = %{public}d", ret);
579        return false;
580    }
581    return true;
582}
583} // namespace NetManagerStandard
584} // namespace OHOS
585