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 "network_register.h"
17
18 #include <cinttypes>
19
20 #include "core_service_hisysevent.h"
21 #include "enum_convert.h"
22 #include "i_network_search_callback.h"
23 #include "network_search_manager.h"
24 #include "parameter.h"
25 #include "resource_utils.h"
26 #include "string_ex.h"
27 #include "tel_ril_modem_parcel.h"
28 #include "telephony_errors.h"
29 #include "telephony_ext_wrapper.h"
30 #include "telephony_log_wrapper.h"
31
32 namespace OHOS {
33 namespace Telephony {
34 constexpr const char *TELEPHONY_NR_CONVERSION_CONFIG = "persist.telephony.nr.config";
35 constexpr const char *TELEPHONY_NR_CONFIG_A = "ConfigA";
36 constexpr const char *TELEPHONY_NR_CONFIG_B = "ConfigB";
37 constexpr const char *TELEPHONY_NR_CONFIG_C = "ConfigC";
38 constexpr const char *TELEPHONY_NR_CONFIG_D = "ConfigD";
39 constexpr const char *TELEPHONY_NR_CONFIG_AD = "ConfigAD";
40 constexpr int32_t SYS_PARAMETER_SIZE = 256;
41 constexpr int32_t MAX_SIZE = 100;
42 constexpr int32_t CS_TYPE = 0;
43 constexpr int32_t IMS_TYPE = 1;
44 const std::map<int32_t, std::string> rilRegisterStateMap = {
45 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_NOT_REG), "REG_STATE_NOT_REG" },
46 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_HOME_ONLY), "REG_STATE_HOME_ONLY" },
47 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_SEARCH), "REG_STATE_SEARCH" },
48 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_NO_SERVICE), "REG_STATE_NO_SERVICE" },
49 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_INVALID), "REG_STATE_INVALID" },
50 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_ROAMING), "REG_STATE_ROAMING" },
51 { static_cast<int32_t>(TelephonyRilRegisterState::REG_STATE_EMERGENCY_ONLY), "REG_STATE_EMERGENCY_ONLY" },
52 };
53
NetworkRegister(std::shared_ptr<NetworkSearchState> networkSearchState,std::weak_ptr<NetworkSearchManager> networkSearchManager,int32_t slotId)54 NetworkRegister::NetworkRegister(std::shared_ptr<NetworkSearchState> networkSearchState,
55 std::weak_ptr<NetworkSearchManager> networkSearchManager, int32_t slotId)
56 : networkSearchState_(networkSearchState), networkSearchManager_(networkSearchManager), slotId_(slotId)
57 {
58 ResourceUtils::Get().GetBooleanValueByName(ResourceUtils::IS_CS_CAPABLE, isCsCapable_);
59 }
60
InitNrConversionConfig()61 void NetworkRegister::InitNrConversionConfig()
62 {
63 GetSystemPropertiesConfig(systemPropertiesConfig_);
64 if (systemPropertiesConfig_ == TELEPHONY_NR_CONFIG_AD) {
65 int32_t rrcState = 0;
66 GetRrcConnectionState(rrcState);
67 if (rrcState == RRC_CONNECTED_STATUS) {
68 currentNrConfig_ = TELEPHONY_NR_CONFIG_A;
69 } else {
70 currentNrConfig_ = TELEPHONY_NR_CONFIG_D;
71 }
72 } else {
73 currentNrConfig_ = systemPropertiesConfig_;
74 }
75 }
76
UpdateNetworkSearchState(RegServiceState regStatus,RadioTech tech,RoamingType roam,DomainType type)77 void NetworkRegister::UpdateNetworkSearchState(RegServiceState regStatus,
78 RadioTech tech,
79 RoamingType roam,
80 DomainType type)
81 {
82 networkSearchState_->SetNetworkState(regStatus, type);
83 networkSearchState_->SetEmergency(
84 (regStatus == RegServiceState::REG_STATE_EMERGENCY_ONLY) && isCsCapable_);
85 networkSearchState_->SetNetworkType(tech, type);
86 networkSearchState_->SetNetworkStateToRoaming(roam, type);
87 }
88
ProcessCsRegister(const std::shared_ptr<CsRegStatusInfo> csRegStateResult)89 void NetworkRegister::ProcessCsRegister(const std::shared_ptr<CsRegStatusInfo> csRegStateResult)
90 {
91 auto networkSearchManager = networkSearchManager_.lock();
92 if (networkSearchManager == nullptr) {
93 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister networkSearchManager is nullptr slotId:%{public}d", slotId_);
94 return;
95 }
96 if (csRegStateResult == nullptr) {
97 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister csRegStateResult is nullptr slotId:%{public}d", slotId_);
98 return;
99 }
100 RilRegister registrationStatus = static_cast<RilRegister>(csRegStateResult->regStatus);
101 RegServiceState regStatus = ConvertRegFromRil(registrationStatus);
102 if (networkSearchState_ == nullptr) {
103 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister networkSearchState_ is nullptr slotId:%{public}d", slotId_);
104 return;
105 }
106 UpdateCellularCall(regStatus, CS_TYPE);
107 RadioTech tech = ConvertTechFromRil(static_cast<TelRilRadioTech>(csRegStateResult->radioTechnology));
108 RoamingType roam = RoamingType::ROAMING_STATE_UNKNOWN;
109 if (registrationStatus == RilRegister::REG_STATE_ROAMING) {
110 roam = RoamingType::ROAMING_STATE_UNSPEC;
111 }
112 UpdateNetworkSearchState(regStatus, tech, roam, DomainType::DOMAIN_TYPE_CS);
113 PrintCurrentRegistrationState(registrationStatus, csRegStateResult->radioTechnology, roam, slotId_);
114 CoreServiceHiSysEvent::WriteNetworkStateBehaviorEvent(slotId_, static_cast<int32_t>(DomainType::DOMAIN_TYPE_CS),
115 static_cast<int32_t>(tech), static_cast<int32_t>(regStatus));
116 }
117
UpdateCellularCall(const RegServiceState & regStatus,const int32_t callType)118 void NetworkRegister::UpdateCellularCall(const RegServiceState ®Status, const int32_t callType)
119 {
120 auto networkSearchManager = networkSearchManager_.lock();
121 if (networkSearchManager == nullptr) {
122 TELEPHONY_LOGE("networkSearchManager is nullptr");
123 return;
124 }
125 if (regStatus == RegServiceState::REG_STATE_IN_SERVICE || regStatus == RegServiceState::REG_STATE_EMERGENCY_ONLY) {
126 sptr<NetworkSearchCallBackBase> cellularCall = networkSearchManager->GetCellularCallCallBack();
127 if (cellularCall) {
128 cellularCall->SetReadyToCall(slotId_, callType, true);
129 }
130 }
131 }
132
ProcessPsRegister(const std::shared_ptr<PsRegStatusResultInfo> psRegStatusResult)133 void NetworkRegister::ProcessPsRegister(const std::shared_ptr<PsRegStatusResultInfo> psRegStatusResult)
134 {
135 auto networkSearchManager = networkSearchManager_.lock();
136 if (networkSearchManager == nullptr) {
137 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister networkSearchManager is nullptr");
138 return;
139 }
140 if (psRegStatusResult == nullptr) {
141 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister psRegStatusResult is nullptr slotId:%{public}d", slotId_);
142 return;
143 }
144 RilRegister registrationStatus = static_cast<RilRegister>(psRegStatusResult->regStatus);
145 RegServiceState regStatus = ConvertRegFromRil(registrationStatus);
146 if (networkSearchState_ == nullptr) {
147 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister networkSearchState_ is nullptr slotId:%{public}d", slotId_);
148 return;
149 }
150 UpdateCellularCall(regStatus, IMS_TYPE);
151 RadioTech tech = ConvertTechFromRil(static_cast<TelRilRadioTech>(psRegStatusResult->radioTechnology));
152 RoamingType roam = RoamingType::ROAMING_STATE_UNKNOWN;
153 if (registrationStatus == RilRegister::REG_STATE_ROAMING) {
154 roam = RoamingType::ROAMING_STATE_UNSPEC;
155 }
156 UpdateNetworkSearchState(regStatus, tech, roam, DomainType::DOMAIN_TYPE_PS);
157 endcSupport_ = psRegStatusResult->isEnDcAvailable;
158 dcNrRestricted_ = psRegStatusResult->isDcNrRestricted;
159 nrSupport_ = psRegStatusResult->isNrAvailable;
160 UpdateNrState();
161 UpdateCfgTech();
162 PrintCurrentRegistrationState(registrationStatus, psRegStatusResult->radioTechnology, roam, slotId_);
163 CoreServiceHiSysEvent::WriteNetworkStateBehaviorEvent(slotId_, static_cast<int32_t>(DomainType::DOMAIN_TYPE_PS),
164 static_cast<int32_t>(tech), static_cast<int32_t>(regStatus));
165 }
166
PrintCurrentRegistrationState(RilRegister regStatus,TelRilRadioTech tech,RoamingType roam,int32_t slotId)167 void NetworkRegister::PrintCurrentRegistrationState(RilRegister regStatus, TelRilRadioTech tech, RoamingType roam,
168 int32_t slotId)
169 {
170 auto iter = rilRegisterStateMap.find(static_cast<int32_t>(regStatus));
171 if (iter != rilRegisterStateMap.end()) {
172 TELEPHONY_LOGI("regStatus=%{public}s(%{public}d) radioTechnology=%{public}d roam=%{public}d slotId:%{public}d",
173 iter->second.c_str(), regStatus, tech, roam, slotId_);
174 } else {
175 TELEPHONY_LOGE("PrintCurrentRegistrationStateFailed: rilRegisterStateMap is empty.");
176 }
177 }
178
RevertLastTechnology()179 int32_t NetworkRegister::RevertLastTechnology()
180 {
181 if (networkSearchState_ == nullptr) {
182 TELEPHONY_LOGE("networkSearchState_ is nullptr slotId:%{public}d", slotId_);
183 return TELEPHONY_ERR_LOCAL_PTR_NULL;
184 }
185 RadioTech lastCfgTech = RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
186 RadioTech lastPsRadioTech = RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
187 networkSearchState_->GetLastCfgTech(lastCfgTech);
188 networkSearchState_->GetLastPsRadioTech(lastPsRadioTech);
189 networkSearchState_->SetCfgTech(lastCfgTech);
190 networkSearchState_->SetNetworkType(lastPsRadioTech, DomainType::DOMAIN_TYPE_PS);
191 TELEPHONY_LOGI(
192 "lastCfgTech:%{public}d lastPsRadioTech:%{public}d slotId:%{public}d", lastCfgTech, lastPsRadioTech, slotId_);
193 return TELEPHONY_ERR_SUCCESS;
194 }
195
NotifyStateChange()196 int32_t NetworkRegister::NotifyStateChange()
197 {
198 if (networkSearchState_ == nullptr) {
199 TELEPHONY_LOGE("networkSearchState_ is nullptr slotId:%{public}d", slotId_);
200 return TELEPHONY_ERR_LOCAL_PTR_NULL;
201 }
202 networkSearchState_->NotifyStateChange();
203 return TELEPHONY_ERR_SUCCESS;
204 }
205
ProcessChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer & event)206 void NetworkRegister::ProcessChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer &event)
207 {
208 std::shared_ptr<ChannelConfigInfoList> channelConfigInfoList = event->GetSharedObject<ChannelConfigInfoList>();
209 if (channelConfigInfoList == nullptr) {
210 TELEPHONY_LOGE(
211 "NetworkRegister::ProcessChannelConfigInfo psRegStatusResult is nullptr slotId:%{public}d", slotId_);
212 return;
213 }
214 int32_t size = channelConfigInfoList->itemNum;
215 TELEPHONY_LOGI("NetworkRegister::ProcessChannelConfigInfo num size:%{public}d slotId:%{public}d", size, slotId_);
216 if (size >= MAX_SIZE) {
217 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo num over max size");
218 return;
219 }
220 if (channelConfigInfoList->channelConfigInfos.size() > 0 &&
221 static_cast<int32_t>(channelConfigInfoList->channelConfigInfos.size()) == size) {
222 std::vector<PhysicalChannelConfig> &configs = channelConfigInfoList->channelConfigInfos;
223 channelConfigInfos_.clear();
224 channelConfigInfos_.insert(channelConfigInfos_.begin(), configs.begin(), configs.end());
225 } else {
226 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo data error slotId:%{public}d", slotId_);
227 return;
228 }
229
230 bool isNrSecondaryCell = false;
231 for (int32_t i = 0; i < size; ++i) {
232 if (static_cast<RadioTech>(channelConfigInfos_[i].ratType) == RadioTech::RADIO_TECHNOLOGY_NR &&
233 static_cast<ConnectServiceCell>(channelConfigInfos_[i].cellConnStatus) ==
234 ConnectServiceCell::CONNECTION_SECONDARY_CELL) {
235 isNrSecondaryCell = true;
236 break;
237 }
238 }
239 TELEPHONY_LOGI("isNrSecondaryCell:%{public}d slotId:%{public}d", isNrSecondaryCell, slotId_);
240 NotifyNrFrequencyChanged();
241 if (isNrSecondaryCell_ != isNrSecondaryCell) {
242 isNrSecondaryCell_ = isNrSecondaryCell;
243 UpdateNrState();
244 UpdateCfgTech();
245 auto networkSearchManager = networkSearchManager_.lock();
246 if (networkSearchManager == nullptr) {
247 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo networkSearchManager is nullptr");
248 return;
249 }
250 TELEPHONY_LOGI("physical channel change, slotId:%{public}d", slotId_);
251 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
252 }
253 }
254
NotifyNrFrequencyChanged()255 void NetworkRegister::NotifyNrFrequencyChanged()
256 {
257 auto networkSearchManager = networkSearchManager_.lock();
258 if (networkSearchManager == nullptr) {
259 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged networkSearchManager is nullptr");
260 return;
261 }
262 bool isFreqChanged = false;
263 FrequencyType curFreqType = FrequencyType::FREQ_TYPE_UNKNOWN;
264
265 sptr<NetworkSearchCallBackBase> cellularData = networkSearchManager->GetCellularDataCallBack();
266 if (cellularData == nullptr) {
267 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged cellularData callback is nullptr");
268 return;
269 }
270 ssize_t size = channelConfigInfos_.size();
271 if (size >= MAX_SIZE) {
272 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged channelConfigInfos_ over max size");
273 return;
274 }
275 for (int32_t i = 0; i < size; ++i) {
276 std::vector<int32_t> &cids = channelConfigInfos_[i].contextIds;
277 if (isFreqChanged) {
278 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged channelConfigInfos:%{public}d isFreqChanged", i);
279 continue;
280 }
281 for (auto &cid : cids) {
282 if (!cellularData->HasInternetCapability(slotId_, cid)) {
283 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged cid:%{public}d hasNoInternetCapability", cid);
284 continue;
285 }
286 curFreqType = static_cast<FrequencyType>(channelConfigInfos_[i].freqRange);
287 isFreqChanged = true;
288 break;
289 }
290 if (isFreqChanged) {
291 break;
292 }
293 }
294 if (freqType_ != curFreqType) {
295 freqType_ = curFreqType;
296 networkSearchManager->NotifyNrFrequencyChanged(slotId_);
297 networkSearchManager->SetFrequencyType(slotId_, freqType_);
298 }
299 }
300
DcPhysicalLinkActiveUpdate(bool isActive)301 void NetworkRegister::DcPhysicalLinkActiveUpdate(bool isActive)
302 {
303 TELEPHONY_LOGI("NetworkRegister::DcPhysicalLinkActiveUpdate isActive:%{public}s slotId:%{public}d",
304 isActive ? "true" : "false", slotId_);
305 isPhysicalLinkActive_ = isActive;
306 UpdateNrState();
307 }
308
UpdateNrState()309 void NetworkRegister::UpdateNrState()
310 {
311 if (networkSearchState_ == nullptr || networkSearchState_->GetNetworkStatus() == nullptr) {
312 TELEPHONY_LOGE("networkSearchState_ is nullptr, slotId:%{public}d", slotId_);
313 return;
314 }
315
316 nrState_ = NrState::NR_STATE_NOT_SUPPORT;
317 RadioTech rat = networkSearchState_->GetNetworkStatus()->GetPsRadioTech();
318 if (rat == RadioTech::RADIO_TECHNOLOGY_NR) {
319 nrState_ = NrState::NR_NSA_STATE_SA_ATTACHED;
320 } else {
321 if (isNrSecondaryCell_) {
322 nrState_ = NrState::NR_NSA_STATE_DUAL_CONNECTED;
323 } else if (endcSupport_) {
324 if (dcNrRestricted_) {
325 nrState_ = NrState::NR_STATE_NOT_SUPPORT;
326 } else {
327 nrState_ = NrState::NR_NSA_STATE_NO_DETECT;
328 }
329 }
330 }
331 nrState_ = static_cast<NrState>(UpdateNsaState(static_cast<int32_t>(nrState_)));
332 networkSearchState_->SetNrState(nrState_);
333 }
334
UpdateNsaState(int32_t nsaState)335 int32_t NetworkRegister::UpdateNsaState(int32_t nsaState)
336 {
337 int32_t newNsaState = nsaState;
338 auto networkSearchManager = networkSearchManager_.lock();
339 if (networkSearchManager == nullptr || networkSearchState_ == nullptr) {
340 TELEPHONY_LOGE("networkSearchState_ is nullptr, slotId:%{public}d", slotId_);
341 return newNsaState;
342 }
343 std::vector<sptr<CellInformation>> cellInfo;
344 networkSearchManager->GetCellInfoList(slotId_, cellInfo);
345 int32_t cellId = 0;
346 auto iter = cellInfo.begin();
347 while (iter != cellInfo.end()) {
348 if ((*iter)->GetNetworkType() == CellInformation::CellType::CELL_TYPE_LTE) {
349 cellId = (*iter)->GetCellId();
350 break;
351 }
352 iter++;
353 }
354 auto networkState = networkSearchState_->GetNetworkStatus();
355 if (networkState == nullptr) {
356 TELEPHONY_LOGE("networkState is nullptr, slotId:%{public}d", slotId_);
357 return newNsaState;
358 }
359 RegServiceState regState = networkState->GetRegStatus();
360 RadioTech psRegTech = networkState->GetPsRadioTech();
361 if (regState != RegServiceState::REG_STATE_IN_SERVICE ||
362 (psRegTech != RadioTech::RADIO_TECHNOLOGY_LTE && psRegTech != RadioTech::RADIO_TECHNOLOGY_LTE_CA)) {
363 return newNsaState;
364 }
365 if (TELEPHONY_EXT_WRAPPER.updateNsaStateExt_ != nullptr) {
366 newNsaState = TELEPHONY_EXT_WRAPPER.updateNsaStateExt_(
367 slotId_, cellId, nrSupport_, dcNrRestricted_, newNsaState);
368 }
369 return newNsaState;
370 }
371
UpdateCfgTech()372 void NetworkRegister::UpdateCfgTech()
373 {
374 if (networkSearchState_ == nullptr || networkSearchState_->GetNetworkStatus() == nullptr) {
375 TELEPHONY_LOGE("NetworkRegister::UpdateCfgTech networkSearchState_ is nullptr slotId:%{public}d", slotId_);
376 return;
377 }
378 auto networkState = networkSearchState_->GetNetworkStatus();
379 RadioTech tech = networkState->GetPsRadioTech() != RadioTech::RADIO_TECHNOLOGY_UNKNOWN ?
380 networkState->GetPsRadioTech() : networkState->GetCsRadioTech();
381 TELEPHONY_LOGD("tech:%{public}d slotId:%{public}d", tech, slotId_);
382 RadioTech cfgTech = GetTechnologyByNrConfig(tech);
383 networkSearchState_->SetCfgTech(cfgTech);
384 }
385
ProcessRestrictedState(const AppExecFwk::InnerEvent::Pointer & event) const386 void NetworkRegister::ProcessRestrictedState(const AppExecFwk::InnerEvent::Pointer &event) const {}
387
ConvertRegFromRil(RilRegister code) const388 RegServiceState NetworkRegister::ConvertRegFromRil(RilRegister code) const
389 {
390 switch (code) {
391 case RilRegister::REG_STATE_SEARCH:
392 return RegServiceState::REG_STATE_SEARCH;
393 case RilRegister::REG_STATE_NOT_REG:
394 case RilRegister::REG_STATE_NO_SERVICE:
395 return RegServiceState::REG_STATE_NO_SERVICE;
396 case RilRegister::REG_STATE_INVALID:
397 return RegServiceState::REG_STATE_UNKNOWN;
398 case RilRegister::REG_STATE_ROAMING:
399 case RilRegister::REG_STATE_HOME_ONLY:
400 return RegServiceState::REG_STATE_IN_SERVICE;
401 case RilRegister::REG_STATE_EMERGENCY_ONLY:
402 return RegServiceState::REG_STATE_EMERGENCY_ONLY;
403 default:
404 return RegServiceState::REG_STATE_NO_SERVICE;
405 }
406 }
407
ConvertTechFromRil(TelRilRadioTech code) const408 RadioTech NetworkRegister::ConvertTechFromRil(TelRilRadioTech code) const
409 {
410 switch (code) {
411 case TelRilRadioTech::RADIO_TECHNOLOGY_GSM:
412 return RadioTech::RADIO_TECHNOLOGY_GSM;
413 case TelRilRadioTech::RADIO_TECHNOLOGY_1XRTT:
414 return RadioTech::RADIO_TECHNOLOGY_1XRTT;
415 case TelRilRadioTech::RADIO_TECHNOLOGY_HSPA:
416 return RadioTech::RADIO_TECHNOLOGY_HSPA;
417 case TelRilRadioTech::RADIO_TECHNOLOGY_HSPAP:
418 return RadioTech::RADIO_TECHNOLOGY_HSPAP;
419 case TelRilRadioTech::RADIO_TECHNOLOGY_WCDMA:
420 return RadioTech::RADIO_TECHNOLOGY_WCDMA;
421 case TelRilRadioTech::RADIO_TECHNOLOGY_LTE:
422 return RadioTech::RADIO_TECHNOLOGY_LTE;
423 case TelRilRadioTech::RADIO_TECHNOLOGY_EVDO:
424 return RadioTech::RADIO_TECHNOLOGY_EVDO;
425 case TelRilRadioTech::RADIO_TECHNOLOGY_EHRPD:
426 return RadioTech::RADIO_TECHNOLOGY_EHRPD;
427 case TelRilRadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
428 return RadioTech::RADIO_TECHNOLOGY_TD_SCDMA;
429 case TelRilRadioTech::RADIO_TECHNOLOGY_LTE_CA:
430 return RadioTech::RADIO_TECHNOLOGY_LTE_CA;
431 case TelRilRadioTech::RADIO_TECHNOLOGY_NR:
432 return RadioTech::RADIO_TECHNOLOGY_NR;
433 default:
434 return RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
435 }
436 }
437
IsValidConfig(const std::string & config)438 bool NetworkRegister::IsValidConfig(const std::string &config)
439 {
440 if (config == TELEPHONY_NR_CONFIG_A || config == TELEPHONY_NR_CONFIG_B || config == TELEPHONY_NR_CONFIG_C ||
441 config == TELEPHONY_NR_CONFIG_D || config == TELEPHONY_NR_CONFIG_AD) {
442 return true;
443 } else {
444 return false;
445 }
446 }
447
GetRrcConnectionState(int32_t & rrcState)448 int32_t NetworkRegister::GetRrcConnectionState(int32_t &rrcState)
449 {
450 auto networkSearchManager = networkSearchManager_.lock();
451 if (networkSearchManager == nullptr) {
452 TELEPHONY_LOGE("NetworkRegister::GetRrcConnectionState networkSearchManager is nullptr");
453 return TELEPHONY_ERR_LOCAL_PTR_NULL;
454 }
455 return networkSearchManager->UpdateRrcConnectionState(slotId_, rrcState);
456 }
457
HandleRrcStateChanged(int32_t status)458 int32_t NetworkRegister::HandleRrcStateChanged(int32_t status)
459 {
460 if (systemPropertiesConfig_ == TELEPHONY_NR_CONFIG_AD) {
461 if (status == RRC_CONNECTED_STATUS) {
462 currentNrConfig_ = TELEPHONY_NR_CONFIG_A;
463 } else {
464 currentNrConfig_ = TELEPHONY_NR_CONFIG_D;
465 }
466 }
467 TELEPHONY_LOGI("currentNrConfig_:%{public}s, slotId:%{public}d", currentNrConfig_.c_str(), slotId_);
468 UpdateNrState();
469 UpdateCfgTech();
470 return TELEPHONY_ERR_SUCCESS;
471 }
472
GetSystemPropertiesConfig(std::string & config)473 int32_t NetworkRegister::GetSystemPropertiesConfig(std::string &config)
474 {
475 char param[SYS_PARAMETER_SIZE] = { 0 };
476 int32_t code = GetParameter(TELEPHONY_NR_CONVERSION_CONFIG, TELEPHONY_NR_CONFIG_D, param, SYS_PARAMETER_SIZE);
477 if (code <= 0 || !IsValidConfig(param)) {
478 TELEPHONY_LOGE("get system properties:%{public}s, slotId:%{public}d", param, slotId_);
479 config = TELEPHONY_NR_CONFIG_D;
480 } else {
481 config = param;
482 }
483 return TELEPHONY_ERR_SUCCESS;
484 }
485
GetTechnologyByNrConfig(RadioTech tech)486 RadioTech NetworkRegister::GetTechnologyByNrConfig(RadioTech tech)
487 {
488 if (tech != RadioTech::RADIO_TECHNOLOGY_LTE_CA && tech != RadioTech::RADIO_TECHNOLOGY_LTE) {
489 return tech;
490 }
491 if (systemPropertiesConfig_ == TELEPHONY_NR_CONFIG_AD) {
492 int32_t rrcState = 0;
493 GetRrcConnectionState(rrcState);
494 if (rrcState == RRC_CONNECTED_STATUS) {
495 currentNrConfig_ = TELEPHONY_NR_CONFIG_A;
496 } else {
497 currentNrConfig_ = TELEPHONY_NR_CONFIG_D;
498 }
499 }
500 TELEPHONY_LOGI("currentNrConfig_:%{public}s, slotId:%{public}d", currentNrConfig_.c_str(), slotId_);
501 switch (nrState_) {
502 case NrState::NR_NSA_STATE_NO_DETECT: {
503 if (currentNrConfig_ == TELEPHONY_NR_CONFIG_D) {
504 tech = RadioTech::RADIO_TECHNOLOGY_NR;
505 }
506 break;
507 }
508 case NrState::NR_NSA_STATE_CONNECTED_DETECT: {
509 if (currentNrConfig_ == TELEPHONY_NR_CONFIG_C || currentNrConfig_ == TELEPHONY_NR_CONFIG_D) {
510 tech = RadioTech::RADIO_TECHNOLOGY_NR;
511 }
512 break;
513 }
514 case NrState::NR_NSA_STATE_IDLE_DETECT: {
515 if (currentNrConfig_ == TELEPHONY_NR_CONFIG_B || currentNrConfig_ == TELEPHONY_NR_CONFIG_C ||
516 currentNrConfig_ == TELEPHONY_NR_CONFIG_D) {
517 tech = RadioTech::RADIO_TECHNOLOGY_NR;
518 }
519 break;
520 }
521 case NrState::NR_NSA_STATE_DUAL_CONNECTED:
522 tech = RadioTech::RADIO_TECHNOLOGY_NR;
523 break;
524 default:
525 break;
526 }
527 return tech;
528 }
529 } // namespace Telephony
530 } // namespace OHOS
531