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 "signal_info.h"
17
18 #include "core_service_hisysevent.h"
19 #include "network_search_notify.h"
20 #include "telephony_log_wrapper.h"
21
22 namespace OHOS {
23 namespace Telephony {
Reset()24 void SignalInfo::Reset()
25 {
26 std::lock_guard<std::mutex> lock(mutex_);
27 cache_.Init();
28 cur_.Init();
29 }
30
InitSignalBar(const int32_t bar) const31 void SignalInfo::InitSignalBar(const int32_t bar) const
32 {
33 SignalInformation::InitSignalBar(bar);
34 }
35
ProcessGsm(const GsmRssi & gsmSignal)36 bool SignalInfo::ProcessGsm(const GsmRssi &gsmSignal)
37 {
38 std::lock_guard<std::mutex> lock(mutex_);
39 cur_.gsm.SetValue(gsmSignal.rxlev, gsmSignal.ber);
40 bool ret = (cur_.gsm == cache_.gsm);
41 cache_.gsm = cur_.gsm;
42 return ret;
43 }
44
ProcessCdma(const CdmaRssi & cdmaSignal)45 bool SignalInfo::ProcessCdma(const CdmaRssi &cdmaSignal)
46 {
47 std::lock_guard<std::mutex> lock(mutex_);
48 cur_.cdma.SetValue(cdmaSignal.absoluteRssi, cdmaSignal.ecno);
49 bool ret = (cur_.cdma == cache_.cdma);
50 cache_.cdma = cur_.cdma;
51 return ret;
52 }
53
ProcessLte(const LteRssi & lteSignal)54 bool SignalInfo::ProcessLte(const LteRssi <eSignal)
55 {
56 std::lock_guard<std::mutex> lock(mutex_);
57 cur_.lte.SetValue(lteSignal.rxlev, lteSignal.rsrp, lteSignal.rsrq, lteSignal.snr);
58 bool ret = (cur_.lte == cache_.lte);
59 cache_.lte = cur_.lte;
60 return ret;
61 }
62
ProcessWcdma(const WCdmaRssi & wcdmaSignal)63 bool SignalInfo::ProcessWcdma(const WCdmaRssi &wcdmaSignal)
64 {
65 std::lock_guard<std::mutex> lock(mutex_);
66 cur_.wcdma.SetValue(wcdmaSignal.rxlev, wcdmaSignal.rscp, wcdmaSignal.ecio, wcdmaSignal.ber);
67 bool ret = (cur_.wcdma == cache_.wcdma);
68 cache_.wcdma = cur_.wcdma;
69 return ret;
70 }
71
ProcessTdScdma(const TdScdmaRssi & tdScdmaSignal)72 bool SignalInfo::ProcessTdScdma(const TdScdmaRssi &tdScdmaSignal)
73 {
74 std::lock_guard<std::mutex> lock(mutex_);
75 cur_.tdScdma.SetValue(tdScdmaSignal.rscp);
76 bool ret = (cur_.tdScdma == cache_.tdScdma);
77 cache_.tdScdma = cur_.tdScdma;
78 return ret;
79 }
80
ProcessNr(const NrRssi & nrSignal)81 bool SignalInfo::ProcessNr(const NrRssi &nrSignal)
82 {
83 std::lock_guard<std::mutex> lock(mutex_);
84 cur_.nr.SetValue(nrSignal.rsrp, nrSignal.rsrq, nrSignal.sinr);
85 bool ret = (cur_.nr == cache_.nr);
86 cache_.nr = cur_.nr;
87 return ret;
88 }
89
PrintfLog(const Rssi & signalIntensity)90 static void PrintfLog(const Rssi &signalIntensity)
91 {
92 TELEPHONY_LOGI("SignalInfo::ProcessSignalIntensity gm.rssi:%{public}d, gm.ber:%{public}d\n",
93 signalIntensity.gw.rxlev, signalIntensity.gw.ber);
94
95 TELEPHONY_LOGI("SignalInfo::ProcessSignalIntensity cdma.absoluteRssi:%{public}d, cdma.ecno:%{public}d ",
96 signalIntensity.cdma.absoluteRssi, signalIntensity.cdma.ecno);
97
98 TELEPHONY_LOGI(
99 "SignalInfo::ProcessSignalIntensity lte.rxlev:%{public}d, "
100 "lte.rsrq:%{public}d, lte.rsrp:%{public}d, lte.snr:%{public}d ",
101 signalIntensity.lte.rxlev, signalIntensity.lte.rsrq, signalIntensity.lte.rsrp, signalIntensity.lte.snr);
102
103 TELEPHONY_LOGI(
104 "SignalInfo::ProcessSignalIntensity wcdma.rxlev:%{public}d, "
105 "SignalInfo::ProcessSignalIntensity wcdma.ecio:%{public}d "
106 "SignalInfo::ProcessSignalIntensity wcdma.rscp:%{public}d "
107 "SignalInfo::ProcessSignalIntensity wcdma.ber:%{public}d ",
108 signalIntensity.wcdma.rxlev, signalIntensity.wcdma.ecio, signalIntensity.wcdma.rscp,
109 signalIntensity.wcdma.ber);
110
111 TELEPHONY_LOGI("SignalInfo::ProcessSignalIntensity tdScdma.rscp:%{public}d\n", signalIntensity.tdScdma.rscp);
112
113 TELEPHONY_LOGI(
114 "SignalInfo::ProcessSignalIntensity nr.rsrp:%{public}d, "
115 "nr.rsrq:%{public}d, nr.sinr:%{public}d ",
116 signalIntensity.nr.rsrp, signalIntensity.nr.rsrq, signalIntensity.nr.sinr);
117 }
118
ProcessSignalIntensity(int32_t slotId,const AppExecFwk::InnerEvent::Pointer & event)119 void SignalInfo::ProcessSignalIntensity(int32_t slotId, const AppExecFwk::InnerEvent::Pointer &event)
120 {
121 TELEPHONY_LOGI("SignalInfo::ProcessSignalIntensity rssi start......\n");
122 if (event == nullptr) {
123 TELEPHONY_LOGE("SignalInfo::ProcessSignalIntensity event is nullptr\n");
124 return;
125 }
126
127 Rssi *signalIntensity = event->GetSharedObject<Rssi>().get();
128 if (signalIntensity == nullptr) {
129 TELEPHONY_LOGE("SignalInfo::ProcessSignalIntensity rssi is nullptr\n");
130 return;
131 }
132 bool gsmUpdate = ProcessGsm(signalIntensity->gw);
133 bool cdmaUpdate = ProcessCdma(signalIntensity->cdma);
134 bool lteUpdate = ProcessLte(signalIntensity->lte);
135 bool wcdmaUpdate = ProcessWcdma(signalIntensity->wcdma);
136 bool tdScdmaUpdate = ProcessTdScdma(signalIntensity->tdScdma);
137 bool nrUpdate = ProcessNr(signalIntensity->nr);
138 if (!gsmUpdate || !cdmaUpdate || !lteUpdate || !wcdmaUpdate || !tdScdmaUpdate || !nrUpdate) {
139 std::vector<sptr<SignalInformation>> signals;
140 GetSignalInfoList(signals);
141 DelayedSingleton<NetworkSearchNotify>::GetInstance()->NotifySignalInfoUpdated(slotId, signals);
142 int level = 0;
143 if (signals.size() != 0) {
144 level = signals[0]->GetSignalLevel();
145 }
146 CoreServiceHiSysEvent::WriteSignalLevelBehaviorEvent(slotId, level);
147 }
148 PrintfLog(*signalIntensity);
149 }
150
GetSignalInfoList(std::vector<sptr<SignalInformation>> & signals)151 void SignalInfo::GetSignalInfoList(std::vector<sptr<SignalInformation>> &signals)
152 {
153 std::lock_guard<std::mutex> lock(mutex_);
154 bool gsmValid = cur_.gsm.ValidateGsmValue();
155 bool cdmaValid = cur_.cdma.ValidateCdmaValue();
156 bool lteValid = cur_.lte.ValidateLteValue();
157 bool wcdmaValid = cur_.wcdma.ValidateWcdmaValue();
158 bool tdScdmaValid = cur_.tdScdma.ValidateTdScdmaValue();
159 bool nrValid = cur_.nr.ValidateNrValue();
160
161 if (lteValid) {
162 signals.emplace_back(cur_.lte.NewInstance());
163 }
164 if (nrValid) {
165 signals.emplace_back(cur_.nr.NewInstance());
166 }
167 if (cdmaValid) {
168 signals.emplace_back(cur_.cdma.NewInstance());
169 }
170 if (tdScdmaValid) {
171 signals.emplace_back(cur_.tdScdma.NewInstance());
172 }
173 if (wcdmaValid) {
174 signals.emplace_back(cur_.wcdma.NewInstance());
175 }
176 if (gsmValid) {
177 signals.emplace_back(cur_.gsm.NewInstance());
178 }
179 }
180 } // namespace Telephony
181 } // namespace OHOS
182