1 /*
2  * Copyright (C) 2021 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 "cell_information.h"
17 
18 #include <cstdint>
19 #include <ctime>
20 #include <memory>
21 #include <securec.h>
22 
23 #include "iosfwd"
24 #include "new"
25 #include "parcel.h"
26 #include "string"
27 
28 namespace OHOS {
29 namespace Telephony {
30 const int32_t MNC_INT_MAX = 999;
31 const int32_t MNC_DIGIT_OFFSET = 28;
32 const uint32_t MNC_VALID_BIT = 0X0FFFFFFF;
Init(int32_t mcc,int32_t mnc,int32_t cellId)33 void CellInformation::Init(int32_t mcc, int32_t mnc, int32_t cellId)
34 {
35     if (mnc > MNC_INT_MAX) {
36         int mnc_digit = mnc >> MNC_DIGIT_OFFSET;
37         mnc = static_cast<int32_t>(static_cast<uint32_t>(mnc) & MNC_VALID_BIT);
38         char mnc_str[MNC_DIGIT_OFFSET] = {0};
39         char strFormat[MNC_DIGIT_OFFSET] = {0};
40         int size = snprintf_s(strFormat, MNC_DIGIT_OFFSET, MNC_DIGIT_OFFSET - 1, "%s%dd", "%0", mnc_digit);
41         if (size > 0) {
42             size = snprintf_s(mnc_str, mnc_digit + 1, mnc_digit, strFormat, mnc);
43         }
44         if (size > 0) {
45             mnc_ = mnc_str;
46         }
47     } else {
48         mnc_ = std::to_string(mnc);
49     }
50     mcc_ = std::to_string(mcc);
51     cellId_ = cellId;
52     timeStamp_ = static_cast<uint64_t>(time(0));
53 }
54 
Init(std::string mcc,std::string mnc,int32_t cellId)55 void CellInformation::Init(std::string mcc, std::string mnc, int32_t cellId)
56 {
57     mnc_ = mnc;
58     mcc_ = mcc;
59     cellId_ = cellId;
60     timeStamp_ = static_cast<uint64_t>(time(0));
61 }
62 
GetCellId() const63 int32_t CellInformation::GetCellId() const
64 {
65     return cellId_;
66 }
67 
GetMcc() const68 std::string CellInformation::GetMcc() const
69 {
70     return mcc_;
71 }
72 
GetMnc() const73 std::string CellInformation::GetMnc() const
74 {
75     return mnc_;
76 }
77 
GetTimeStamp() const78 uint64_t CellInformation::GetTimeStamp() const
79 {
80     return timeStamp_;
81 }
82 
GetSignalIntensity() const83 int32_t CellInformation::GetSignalIntensity() const
84 {
85     return signalIntensity_;
86 }
87 
SetSignalIntensity(int32_t signalIntensity)88 void CellInformation::SetSignalIntensity(int32_t signalIntensity)
89 {
90     signalIntensity_ = signalIntensity;
91     timeStamp_ = static_cast<uint64_t>(time(0));
92 }
93 
GetSignalLevel() const94 int32_t CellInformation::GetSignalLevel() const
95 {
96     return signalLevel_;
97 }
98 
SetSignalLevel(int32_t signalLevel)99 void CellInformation::SetSignalLevel(int32_t signalLevel)
100 {
101     signalLevel_ = signalLevel;
102     timeStamp_ = static_cast<uint64_t>(time(0));
103 }
104 
GetIsCamped() const105 bool CellInformation::GetIsCamped() const
106 {
107     return isCamped_;
108 }
109 
SetIsCamped(bool isCamped)110 void CellInformation::SetIsCamped(bool isCamped)
111 {
112     isCamped_ = isCamped;
113     timeStamp_ = static_cast<uint64_t>(time(0));
114 }
115 
Unmarshalling(Parcel & parcel)116 CellInformation *CellInformation::Unmarshalling(Parcel &parcel)
117 {
118     return nullptr;
119 }
120 
SetGsmParam(int32_t bsic,int32_t lac,int32_t arfcn)121 void GsmCellInformation::SetGsmParam(int32_t bsic, int32_t lac, int32_t arfcn)
122 {
123     bsic_ = bsic;
124     lac_ = lac;
125     arfcn_ = arfcn;
126 }
127 
GsmCellInformation(const GsmCellInformation & gsmCell)128 GsmCellInformation::GsmCellInformation(const GsmCellInformation &gsmCell)
129 {
130     mcc_ = gsmCell.mcc_;
131     mnc_ = gsmCell.mnc_;
132     arfcn_ = gsmCell.arfcn_;
133     cellId_ = gsmCell.cellId_;
134     bsic_ = gsmCell.bsic_;
135     lac_ = gsmCell.lac_;
136     timeStamp_ = gsmCell.timeStamp_;
137     signalLevel_ = gsmCell.signalLevel_;
138     signalIntensity_ = gsmCell.signalIntensity_;
139     isCamped_ = gsmCell.isCamped_;
140 }
141 
operator =(const GsmCellInformation & gsmCell)142 GsmCellInformation &GsmCellInformation::operator=(const GsmCellInformation &gsmCell)
143 {
144     mcc_ = gsmCell.mcc_;
145     mnc_ = gsmCell.mnc_;
146     arfcn_ = gsmCell.arfcn_;
147     cellId_ = gsmCell.cellId_;
148     bsic_ = gsmCell.bsic_;
149     lac_ = gsmCell.lac_;
150     timeStamp_ = gsmCell.timeStamp_;
151     signalLevel_ = gsmCell.signalLevel_;
152     signalIntensity_ = gsmCell.signalIntensity_;
153     isCamped_ = gsmCell.isCamped_;
154     return *this;
155 }
156 
operator ==(const GsmCellInformation & other) const157 bool GsmCellInformation::operator==(const GsmCellInformation &other) const
158 {
159     return mcc_ == other.mcc_ && mnc_ == other.mnc_ &&
160         arfcn_ == other.arfcn_ && cellId_ == other.cellId_ &&
161         bsic_ == other.bsic_ && lac_ == other.lac_ &&
162         signalLevel_ == other.signalLevel_ &&
163         signalIntensity_ == other.signalIntensity_ &&
164         isCamped_ == other.isCamped_;
165 }
166 
GetNetworkType() const167 CellInformation::CellType GsmCellInformation::GetNetworkType() const
168 {
169     return CellType::CELL_TYPE_GSM;
170 }
171 
GetArfcn() const172 int32_t GsmCellInformation::GetArfcn() const
173 {
174     return arfcn_;
175 }
176 
ToString() const177 std::string GsmCellInformation::ToString() const
178 {
179     int32_t netWorkType = static_cast<int32_t>(GsmCellInformation::GetNetworkType());
180     std::string content("netWorkType:" + std::to_string(netWorkType) + ",mcc:" + mcc_ +
181         ",mnc:" + mnc_ + ",arfcn:" + std::to_string(arfcn_) + ",cellId:" + std::to_string(cellId_) +
182         ",timeStamp:" + std::to_string(timeStamp_) + ",signalLevel:" + std::to_string(signalLevel_) +
183         ",signalIntensity_:" + std::to_string(signalIntensity_) + ",bsic:" + std::to_string(bsic_) +
184         ",lac:" + std::to_string(lac_));
185     return content;
186 }
187 
Marshalling(Parcel & parcel) const188 bool GsmCellInformation::Marshalling(Parcel &parcel) const
189 {
190     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_GSM))) {
191         return false;
192     }
193     if (!parcel.WriteString(mcc_)) {
194         return false;
195     }
196     if (!parcel.WriteString(mnc_)) {
197         return false;
198     }
199     if (!parcel.WriteInt32(arfcn_)) {
200         return false;
201     }
202     if (!parcel.WriteInt32(cellId_)) {
203         return false;
204     }
205     if (!parcel.WriteInt32(bsic_)) {
206         return false;
207     }
208     if (!parcel.WriteInt32(lac_)) {
209         return false;
210     }
211     if (!parcel.WriteUint64(timeStamp_)) {
212         return false;
213     }
214     if (!parcel.WriteInt32(signalLevel_)) {
215         return false;
216     }
217     if (!parcel.WriteInt32(signalIntensity_)) {
218         return false;
219     }
220     if (!parcel.WriteBool(isCamped_)) {
221         return false;
222     }
223     return true;
224 }
225 
Unmarshalling(Parcel & parcel)226 GsmCellInformation *GsmCellInformation::Unmarshalling(Parcel &parcel)
227 {
228     GsmCellInformation *param = new (std::nothrow) GsmCellInformation();
229     if (param == nullptr) {
230         return nullptr;
231     }
232     if (!param->ReadFromParcel(parcel)) {
233         delete param;
234         param = nullptr;
235     }
236     return param;
237 }
238 
ReadFromParcel(Parcel & parcel)239 bool GsmCellInformation::ReadFromParcel(Parcel &parcel)
240 {
241     std::string readString;
242     if (!parcel.ReadString(readString)) {
243         return false;
244     }
245     mcc_ = readString;
246     if (!parcel.ReadString(readString)) {
247         return false;
248     }
249     mnc_ = readString;
250     int32_t rat;
251     if (!parcel.ReadInt32(rat)) {
252         return false;
253     }
254     arfcn_ = rat;
255     if (!parcel.ReadInt32(rat)) {
256         return false;
257     }
258     cellId_ = rat;
259     if (!parcel.ReadInt32(rat)) {
260         return false;
261     }
262     bsic_ = rat;
263     if (!parcel.ReadInt32(rat)) {
264         return false;
265     }
266     lac_ = rat;
267     uint64_t gsmTime = 0;
268     if (!parcel.ReadUint64(gsmTime)) {
269         return false;
270     }
271     timeStamp_ = gsmTime;
272     if (!parcel.ReadInt32(rat)) {
273         return false;
274     }
275     signalLevel_ = rat;
276     int32_t gsmSignalIntensity = 0;
277     if (!parcel.ReadInt32(gsmSignalIntensity)) {
278         return false;
279     }
280     signalIntensity_ = gsmSignalIntensity;
281     bool gsmTemCamped = false;
282     if (!parcel.ReadBool(gsmTemCamped)) {
283         return false;
284     }
285     isCamped_ = gsmTemCamped;
286 
287     return true;
288 }
289 
GetLac() const290 int32_t GsmCellInformation::GetLac() const
291 {
292     return lac_;
293 }
294 
GetBsic() const295 int32_t GsmCellInformation::GetBsic() const
296 {
297     return bsic_;
298 }
299 
UpdateLocation(int32_t cellId,int32_t lac)300 void GsmCellInformation::UpdateLocation(int32_t cellId, int32_t lac)
301 {
302     cellId_ = cellId;
303     lac_ = lac;
304     timeStamp_ = time(0);
305 }
306 
SetLteParam(int32_t pci,int32_t tac,int32_t arfcn)307 void LteCellInformation::SetLteParam(int32_t pci, int32_t tac, int32_t arfcn)
308 {
309     pci_ = pci;
310     tac_ = tac;
311     earfcn_ = arfcn;
312 }
313 
LteCellInformation(const LteCellInformation & lteCell)314 LteCellInformation::LteCellInformation(const LteCellInformation &lteCell)
315 {
316     mcc_ = lteCell.mcc_;
317     mnc_ = lteCell.mnc_;
318     earfcn_ = lteCell.earfcn_;
319     cellId_ = lteCell.cellId_;
320     pci_ = lteCell.pci_;
321     tac_ = lteCell.tac_;
322     timeStamp_ = lteCell.timeStamp_;
323     signalLevel_ = lteCell.signalLevel_;
324     signalIntensity_ = lteCell.signalIntensity_;
325     isCamped_ = lteCell.isCamped_;
326 }
327 
operator =(const LteCellInformation & lteCell)328 LteCellInformation &LteCellInformation::operator=(const LteCellInformation &lteCell)
329 {
330     mcc_ = lteCell.mcc_;
331     mnc_ = lteCell.mnc_;
332     earfcn_ = lteCell.earfcn_;
333     cellId_ = lteCell.cellId_;
334     pci_ = lteCell.pci_;
335     tac_ = lteCell.tac_;
336     timeStamp_ = lteCell.timeStamp_;
337     signalLevel_ = lteCell.signalLevel_;
338     signalIntensity_ = lteCell.signalIntensity_;
339     isCamped_ = lteCell.isCamped_;
340     return *this;
341 }
342 
operator ==(const LteCellInformation & other) const343 bool LteCellInformation::operator==(const LteCellInformation &other) const
344 {
345     return mcc_ == other.mcc_ && mnc_ == other.mnc_ &&
346         earfcn_ == other.earfcn_ && cellId_ == other.cellId_ &&
347         pci_ == other.pci_ && tac_ == other.tac_ &&
348         signalLevel_ == other.signalLevel_ && signalIntensity_ == other.signalIntensity_ &&
349         isCamped_ == other.isCamped_;
350 }
351 
GetNetworkType() const352 CellInformation::CellType LteCellInformation::GetNetworkType() const
353 {
354     return CellType::CELL_TYPE_LTE;
355 }
356 
GetArfcn() const357 int32_t LteCellInformation::GetArfcn() const
358 {
359     return earfcn_;
360 }
361 
Marshalling(Parcel & parcel) const362 bool LteCellInformation::Marshalling(Parcel &parcel) const
363 {
364     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_LTE))) {
365         return false;
366     }
367     if (!parcel.WriteString(mcc_)) {
368         return false;
369     }
370     if (!parcel.WriteString(mnc_)) {
371         return false;
372     }
373     if (!parcel.WriteInt32(earfcn_)) {
374         return false;
375     }
376     if (!parcel.WriteInt32(cellId_)) {
377         return false;
378     }
379     if (!parcel.WriteInt32(pci_)) {
380         return false;
381     }
382     if (!parcel.WriteInt32(tac_)) {
383         return false;
384     }
385     if (!parcel.WriteInt64(timeStamp_)) {
386         return false;
387     }
388     if (!parcel.WriteInt32(signalLevel_)) {
389         return false;
390     }
391     if (!parcel.WriteInt32(signalIntensity_)) {
392         return false;
393     }
394     if (!parcel.WriteBool(isCamped_)) {
395         return false;
396     }
397     return true;
398 }
399 
Unmarshalling(Parcel & parcel)400 LteCellInformation *LteCellInformation::Unmarshalling(Parcel &parcel)
401 {
402     LteCellInformation *param = new (std::nothrow) LteCellInformation();
403     if (param == nullptr) {
404         return nullptr;
405     }
406     if (!param->ReadFromParcel(parcel)) {
407         delete param;
408         param = nullptr;
409     }
410     return param;
411 }
412 
ReadFromParcel(Parcel & parcel)413 bool LteCellInformation::ReadFromParcel(Parcel &parcel)
414 {
415     std::string readString;
416     if (!parcel.ReadString(readString)) {
417         return false;
418     }
419     mcc_ = readString;
420     if (!parcel.ReadString(readString)) {
421         return false;
422     }
423     mnc_ = readString;
424     int32_t rat;
425     if (!parcel.ReadInt32(rat)) {
426         return false;
427     }
428     earfcn_ = rat;
429     if (!parcel.ReadInt32(rat)) {
430         return false;
431     }
432     cellId_ = rat;
433     if (!parcel.ReadInt32(rat)) {
434         return false;
435     }
436     pci_ = rat;
437     if (!parcel.ReadInt32(rat)) {
438         return false;
439     }
440     tac_ = rat;
441     uint64_t lteTime = 0;
442     if (!parcel.ReadUint64(lteTime)) {
443         return false;
444     }
445     timeStamp_ = lteTime;
446     if (!parcel.ReadInt32(rat)) {
447         return false;
448     }
449     signalLevel_ = rat;
450     int32_t lteSignalIntensity = 0;
451     if (!parcel.ReadInt32(lteSignalIntensity)) {
452         return false;
453     }
454     signalIntensity_ = lteSignalIntensity;
455     bool lteTemCamped = false;
456     if (!parcel.ReadBool(lteTemCamped)) {
457         return false;
458     }
459     isCamped_ = lteTemCamped;
460     return true;
461 }
462 
GetPci() const463 int32_t LteCellInformation::GetPci() const
464 {
465     return pci_;
466 }
467 
GetTac() const468 int32_t LteCellInformation::GetTac() const
469 {
470     return tac_;
471 }
472 
UpdateLocation(int32_t cellId,int32_t tac)473 void LteCellInformation::UpdateLocation(int32_t cellId, int32_t tac)
474 {
475     cellId_ = cellId;
476     tac_ = tac;
477     timeStamp_ = static_cast<uint64_t>(time(0));
478 }
479 
ToString() const480 std::string LteCellInformation::ToString() const
481 {
482     int32_t netWorkType = static_cast<int32_t>(LteCellInformation::GetNetworkType());
483     std::string content("netWorkType:" + std::to_string(netWorkType) + ",mcc:" + mcc_ +
484         ",mnc:" + mnc_ + ",earfcn:" + std::to_string(earfcn_) + ",cellId:" + std::to_string(cellId_) +
485         ",timeStamp:" + std::to_string(timeStamp_) + ",signalLevel:" + std::to_string(signalLevel_) +
486         ",signalIntensity:" + std::to_string(signalIntensity_) + ",pci:" + std::to_string(pci_) +
487         ",pci:" + std::to_string(pci_) + ",tac:" + std::to_string(tac_));
488     return content;
489 }
490 
SetWcdmaParam(int32_t psc,int32_t lac,int32_t arfcn)491 void WcdmaCellInformation::SetWcdmaParam(int32_t psc, int32_t lac, int32_t arfcn)
492 {
493     psc_ = psc;
494     lac_ = lac;
495     uarfcn_ = arfcn;
496 }
497 
WcdmaCellInformation(const WcdmaCellInformation & wcdmaCell)498 WcdmaCellInformation::WcdmaCellInformation(const WcdmaCellInformation &wcdmaCell)
499 {
500     mcc_ = wcdmaCell.mcc_;
501     mnc_ = wcdmaCell.mnc_;
502     uarfcn_ = wcdmaCell.uarfcn_;
503     cellId_ = wcdmaCell.cellId_;
504     psc_ = wcdmaCell.psc_;
505     lac_ = wcdmaCell.lac_;
506     timeStamp_ = wcdmaCell.timeStamp_;
507     signalLevel_ = wcdmaCell.signalLevel_;
508     signalIntensity_ = wcdmaCell.signalIntensity_;
509     isCamped_ = wcdmaCell.isCamped_;
510 }
511 
operator =(const WcdmaCellInformation & wcdmaCell)512 WcdmaCellInformation &WcdmaCellInformation::operator=(const WcdmaCellInformation &wcdmaCell)
513 {
514     mcc_ = wcdmaCell.mcc_;
515     mnc_ = wcdmaCell.mnc_;
516     uarfcn_ = wcdmaCell.uarfcn_;
517     cellId_ = wcdmaCell.cellId_;
518     psc_ = wcdmaCell.psc_;
519     lac_ = wcdmaCell.lac_;
520     timeStamp_ = wcdmaCell.timeStamp_;
521     signalLevel_ = wcdmaCell.signalLevel_;
522     signalIntensity_ = wcdmaCell.signalIntensity_;
523     isCamped_ = wcdmaCell.isCamped_;
524     return *this;
525 }
526 
operator ==(const WcdmaCellInformation & other) const527 bool WcdmaCellInformation::operator==(const WcdmaCellInformation &other) const
528 {
529     return mcc_ == other.mcc_ && mnc_ == other.mnc_ &&
530         uarfcn_ == other.uarfcn_ && cellId_ == other.cellId_ &&
531         psc_ == other.psc_ && lac_ == other.lac_ &&
532         signalLevel_ == other.signalLevel_ && signalIntensity_ == other.signalIntensity_ &&
533         isCamped_ == other.isCamped_;
534 }
535 
GetNetworkType() const536 CellInformation::CellType WcdmaCellInformation::GetNetworkType() const
537 {
538     return CellType::CELL_TYPE_WCDMA;
539 }
540 
GetArfcn() const541 int32_t WcdmaCellInformation::GetArfcn() const
542 {
543     return uarfcn_;
544 }
545 
Marshalling(Parcel & parcel) const546 bool WcdmaCellInformation::Marshalling(Parcel &parcel) const
547 {
548     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_WCDMA))) {
549         return false;
550     }
551     if (!parcel.WriteString(mcc_)) {
552         return false;
553     }
554     if (!parcel.WriteString(mnc_)) {
555         return false;
556     }
557     if (!parcel.WriteInt32(uarfcn_)) {
558         return false;
559     }
560     if (!parcel.WriteInt32(cellId_)) {
561         return false;
562     }
563     if (!parcel.WriteInt32(psc_)) {
564         return false;
565     }
566     if (!parcel.WriteInt32(lac_)) {
567         return false;
568     }
569     if (!parcel.WriteInt64(timeStamp_)) {
570         return false;
571     }
572     if (!parcel.WriteInt32(signalLevel_)) {
573         return false;
574     }
575     if (!parcel.WriteInt32(signalIntensity_)) {
576         return false;
577     }
578     if (!parcel.WriteBool(isCamped_)) {
579         return false;
580     }
581     return true;
582 }
583 
Unmarshalling(Parcel & parcel)584 WcdmaCellInformation *WcdmaCellInformation::Unmarshalling(Parcel &parcel)
585 {
586     WcdmaCellInformation *param = new (std::nothrow) WcdmaCellInformation();
587     if (param == nullptr) {
588         return nullptr;
589     }
590     if (!param->ReadFromParcel(parcel)) {
591         delete param;
592         param = nullptr;
593     }
594     return param;
595 }
596 
ReadFromParcel(Parcel & parcel)597 bool WcdmaCellInformation::ReadFromParcel(Parcel &parcel)
598 {
599     std::string readString;
600     if (!parcel.ReadString(readString)) {
601         return false;
602     }
603     mcc_ = readString;
604     if (!parcel.ReadString(readString)) {
605         return false;
606     }
607     mnc_ = readString;
608     int32_t rat;
609     if (!parcel.ReadInt32(rat)) {
610         return false;
611     }
612     uarfcn_ = rat;
613     if (!parcel.ReadInt32(rat)) {
614         return false;
615     }
616     cellId_ = rat;
617     if (!parcel.ReadInt32(rat)) {
618         return false;
619     }
620     psc_ = rat;
621     if (!parcel.ReadInt32(rat)) {
622         return false;
623     }
624     lac_ = rat;
625     uint64_t wcdmaTime = 0;
626     if (!parcel.ReadUint64(wcdmaTime)) {
627         return false;
628     }
629     timeStamp_ = wcdmaTime;
630     if (!parcel.ReadInt32(rat)) {
631         return false;
632     }
633     signalLevel_ = rat;
634     int32_t wcdmaSignalIntensity = 0;
635     if (!parcel.ReadInt32(wcdmaSignalIntensity)) {
636         return false;
637     }
638     signalIntensity_ = wcdmaSignalIntensity;
639     bool wcdmaTemCamped = false;
640     if (!parcel.ReadBool(wcdmaTemCamped)) {
641         return false;
642     }
643     isCamped_ = wcdmaTemCamped;
644     return true;
645 }
646 
GetPsc() const647 int32_t WcdmaCellInformation::GetPsc() const
648 {
649     return psc_;
650 }
651 
GetLac() const652 int32_t WcdmaCellInformation::GetLac() const
653 {
654     return lac_;
655 }
656 
UpdateLocation(int32_t cellId,int32_t lac)657 void WcdmaCellInformation::UpdateLocation(int32_t cellId, int32_t lac)
658 {
659     cellId_ = cellId;
660     lac_ = lac;
661     timeStamp_ = time(0);
662 }
663 
ToString() const664 std::string WcdmaCellInformation::ToString() const
665 {
666     int32_t netWorkType = static_cast<int32_t>(WcdmaCellInformation::GetNetworkType());
667     std::string content("netWorkType:" + std::to_string(netWorkType) + ",mcc:" + mcc_ +
668         ",mnc:" + mnc_ + ",uarfcn:" + std::to_string(uarfcn_) + ",cellId:" + std::to_string(cellId_) +
669         ",timeStamp:" + std::to_string(timeStamp_) + ",signalLevel:" + std::to_string(signalLevel_) +
670         ",signalIntensity:" + std::to_string(signalIntensity_) + ",psc:" + std::to_string(psc_) +
671         ",lac:" + std::to_string(lac_));
672     return content;
673 }
674 
SetTdscdmaParam(int32_t cpid,int32_t lac,int32_t arfcn)675 void TdscdmaCellInformation::SetTdscdmaParam(int32_t cpid, int32_t lac, int32_t arfcn)
676 {
677     cpid_ = cpid;
678     lac_ = lac;
679     uarfcn_ = arfcn;
680 }
681 
TdscdmaCellInformation(const TdscdmaCellInformation & tdscdmaCell)682 TdscdmaCellInformation::TdscdmaCellInformation(const TdscdmaCellInformation &tdscdmaCell)
683 {
684     mcc_ = tdscdmaCell.mcc_;
685     mnc_ = tdscdmaCell.mnc_;
686     uarfcn_ = tdscdmaCell.uarfcn_;
687     cellId_ = tdscdmaCell.cellId_;
688     cpid_ = tdscdmaCell.cpid_;
689     lac_ = tdscdmaCell.lac_;
690     timeStamp_ = tdscdmaCell.timeStamp_;
691     signalLevel_ = tdscdmaCell.signalLevel_;
692     signalIntensity_ = tdscdmaCell.signalIntensity_;
693     isCamped_ = tdscdmaCell.isCamped_;
694 }
695 
operator =(const TdscdmaCellInformation & tdscdmaCell)696 TdscdmaCellInformation &TdscdmaCellInformation::operator=(const TdscdmaCellInformation &tdscdmaCell)
697 {
698     mcc_ = tdscdmaCell.mcc_;
699     mnc_ = tdscdmaCell.mnc_;
700     uarfcn_ = tdscdmaCell.uarfcn_;
701     cellId_ = tdscdmaCell.cellId_;
702     cpid_ = tdscdmaCell.cpid_;
703     lac_ = tdscdmaCell.lac_;
704     timeStamp_ = tdscdmaCell.timeStamp_;
705     signalLevel_ = tdscdmaCell.signalLevel_;
706     signalIntensity_ = tdscdmaCell.signalIntensity_;
707     isCamped_ = tdscdmaCell.isCamped_;
708     return *this;
709 }
710 
operator ==(const TdscdmaCellInformation & other) const711 bool TdscdmaCellInformation::operator==(const TdscdmaCellInformation &other) const
712 {
713     return mcc_ == other.mcc_ && mnc_ == other.mnc_ &&
714         uarfcn_ == other.uarfcn_ && cellId_ == other.cellId_ &&
715         cpid_ == other.cpid_ && lac_ == other.lac_ &&
716         signalLevel_ == other.signalLevel_ && signalIntensity_ == other.signalIntensity_ &&
717         isCamped_ == other.isCamped_;
718 }
719 
GetNetworkType() const720 CellInformation::CellType TdscdmaCellInformation::GetNetworkType() const
721 {
722     return CellType::CELL_TYPE_TDSCDMA;
723 }
724 
GetArfcn() const725 int32_t TdscdmaCellInformation::GetArfcn() const
726 {
727     return uarfcn_;
728 }
729 
Marshalling(Parcel & parcel) const730 bool TdscdmaCellInformation::Marshalling(Parcel &parcel) const
731 {
732     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_TDSCDMA))) {
733         return false;
734     }
735     if (!parcel.WriteString(mcc_)) {
736         return false;
737     }
738     if (!parcel.WriteString(mnc_)) {
739         return false;
740     }
741     if (!parcel.WriteInt32(uarfcn_)) {
742         return false;
743     }
744     if (!parcel.WriteInt32(cellId_)) {
745         return false;
746     }
747     if (!parcel.WriteInt32(cpid_)) {
748         return false;
749     }
750     if (!parcel.WriteInt32(lac_)) {
751         return false;
752     }
753     if (!parcel.WriteUint64(timeStamp_)) {
754         return false;
755     }
756     if (!parcel.WriteInt32(signalLevel_)) {
757         return false;
758     }
759     if (!parcel.WriteInt32(signalIntensity_)) {
760         return false;
761     }
762     if (!parcel.WriteBool(isCamped_)) {
763         return false;
764     }
765     return true;
766 }
767 
Unmarshalling(Parcel & parcel)768 TdscdmaCellInformation *TdscdmaCellInformation::Unmarshalling(Parcel &parcel)
769 {
770     TdscdmaCellInformation *param = new (std::nothrow) TdscdmaCellInformation();
771     if (param == nullptr) {
772         return nullptr;
773     }
774     if (!param->ReadFromParcel(parcel)) {
775         delete param;
776         param = nullptr;
777     }
778     return param;
779 }
780 
ReadFromParcel(Parcel & parcel)781 bool TdscdmaCellInformation::ReadFromParcel(Parcel &parcel)
782 {
783     std::string readString;
784     if (!parcel.ReadString(readString)) {
785         return false;
786     }
787     mcc_ = readString;
788     if (!parcel.ReadString(readString)) {
789         return false;
790     }
791     mnc_ = readString;
792     int32_t rat;
793     if (!parcel.ReadInt32(rat)) {
794         return false;
795     }
796     uarfcn_ = rat;
797     if (!parcel.ReadInt32(rat)) {
798         return false;
799     }
800     cellId_ = rat;
801     if (!parcel.ReadInt32(rat)) {
802         return false;
803     }
804     cpid_ = rat;
805     if (!parcel.ReadInt32(rat)) {
806         return false;
807     }
808     lac_ = rat;
809     uint64_t tdscdmaTime = 0;
810     if (!parcel.ReadUint64(tdscdmaTime)) {
811         return false;
812     }
813     timeStamp_ = tdscdmaTime;
814     if (!parcel.ReadInt32(rat)) {
815         return false;
816     }
817     signalLevel_ = rat;
818     int32_t tdscdmaSignalIntensity = 0;
819     if (!parcel.ReadInt32(tdscdmaSignalIntensity)) {
820         return false;
821     }
822     signalIntensity_ = tdscdmaSignalIntensity;
823     bool tdscdmaTemCamped = false;
824     if (!parcel.ReadBool(tdscdmaTemCamped)) {
825         return false;
826     }
827     isCamped_ = tdscdmaTemCamped;
828     return true;
829 }
830 
GetCpid() const831 int32_t TdscdmaCellInformation::GetCpid() const
832 {
833     return cpid_;
834 }
835 
GetLac() const836 int32_t TdscdmaCellInformation::GetLac() const
837 {
838     return lac_;
839 }
840 
UpdateLocation(int32_t cellId,int32_t lac)841 void TdscdmaCellInformation::UpdateLocation(int32_t cellId, int32_t lac)
842 {
843     cellId_ = cellId;
844     lac_ = lac;
845     timeStamp_ = time(0);
846 }
847 
ToString() const848 std::string TdscdmaCellInformation::ToString() const
849 {
850     int32_t netWorkType = static_cast<int32_t>(TdscdmaCellInformation::GetNetworkType());
851     std::string content("netWorkType:" + std::to_string(netWorkType) + ",mcc:" + mcc_ +
852         ",mnc:" + mnc_ + ",uarfcn:" + std::to_string(uarfcn_) + ",cellId:" + std::to_string(cellId_) +
853         ",timeStamp:" + std::to_string(timeStamp_) + ",signalLevel:" + std::to_string(signalLevel_) +
854         ",signalIntensity:" + std::to_string(signalIntensity_) + ",cpid:" + std::to_string(cpid_) +
855         ",lac:" + std::to_string(lac_));
856     return content;
857 }
858 
SetCdmaParam(int32_t baseId,int32_t latitude,int32_t longitude,int32_t nid,int32_t sid)859 void CdmaCellInformation::SetCdmaParam(int32_t baseId, int32_t latitude, int32_t longitude, int32_t nid, int32_t sid)
860 {
861     baseId_ = baseId;
862     latitude_ = latitude;
863     longitude_ = longitude;
864     nid_ = nid;
865     sid_ = sid;
866 }
867 
CdmaCellInformation(const CdmaCellInformation & cdmaCell)868 CdmaCellInformation::CdmaCellInformation(const CdmaCellInformation &cdmaCell)
869 {
870     baseId_ = cdmaCell.baseId_;
871     latitude_ = cdmaCell.latitude_;
872     longitude_ = cdmaCell.longitude_;
873     nid_ = cdmaCell.nid_;
874     sid_ = cdmaCell.sid_;
875     timeStamp_ = cdmaCell.timeStamp_;
876     signalLevel_ = cdmaCell.signalLevel_;
877     signalIntensity_ = cdmaCell.signalIntensity_;
878     isCamped_ = cdmaCell.isCamped_;
879 }
880 
operator =(const CdmaCellInformation & cdmaCell)881 CdmaCellInformation &CdmaCellInformation::operator=(const CdmaCellInformation &cdmaCell)
882 {
883     baseId_ = cdmaCell.baseId_;
884     latitude_ = cdmaCell.latitude_;
885     longitude_ = cdmaCell.longitude_;
886     nid_ = cdmaCell.nid_;
887     sid_ = cdmaCell.sid_;
888     timeStamp_ = cdmaCell.timeStamp_;
889     signalLevel_ = cdmaCell.signalLevel_;
890     signalIntensity_ = cdmaCell.signalIntensity_;
891     isCamped_ = cdmaCell.isCamped_;
892     return *this;
893 }
894 
operator ==(const CdmaCellInformation & other) const895 bool CdmaCellInformation::operator==(const CdmaCellInformation &other) const
896 {
897     return baseId_ == other.baseId_ && latitude_ == other.latitude_ &&
898         longitude_ == other.longitude_ && nid_ == other.nid_ &&
899         sid_ == other.sid_ && signalLevel_ == other.signalLevel_ &&
900         signalIntensity_ == other.signalIntensity_ && isCamped_ == other.isCamped_;
901 }
902 
GetNetworkType() const903 CellInformation::CellType CdmaCellInformation::GetNetworkType() const
904 {
905     return CellType::CELL_TYPE_CDMA;
906 }
907 
Marshalling(Parcel & parcel) const908 bool CdmaCellInformation::Marshalling(Parcel &parcel) const
909 {
910     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_CDMA))) {
911         return false;
912     }
913     if (!parcel.WriteInt32(baseId_)) {
914         return false;
915     }
916     if (!parcel.WriteInt32(latitude_)) {
917         return false;
918     }
919     if (!parcel.WriteInt32(longitude_)) {
920         return false;
921     }
922     if (!parcel.WriteInt32(nid_)) {
923         return false;
924     }
925     if (!parcel.WriteInt32(sid_)) {
926         return false;
927     }
928     if (!parcel.WriteUint64(timeStamp_)) {
929         return false;
930     }
931     if (!parcel.WriteInt32(signalLevel_)) {
932         return false;
933     }
934     if (!parcel.WriteInt32(signalIntensity_)) {
935         return false;
936     }
937     if (!parcel.WriteBool(isCamped_)) {
938         return false;
939     }
940     return true;
941 }
942 
Unmarshalling(Parcel & parcel)943 CdmaCellInformation *CdmaCellInformation::Unmarshalling(Parcel &parcel)
944 {
945     CdmaCellInformation *param = new (std::nothrow) CdmaCellInformation();
946     if (param == nullptr) {
947         return nullptr;
948     }
949     if (!param->ReadFromParcel(parcel)) {
950         delete param;
951         param = nullptr;
952     }
953     return param;
954 }
955 
ReadFromParcel(Parcel & parcel)956 bool CdmaCellInformation::ReadFromParcel(Parcel &parcel)
957 {
958     int32_t rat;
959     if (!parcel.ReadInt32(rat)) {
960         return false;
961     }
962     baseId_ = rat;
963     if (!parcel.ReadInt32(rat)) {
964         return false;
965     }
966     latitude_ = rat;
967     if (!parcel.ReadInt32(rat)) {
968         return false;
969     }
970     longitude_ = rat;
971     if (!parcel.ReadInt32(rat)) {
972         return false;
973     }
974     nid_ = rat;
975     if (!parcel.ReadInt32(rat)) {
976         return false;
977     }
978     sid_ = rat;
979     uint64_t cdmaTime = 0;
980     if (!parcel.ReadUint64(cdmaTime)) {
981         return false;
982     }
983     timeStamp_ = cdmaTime;
984     if (!parcel.ReadInt32(rat)) {
985         return false;
986     }
987     signalLevel_ = rat;
988     int32_t cdmaSignalIntensity = 0;
989     if (!parcel.ReadInt32(cdmaSignalIntensity)) {
990         return false;
991     }
992     signalIntensity_ = cdmaSignalIntensity;
993     bool cdmaTemCamped;
994     if (!parcel.ReadBool(cdmaTemCamped)) {
995         return false;
996     }
997     isCamped_ = cdmaTemCamped;
998     return true;
999 }
1000 
GetBaseId() const1001 int32_t CdmaCellInformation::GetBaseId() const
1002 {
1003     return baseId_;
1004 }
1005 
GetLatitude() const1006 int32_t CdmaCellInformation::GetLatitude() const
1007 {
1008     return latitude_;
1009 }
1010 
GetLongitude() const1011 int32_t CdmaCellInformation::GetLongitude() const
1012 {
1013     return longitude_;
1014 }
1015 
GetNid() const1016 int32_t CdmaCellInformation::GetNid() const
1017 {
1018     return nid_;
1019 }
1020 
GetSid() const1021 int32_t CdmaCellInformation::GetSid() const
1022 {
1023     return sid_;
1024 }
1025 
UpdateLocation(int32_t baseId,int32_t latitude,int32_t longitude)1026 void CdmaCellInformation::UpdateLocation(int32_t baseId, int32_t latitude, int32_t longitude)
1027 {
1028     baseId_ = baseId;
1029     latitude_ = latitude;
1030     longitude_ = longitude;
1031     timeStamp_ = time(0);
1032 }
1033 
ToString() const1034 std::string CdmaCellInformation::ToString() const
1035 {
1036     int32_t netWorkType = static_cast<int32_t>(CdmaCellInformation::GetNetworkType());
1037     std::string content("netWorkType:" + std::to_string(netWorkType) + ",baseId:" + std::to_string(baseId_) +
1038         ",latitude:" + std::to_string(latitude_) + ",longitude:" + std::to_string(longitude_) +
1039         ",nid:" + std::to_string(nid_) + ",timeStamp:" + std::to_string(timeStamp_) +
1040         ",signalLevel:" + std::to_string(signalLevel_) + ",signalIntensity:" + std::to_string(signalIntensity_) +
1041         ",sid:" + std::to_string(sid_));
1042     return content;
1043 }
1044 
SetNrParam(int32_t nrArfcn,int32_t pci,int32_t tac,int64_t nci)1045 void NrCellInformation::SetNrParam(int32_t nrArfcn, int32_t pci, int32_t tac, int64_t nci)
1046 {
1047     nrArfcn_ = nrArfcn;
1048     pci_ = pci;
1049     tac_ = tac;
1050     nci_ = nci;
1051 }
1052 
SetNrSignalParam(int32_t rsrp,int32_t rsrq)1053 void NrCellInformation::SetNrSignalParam(int32_t rsrp, int32_t rsrq)
1054 {
1055     rsrp_ = rsrp;
1056     rsrq_ = rsrq;
1057 }
1058 
NrCellInformation(const NrCellInformation & nrCell)1059 NrCellInformation::NrCellInformation(const NrCellInformation &nrCell)
1060 {
1061     mcc_ = nrCell.mcc_;
1062     mnc_ = nrCell.mnc_;
1063     cellId_ = nrCell.cellId_;
1064     nrArfcn_ = nrCell.nrArfcn_;
1065     pci_ = nrCell.pci_;
1066     tac_ = nrCell.tac_;
1067     nci_ = nrCell.nci_;
1068     rsrp_ = nrCell.rsrp_;
1069     rsrq_ = nrCell.rsrq_;
1070     timeStamp_ = nrCell.timeStamp_;
1071     signalLevel_ = nrCell.signalLevel_;
1072     signalIntensity_ = nrCell.signalIntensity_;
1073     isCamped_ = nrCell.isCamped_;
1074 }
1075 
operator =(const NrCellInformation & nrCell)1076 NrCellInformation &NrCellInformation::operator=(const NrCellInformation &nrCell)
1077 {
1078     mcc_ = nrCell.mcc_;
1079     mnc_ = nrCell.mnc_;
1080     cellId_ = nrCell.cellId_;
1081     nrArfcn_ = nrCell.nrArfcn_;
1082     pci_ = nrCell.pci_;
1083     tac_ = nrCell.tac_;
1084     nci_ = nrCell.nci_;
1085     rsrp_ = nrCell.rsrp_;
1086     rsrq_ = nrCell.rsrq_;
1087     timeStamp_ = nrCell.timeStamp_;
1088     signalLevel_ = nrCell.signalLevel_;
1089     signalIntensity_ = nrCell.signalIntensity_;
1090     isCamped_ = nrCell.isCamped_;
1091     return *this;
1092 }
1093 
operator ==(const NrCellInformation & other) const1094 bool NrCellInformation::operator==(const NrCellInformation &other) const
1095 {
1096     return mcc_ == other.mcc_ && mnc_ == other.mnc_ && cellId_ == other.cellId_ && nrArfcn_ == other.nrArfcn_ &&
1097         pci_ == other.pci_ && tac_ == other.tac_ && nci_ == other.nci_ && rsrp_ == other.rsrp_ &&
1098         rsrq_ == other.rsrq_ && timeStamp_ == other.timeStamp_ && signalLevel_ == other.signalLevel_ &&
1099         signalIntensity_ == other.signalIntensity_ && isCamped_ == other.isCamped_;
1100 }
1101 
GetNetworkType() const1102 CellInformation::CellType NrCellInformation::GetNetworkType() const
1103 {
1104     return CellType::CELL_TYPE_NR;
1105 }
1106 
Marshalling(Parcel & parcel) const1107 bool NrCellInformation::Marshalling(Parcel &parcel) const
1108 {
1109     if (!parcel.WriteInt32(static_cast<int32_t>(CellInformation::CellType::CELL_TYPE_NR))) {
1110         return false;
1111     }
1112     if (!parcel.WriteString(mcc_)) {
1113         return false;
1114     }
1115     if (!parcel.WriteString(mnc_)) {
1116         return false;
1117     }
1118     if (!parcel.WriteInt32(cellId_)) {
1119         return false;
1120     }
1121     if (!parcel.WriteInt32(nrArfcn_)) {
1122         return false;
1123     }
1124     if (!parcel.WriteInt32(pci_)) {
1125         return false;
1126     }
1127     if (!parcel.WriteInt32(tac_)) {
1128         return false;
1129     }
1130     if (!parcel.WriteInt64(nci_)) {
1131         return false;
1132     }
1133     if (!parcel.WriteInt32(rsrp_)) {
1134         return false;
1135     }
1136     if (!parcel.WriteInt32(rsrq_)) {
1137         return false;
1138     }
1139     if (!parcel.WriteInt64(timeStamp_)) {
1140         return false;
1141     }
1142     if (!parcel.WriteInt32(signalLevel_)) {
1143         return false;
1144     }
1145     if (!parcel.WriteInt32(signalIntensity_)) {
1146         return false;
1147     }
1148     if (!parcel.WriteBool(isCamped_)) {
1149         return false;
1150     }
1151     return true;
1152 }
1153 
Unmarshalling(Parcel & parcel)1154 NrCellInformation *NrCellInformation::Unmarshalling(Parcel &parcel)
1155 {
1156     NrCellInformation *param = new (std::nothrow) NrCellInformation();
1157     if (param == nullptr) {
1158         return nullptr;
1159     }
1160     if (!param->ReadFromParcel(parcel)) {
1161         delete param;
1162         param = nullptr;
1163     }
1164     return param;
1165 }
1166 
ReadFromParcel(Parcel & parcel)1167 bool NrCellInformation::ReadFromParcel(Parcel &parcel)
1168 {
1169     std::string readString;
1170     if (!parcel.ReadString(readString)) {
1171         return false;
1172     }
1173     mcc_ = readString;
1174     if (!parcel.ReadString(readString)) {
1175         return false;
1176     }
1177     mnc_ = readString;
1178     if (!ReadIntFromParcel(parcel)) {
1179         return false;
1180     }
1181     uint64_t nrTime = 0;
1182     if (!parcel.ReadUint64(nrTime)) {
1183         return false;
1184     }
1185     int32_t rat;
1186     timeStamp_ = nrTime;
1187     if (!parcel.ReadInt32(rat)) {
1188         return false;
1189     }
1190     signalLevel_ = rat;
1191     int32_t nrSignalIntensity = 0;
1192     if (!parcel.ReadInt32(nrSignalIntensity)) {
1193         return false;
1194     }
1195     signalIntensity_ = nrSignalIntensity;
1196     bool nrTemCamped = false;
1197     if (!parcel.ReadBool(nrTemCamped)) {
1198         return false;
1199     }
1200     isCamped_ = nrTemCamped;
1201     return true;
1202 }
1203 
ReadIntFromParcel(Parcel & parcel)1204 bool NrCellInformation::ReadIntFromParcel(Parcel &parcel)
1205 {
1206     int32_t rat;
1207     if (!parcel.ReadInt32(rat)) {
1208         return false;
1209     }
1210     cellId_ = rat;
1211     if (!parcel.ReadInt32(rat)) {
1212         return false;
1213     }
1214     nrArfcn_ = rat;
1215     if (!parcel.ReadInt32(rat)) {
1216         return false;
1217     }
1218     pci_ = rat;
1219     if (!parcel.ReadInt32(rat)) {
1220         return false;
1221     }
1222     tac_ = rat;
1223     int64_t tempNci;
1224     if (!parcel.ReadInt64(tempNci)) {
1225         return false;
1226     }
1227     nci_ = tempNci;
1228     if (!parcel.ReadInt32(rat)) {
1229         return false;
1230     }
1231     rsrp_ = rat;
1232     if (!parcel.ReadInt32(rat)) {
1233         return false;
1234     }
1235     rsrq_ = rat;
1236     return true;
1237 }
1238 
GetArfcn() const1239 int32_t NrCellInformation::GetArfcn() const
1240 {
1241     return nrArfcn_;
1242 }
1243 
GetPci() const1244 int32_t NrCellInformation::GetPci() const
1245 {
1246     return pci_;
1247 }
1248 
GetTac() const1249 int32_t NrCellInformation::GetTac() const
1250 {
1251     return tac_;
1252 }
1253 
GetNci() const1254 int64_t NrCellInformation::GetNci() const
1255 {
1256     return nci_;
1257 }
1258 
UpdateLocation(int32_t pci,int32_t tac)1259 void NrCellInformation::UpdateLocation(int32_t pci, int32_t tac)
1260 {
1261     pci_ = pci;
1262     tac_ = tac;
1263     timeStamp_ = time(0);
1264 }
1265 
ToString() const1266 std::string NrCellInformation::ToString() const
1267 {
1268     int32_t netWorkType = static_cast<int32_t>(NrCellInformation::GetNetworkType());
1269     std::string content("netWorkType:" + std::to_string(netWorkType) + ",mcc:" + mcc_ +
1270         ",mnc:" + mnc_ + ",earfcn:" + std::to_string(nrArfcn_) + ",cellId:" + std::to_string(cellId_) +
1271         ",timeStamp:" + std::to_string(timeStamp_) + ",signalLevel:" + std::to_string(signalLevel_) +
1272         ",signalIntensity:" + std::to_string(signalIntensity_) + ",pci:" + std::to_string(pci_) +
1273         ",tac:" + std::to_string(tac_) + ",nci:" + std::to_string(nci_) + ",rsrp:" + std::to_string(rsrp_) +
1274         ",rsrq:" + std::to_string(rsrq_));
1275     return content;
1276 }
1277 } // namespace Telephony
1278 } // namespace OHOS
1279