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