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