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 constexpr int32_t CS_TYPE = 0;
41 constexpr int32_t IMS_TYPE = 1;
42
NetworkRegister(std::shared_ptr<NetworkSearchState> networkSearchState,std::weak_ptr<NetworkSearchManager> networkSearchManager,int32_t slotId)43 NetworkRegister::NetworkRegister(std::shared_ptr<NetworkSearchState> networkSearchState,
44 std::weak_ptr<NetworkSearchManager> networkSearchManager, int32_t slotId)
45 : networkSearchState_(networkSearchState), networkSearchManager_(networkSearchManager), slotId_(slotId)
46 {
47 ResourceUtils::Get().GetBooleanValueByName(ResourceUtils::IS_CS_CAPABLE, isCsCapable_);
48 }
49
InitNrConversionConfig()50 void NetworkRegister::InitNrConversionConfig()
51 {
52 GetSystemPropertiesConfig(systemPropertiesConfig_);
53 if (systemPropertiesConfig_ == TELEPHONY_NR_CONFIG_AD) {
54 int32_t rrcState = 0;
55 GetRrcConnectionState(rrcState);
56 if (rrcState == RRC_CONNECTED_STATUS) {
57 currentNrConfig_ = TELEPHONY_NR_CONFIG_A;
58 } else {
59 currentNrConfig_ = TELEPHONY_NR_CONFIG_D;
60 }
61 } else {
62 currentNrConfig_ = systemPropertiesConfig_;
63 }
64 }
65
UpdateNetworkSearchState(RegServiceState regStatus,RadioTech tech,RoamingType roam,DomainType type)66 void NetworkRegister::UpdateNetworkSearchState(RegServiceState regStatus,
67 RadioTech tech,
68 RoamingType roam,
69 DomainType type)
70 {
71 regStatusResult_ = regStatus;
72 networkSearchState_->SetNetworkState(regStatus, type);
73 networkSearchState_->SetEmergency(
74 (regStatus == RegServiceState::REG_STATE_EMERGENCY_ONLY) && isCsCapable_);
75 networkSearchState_->SetNetworkType(tech, type);
76 networkSearchState_->SetNetworkStateToRoaming(roam, type);
77 }
78
ProcessCsRegister(const AppExecFwk::InnerEvent::Pointer & event)79 void NetworkRegister::ProcessCsRegister(const AppExecFwk::InnerEvent::Pointer &event)
80 {
81 auto networkSearchManager = networkSearchManager_.lock();
82 if (networkSearchManager == nullptr) {
83 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister networkSearchManager is nullptr slotId:%{public}d", slotId_);
84 return;
85 }
86 if (event == nullptr) {
87 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister event is nullptr slotId:%{public}d", slotId_);
88 return;
89 }
90 std::shared_ptr<CsRegStatusInfo> csRegStateResult = event->GetSharedObject<CsRegStatusInfo>();
91 if (csRegStateResult == nullptr) {
92 TELEPHONY_LOGE("NetworkRegister::ProcessCsRegister csRegStateResult is nullptr slotId:%{public}d", slotId_);
93 return;
94 }
95 if (csRegStateResult->flag != networkSearchManager->GetSerialNum(slotId_)) {
96 TELEPHONY_LOGI("Aborting outdated cs registration event slotId:%{public}d", slotId_);
97 return;
98 }
99 networkSearchManager->decMsgNum(slotId_);
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<HRilRadioTech>(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 TELEPHONY_LOGI("regStatus= %{public}d radioTechnology=%{public}d roam=%{public}d slotId:%{public}d",
114 registrationStatus, csRegStateResult->radioTechnology, roam, slotId_);
115 if (networkSearchManager->CheckIsNeedNotify(slotId_) || networkSearchState_->IsEmergency()) {
116 TELEPHONY_LOGI("cs domain change, slotId:%{public}d", slotId_);
117 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
118 }
119 CoreServiceHiSysEvent::WriteNetworkStateBehaviorEvent(slotId_, static_cast<int32_t>(DomainType::DOMAIN_TYPE_CS),
120 static_cast<int32_t>(tech), static_cast<int32_t>(regStatus));
121 }
122
UpdateCellularCall(const RegServiceState & regStatus,const int32_t callType)123 void NetworkRegister::UpdateCellularCall(const RegServiceState ®Status, const int32_t callType)
124 {
125 auto networkSearchManager = networkSearchManager_.lock();
126 if (networkSearchManager == nullptr) {
127 TELEPHONY_LOGE("networkSearchManager is nullptr");
128 return;
129 }
130 if (regStatus == RegServiceState::REG_STATE_IN_SERVICE || regStatus == RegServiceState::REG_STATE_EMERGENCY_ONLY) {
131 sptr<NetworkSearchCallBackBase> cellularCall = networkSearchManager->GetCellularCallCallBack();
132 if (cellularCall) {
133 cellularCall->SetReadyToCall(slotId_, callType, true);
134 }
135 }
136 }
137
ProcessPsRegister(const AppExecFwk::InnerEvent::Pointer & event)138 void NetworkRegister::ProcessPsRegister(const AppExecFwk::InnerEvent::Pointer &event)
139 {
140 auto networkSearchManager = networkSearchManager_.lock();
141 if (networkSearchManager == nullptr) {
142 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister networkSearchManager is nullptr");
143 return;
144 }
145 if (event == nullptr) {
146 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister event is nullptr slotId:%{public}d", slotId_);
147 return;
148 }
149 std::shared_ptr<PsRegStatusResultInfo> psRegStatusResult = event->GetSharedObject<PsRegStatusResultInfo>();
150 if (psRegStatusResult == nullptr) {
151 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister psRegStatusResult is nullptr slotId:%{public}d", slotId_);
152 return;
153 }
154 if (psRegStatusResult->flag != networkSearchManager->GetSerialNum(slotId_)) {
155 TELEPHONY_LOGI("Aborting outdated ps registration event slotId:%{public}d", slotId_);
156 return;
157 }
158 networkSearchManager->decMsgNum(slotId_);
159 RilRegister registrationStatus = static_cast<RilRegister>(psRegStatusResult->regStatus);
160 RegServiceState regStatus = ConvertRegFromRil(registrationStatus);
161 if (networkSearchState_ == nullptr) {
162 TELEPHONY_LOGE("NetworkRegister::ProcessPsRegister networkSearchState_ is nullptr slotId:%{public}d", slotId_);
163 return;
164 }
165 UpdateCellularCall(regStatus, IMS_TYPE);
166 RadioTech tech = ConvertTechFromRil(static_cast<HRilRadioTech>(psRegStatusResult->radioTechnology));
167 RoamingType roam = RoamingType::ROAMING_STATE_UNKNOWN;
168 if (registrationStatus == RilRegister::REG_STATE_ROAMING) {
169 roam = RoamingType::ROAMING_STATE_UNSPEC;
170 }
171 UpdateNetworkSearchState(regStatus, tech, roam, DomainType::DOMAIN_TYPE_PS);
172 endcSupport_ = psRegStatusResult->isEnDcAvailable;
173 dcNrRestricted_ = psRegStatusResult->isDcNrRestricted;
174 nrSupport_ = psRegStatusResult->isNrAvailable;
175 UpdateNrState();
176 UpdateCfgTech();
177 TELEPHONY_LOGI("regStatus= %{public}d radioTechnology=%{public}d roam=%{public}d slotId:%{public}d",
178 registrationStatus, psRegStatusResult->radioTechnology, roam, slotId_);
179 if (networkSearchManager->CheckIsNeedNotify(slotId_) || networkSearchState_->IsEmergency()) {
180 TELEPHONY_LOGI("ps domain change, slotId:%{public}d", slotId_);
181 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
182 }
183 CoreServiceHiSysEvent::WriteNetworkStateBehaviorEvent(slotId_, static_cast<int32_t>(DomainType::DOMAIN_TYPE_PS),
184 static_cast<int32_t>(tech), static_cast<int32_t>(regStatus));
185 }
186
RevertLastTechnology()187 int32_t NetworkRegister::RevertLastTechnology()
188 {
189 if (networkSearchState_ == nullptr) {
190 TELEPHONY_LOGE("networkSearchState_ is nullptr slotId:%{public}d", slotId_);
191 return TELEPHONY_ERR_LOCAL_PTR_NULL;
192 }
193 RadioTech lastCfgTech = RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
194 RadioTech lastPsRadioTech = RadioTech::RADIO_TECHNOLOGY_UNKNOWN;
195 networkSearchState_->GetLastCfgTech(lastCfgTech);
196 networkSearchState_->GetLastPsRadioTech(lastPsRadioTech);
197 networkSearchState_->SetCfgTech(lastCfgTech);
198 networkSearchState_->SetNetworkType(lastPsRadioTech, DomainType::DOMAIN_TYPE_PS);
199 TELEPHONY_LOGI(
200 "lastCfgTech:%{public}d lastPsRadioTech:%{public}d slotId:%{public}d", lastCfgTech, lastPsRadioTech, slotId_);
201 return TELEPHONY_ERR_SUCCESS;
202 }
203
NotifyStateChange()204 int32_t NetworkRegister::NotifyStateChange()
205 {
206 if (networkSearchState_ == nullptr) {
207 TELEPHONY_LOGE("networkSearchState_ is nullptr slotId:%{public}d", slotId_);
208 return TELEPHONY_ERR_LOCAL_PTR_NULL;
209 }
210 networkSearchState_->NotifyStateChange();
211 return TELEPHONY_ERR_SUCCESS;
212 }
213
ProcessChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer & event)214 void NetworkRegister::ProcessChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer &event)
215 {
216 std::shared_ptr<ChannelConfigInfoList> channelConfigInfoList = event->GetSharedObject<ChannelConfigInfoList>();
217 if (channelConfigInfoList == nullptr) {
218 TELEPHONY_LOGE(
219 "NetworkRegister::ProcessChannelConfigInfo psRegStatusResult is nullptr slotId:%{public}d", slotId_);
220 return;
221 }
222 int32_t size = channelConfigInfoList->itemNum;
223 TELEPHONY_LOGI("NetworkRegister::ProcessChannelConfigInfo num size:%{public}d slotId:%{public}d", size, slotId_);
224 if (size >= MAX_SIZE) {
225 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo num over max size");
226 return;
227 }
228 if (channelConfigInfoList->channelConfigInfos.size() > 0 &&
229 static_cast<int32_t>(channelConfigInfoList->channelConfigInfos.size()) == size) {
230 std::vector<PhysicalChannelConfig> &configs = channelConfigInfoList->channelConfigInfos;
231 channelConfigInfos_.clear();
232 channelConfigInfos_.insert(channelConfigInfos_.begin(), configs.begin(), configs.end());
233 } else {
234 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo data error slotId:%{public}d", slotId_);
235 return;
236 }
237
238 bool isNrSecondaryCell = false;
239 for (int32_t i = 0; i < size; ++i) {
240 if (static_cast<RadioTech>(channelConfigInfos_[i].ratType) == RadioTech::RADIO_TECHNOLOGY_NR &&
241 static_cast<ConnectServiceCell>(channelConfigInfos_[i].cellConnStatus) ==
242 ConnectServiceCell::CONNECTION_SECONDARY_CELL) {
243 isNrSecondaryCell = true;
244 break;
245 }
246 }
247 TELEPHONY_LOGI("isNrSecondaryCell:%{public}d slotId:%{public}d", isNrSecondaryCell, slotId_);
248 NotifyNrFrequencyChanged();
249 if (isNrSecondaryCell_ != isNrSecondaryCell) {
250 isNrSecondaryCell_ = isNrSecondaryCell;
251 UpdateNrState();
252 UpdateCfgTech();
253 auto networkSearchManager = networkSearchManager_.lock();
254 if (networkSearchManager == nullptr) {
255 TELEPHONY_LOGE("NetworkRegister::ProcessChannelConfigInfo networkSearchManager is nullptr");
256 return;
257 }
258 TELEPHONY_LOGI("physical channel change, slotId:%{public}d", slotId_);
259 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
260 }
261 }
262
NotifyNrFrequencyChanged()263 void NetworkRegister::NotifyNrFrequencyChanged()
264 {
265 auto networkSearchManager = networkSearchManager_.lock();
266 if (networkSearchManager == nullptr) {
267 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged networkSearchManager is nullptr");
268 return;
269 }
270 bool isFreqChanged = false;
271 FrequencyType curFreqType = FrequencyType::FREQ_TYPE_UNKNOWN;
272
273 sptr<NetworkSearchCallBackBase> cellularData = networkSearchManager->GetCellularDataCallBack();
274 if (cellularData == nullptr) {
275 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged cellularData callback is nullptr");
276 return;
277 }
278 ssize_t size = channelConfigInfos_.size();
279 if (size >= MAX_SIZE) {
280 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged channelConfigInfos_ over max size");
281 return;
282 }
283 for (int32_t i = 0; i < size; ++i) {
284 std::vector<int32_t> &cids = channelConfigInfos_[i].contextIds;
285 if (isFreqChanged) {
286 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged channelConfigInfos:%{public}d isFreqChanged", i);
287 continue;
288 }
289 for (auto &cid : cids) {
290 if (!cellularData->HasInternetCapability(slotId_, cid)) {
291 TELEPHONY_LOGE("NetworkRegister::NotifyNrFrequencyChanged cid:%{public}d hasNoInternetCapability", cid);
292 continue;
293 }
294 curFreqType = static_cast<FrequencyType>(channelConfigInfos_[i].freqRange);
295 isFreqChanged = true;
296 break;
297 }
298 if (isFreqChanged) {
299 break;
300 }
301 }
302 if (freqType_ != curFreqType) {
303 freqType_ = curFreqType;
304 networkSearchManager->NotifyNrFrequencyChanged(slotId_);
305 networkSearchManager->SetFrequencyType(slotId_, freqType_);
306 }
307 }
308
DcPhysicalLinkActiveUpdate(bool isActive)309 void NetworkRegister::DcPhysicalLinkActiveUpdate(bool isActive)
310 {
311 TELEPHONY_LOGI("NetworkRegister::DcPhysicalLinkActiveUpdate isActive:%{public}s slotId:%{public}d",
312 isActive ? "true" : "false", slotId_);
313 isPhysicalLinkActive_ = isActive;
314 UpdateNrState();
315 }
316
UpdateNrState()317 void NetworkRegister::UpdateNrState()
318 {
319 if (networkSearchState_ == nullptr || networkSearchState_->GetNetworkStatus() == nullptr) {
320 TELEPHONY_LOGE("networkSearchState_ is nullptr, slotId:%{public}d", slotId_);
321 return;
322 }
323
324 nrState_ = NrState::NR_STATE_NOT_SUPPORT;
325 RadioTech rat = networkSearchState_->GetNetworkStatus()->GetPsRadioTech();
326 if (rat == RadioTech::RADIO_TECHNOLOGY_NR) {
327 nrState_ = NrState::NR_NSA_STATE_SA_ATTACHED;
328 networkSearchState_->SetNrState(nrState_);
329 return;
330 }
331 if (isNrSecondaryCell_) {
332 nrState_ = NrState::NR_NSA_STATE_DUAL_CONNECTED;
333 networkSearchState_->SetNrState(nrState_);
334 return;
335 }
336 if (endcSupport_) {
337 if (dcNrRestricted_) {
338 nrState_ = NrState::NR_STATE_NOT_SUPPORT;
339 networkSearchState_->SetNrState(nrState_);
340 return;
341 }
342 if (!dcNrRestricted_) {
343 nrState_ = NrState::NR_NSA_STATE_NO_DETECT;
344 networkSearchState_->SetNrState(nrState_);
345 return;
346 }
347 }
348 }
349
UpdateCfgTech()350 void NetworkRegister::UpdateCfgTech()
351 {
352 if (networkSearchState_ == nullptr || networkSearchState_->GetNetworkStatus() == nullptr) {
353 TELEPHONY_LOGE("NetworkRegister::UpdateCfgTech networkSearchState_ is nullptr slotId:%{public}d", slotId_);
354 return;
355 }
356 RadioTech tech = networkSearchState_->GetNetworkStatus()->GetPsRadioTech();
357 TELEPHONY_LOGI("tech:%{public}d slotId:%{public}d", tech, slotId_);
358 RadioTech cfgTech = GetTechnologyByNrConfig(tech);
359 networkSearchState_->SetCfgTech(cfgTech);
360 }
361
ProcessRestrictedState(const AppExecFwk::InnerEvent::Pointer & event) const362 void NetworkRegister::ProcessRestrictedState(const AppExecFwk::InnerEvent::Pointer &event) const {}
363
ConvertRegFromRil(RilRegister code) const364 RegServiceState NetworkRegister::ConvertRegFromRil(RilRegister code) const
365 {
366 switch (code) {
367 case RilRegister::REG_STATE_SEARCH:
368 return RegServiceState::REG_STATE_SEARCH;
369 case RilRegister::REG_STATE_NOT_REG:
370 case RilRegister::REG_STATE_NO_SERVICE:
371 return RegServiceState::REG_STATE_NO_SERVICE;
372 case RilRegister::REG_STATE_INVALID:
373 return RegServiceState::REG_STATE_UNKNOWN;
374 case RilRegister::REG_STATE_ROAMING:
375 case RilRegister::REG_STATE_HOME_ONLY:
376 return RegServiceState::REG_STATE_IN_SERVICE;
377 case RilRegister::REG_STATE_EMERGENCY_ONLY:
378 return RegServiceState::REG_STATE_EMERGENCY_ONLY;
379 default:
380 return RegServiceState::REG_STATE_NO_SERVICE;
381 }
382 }
383
GetRegServiceState() const384 RegServiceState NetworkRegister::GetRegServiceState() const
385 {
386 return regStatusResult_;
387 }
388
ConvertTechFromRil(HRilRadioTech code) const389 RadioTech NetworkRegister::ConvertTechFromRil(HRilRadioTech code) const
390 {
391 switch (code) {
392 case HRilRadioTech::RADIO_TECHNOLOGY_GSM:
393 return RadioTech::RADIO_TECHNOLOGY_GSM;
394 case HRilRadioTech::RADIO_TECHNOLOGY_1XRTT:
395 return RadioTech::RADIO_TECHNOLOGY_1XRTT;
396 case HRilRadioTech::RADIO_TECHNOLOGY_HSPA:
397 return RadioTech::RADIO_TECHNOLOGY_HSPA;
398 case HRilRadioTech::RADIO_TECHNOLOGY_HSPAP:
399 return RadioTech::RADIO_TECHNOLOGY_HSPAP;
400 case HRilRadioTech::RADIO_TECHNOLOGY_WCDMA:
401 return RadioTech::RADIO_TECHNOLOGY_WCDMA;
402 case HRilRadioTech::RADIO_TECHNOLOGY_LTE:
403 return RadioTech::RADIO_TECHNOLOGY_LTE;
404 case HRilRadioTech::RADIO_TECHNOLOGY_EVDO:
405 return RadioTech::RADIO_TECHNOLOGY_EVDO;
406 case HRilRadioTech::RADIO_TECHNOLOGY_EHRPD:
407 return RadioTech::RADIO_TECHNOLOGY_EHRPD;
408 case HRilRadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
409 return RadioTech::RADIO_TECHNOLOGY_TD_SCDMA;
410 case HRilRadioTech::RADIO_TECHNOLOGY_LTE_CA:
411 return RadioTech::RADIO_TECHNOLOGY_LTE_CA;
412 case HRilRadioTech::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