1 /*
2 * Copyright (c) 2022-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 "statistics_exec.h"
17
18 #include "errorcode_convertor.h"
19 #include "napi_utils.h"
20 #include "net_stats_client.h"
21 #include "net_stats_constants.h"
22 #include "net_stats_network.h"
23 #include "netmanager_base_log.h"
24 #include "statistics_observer_wrapper.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
28 namespace {
29 const std::string RX_BYTES = "rxBytes";
30 const std::string TX_BYTES = "txBytes";
31 const std::string RX_PACKETS = "rxPackets";
32 const std::string TX_PACKETS = "txPackets";
33 const std::string START_TIME = "startTime";
34 const std::string END_TIME = "endTime";
35 const std::string NET_STATS_INFO = "info";
36 } // namespace
37
ExecGetCellularRxBytes(GetCellularRxBytesContext * context)38 bool StatisticsExec::ExecGetCellularRxBytes(GetCellularRxBytesContext *context)
39 {
40 int32_t result = NetStatsClient::GetInstance().GetCellularRxBytes(context->bytes64_);
41 context->SetErrorCode(result);
42 return result == NETMANAGER_SUCCESS;
43 }
44
ExecGetCellularTxBytes(GetCellularTxBytesContext * context)45 bool StatisticsExec::ExecGetCellularTxBytes(GetCellularTxBytesContext *context)
46 {
47 int32_t result = NetStatsClient::GetInstance().GetCellularTxBytes(context->bytes64_);
48 context->SetErrorCode(result);
49 return result == NETMANAGER_SUCCESS;
50 }
51
ExecGetAllRxBytes(GetAllRxBytesContext * context)52 bool StatisticsExec::ExecGetAllRxBytes(GetAllRxBytesContext *context)
53 {
54 int32_t result = NetStatsClient::GetInstance().GetAllRxBytes(context->bytes64_);
55 context->SetErrorCode(result);
56 return result == NETMANAGER_SUCCESS;
57 }
58
ExecGetAllTxBytes(GetAllTxBytesContext * context)59 bool StatisticsExec::ExecGetAllTxBytes(GetAllTxBytesContext *context)
60 {
61 int32_t result = NetStatsClient::GetInstance().GetAllTxBytes(context->bytes64_);
62 context->SetErrorCode(result);
63 return result == NETMANAGER_SUCCESS;
64 }
65
ExecGetUidRxBytes(GetUidRxBytesContext * context)66 bool StatisticsExec::ExecGetUidRxBytes(GetUidRxBytesContext *context)
67 {
68 int32_t result = NetStatsClient::GetInstance().GetUidRxBytes(context->bytes64_, context->uid_);
69 context->SetErrorCode(result);
70 return result == NETMANAGER_SUCCESS;
71 }
72
ExecGetUidTxBytes(GetUidTxBytesContext * context)73 bool StatisticsExec::ExecGetUidTxBytes(GetUidTxBytesContext *context)
74 {
75 int32_t result = NetStatsClient::GetInstance().GetUidTxBytes(context->bytes64_, context->uid_);
76 context->SetErrorCode(result);
77 return result == NETMANAGER_SUCCESS;
78 }
79
ExecGetIfaceRxBytes(GetIfaceRxBytesContext * context)80 bool StatisticsExec::ExecGetIfaceRxBytes(GetIfaceRxBytesContext *context)
81 {
82 int32_t result = NetStatsClient::GetInstance().GetIfaceRxBytes(context->bytes64_, context->interfaceName_);
83 context->SetErrorCode(result);
84 return result == NETMANAGER_SUCCESS;
85 }
86
ExecGetIfaceTxBytes(GetIfaceTxBytesContext * context)87 bool StatisticsExec::ExecGetIfaceTxBytes(GetIfaceTxBytesContext *context)
88 {
89 int32_t result = NetStatsClient::GetInstance().GetIfaceTxBytes(context->bytes64_, context->interfaceName_);
90 context->SetErrorCode(result);
91 return result == NETMANAGER_SUCCESS;
92 }
93
ExecGetIfaceStats(GetIfaceStatsContext * context)94 bool StatisticsExec::ExecGetIfaceStats(GetIfaceStatsContext *context)
95 {
96 int32_t result = NetStatsClient::GetInstance().GetIfaceStatsDetail(context->GetInterfaceName(), context->GetStart(),
97 context->GetEnd(), context->GetStatsInfo());
98 context->SetErrorCode(result);
99 return result == NETMANAGER_SUCCESS;
100 }
101
ExecGetIfaceUidStats(GetIfaceUidStatsContext * context)102 bool StatisticsExec::ExecGetIfaceUidStats(GetIfaceUidStatsContext *context)
103 {
104 int32_t result = NetStatsClient::GetInstance().GetUidStatsDetail(context->GetInterfaceName(), context->GetUid(),
105 context->GetStart(), context->GetEnd(),
106 context->GetStatsInfo());
107 context->SetErrorCode(result);
108 return result == NETMANAGER_SUCCESS;
109 }
110
ExecUpdateIfacesStats(UpdateIfacesStatsContext * context)111 bool StatisticsExec::ExecUpdateIfacesStats(UpdateIfacesStatsContext *context)
112 {
113 int32_t result = NetStatsClient::GetInstance().UpdateIfacesStats(context->GetInterfaceName(), context->GetStart(),
114 context->GetEnd(), context->GetStatsInfo());
115 context->SetErrorCode(result);
116 return result == NETMANAGER_SUCCESS;
117 }
118
ExecUpdateStatsData(UpdateStatsDataContext * context)119 bool StatisticsExec::ExecUpdateStatsData(UpdateStatsDataContext *context)
120 {
121 int32_t result = NetStatsClient::GetInstance().UpdateStatsData();
122 context->SetErrorCode(result);
123 return result == NETMANAGER_SUCCESS;
124 }
125
ExecGetSockfdRxBytes(GetSockfdRxBytesContext * context)126 bool StatisticsExec::ExecGetSockfdRxBytes(GetSockfdRxBytesContext *context)
127 {
128 int32_t result = NetStatsClient::GetInstance().GetSockfdRxBytes(context->bytes64_, context->sockfd_);
129 context->SetErrorCode(result);
130 return result == NETMANAGER_SUCCESS;
131 }
132
ExecGetSockfdTxBytes(GetSockfdTxBytesContext * context)133 bool StatisticsExec::ExecGetSockfdTxBytes(GetSockfdTxBytesContext *context)
134 {
135 int32_t result = NetStatsClient::GetInstance().GetSockfdTxBytes(context->bytes64_, context->sockfd_);
136 context->SetErrorCode(result);
137 return result == NETMANAGER_SUCCESS;
138 }
139
ExecGetTrafficStatsByNetwork(GetTrafficStatsByNetworkContext * context)140 bool StatisticsExec::ExecGetTrafficStatsByNetwork(GetTrafficStatsByNetworkContext *context)
141 {
142 sptr<NetStatsNetwork> network = new (std::nothrow) NetStatsNetwork();
143 if (network == nullptr) {
144 NETMANAGER_BASE_LOGE("the network of param to get traffic stats is null");
145 return false;
146 }
147 network->simId_ = context->GetSimId();
148 network->startTime_ = context->GetStartTime();
149 network->endTime_ = context->GetEndTime();
150 network->type_ = context->GetNetBearType();
151 int32_t result = NetStatsClient::GetInstance().GetTrafficStatsByNetwork(context->GetNetStatsInfo(), network);
152 context->SetErrorCode(result);
153 return result == NETMANAGER_SUCCESS;
154 }
155
ExecGetTrafficStatsByUidNetwork(GetTrafficStatsByUidNetworkContext * context)156 bool StatisticsExec::ExecGetTrafficStatsByUidNetwork(GetTrafficStatsByUidNetworkContext *context)
157 {
158 sptr<NetStatsNetwork> network = new (std::nothrow) NetStatsNetwork();
159 if (network == nullptr) {
160 NETMANAGER_BASE_LOGE("the network of param to get traffic stats is null");
161 return false;
162 }
163 network->simId_ = context->GetSimId();
164 network->startTime_ = context->GetStartTime();
165 network->endTime_ = context->GetEndTime();
166 network->type_ = context->GetNetBearType();
167 int32_t result = NetStatsClient::GetInstance().GetTrafficStatsByUidNetwork(context->GetNetStatsInfoSequence(),
168 context->GetUid(), network);
169 context->SetErrorCode(result);
170 return result == NETMANAGER_SUCCESS;
171 }
172
GetCellularRxBytesCallback(GetCellularRxBytesContext * context)173 napi_value StatisticsExec::GetCellularRxBytesCallback(GetCellularRxBytesContext *context)
174 {
175 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
176 }
177
GetCellularTxBytesCallback(GetCellularTxBytesContext * context)178 napi_value StatisticsExec::GetCellularTxBytesCallback(GetCellularTxBytesContext *context)
179 {
180 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
181 }
182
GetAllRxBytesCallback(GetAllRxBytesContext * context)183 napi_value StatisticsExec::GetAllRxBytesCallback(GetAllRxBytesContext *context)
184 {
185 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
186 }
187
GetAllTxBytesCallback(GetAllTxBytesContext * context)188 napi_value StatisticsExec::GetAllTxBytesCallback(GetAllTxBytesContext *context)
189 {
190 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
191 }
192
GetUidRxBytesCallback(GetUidRxBytesContext * context)193 napi_value StatisticsExec::GetUidRxBytesCallback(GetUidRxBytesContext *context)
194 {
195 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
196 }
197
GetUidTxBytesCallback(GetUidTxBytesContext * context)198 napi_value StatisticsExec::GetUidTxBytesCallback(GetUidTxBytesContext *context)
199 {
200 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
201 }
202
GetIfaceRxBytesCallback(GetIfaceRxBytesContext * context)203 napi_value StatisticsExec::GetIfaceRxBytesCallback(GetIfaceRxBytesContext *context)
204 {
205 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
206 }
207
GetIfaceTxBytesCallback(GetIfaceTxBytesContext * context)208 napi_value StatisticsExec::GetIfaceTxBytesCallback(GetIfaceTxBytesContext *context)
209 {
210 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
211 }
212
GetIfaceStatsCallback(GetIfaceStatsContext * context)213 napi_value StatisticsExec::GetIfaceStatsCallback(GetIfaceStatsContext *context)
214 {
215 napi_value netStatsInfo = NapiUtils::CreateObject(context->GetEnv());
216 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, RX_BYTES, context->GetStatsInfo().rxBytes_);
217 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, TX_BYTES, context->GetStatsInfo().txBytes_);
218 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, RX_PACKETS, context->GetStatsInfo().rxPackets_);
219 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, TX_PACKETS, context->GetStatsInfo().txPackets_);
220 return netStatsInfo;
221 }
222
GetIfaceUidStatsCallback(GetIfaceUidStatsContext * context)223 napi_value StatisticsExec::GetIfaceUidStatsCallback(GetIfaceUidStatsContext *context)
224 {
225 napi_value netStatsInfo = NapiUtils::CreateObject(context->GetEnv());
226 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, RX_BYTES, context->GetStatsInfo().rxBytes_);
227 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, TX_BYTES, context->GetStatsInfo().txBytes_);
228 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, RX_PACKETS, context->GetStatsInfo().rxPackets_);
229 NapiUtils::SetInt64Property(context->GetEnv(), netStatsInfo, TX_PACKETS, context->GetStatsInfo().txPackets_);
230 return netStatsInfo;
231 }
232
GetGetTrafficStatsByNetworkCallback(GetTrafficStatsByNetworkContext * context)233 napi_value StatisticsExec::GetGetTrafficStatsByNetworkCallback(GetTrafficStatsByNetworkContext *context)
234 {
235 napi_value infos = NapiUtils::CreateObject(context->GetEnv());
236 auto data = context->GetNetStatsInfo();
237 for (const auto &item : data) {
238 napi_value tmp = NapiUtils::CreateObject(context->GetEnv());
239 NapiUtils::SetInt64Property(context->GetEnv(), tmp, RX_BYTES, item.second.rxBytes_);
240 NapiUtils::SetInt64Property(context->GetEnv(), tmp, TX_BYTES, item.second.txBytes_);
241 NapiUtils::SetInt64Property(context->GetEnv(), tmp, RX_PACKETS, item.second.rxPackets_);
242 NapiUtils::SetInt64Property(context->GetEnv(), tmp, TX_PACKETS, item.second.txPackets_);
243 std::string key = std::to_string(item.first);
244 NapiUtils::SetNamedProperty(context->GetEnv(), infos, key, tmp);
245 }
246 return infos;
247 }
248
GetGetTrafficStatsByUidNetworkCallback(GetTrafficStatsByUidNetworkContext * context)249 napi_value StatisticsExec::GetGetTrafficStatsByUidNetworkCallback(GetTrafficStatsByUidNetworkContext *context)
250 {
251 auto list = context->GetNetStatsInfoSequence();
252 napi_value stats = NapiUtils::CreateArray(context->GetEnv(), list.size());
253 size_t index = 0;
254 for (const auto &item : list) {
255 napi_value info = NapiUtils::CreateObject(context->GetEnv());
256 NapiUtils::SetInt64Property(context->GetEnv(), info, RX_BYTES, item.info_.rxBytes_);
257 NapiUtils::SetInt64Property(context->GetEnv(), info, TX_BYTES, item.info_.txBytes_);
258 NapiUtils::SetInt64Property(context->GetEnv(), info, RX_PACKETS, item.info_.rxPackets_);
259 NapiUtils::SetInt64Property(context->GetEnv(), info, TX_PACKETS, item.info_.txPackets_);
260
261 napi_value tmp = NapiUtils::CreateObject(context->GetEnv());
262 NapiUtils::SetInt64Property(context->GetEnv(), tmp, START_TIME, item.startTime_);
263 NapiUtils::SetInt64Property(context->GetEnv(), tmp, END_TIME, item.endTime_);
264 NapiUtils::SetNamedProperty(context->GetEnv(), tmp, NET_STATS_INFO, info);
265
266 NapiUtils::SetArrayElement(context->GetEnv(), stats, index++, tmp);
267 }
268 return stats;
269 }
270
UpdateIfacesStatsCallback(UpdateIfacesStatsContext * context)271 napi_value StatisticsExec::UpdateIfacesStatsCallback(UpdateIfacesStatsContext *context)
272 {
273 return NapiUtils::GetUndefined(context->GetEnv());
274 }
275
UpdateStatsDataCallback(UpdateStatsDataContext * context)276 napi_value StatisticsExec::UpdateStatsDataCallback(UpdateStatsDataContext *context)
277 {
278 return NapiUtils::GetUndefined(context->GetEnv());
279 }
280
GetSockfdRxBytesCallback(GetSockfdRxBytesContext * context)281 napi_value StatisticsExec::GetSockfdRxBytesCallback(GetSockfdRxBytesContext *context)
282 {
283 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
284 }
285
GetSockfdTxBytesCallback(GetSockfdTxBytesContext * context)286 napi_value StatisticsExec::GetSockfdTxBytesCallback(GetSockfdTxBytesContext *context)
287 {
288 return NapiUtils::CreateInt64(context->GetEnv(), context->bytes64_);
289 }
290 } // namespace NetManagerStandard
291 } // namespace OHOS
292