1 /*
2 * Copyright (C) 2021-2024 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 "signal_information.h"
17
18 #include <string_ex.h>
19 #include "telephony_log_wrapper.h"
20
21 namespace OHOS {
22 namespace Telephony {
23 constexpr int32_t SIGNAL_RSSI_MAXIMUM = -1;
24 constexpr int32_t SIGNAL_INTENSITY_INVALID = 0;
25 constexpr int32_t SIGNAL_LEVEL_INVALID = 0;
26 constexpr int32_t SIGNAL_LEVEL_UNSET = -1;
27 constexpr int32_t SIGNAL_FIVE_BARS = 5;
28 constexpr int32_t SIGNAL_FOUR_BARS = 4;
29 const int32_t *GSM_SIGNAL_THRESHOLD = SignalInformation::GSM_SIGNAL_THRESHOLD_5BAR;
30 const int32_t *CDMA_SIGNAL_THRESHOLD = SignalInformation::CDMA_SIGNAL_THRESHOLD_5BAR;
31 const int32_t *LTE_SIGNAL_THRESHOLD = SignalInformation::LTE_SIGNAL_THRESHOLD_5BAR;
32 const int32_t *WCDMA_SIGNAL_THRESHOLD = SignalInformation::WCDMA_SIGNAL_THRESHOLD_5BAR;
33 const int32_t *TD_SCDMA_SIGNAL_THRESHOLD = SignalInformation::TD_SCDMA_SIGNAL_THRESHOLD_5BAR;
34 const int32_t *NR_SIGNAL_THRESHOLD = SignalInformation::NR_SIGNAL_THRESHOLD_5BAR;
35 int32_t SignalInformation::signalBar_ = SIGNAL_FIVE_BARS;
36
SignalInformation()37 SignalInformation::SignalInformation()
38 {
39 InitSignalBar();
40 }
41
InitSignalBar(const int32_t bar)42 void SignalInformation::InitSignalBar(const int32_t bar)
43 {
44 if (bar == SIGNAL_FOUR_BARS) {
45 GSM_SIGNAL_THRESHOLD = SignalInformation::GSM_SIGNAL_THRESHOLD_4BAR;
46 CDMA_SIGNAL_THRESHOLD = SignalInformation::CDMA_SIGNAL_THRESHOLD_4BAR;
47 LTE_SIGNAL_THRESHOLD = SignalInformation::LTE_SIGNAL_THRESHOLD_4BAR;
48 WCDMA_SIGNAL_THRESHOLD = SignalInformation::WCDMA_SIGNAL_THRESHOLD_4BAR;
49 TD_SCDMA_SIGNAL_THRESHOLD = SignalInformation::TD_SCDMA_SIGNAL_THRESHOLD_4BAR;
50 NR_SIGNAL_THRESHOLD = SignalInformation::NR_SIGNAL_THRESHOLD_4BAR;
51 signalBar_ = SIGNAL_FOUR_BARS;
52 } else {
53 GSM_SIGNAL_THRESHOLD = SignalInformation::GSM_SIGNAL_THRESHOLD_5BAR;
54 CDMA_SIGNAL_THRESHOLD = SignalInformation::CDMA_SIGNAL_THRESHOLD_5BAR;
55 LTE_SIGNAL_THRESHOLD = SignalInformation::LTE_SIGNAL_THRESHOLD_5BAR;
56 WCDMA_SIGNAL_THRESHOLD = SignalInformation::WCDMA_SIGNAL_THRESHOLD_5BAR;
57 TD_SCDMA_SIGNAL_THRESHOLD = SignalInformation::TD_SCDMA_SIGNAL_THRESHOLD_5BAR;
58 NR_SIGNAL_THRESHOLD = SignalInformation::NR_SIGNAL_THRESHOLD_5BAR;
59 signalBar_ = SIGNAL_FIVE_BARS;
60 }
61 }
62
Unmarshalling(Parcel & parcel)63 std::unique_ptr<SignalInformation> SignalInformation::Unmarshalling(Parcel &parcel)
64 {
65 return nullptr;
66 }
67
SetSignalLevel(const int32_t level)68 void SignalInformation::SetSignalLevel(const int32_t level)
69 {
70 signalLevel_ = level;
71 }
72
operator =(const GsmSignalInformation & gsm)73 GsmSignalInformation &GsmSignalInformation::operator=(const GsmSignalInformation &gsm)
74 {
75 signalBar_ = gsm.signalBar_;
76 gsmRxlev_ = gsm.gsmRxlev_;
77 gsmBer_ = gsm.gsmBer_;
78 signalLevel_ = gsm.signalLevel_;
79 return *this;
80 }
81
operator ==(const GsmSignalInformation & gsm) const82 bool GsmSignalInformation::operator==(const GsmSignalInformation &gsm) const
83 {
84 return gsmRxlev_ == gsm.gsmRxlev_ && gsmBer_ == gsm.gsmBer_;
85 }
86
SetValue(const int32_t gsmRssi,const int32_t gsmBer)87 void GsmSignalInformation::SetValue(const int32_t gsmRssi, const int32_t gsmBer)
88 {
89 gsmRxlev_ = gsmRssi;
90 gsmBer_ = gsmBer;
91 }
92
GetRssi() const93 int32_t GsmSignalInformation::GetRssi() const
94 {
95 return gsmRxlev_;
96 }
97
GetGsmBer() const98 int32_t GsmSignalInformation::GetGsmBer() const
99 {
100 return gsmBer_;
101 }
102
GetSignalIntensity() const103 int32_t GsmSignalInformation::GetSignalIntensity() const
104 {
105 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
106
107 if (ValidateGsmValue()) {
108 signalIntensity = GetRssi();
109 } else {
110 TELEPHONY_LOGE("GsmSignalInformation::GetSignalIntensity Value is Invalid.");
111 }
112
113 return signalIntensity;
114 }
115
GetSignalLevel() const116 int32_t GsmSignalInformation::GetSignalLevel() const
117 {
118 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
119 return signalLevel_;
120 }
121 int32_t level = SIGNAL_LEVEL_INVALID;
122 int32_t gsmRxlev = GetRssi();
123 if (ValidateGsmValue()) {
124 // Reference: TS 27.007 section 8.69
125 for (int32_t i = signalBar_; i >= 0; --i) {
126 if (gsmRxlev >= GSM_SIGNAL_THRESHOLD[i]) {
127 level = i;
128 break;
129 }
130 }
131 } else {
132 TELEPHONY_LOGE("GsmSignalInformation::GetSignalLevel Value is Invalid.");
133 }
134 return level;
135 }
136
GetNetworkType() const137 SignalInformation::NetworkType GsmSignalInformation::GetNetworkType() const
138 {
139 return SignalInformation::NetworkType::GSM;
140 }
141
ToString() const142 std::string GsmSignalInformation::ToString() const
143 {
144 int32_t netWorkType = static_cast<int32_t>(GsmSignalInformation::GetNetworkType());
145 std::string content("networkType:" + std::to_string(netWorkType) + ",gsmRxlev:" + std::to_string(gsmRxlev_) +
146 ",signalLevel:" + std::to_string(GsmSignalInformation::GetSignalLevel()) +
147 ",gsmBer:" + std::to_string(gsmBer_));
148 return content;
149 }
150
NewInstance() const151 sptr<SignalInformation> GsmSignalInformation::NewInstance() const
152 {
153 std::unique_ptr<GsmSignalInformation> gsm = std::make_unique<GsmSignalInformation>();
154 if (gsm == nullptr) {
155 return nullptr;
156 }
157 gsm->SetValue(this->gsmRxlev_, this->gsmBer_);
158 return gsm.release();
159 }
160
Marshalling(Parcel & parcel) const161 bool GsmSignalInformation::Marshalling(Parcel &parcel) const
162 {
163 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::GSM))) {
164 return false;
165 }
166 if (!parcel.WriteInt32(gsmRxlev_)) {
167 return false;
168 }
169 if (!parcel.WriteInt32(gsmBer_)) {
170 return false;
171 }
172 if (!parcel.WriteInt32(signalLevel_)) {
173 return false;
174 }
175 return true;
176 }
177
Unmarshalling(Parcel & parcel)178 std::unique_ptr<GsmSignalInformation> GsmSignalInformation::Unmarshalling(Parcel &parcel)
179 {
180 std::unique_ptr<GsmSignalInformation> signal = std::make_unique<GsmSignalInformation>();
181 if (signal && !signal->ReadFromParcel(parcel)) {
182 signal = nullptr;
183 }
184 return signal;
185 }
186
ReadFromParcel(Parcel & parcel)187 bool GsmSignalInformation::ReadFromParcel(Parcel &parcel)
188 {
189 if (!parcel.ReadInt32(gsmRxlev_)) {
190 return false;
191 }
192 if (!parcel.ReadInt32(gsmBer_)) {
193 return false;
194 }
195 if (!parcel.ReadInt32(signalLevel_)) {
196 return false;
197 }
198 return true;
199 }
200
ValidateGsmValue() const201 bool GsmSignalInformation::ValidateGsmValue() const
202 {
203 return gsmRxlev_ < SIGNAL_RSSI_MAXIMUM;
204 }
205
SetValue(const int32_t cdmaRssi,const int32_t cdmaEcno)206 void CdmaSignalInformation::SetValue(const int32_t cdmaRssi, const int32_t cdmaEcno)
207 {
208 cdmaRssi_ = cdmaRssi;
209 cdmaEcno_ = cdmaEcno;
210 }
211
operator =(const CdmaSignalInformation & cdma)212 CdmaSignalInformation &CdmaSignalInformation::operator=(const CdmaSignalInformation &cdma)
213 {
214 signalBar_ = cdma.signalBar_;
215 cdmaRssi_ = cdma.cdmaRssi_;
216 cdmaEcno_ = cdma.cdmaEcno_;
217 signalLevel_ = cdma.signalLevel_;
218 return *this;
219 }
220
operator ==(const CdmaSignalInformation & cdma) const221 bool CdmaSignalInformation::operator==(const CdmaSignalInformation &cdma) const
222 {
223 return (cdmaRssi_ == cdma.cdmaRssi_ && cdmaEcno_ == cdma.cdmaEcno_);
224 }
225
GetCdmaRssi() const226 int32_t CdmaSignalInformation::GetCdmaRssi() const
227 {
228 return cdmaRssi_;
229 }
230
GetSignalIntensity() const231 int32_t CdmaSignalInformation::GetSignalIntensity() const
232 {
233 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
234
235 if (ValidateCdmaValue()) {
236 signalIntensity = GetCdmaRssi();
237 } else {
238 TELEPHONY_LOGE("CdmaSignalInformation::GetSignalIntensity Value is Invalid.");
239 }
240
241 return signalIntensity;
242 }
243
GetSignalLevel() const244 int32_t CdmaSignalInformation::GetSignalLevel() const
245 {
246 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
247 return signalLevel_;
248 }
249 int32_t cdmaRssi = GetCdmaRssi();
250 int32_t level = SIGNAL_LEVEL_INVALID;
251 if (ValidateCdmaValue()) {
252 // Reference: TS 27.007 section 8.69
253 for (int32_t i = signalBar_; i >= 0; --i) {
254 if (cdmaRssi >= CDMA_SIGNAL_THRESHOLD[i]) {
255 level = i;
256 break;
257 }
258 }
259 }
260 return level;
261 }
262
GetNetworkType() const263 SignalInformation::NetworkType CdmaSignalInformation::GetNetworkType() const
264 {
265 return SignalInformation::NetworkType::CDMA;
266 }
267
ToString() const268 std::string CdmaSignalInformation::ToString() const
269 {
270 int32_t netWorkType = static_cast<int32_t>(CdmaSignalInformation::GetNetworkType());
271 std::string content(",networkType:" + std::to_string(netWorkType) + ",cdmaRssi:" + std::to_string(cdmaRssi_) +
272 ",cdmaEcno:" + std::to_string(cdmaEcno_) +
273 ",signalLevel:" + std::to_string(CdmaSignalInformation::GetSignalLevel()));
274 return content;
275 }
276
NewInstance() const277 sptr<SignalInformation> CdmaSignalInformation::NewInstance() const
278 {
279 std::unique_ptr<CdmaSignalInformation> cdma = std::make_unique<CdmaSignalInformation>();
280 if (cdma == nullptr) {
281 return nullptr;
282 }
283 cdma->SetValue(this->cdmaRssi_, this->cdmaEcno_);
284 return cdma.release();
285 }
286
Marshalling(Parcel & parcel) const287 bool CdmaSignalInformation::Marshalling(Parcel &parcel) const
288 {
289 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::CDMA))) {
290 return false;
291 }
292 if (!parcel.WriteInt32(cdmaRssi_)) {
293 return false;
294 }
295 if (!parcel.WriteInt32(cdmaEcno_)) {
296 return false;
297 }
298 if (!parcel.WriteInt32(signalLevel_)) {
299 return false;
300 }
301 return true;
302 }
303
Unmarshalling(Parcel & parcel)304 std::unique_ptr<CdmaSignalInformation> CdmaSignalInformation::Unmarshalling(Parcel &parcel)
305 {
306 std::unique_ptr<CdmaSignalInformation> signal = std::make_unique<CdmaSignalInformation>();
307 if (signal && !signal->ReadFromParcel(parcel)) {
308 signal = nullptr;
309 }
310 return signal;
311 }
312
ReadFromParcel(Parcel & parcel)313 bool CdmaSignalInformation::ReadFromParcel(Parcel &parcel)
314 {
315 if (!parcel.ReadInt32(cdmaRssi_)) {
316 return false;
317 }
318 if (!parcel.ReadInt32(cdmaEcno_)) {
319 return false;
320 }
321 if (!parcel.ReadInt32(signalLevel_)) {
322 return false;
323 }
324 return true;
325 }
326
ValidateCdmaValue() const327 bool CdmaSignalInformation::ValidateCdmaValue() const
328 {
329 return cdmaRssi_ < SIGNAL_RSSI_MAXIMUM;
330 }
331
operator =(const LteSignalInformation & lte)332 LteSignalInformation &LteSignalInformation::operator=(const LteSignalInformation <e)
333 {
334 signalBar_ = lte.signalBar_;
335 rxlev_ = lte.rxlev_;
336 lteRsrp_ = lte.lteRsrp_;
337 lteRsrq_ = lte.lteRsrq_;
338 lteSnr_ = lte.lteSnr_;
339 signalLevel_ = lte.signalLevel_;
340 return *this;
341 }
342
operator ==(const LteSignalInformation & lte) const343 bool LteSignalInformation::operator==(const LteSignalInformation <e) const
344 {
345 return rxlev_ == lte.rxlev_ && lteRsrp_ == lte.lteRsrp_ && lteRsrq_ == lte.lteRsrq_ && lteSnr_ == lte.lteSnr_;
346 }
347
SetValue(const int32_t rxlev,const int32_t lteRsrp,const int32_t lteRsrq,const int32_t lteSnr)348 void LteSignalInformation::SetValue(
349 const int32_t rxlev, const int32_t lteRsrp, const int32_t lteRsrq, const int32_t lteSnr)
350 {
351 rxlev_ = rxlev;
352 lteRsrp_ = lteRsrp;
353 lteRsrq_ = lteRsrq;
354 lteSnr_ = lteSnr;
355 }
356
GetRxlev() const357 int32_t LteSignalInformation::GetRxlev() const
358 {
359 return rxlev_;
360 }
361
GetRsrp() const362 int32_t LteSignalInformation::GetRsrp() const
363 {
364 return lteRsrp_;
365 }
366
GetRsrq() const367 int32_t LteSignalInformation::GetRsrq() const
368 {
369 return lteRsrq_;
370 }
371
GetSnr() const372 int32_t LteSignalInformation::GetSnr() const
373 {
374 return lteSnr_;
375 }
376
GetSignalIntensity() const377 int32_t LteSignalInformation::GetSignalIntensity() const
378 {
379 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
380
381 if (ValidateLteValue()) {
382 signalIntensity = GetRsrp();
383 } else {
384 TELEPHONY_LOGE("LteSignalInformation::GetSignalIntensity Value is Invalid.");
385 }
386
387 return signalIntensity;
388 }
389
GetSignalLevel() const390 int32_t LteSignalInformation::GetSignalLevel() const
391 {
392 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
393 return signalLevel_;
394 }
395 int32_t level = SIGNAL_LEVEL_INVALID;
396 int32_t lteRsrp = GetRsrp();
397 if (ValidateLteValue()) {
398 // Reference: TS 27.007 section 8.69
399 for (int32_t i = signalBar_; i >= 0; --i) {
400 if (lteRsrp >= LTE_SIGNAL_THRESHOLD[i]) {
401 level = i;
402 break;
403 }
404 }
405 } else {
406 TELEPHONY_LOGE("LteSignalInformation::GetSignalLevel Value is Invalid.");
407 }
408 return level;
409 }
410
GetNetworkType() const411 SignalInformation::NetworkType LteSignalInformation::GetNetworkType() const
412 {
413 return SignalInformation::NetworkType::LTE;
414 }
415
ToString() const416 std::string LteSignalInformation::ToString() const
417 {
418 int32_t netWorkType = static_cast<int32_t>(LteSignalInformation::GetNetworkType());
419 std::string content("networkType:" + std::to_string(netWorkType) + ",lteRsrp:" + std::to_string(lteRsrp_) +
420 ",lteRsrq:" + std::to_string(lteRsrq_) + ",lteSnr:" + std::to_string(lteSnr_) + ",lteRxlev:" +
421 std::to_string(rxlev_) + ",signalLevel:" + std::to_string(LteSignalInformation::GetSignalLevel()));
422 return content;
423 }
424
NewInstance() const425 sptr<SignalInformation> LteSignalInformation::NewInstance() const
426 {
427 std::unique_ptr<LteSignalInformation> lte = std::make_unique<LteSignalInformation>();
428 if (lte == nullptr) {
429 return nullptr;
430 }
431 lte->SetValue(this->rxlev_, this->lteRsrp_, this->lteRsrq_, this->lteSnr_);
432 return lte.release();
433 }
434
Marshalling(Parcel & parcel) const435 bool LteSignalInformation::Marshalling(Parcel &parcel) const
436 {
437 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::LTE))) {
438 return false;
439 }
440 if (!parcel.WriteInt32(rxlev_)) {
441 return false;
442 }
443 if (!parcel.WriteInt32(lteRsrp_)) {
444 return false;
445 }
446 if (!parcel.WriteInt32(lteRsrq_)) {
447 return false;
448 }
449 if (!parcel.WriteInt32(lteSnr_)) {
450 return false;
451 }
452 if (!parcel.WriteInt32(signalLevel_)) {
453 return false;
454 }
455 return true;
456 }
457
Unmarshalling(Parcel & parcel)458 std::unique_ptr<LteSignalInformation> LteSignalInformation::Unmarshalling(Parcel &parcel)
459 {
460 std::unique_ptr<LteSignalInformation> signal = std::make_unique<LteSignalInformation>();
461 if (signal && !signal->ReadFromParcel(parcel)) {
462 signal = nullptr;
463 }
464 return signal;
465 }
466
ReadFromParcel(Parcel & parcel)467 bool LteSignalInformation::ReadFromParcel(Parcel &parcel)
468 {
469 if (!parcel.ReadInt32(rxlev_)) {
470 return false;
471 }
472 if (!parcel.ReadInt32(lteRsrp_)) {
473 return false;
474 }
475 if (!parcel.ReadInt32(lteRsrq_)) {
476 return false;
477 }
478 if (!parcel.ReadInt32(lteSnr_)) {
479 return false;
480 }
481 if (!parcel.ReadInt32(signalLevel_)) {
482 return false;
483 }
484 return true;
485 }
486
ValidateLteValue() const487 bool LteSignalInformation::ValidateLteValue() const
488 {
489 return lteRsrp_ < SIGNAL_RSSI_MAXIMUM;
490 }
491
operator =(const WcdmaSignalInformation & wcdma)492 WcdmaSignalInformation &WcdmaSignalInformation::operator=(const WcdmaSignalInformation &wcdma)
493 {
494 signalBar_ = wcdma.signalBar_;
495 wcdmaRxlev_ = wcdma.wcdmaRxlev_;
496 wcdmaRscp_ = wcdma.wcdmaRscp_;
497 wcdmaEcio_ = wcdma.wcdmaEcio_;
498 wcdmaBer_ = wcdma.wcdmaBer_;
499 signalLevel_ = wcdma.signalLevel_;
500 return *this;
501 }
502
operator ==(const WcdmaSignalInformation & wcdma) const503 bool WcdmaSignalInformation::operator==(const WcdmaSignalInformation &wcdma) const
504 {
505 return wcdmaRxlev_ == wcdma.wcdmaRxlev_ && wcdmaRscp_ == wcdma.wcdmaRscp_ && wcdmaEcio_ == wcdma.wcdmaEcio_ &&
506 wcdmaBer_ == wcdma.wcdmaBer_;
507 }
508
SetValue(const int32_t wcdmaRxlev,const int32_t wcdmaRscp,const int32_t wcdmaEcio,const int32_t wcdmaBer)509 void WcdmaSignalInformation::SetValue(
510 const int32_t wcdmaRxlev, const int32_t wcdmaRscp, const int32_t wcdmaEcio, const int32_t wcdmaBer)
511 {
512 wcdmaRxlev_ = wcdmaRxlev;
513 wcdmaRscp_ = wcdmaRscp;
514 wcdmaEcio_ = wcdmaEcio;
515 wcdmaBer_ = wcdmaBer;
516 }
517
GetRxlev() const518 int32_t WcdmaSignalInformation::GetRxlev() const
519 {
520 return wcdmaRxlev_;
521 }
522
GetRscp() const523 int32_t WcdmaSignalInformation::GetRscp() const
524 {
525 return wcdmaRscp_;
526 }
527
GetEcno() const528 int32_t WcdmaSignalInformation::GetEcno() const
529 {
530 return wcdmaEcio_;
531 }
532
GetBer() const533 int32_t WcdmaSignalInformation::GetBer() const
534 {
535 return wcdmaBer_;
536 }
537
GetSignalIntensity() const538 int32_t WcdmaSignalInformation::GetSignalIntensity() const
539 {
540 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
541
542 if (ValidateWcdmaValue()) {
543 signalIntensity = GetRscp();
544 } else {
545 TELEPHONY_LOGE("WcdmaSignalInformation::GetSignalIntensity Value is Invalid.");
546 }
547
548 return signalIntensity;
549 }
550
GetSignalLevel() const551 int32_t WcdmaSignalInformation::GetSignalLevel() const
552 {
553 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
554 return signalLevel_;
555 }
556 int32_t level = SIGNAL_LEVEL_INVALID;
557 int32_t wcdmaRscp = GetRscp();
558 if (ValidateWcdmaValue()) {
559 // Reference: TS 27.007 section 8.69
560 for (int32_t i = signalBar_; i >= 0; --i) {
561 if (wcdmaRscp >= WCDMA_SIGNAL_THRESHOLD[i]) {
562 level = i;
563 break;
564 }
565 }
566 } else {
567 TELEPHONY_LOGE("WcdmaSignalInformation::GetSignalLevel Value is Invalid.");
568 }
569 return level;
570 }
571
GetNetworkType() const572 SignalInformation::NetworkType WcdmaSignalInformation::GetNetworkType() const
573 {
574 return SignalInformation::NetworkType::WCDMA;
575 }
576
ToString() const577 std::string WcdmaSignalInformation::ToString() const
578 {
579 int32_t netWorkType = static_cast<int32_t>(WcdmaSignalInformation::GetNetworkType());
580 std::string content("networkType:" + std::to_string(netWorkType) + ",wcdmaRscp:" + std::to_string(wcdmaRscp_) +
581 ",wcdmaEcio:" + std::to_string(wcdmaEcio_) + ",wcdmaBer:" + std::to_string(wcdmaBer_) + ",wcdmaRxlev:" +
582 std::to_string(wcdmaRxlev_) + ",signalLevel:" + std::to_string(WcdmaSignalInformation::GetSignalLevel()));
583 return content;
584 }
585
NewInstance() const586 sptr<SignalInformation> WcdmaSignalInformation::NewInstance() const
587 {
588 std::unique_ptr<WcdmaSignalInformation> wcdma = std::make_unique<WcdmaSignalInformation>();
589 if (wcdma == nullptr) {
590 return nullptr;
591 }
592 wcdma->SetValue(this->wcdmaRxlev_, this->wcdmaRscp_, this->wcdmaEcio_, this->wcdmaBer_);
593 return wcdma.release();
594 }
595
Marshalling(Parcel & parcel) const596 bool WcdmaSignalInformation::Marshalling(Parcel &parcel) const
597 {
598 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::WCDMA))) {
599 return false;
600 }
601 if (!parcel.WriteInt32(wcdmaRxlev_)) {
602 return false;
603 }
604 if (!parcel.WriteInt32(wcdmaRscp_)) {
605 return false;
606 }
607 if (!parcel.WriteInt32(wcdmaEcio_)) {
608 return false;
609 }
610 if (!parcel.WriteInt32(wcdmaBer_)) {
611 return false;
612 }
613 if (!parcel.WriteInt32(signalLevel_)) {
614 return false;
615 }
616 return true;
617 }
618
Unmarshalling(Parcel & parcel)619 std::unique_ptr<WcdmaSignalInformation> WcdmaSignalInformation::Unmarshalling(Parcel &parcel)
620 {
621 std::unique_ptr<WcdmaSignalInformation> signal = std::make_unique<WcdmaSignalInformation>();
622 if (signal && !signal->ReadFromParcel(parcel)) {
623 signal = nullptr;
624 }
625 return signal;
626 }
627
ReadFromParcel(Parcel & parcel)628 bool WcdmaSignalInformation::ReadFromParcel(Parcel &parcel)
629 {
630 if (!parcel.ReadInt32(wcdmaRxlev_)) {
631 return false;
632 }
633 if (!parcel.ReadInt32(wcdmaRscp_)) {
634 return false;
635 }
636 if (!parcel.ReadInt32(wcdmaEcio_)) {
637 return false;
638 }
639 if (!parcel.ReadInt32(wcdmaBer_)) {
640 return false;
641 }
642 if (!parcel.ReadInt32(signalLevel_)) {
643 return false;
644 }
645 return true;
646 }
647
ValidateWcdmaValue() const648 bool WcdmaSignalInformation::ValidateWcdmaValue() const
649 {
650 return wcdmaRscp_ < SIGNAL_RSSI_MAXIMUM;
651 }
652
operator =(const TdScdmaSignalInformation & tdScdma)653 TdScdmaSignalInformation &TdScdmaSignalInformation::operator=(const TdScdmaSignalInformation &tdScdma)
654 {
655 signalBar_ = tdScdma.signalBar_;
656 tdScdmaRscp_ = tdScdma.tdScdmaRscp_;
657 signalLevel_ = tdScdma.signalLevel_;
658 return *this;
659 }
660
operator ==(const TdScdmaSignalInformation & tdScdma) const661 bool TdScdmaSignalInformation::operator==(const TdScdmaSignalInformation &tdScdma) const
662 {
663 return tdScdmaRscp_ == tdScdma.tdScdmaRscp_;
664 }
665
SetValue(const int32_t tdScdmaRscp)666 void TdScdmaSignalInformation::SetValue(const int32_t tdScdmaRscp)
667 {
668 tdScdmaRscp_ = tdScdmaRscp;
669 }
670
GetRscp() const671 int32_t TdScdmaSignalInformation::GetRscp() const
672 {
673 return tdScdmaRscp_;
674 }
675
GetSignalIntensity() const676 int32_t TdScdmaSignalInformation::GetSignalIntensity() const
677 {
678 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
679
680 if (ValidateTdScdmaValue()) {
681 signalIntensity = GetRscp();
682 } else {
683 TELEPHONY_LOGE("TdScdmaSignalInformation::GetSignalIntensity Value is Invalid.");
684 }
685
686 return signalIntensity;
687 }
688
GetSignalLevel() const689 int32_t TdScdmaSignalInformation::GetSignalLevel() const
690 {
691 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
692 return signalLevel_;
693 }
694 int32_t tdScdmaRscp = GetRscp();
695 int32_t level = SIGNAL_LEVEL_INVALID;
696 if (ValidateTdScdmaValue()) {
697 // Reference: TS 27.007 section 8.69
698 for (int32_t i = signalBar_; i >= 0; --i) {
699 if (tdScdmaRscp >= TD_SCDMA_SIGNAL_THRESHOLD[i]) {
700 level = i;
701 break;
702 }
703 }
704 }
705 return level;
706 }
707
GetNetworkType() const708 SignalInformation::NetworkType TdScdmaSignalInformation::GetNetworkType() const
709 {
710 return SignalInformation::NetworkType::TDSCDMA;
711 }
712
ToString() const713 std::string TdScdmaSignalInformation::ToString() const
714 {
715 int32_t netWorkType = static_cast<int32_t>(TdScdmaSignalInformation::GetNetworkType());
716 std::string content("networkType:" + std::to_string(netWorkType) + ",tdScdmaRscp:" + std::to_string(tdScdmaRscp_) +
717 ",signalLevel:" + std::to_string(TdScdmaSignalInformation::GetSignalLevel()));
718 return content;
719 }
720
NewInstance() const721 sptr<SignalInformation> TdScdmaSignalInformation::NewInstance() const
722 {
723 std::unique_ptr<TdScdmaSignalInformation> tdScdma = std::make_unique<TdScdmaSignalInformation>();
724 if (tdScdma == nullptr) {
725 return nullptr;
726 }
727 tdScdma->SetValue(this->tdScdmaRscp_);
728 return tdScdma.release();
729 }
730
Marshalling(Parcel & parcel) const731 bool TdScdmaSignalInformation::Marshalling(Parcel &parcel) const
732 {
733 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::TDSCDMA))) {
734 return false;
735 }
736 if (!parcel.WriteInt32(tdScdmaRscp_)) {
737 return false;
738 }
739 if (!parcel.WriteInt32(signalLevel_)) {
740 return false;
741 }
742 return true;
743 }
744
Unmarshalling(Parcel & parcel)745 std::unique_ptr<TdScdmaSignalInformation> TdScdmaSignalInformation::Unmarshalling(Parcel &parcel)
746 {
747 std::unique_ptr<TdScdmaSignalInformation> signal = std::make_unique<TdScdmaSignalInformation>();
748 if (signal && !signal->ReadFromParcel(parcel)) {
749 signal = nullptr;
750 }
751 return signal;
752 }
753
ReadFromParcel(Parcel & parcel)754 bool TdScdmaSignalInformation::ReadFromParcel(Parcel &parcel)
755 {
756 if (!parcel.ReadInt32(tdScdmaRscp_)) {
757 return false;
758 }
759 if (!parcel.ReadInt32(signalLevel_)) {
760 return false;
761 }
762 return true;
763 }
764
ValidateTdScdmaValue() const765 bool TdScdmaSignalInformation::ValidateTdScdmaValue() const
766 {
767 return tdScdmaRscp_ < SIGNAL_RSSI_MAXIMUM;
768 }
769
operator =(const NrSignalInformation & nr)770 NrSignalInformation &NrSignalInformation::operator=(const NrSignalInformation &nr)
771 {
772 signalBar_ = nr.signalBar_;
773 nrRsrp_ = nr.nrRsrp_;
774 nrRsrq_ = nr.nrRsrq_;
775 nrSinr_ = nr.nrSinr_;
776 signalLevel_ = nr.signalLevel_;
777 return *this;
778 }
779
operator ==(const NrSignalInformation & nr) const780 bool NrSignalInformation::operator==(const NrSignalInformation &nr) const
781 {
782 return nrRsrp_ == nr.nrRsrp_ && nrRsrq_ == nr.nrRsrq_ && nrSinr_ == nr.nrSinr_;
783 }
784
SetValue(const int32_t rsrp,const int32_t rsrq,const int32_t sinr)785 void NrSignalInformation::SetValue(const int32_t rsrp, const int32_t rsrq, const int32_t sinr)
786 {
787 nrRsrp_ = rsrp;
788 nrRsrq_ = rsrq;
789 nrSinr_ = sinr;
790 }
791
GetRsrp() const792 int32_t NrSignalInformation::GetRsrp() const
793 {
794 return nrRsrp_;
795 }
796
GetRsrq() const797 int32_t NrSignalInformation::GetRsrq() const
798 {
799 return nrRsrq_;
800 }
801
GetSinr() const802 int32_t NrSignalInformation::GetSinr() const
803 {
804 return nrSinr_;
805 }
806
GetSignalIntensity() const807 int32_t NrSignalInformation::GetSignalIntensity() const
808 {
809 int32_t signalIntensity = SIGNAL_INTENSITY_INVALID;
810
811 if (ValidateNrValue()) {
812 signalIntensity = GetRsrp();
813 } else {
814 TELEPHONY_LOGE("NrSignalInformation::GetSignalIntensity Value is Invalid.");
815 }
816
817 return signalIntensity;
818 }
819
GetSignalLevel() const820 int32_t NrSignalInformation::GetSignalLevel() const
821 {
822 if (signalLevel_ != SIGNAL_LEVEL_UNSET) {
823 return signalLevel_;
824 }
825 int32_t nrRsrp = GetRsrp();
826 int32_t level = SIGNAL_LEVEL_INVALID;
827 if (ValidateNrValue()) {
828 // Reference: TS 27.007 section 8.69
829 for (int32_t i = signalBar_; i >= 0; --i) {
830 if (nrRsrp >= NR_SIGNAL_THRESHOLD[i]) {
831 level = i;
832 break;
833 }
834 }
835 }
836 return level;
837 }
838
GetNetworkType() const839 SignalInformation::NetworkType NrSignalInformation::GetNetworkType() const
840 {
841 return SignalInformation::NetworkType::NR;
842 }
843
ToString() const844 std::string NrSignalInformation::ToString() const
845 {
846 int32_t netWorkType = static_cast<int32_t>(NrSignalInformation::GetNetworkType());
847 std::string content("networkType:" + std::to_string(netWorkType) + ",nrRsrp:" + std::to_string(nrRsrp_) +
848 ",nrRsrq:" + std::to_string(nrRsrq_) + ",nrSinr:" + std::to_string(nrSinr_) +
849 ",signalLevel:" + std::to_string(NrSignalInformation::GetSignalLevel()));
850 return content;
851 }
852
NewInstance() const853 sptr<SignalInformation> NrSignalInformation::NewInstance() const
854 {
855 std::unique_ptr<NrSignalInformation> nr = std::make_unique<NrSignalInformation>();
856 if (nr == nullptr) {
857 return nullptr;
858 }
859 nr->SetValue(this->nrRsrp_, this->nrRsrq_, this->nrSinr_);
860 return nr.release();
861 }
862
Marshalling(Parcel & parcel) const863 bool NrSignalInformation::Marshalling(Parcel &parcel) const
864 {
865 if (!parcel.WriteInt32(static_cast<int32_t>(SignalInformation::NetworkType::NR))) {
866 return false;
867 }
868 if (!parcel.WriteInt32(nrRsrp_)) {
869 return false;
870 }
871 if (!parcel.WriteInt32(nrRsrq_)) {
872 return false;
873 }
874 if (!parcel.WriteInt32(nrSinr_)) {
875 return false;
876 }
877 if (!parcel.WriteInt32(signalLevel_)) {
878 return false;
879 }
880 return true;
881 }
882
Unmarshalling(Parcel & parcel)883 std::unique_ptr<NrSignalInformation> NrSignalInformation::Unmarshalling(Parcel &parcel)
884 {
885 std::unique_ptr<NrSignalInformation> signal = std::make_unique<NrSignalInformation>();
886 if (signal && !signal->ReadFromParcel(parcel)) {
887 signal = nullptr;
888 }
889 return signal;
890 }
891
ReadFromParcel(Parcel & parcel)892 bool NrSignalInformation::ReadFromParcel(Parcel &parcel)
893 {
894 if (!parcel.ReadInt32(nrRsrp_)) {
895 return false;
896 }
897 if (!parcel.ReadInt32(nrRsrq_)) {
898 return false;
899 }
900 if (!parcel.ReadInt32(nrSinr_)) {
901 return false;
902 }
903 if (!parcel.ReadInt32(signalLevel_)) {
904 return false;
905 }
906 return true;
907 }
908
ValidateNrValue() const909 bool NrSignalInformation::ValidateNrValue() const
910 {
911 return nrRsrp_ < SIGNAL_RSSI_MAXIMUM;
912 }
913 } // namespace Telephony
914 } // namespace OHOS
915