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_search_manager.h"
17
18 #include <cinttypes>
19 #include <parameters.h>
20 #include <securec.h>
21 #include <string_ex.h>
22
23 #include "core_service_errors.h"
24 #include "enum_convert.h"
25 #include "mcc_pool.h"
26 #include "network_search_types.h"
27 #include "operator_name_utils.h"
28 #include "parameter.h"
29 #include "satellite_service_client.h"
30 #include "telephony_common_utils.h"
31 #include "telephony_config.h"
32 #include "telephony_errors.h"
33 #include "telephony_ext_wrapper.h"
34 #include "telephony_log_wrapper.h"
35 #include "telephony_ext_wrapper.h"
36
37 namespace OHOS {
38 namespace Telephony {
39 const size_t MCC_LEN = 3;
40 const int32_t SERVICE_TYPE_UNKNOWN = -1;
41 const int32_t SERVICE_TYPE_LTE = 0;
42 const int32_t SERVICE_TYPE_NR = 1;
43 const int32_t SERVICE_ABILITY_OFF = 0;
44 const int32_t SERVICE_ABILITY_ON = 1;
45 const int32_t SYS_PARAMETER_SIZE = 256;
46 const int32_t INVALID_DELAY_TIME = 0;
47 constexpr const char *NO_DELAY_TIME__CONFIG = "0";
48 constexpr const char *CFG_TECH_UPDATE_TIME = "persist.radio.cfg.update.time";
49 constexpr static const int32_t GET_SSB_WAIT_TIME_SECOND = 5;
50
NetworkSearchManager(std::shared_ptr<ITelRilManager> telRilManager,std::shared_ptr<ISimManager> simManager)51 NetworkSearchManager::NetworkSearchManager(
52 std::shared_ptr<ITelRilManager> telRilManager, std::shared_ptr<ISimManager> simManager)
53 : telRilManager_(telRilManager), simManager_(simManager)
54 {
55 TELEPHONY_LOGI("NetworkSearchManager");
56 }
57
~NetworkSearchManager()58 NetworkSearchManager::~NetworkSearchManager()
59 {
60 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
61 std::shared_ptr<NetworkSearchManagerInner> inner = FindManagerInner(slotId);
62 if (inner != nullptr) {
63 inner->UnRegisterSetting();
64 inner->UnRegisterDeviceStateObserver();
65 }
66 }
67 }
68
InitPointer(std::shared_ptr<NetworkSearchManagerInner> & inner,int32_t slotId)69 bool NetworkSearchManager::InitPointer(std::shared_ptr<NetworkSearchManagerInner> &inner, int32_t slotId)
70 {
71 if (inner == nullptr) {
72 TELEPHONY_LOGE("NetworkSearchManager::InitPointer failed . inner is null");
73 return false;
74 }
75 inner->observerHandler_ = std::make_unique<ObserverHandler>();
76 if (inner->observerHandler_ == nullptr) {
77 TELEPHONY_LOGE("failed to create new ObserverHandler slotId:%{public}d", slotId);
78 return false;
79 }
80 inner->networkSearchState_ = std::make_shared<NetworkSearchState>(shared_from_this(), slotId);
81 if (inner->networkSearchState_ == nullptr) {
82 TELEPHONY_LOGE("failed to create new NetworkSearchState slotId:%{public}d", slotId);
83 return false;
84 }
85 inner->networkSearchHandler_ =
86 std::make_shared<NetworkSearchHandler>(shared_from_this(), telRilManager_, simManager_, slotId);
87 if (inner->networkSearchHandler_ == nullptr) {
88 TELEPHONY_LOGE("failed to create new NetworkSearchHandler slotId:%{public}d", slotId);
89 return false;
90 }
91 inner->networkSearchResult_ = std::make_unique<NetworkSearchResult>();
92 if (inner->networkSearchResult_ == nullptr) {
93 TELEPHONY_LOGE("failed to create new NetworkSearchResult slotId:%{public}d", slotId);
94 return false;
95 }
96 inner->deviceStateHandler_ = std::make_shared<DeviceStateHandler>(shared_from_this(), telRilManager_, slotId);
97 if (inner->deviceStateHandler_ == nullptr) {
98 TELEPHONY_LOGE("failed to create new DeviceStateHandler slotId:%{public}d", slotId);
99 return false;
100 }
101
102 return true;
103 }
104
RegisterSetting()105 bool NetworkSearchManagerInner::RegisterSetting()
106 {
107 settingAutoTimeObserver_ = new AutoTimeObserver(networkSearchHandler_);
108 airplaneModeObserver_ = new AirplaneModeObserver(networkSearchHandler_);
109 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
110 if (settingAutoTimeObserver_ == nullptr || airplaneModeObserver_ == nullptr || settingHelper == nullptr) {
111 TELEPHONY_LOGE("NetworkSearchManager::RegisterSetting is null.");
112 return false;
113 }
114
115 Uri autoTimeUri(SettingUtils::NETWORK_SEARCH_SETTING_AUTO_TIME_URI);
116 Uri airplaneModeUri(SettingUtils::NETWORK_SEARCH_SETTING_AIRPLANE_MODE_URI);
117 settingHelper->RegisterSettingsObserver(autoTimeUri, settingAutoTimeObserver_);
118 settingHelper->RegisterSettingsObserver(airplaneModeUri, airplaneModeObserver_);
119 if (TELEPHONY_EXT_WRAPPER.updateCountryCodeExt_ == nullptr) {
120 settingAutoTimezoneObserver_ = new AutoTimezoneObserver(networkSearchHandler_);
121 if (settingAutoTimezoneObserver_ == nullptr) {
122 TELEPHONY_LOGE("NetworkSearchManager::RegisterSetting is null.");
123 return false;
124 }
125 Uri autoTimezoneUri(SettingUtils::NETWORK_SEARCH_SETTING_AUTO_TIMEZONE_URI);
126 settingHelper->RegisterSettingsObserver(autoTimezoneUri, settingAutoTimezoneObserver_);
127 }
128 return true;
129 }
130
UnRegisterSetting()131 bool NetworkSearchManagerInner::UnRegisterSetting()
132 {
133 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
134 if (settingHelper == nullptr) {
135 TELEPHONY_LOGE("NetworkSearchManager::UnRegisterSetting is null.");
136 return false;
137 }
138
139 Uri autoTimeUri(SettingUtils::NETWORK_SEARCH_SETTING_AUTO_TIME_URI);
140 Uri airplaneModeUri(SettingUtils::NETWORK_SEARCH_SETTING_AIRPLANE_MODE_URI);
141 settingHelper->UnRegisterSettingsObserver(autoTimeUri, settingAutoTimeObserver_);
142 settingHelper->UnRegisterSettingsObserver(airplaneModeUri, airplaneModeObserver_);
143 if (settingAutoTimezoneObserver_ != nullptr) {
144 Uri autoTimezoneUri(SettingUtils::NETWORK_SEARCH_SETTING_AUTO_TIMEZONE_URI);
145 settingHelper->UnRegisterSettingsObserver(autoTimezoneUri, settingAutoTimezoneObserver_);
146 }
147 return true;
148 }
149
RegisterDeviceStateObserver()150 bool NetworkSearchManagerInner::RegisterDeviceStateObserver()
151 {
152 deviceStateObserver_ = std::make_shared<DeviceStateObserver>();
153 deviceStateObserver_->StartEventSubscriber(deviceStateHandler_);
154 return true;
155 }
156
UnRegisterDeviceStateObserver()157 bool NetworkSearchManagerInner::UnRegisterDeviceStateObserver()
158 {
159 if (deviceStateObserver_ == nullptr) {
160 TELEPHONY_LOGE("NetworkSearchManager::UnRegisterDeviceStateObserver deviceStateObserver_ is null.");
161 return false;
162 }
163 deviceStateObserver_->StopEventSubscriber();
164 return true;
165 }
166
OnInit()167 bool NetworkSearchManager::OnInit()
168 {
169 TELEPHONY_LOGI("NetworkSearchManager::Init");
170 if (telRilManager_ == nullptr) {
171 TELEPHONY_LOGE("NetworkSearchManager::Init telRilManager_ is null.");
172 return false;
173 }
174 if (simManager_ == nullptr) {
175 TELEPHONY_LOGE("NetworkSearchManager::Init simManager_ is null.");
176 return false;
177 }
178 eventSender_ = std::make_unique<EventSender>(telRilManager_, shared_from_this());
179 if (eventSender_ == nullptr) {
180 TELEPHONY_LOGE("failed to create new EventSender");
181 return false;
182 }
183 ClearManagerInner();
184 bool mode = false;
185 if (GetAirplaneMode(mode) != TELEPHONY_SUCCESS) {
186 TELEPHONY_LOGE("NetworkSearchManager::Init GetAirplaneMode fail");
187 }
188 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
189 std::shared_ptr<NetworkSearchManagerInner> inner = FindManagerInner(slotId);
190 if (inner == nullptr) {
191 inner = std::make_shared<NetworkSearchManagerInner>();
192 AddManagerInner(slotId, inner);
193 }
194 if (inner != nullptr && eventSender_ != nullptr) {
195 if (inner->state_ == HandleRunningState::STATE_RUNNING) {
196 TELEPHONY_LOGE("NetworkSearchManager::Init HandleRunningState is running. slotId:%{public}d", slotId);
197 continue;
198 }
199 if (!InitPointer(inner, slotId)) {
200 ClearManagerInner();
201 return false;
202 }
203 if (!inner->Init()) {
204 ClearManagerInner();
205 return false;
206 }
207 SetLocalAirplaneMode(slotId, mode);
208 TELEPHONY_LOGI("NetworkSearchManager::Init airplaneMode:%{public}d slotId:%{public}d", mode, slotId);
209 // Prevent running crash and query the radio status at startup
210 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_STATUS);
211 }
212 }
213 delayTime_ = GetDelayNotifyTime();
214 TELEPHONY_LOGI("NetworkSearchManager::Init success");
215 return true;
216 }
217
GetNetworkSearchState(int32_t slotId)218 std::shared_ptr<NetworkSearchState> NetworkSearchManager::GetNetworkSearchState(int32_t slotId)
219 {
220 auto inner = FindManagerInner(slotId);
221 if (inner != nullptr) {
222 TELEPHONY_LOGD("NetworkSearchManager::GetNetworkSearchState slotId:%{public}d", slotId);
223 return inner->networkSearchState_;
224 }
225 return nullptr;
226 }
227
SetRadioState(int32_t slotId,bool isOn,int32_t rst)228 void NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t rst)
229 {
230 TELEPHONY_LOGD("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
231 if (eventSender_ == nullptr) {
232 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
233 return;
234 }
235 int32_t fun = static_cast<int32_t>(isOn);
236 eventSender_->SendBase(slotId, RadioEvent::RADIO_SET_STATUS, fun, rst);
237 }
238
SetRadioState(int32_t slotId,bool isOn,int32_t rst,NSCALLBACK & callback)239 int32_t NetworkSearchManager::SetRadioState(int32_t slotId, bool isOn, int32_t rst, NSCALLBACK &callback)
240 {
241 TELEPHONY_LOGD("NetworkSearchManager SetRadioState isOn:%{public}d slotId:%{public}d", isOn, slotId);
242 if (eventSender_ == nullptr) {
243 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
244 return TELEPHONY_ERR_LOCAL_PTR_NULL;
245 }
246 int32_t fun = static_cast<int32_t>(isOn);
247 if (!eventSender_->SendCallback(slotId, RadioEvent::RADIO_SET_STATUS, &callback, fun, rst)) {
248 TELEPHONY_LOGE("slotId:%{public}d SetRadioState SendCallback failed.", slotId);
249 return CORE_SERVICE_SEND_CALLBACK_FAILED;
250 }
251 return TELEPHONY_ERR_SUCCESS;
252 }
253
RegisterCoreNotify(int32_t slotId,HANDLE & handler,int32_t what)254 void NetworkSearchManager::RegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what)
255 {
256 TELEPHONY_LOGD("NetworkSearchManager::RegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
257 auto inner = FindManagerInner(slotId);
258 if (inner != nullptr) {
259 if (inner->observerHandler_ != nullptr) {
260 inner->observerHandler_->RegObserver(what, handler);
261 }
262 }
263 }
264
UnRegisterCoreNotify(int32_t slotId,HANDLE & handler,int32_t what)265 void NetworkSearchManager::UnRegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what)
266 {
267 TELEPHONY_LOGD("NetworkSearchManager::UnRegisterCoreNotify %{public}d slotId:%{public}d", what, slotId);
268 auto inner = FindManagerInner(slotId);
269 if (inner != nullptr) {
270 if (inner->observerHandler_ != nullptr) {
271 inner->observerHandler_->Remove(what, handler);
272 }
273 }
274 }
275
RegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> & callback)276 void NetworkSearchManager::RegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> &callback)
277 {
278 cellularDataCallBack_ = callback;
279 }
280
UnRegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> & callback)281 void NetworkSearchManager::UnRegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> &callback)
282 {
283 cellularDataCallBack_ = nullptr;
284 }
285
RegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> & callback)286 void NetworkSearchManager::RegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> &callback)
287 {
288 cellularCallCallBack_ = callback;
289 }
290
UnRegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> & callback)291 void NetworkSearchManager::UnRegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> &callback)
292 {
293 cellularCallCallBack_ = nullptr;
294 }
295
NotifyPsRoamingOpenChanged(int32_t slotId)296 void NetworkSearchManager::NotifyPsRoamingOpenChanged(int32_t slotId)
297 {
298 TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRoamingOpenChanged slotId:%{public}d", slotId);
299 auto inner = FindManagerInner(slotId);
300 if (inner != nullptr) {
301 if (inner->observerHandler_ != nullptr) {
302 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_PS_ROAMING_OPEN);
303 }
304 }
305 }
306
NotifyPsRoamingCloseChanged(int32_t slotId)307 void NetworkSearchManager::NotifyPsRoamingCloseChanged(int32_t slotId)
308 {
309 TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRoamingCloseChanged slotId:%{public}d", slotId);
310 auto inner = FindManagerInner(slotId);
311 if (inner != nullptr) {
312 if (inner->observerHandler_ != nullptr) {
313 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_PS_ROAMING_CLOSE);
314 }
315 }
316 }
317
NotifyEmergencyOpenChanged(int32_t slotId)318 void NetworkSearchManager::NotifyEmergencyOpenChanged(int32_t slotId)
319 {
320 TELEPHONY_LOGD("NetworkSearchManager::NotifyEmergencyOpenChanged slotId:%{public}d", slotId);
321 auto inner = FindManagerInner(slotId);
322 if (inner != nullptr) {
323 if (inner->observerHandler_ != nullptr) {
324 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_EMERGENCY_STATE_OPEN);
325 }
326 }
327 }
328
NotifyEmergencyCloseChanged(int32_t slotId)329 void NetworkSearchManager::NotifyEmergencyCloseChanged(int32_t slotId)
330 {
331 TELEPHONY_LOGD("NetworkSearchManager::NotifyEmergencyCloseChanged slotId:%{public}d", slotId);
332 auto inner = FindManagerInner(slotId);
333 if (inner != nullptr) {
334 if (inner->observerHandler_ != nullptr) {
335 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_EMERGENCY_STATE_CLOSE);
336 }
337 }
338 }
339
NotifyPsRatChanged(int32_t slotId)340 void NetworkSearchManager::NotifyPsRatChanged(int32_t slotId)
341 {
342 TELEPHONY_LOGD("NetworkSearchManager::NotifyPsRatChanged slotId:%{public}d", slotId);
343 auto inner = FindManagerInner(slotId);
344 if (inner != nullptr) {
345 if (inner->observerHandler_ != nullptr) {
346 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_PS_RAT_CHANGED);
347 }
348 }
349 }
350
NotifyPsConnectionAttachedChanged(int32_t slotId)351 void NetworkSearchManager::NotifyPsConnectionAttachedChanged(int32_t slotId)
352 {
353 TELEPHONY_LOGD("NetworkSearchManager::NotifyPsConnectionAttachedChanged slotId:%{public}d", slotId);
354 auto inner = FindManagerInner(slotId);
355 if (inner != nullptr) {
356 if (inner->observerHandler_ != nullptr) {
357 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_PS_CONNECTION_ATTACHED);
358 }
359 }
360 }
361
NotifyPsConnectionDetachedChanged(int32_t slotId)362 void NetworkSearchManager::NotifyPsConnectionDetachedChanged(int32_t slotId)
363 {
364 TELEPHONY_LOGD("NetworkSearchManager::NotifyPsConnectionDetachedChanged slotId:%{public}d", slotId);
365 auto inner = FindManagerInner(slotId);
366 if (inner != nullptr) {
367 if (inner->observerHandler_ != nullptr) {
368 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_PS_CONNECTION_DETACHED);
369 }
370 }
371 }
372
NotifyNrStateChanged(int32_t slotId)373 void NetworkSearchManager::NotifyNrStateChanged(int32_t slotId)
374 {
375 TELEPHONY_LOGD("NetworkSearchManager::NotifyNrStateChanged slotId:%{public}d", slotId);
376 auto inner = FindManagerInner(slotId);
377 if (inner != nullptr) {
378 if (inner->observerHandler_ != nullptr) {
379 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_NR_STATE_CHANGED);
380 }
381 }
382 }
383
NotifyNrFrequencyChanged(int32_t slotId)384 void NetworkSearchManager::NotifyNrFrequencyChanged(int32_t slotId)
385 {
386 TELEPHONY_LOGD("NetworkSearchManager::NotifyNrFrequencyChanged slotId:%{public}d", slotId);
387 auto inner = FindManagerInner(slotId);
388 if (inner != nullptr) {
389 if (inner->observerHandler_ != nullptr) {
390 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_NR_FREQUENCY_CHANGED);
391 }
392 }
393 }
394
NotifyFactoryReset(int32_t slotId)395 void NetworkSearchManager::NotifyFactoryReset(int32_t slotId)
396 {
397 TELEPHONY_LOGD("NotifyFactoryReset slotId:%{public}d", slotId);
398 auto inner = FindManagerInner(slotId);
399 if (inner != nullptr) {
400 if (inner->observerHandler_ != nullptr) {
401 inner->observerHandler_->NotifyObserver(RadioEvent::RADIO_FACTORY_RESET);
402 }
403 }
404 }
405
GetPsRadioTech(int32_t slotId,int32_t & psRadioTech)406 int32_t NetworkSearchManager::GetPsRadioTech(int32_t slotId, int32_t &psRadioTech)
407 {
408 auto inner = FindManagerInner(slotId);
409 if (inner == nullptr) {
410 TELEPHONY_LOGE("NetworkSearchManager::GetPsRadioTech Failed slotId:%{public}d", slotId);
411 return TELEPHONY_ERR_LOCAL_PTR_NULL;
412 }
413 if ((inner->networkSearchState_ == nullptr) || (inner->networkSearchState_->GetNetworkStatus() == nullptr)) {
414 TELEPHONY_LOGE("NetworkSearchManager::GetPsRadioTech failed due to nullptr!");
415 return TELEPHONY_ERR_LOCAL_PTR_NULL;
416 }
417 psRadioTech = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRadioTech());
418 if (TELEPHONY_EXT_WRAPPER.getRadioTechExt_ != nullptr) {
419 TELEPHONY_EXT_WRAPPER.getRadioTechExt_(slotId, psRadioTech);
420 }
421 TELEPHONY_LOGD("NetworkSearchManager::GetPsRadioTech result=%{public}d slotId:%{public}d", psRadioTech, slotId);
422 return TELEPHONY_ERR_SUCCESS;
423 }
424
GetCsRadioTech(int32_t slotId,int32_t & csRadioTech)425 int32_t NetworkSearchManager::GetCsRadioTech(int32_t slotId, int32_t &csRadioTech)
426 {
427 auto inner = FindManagerInner(slotId);
428 if (inner == nullptr) {
429 TELEPHONY_LOGE("NetworkSearchManager::GetCsRadioTech Failed slotId:%{public}d", slotId);
430 return TELEPHONY_ERR_LOCAL_PTR_NULL;
431 }
432 if ((inner->networkSearchState_ == nullptr) || (inner->networkSearchState_->GetNetworkStatus() == nullptr)) {
433 TELEPHONY_LOGE("NetworkSearchManager::GetCsRadioTech failed due to nullptr!");
434 return TELEPHONY_ERR_LOCAL_PTR_NULL;
435 }
436 csRadioTech = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetCsRadioTech());
437 if (TELEPHONY_EXT_WRAPPER.getRadioTechExt_ != nullptr) {
438 TELEPHONY_EXT_WRAPPER.getRadioTechExt_(slotId, csRadioTech);
439 }
440 TELEPHONY_LOGD("NetworkSearchManager::GetCsRadioTech result=%{public}d slotId:%{public}d", csRadioTech, slotId);
441 return TELEPHONY_ERR_SUCCESS;
442 }
443
GetPsRegState(int32_t slotId)444 int32_t NetworkSearchManager::GetPsRegState(int32_t slotId)
445 {
446 auto inner = FindManagerInner(slotId);
447 if (inner != nullptr) {
448 if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
449 auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRegStatus());
450 TELEPHONY_LOGD("NetworkSearchManager::GetPsRegState result=%{public}d slotId:%{public}d", event, slotId);
451 return event;
452 }
453 TELEPHONY_LOGE("NetworkSearchManager::GetPsRegState failed due to nullptr!");
454 }
455 TELEPHONY_LOGE("NetworkSearchManager::GetPsRegState Failed slotId:%{public}d", slotId);
456 return TELEPHONY_ERROR;
457 }
458
GetCsRegState(int32_t slotId)459 int32_t NetworkSearchManager::GetCsRegState(int32_t slotId)
460 {
461 auto inner = FindManagerInner(slotId);
462 if (inner != nullptr) {
463 if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
464 auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetCsRegStatus());
465 TELEPHONY_LOGD("NetworkSearchManager::GetCsRegState result=%{public}d slotId:%{public}d", event, slotId);
466 return event;
467 }
468 TELEPHONY_LOGE("NetworkSearchManager::GetCsRegState failed due to nullptr!");
469 }
470 TELEPHONY_LOGE("NetworkSearchManager::GetCsRegState Failed slotId:%{public}d", slotId);
471 return TELEPHONY_ERROR;
472 }
473
GetPsRoamingState(int32_t slotId)474 int32_t NetworkSearchManager::GetPsRoamingState(int32_t slotId)
475 {
476 auto inner = FindManagerInner(slotId);
477 if (inner != nullptr) {
478 if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
479 auto event = static_cast<int32_t>(inner->networkSearchState_->GetNetworkStatus()->GetPsRoamingStatus());
480 TELEPHONY_LOGD(
481 "NetworkSearchManager::GetPsRoamingState result=%{public}d slotId:%{public}d", event, slotId);
482 return event;
483 }
484 TELEPHONY_LOGE("NetworkSearchManager::GetPsRoamingState failed due to nullptr!");
485 }
486 TELEPHONY_LOGE("NetworkSearchManager::GetPsRoamingState Failed slotId:%{public}d", slotId);
487 return TELEPHONY_ERROR;
488 }
489
GetOperatorNumeric(int32_t slotId)490 std::u16string NetworkSearchManager::GetOperatorNumeric(int32_t slotId)
491 {
492 TELEPHONY_LOGD("NetworkSearchManager::GetOperatorNumeric start slotId:%{public}d", slotId);
493 std::u16string str;
494 auto inner = FindManagerInner(slotId);
495 if (inner != nullptr) {
496 if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
497 auto event = inner->networkSearchState_->GetNetworkStatus()->GetPlmnNumeric();
498 str = Str8ToStr16(event);
499 TELEPHONY_LOGD(
500 "NetworkSearchManager::GetOperatorNumeric result=%{public}s slotId:%{public}d", event.c_str(), slotId);
501 }
502 }
503 return str;
504 }
505
GetOperatorName(int32_t slotId,std::u16string & operatorName)506 int32_t NetworkSearchManager::GetOperatorName(int32_t slotId, std::u16string &operatorName)
507 {
508 operatorName = u"";
509 auto inner = FindManagerInner(slotId);
510 if (inner == nullptr) {
511 return TELEPHONY_ERR_SLOTID_INVALID;
512 }
513 if (inner->networkSearchState_ == nullptr) {
514 return TELEPHONY_ERR_SLOTID_INVALID;
515 }
516 if (inner->networkSearchState_->GetNetworkStatus() == nullptr) {
517 return TELEPHONY_ERR_SLOTID_INVALID;
518 }
519 auto longOperatorName = inner->networkSearchState_->GetNetworkStatus()->GetLongOperatorName();
520 operatorName = Str8ToStr16(longOperatorName);
521 TELEPHONY_LOGD("NetworkSearchManager::GetOperatorName result:%{public}s slotId:%{public}d",
522 longOperatorName.c_str(), slotId);
523 return TELEPHONY_ERR_SUCCESS;
524 }
525
GetNetworkStatus(int32_t slotId,sptr<NetworkState> & networkState)526 int32_t NetworkSearchManager::GetNetworkStatus(int32_t slotId, sptr<NetworkState> &networkState)
527 {
528 auto inner = FindManagerInner(slotId);
529 if (inner != nullptr) {
530 if (inner->networkSearchState_ != nullptr) {
531 networkState = inner->networkSearchState_->GetNetworkStatus().release();
532 if (TELEPHONY_EXT_WRAPPER.getNetworkStatusExt_ != nullptr) {
533 TELEPHONY_EXT_WRAPPER.getNetworkStatusExt_(slotId, networkState);
534 }
535 return TELEPHONY_ERR_SUCCESS;
536 }
537 }
538 return TELEPHONY_ERR_SLOTID_INVALID;
539 }
540
SetRadioStateValue(int32_t slotId,ModemPowerState radioState)541 void NetworkSearchManager::SetRadioStateValue(int32_t slotId, ModemPowerState radioState)
542 {
543 auto inner = FindManagerInner(slotId);
544 if (inner != nullptr) {
545 inner->radioState_ = radioState;
546 }
547 }
548
SetNetworkSelectionValue(int32_t slotId,SelectionMode selection)549 void NetworkSearchManager::SetNetworkSelectionValue(int32_t slotId, SelectionMode selection)
550 {
551 auto inner = FindManagerInner(slotId);
552 if (inner != nullptr) {
553 inner->selection_ = selection;
554 }
555 }
556
GetRadioState(int32_t slotId)557 int32_t NetworkSearchManager::GetRadioState(int32_t slotId)
558 {
559 auto inner = FindManagerInner(slotId);
560 if (inner != nullptr) {
561 return inner->radioState_;
562 }
563 return ModemPowerState::CORE_SERVICE_POWER_NOT_AVAILABLE;
564 }
565
GetRadioState(int32_t slotId,NSCALLBACK & callback)566 int32_t NetworkSearchManager::GetRadioState(int32_t slotId, NSCALLBACK &callback)
567 {
568 TELEPHONY_LOGD("NetworkSearchManager::GetRadioState... slotId:%{public}d", slotId);
569 if (eventSender_ == nullptr) {
570 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
571 return TELEPHONY_ERR_LOCAL_PTR_NULL;
572 }
573 if (!eventSender_->SendCallback(slotId, RadioEvent::RADIO_GET_STATUS, &callback)) {
574 TELEPHONY_LOGE("slotId:%{public}d GetRadioState SendCallback failed.", slotId);
575 return CORE_SERVICE_SEND_CALLBACK_FAILED;
576 }
577 return TELEPHONY_ERR_SUCCESS;
578 }
579
GetSignalInfoList(int32_t slotId,std::vector<sptr<SignalInformation>> & signals)580 int32_t NetworkSearchManager::GetSignalInfoList(int32_t slotId, std::vector<sptr<SignalInformation>> &signals)
581 {
582 auto inner = FindManagerInner(slotId);
583 if (inner == nullptr || inner->networkSearchHandler_ == nullptr) {
584 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
585 return TELEPHONY_ERR_LOCAL_PTR_NULL;
586 }
587 inner->networkSearchHandler_->GetSignalInfo(signals);
588 if (TELEPHONY_EXT_WRAPPER.getSignalInfoListExt_ != nullptr) {
589 TELEPHONY_EXT_WRAPPER.getSignalInfoListExt_(slotId, signals);
590 }
591 return TELEPHONY_ERR_SUCCESS;
592 }
593
GetNetworkSearchInformation(int32_t slotId,NSCALLBACK & callback)594 int32_t NetworkSearchManager::GetNetworkSearchInformation(int32_t slotId, NSCALLBACK &callback)
595 {
596 if (eventSender_ == nullptr) {
597 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
598 return TELEPHONY_ERR_LOCAL_PTR_NULL;
599 }
600 if (!eventSender_->SendCallback(slotId, RadioEvent::RADIO_NETWORK_SEARCH_RESULT, &callback)) {
601 TELEPHONY_LOGE("slotId:%{public}d GetNetworkSearchInformation SendCallback failed.", slotId);
602 return CORE_SERVICE_SEND_CALLBACK_FAILED;
603 }
604 return TELEPHONY_ERR_SUCCESS;
605 }
606
SetNetworkSearchResultValue(int32_t slotId,int32_t listSize,const std::vector<NetworkInformation> & operatorInfo)607 void NetworkSearchManager::SetNetworkSearchResultValue(
608 int32_t slotId, int32_t listSize, const std::vector<NetworkInformation> &operatorInfo)
609 {
610 auto inner = FindManagerInner(slotId);
611 if (inner != nullptr) {
612 if (inner->networkSearchResult_ != nullptr) {
613 inner->networkSearchResult_->SetNetworkSearchResultValue(listSize, operatorInfo);
614 }
615 }
616 }
617
GetNetworkSearchInformationValue(int32_t slotId)618 sptr<NetworkSearchResult> NetworkSearchManager::GetNetworkSearchInformationValue(int32_t slotId)
619 {
620 sptr<NetworkSearchResult> networkSearchResult = new (std::nothrow) NetworkSearchResult;
621 if (networkSearchResult == nullptr) {
622 TELEPHONY_LOGE(
623 "GetNetworkSearchInformationValue failed to create new NetWorkSearchResult slotId:%{public}d", slotId);
624 return nullptr;
625 }
626
627 auto inner = FindManagerInner(slotId);
628 if (inner != nullptr) {
629 if (inner->networkSearchResult_ == nullptr) {
630 TELEPHONY_LOGE("GetNetworkSearchInformationValue networkSearchResult_ is null slotId:%{public}d", slotId);
631 return nullptr;
632 }
633
634 int32_t listSize = inner->networkSearchResult_->GetNetworkSearchInformationSize();
635 std::vector<NetworkInformation> operatorInfoList = inner->networkSearchResult_->GetNetworkSearchInformation();
636 networkSearchResult->SetNetworkSearchResultValue(listSize, operatorInfoList);
637 return networkSearchResult;
638 }
639 return nullptr;
640 }
641
GetNetworkSelectionMode(int32_t slotId)642 int32_t NetworkSearchManager::GetNetworkSelectionMode(int32_t slotId)
643 {
644 auto inner = FindManagerInner(slotId);
645 if (inner != nullptr && eventSender_ != nullptr) {
646 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_NETWORK_SELECTION_MODE);
647 return static_cast<int32_t>(inner->selection_);
648 }
649 return static_cast<int32_t>(SelectionMode::MODE_TYPE_UNKNOWN);
650 }
651
GetNetworkSelectionMode(int32_t slotId,NSCALLBACK & callback)652 int32_t NetworkSearchManager::GetNetworkSelectionMode(int32_t slotId, NSCALLBACK &callback)
653 {
654 if (eventSender_ == nullptr) {
655 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
656 return TELEPHONY_ERR_LOCAL_PTR_NULL;
657 }
658
659 bool ret = eventSender_->SendCallback(slotId, RadioEvent::RADIO_GET_NETWORK_SELECTION_MODE, &callback);
660 if (!ret) {
661 TELEPHONY_LOGE("slotId:%{public}d GetNetworkSelectionMode SendCallback failed.", slotId);
662 return CORE_SERVICE_SEND_CALLBACK_FAILED;
663 }
664 return TELEPHONY_ERR_SUCCESS;
665 }
666
SetNetworkSelectionMode(int32_t slotId,int32_t selectMode,const sptr<NetworkInformation> & networkInformation,bool resumeSelection)667 bool NetworkSearchManager::SetNetworkSelectionMode(
668 int32_t slotId, int32_t selectMode, const sptr<NetworkInformation> &networkInformation, bool resumeSelection)
669 {
670 TELEPHONY_LOGD(
671 "NetworkSearchManager SetNetworkSelectionMode selectMode:%{public}d slotId:%{public}d", selectMode, slotId);
672 if (eventSender_ == nullptr) {
673 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
674 return false;
675 }
676 std::string plmnNumeric = "";
677 std::string operatorCurrentRadio = "";
678 std::string operatorInfo = "";
679 if (networkInformation != nullptr) {
680 plmnNumeric = networkInformation->GetOperatorNumeric();
681 operatorCurrentRadio = std::to_string(networkInformation->GetRadioTech());
682 operatorInfo = plmnNumeric + "," + operatorCurrentRadio;
683 }
684 return eventSender_->SendBase(slotId, RadioEvent::RADIO_SET_NETWORK_SELECTION_MODE, selectMode, operatorInfo);
685 }
686
SetNetworkSelectionMode(int32_t slotId,int32_t selectMode,const sptr<NetworkInformation> & networkInformation,bool resumeSelection,NSCALLBACK & callback)687 int32_t NetworkSearchManager::SetNetworkSelectionMode(int32_t slotId, int32_t selectMode,
688 const sptr<NetworkInformation> &networkInformation, bool resumeSelection, NSCALLBACK &callback)
689 {
690 TELEPHONY_LOGD(
691 "NetworkSearchManager SetNetworkSelectionMode selectMode:%{public}d slotId:%{public}d", selectMode, slotId);
692 if (eventSender_ == nullptr) {
693 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
694 return TELEPHONY_ERR_LOCAL_PTR_NULL;
695 }
696 std::string plmnNumeric = "";
697 std::string operatorCurrentRadio = "";
698 std::string operatorInfo = "";
699 if (networkInformation != nullptr) {
700 plmnNumeric = networkInformation->GetOperatorNumeric();
701 operatorCurrentRadio = std::to_string(networkInformation->GetRadioTech());
702 operatorInfo = plmnNumeric + "," + operatorCurrentRadio;
703 }
704 bool ret = eventSender_->SendCallback(
705 slotId, RadioEvent::RADIO_SET_NETWORK_SELECTION_MODE, &callback, selectMode, operatorInfo);
706 if (!ret) {
707 TELEPHONY_LOGE("slotId:%{public}d SetNetworkSelectionMode SendCallback failed.", slotId);
708 return CORE_SERVICE_SEND_CALLBACK_FAILED;
709 }
710 return TELEPHONY_ERR_SUCCESS;
711 }
712
GetIsoCountryCodeForNetwork(int32_t slotId,std::u16string & countryCode)713 int32_t NetworkSearchManager::GetIsoCountryCodeForNetwork(int32_t slotId, std::u16string &countryCode)
714 {
715 std::string iso = "";
716 countryCode = u"";
717 auto inner = FindManagerInner(slotId);
718 if ((inner == nullptr) || (inner->networkSearchHandler_ == nullptr)) {
719 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
720 return TELEPHONY_ERR_LOCAL_PTR_NULL;
721 }
722
723 if (inner->networkSearchState_ == nullptr || inner->networkSearchState_->GetNetworkStatus() == nullptr) {
724 TELEPHONY_LOGE(
725 "NetworkSearchManager::GetIsoCountryCodeForNetwork Failed due to nullptr, slotId:%{public}d", slotId);
726 return TELEPHONY_ERR_LOCAL_PTR_NULL;
727 }
728 std::string plmn = inner->networkSearchState_->GetNetworkStatus()->GetPlmnNumeric();
729 size_t len = plmn.length();
730 if (len >= MCC_LEN) {
731 std::string mcc = plmn.substr(0, MCC_LEN);
732 int32_t value = 0;
733 bool succ = StrToInt(mcc, value);
734 if (succ) {
735 iso = MccPool::MccCountryCode(value);
736 } else {
737 TELEPHONY_LOGE("GetIsoCountryCodeForNetwork parse Failed!! slotId:%{public}d", slotId);
738 }
739 TELEPHONY_LOGD(
740 "NetworkSearchManager::GetIsoCountryCodeForNetwork mcc=%{public}s code=%{public}d slotId:%{public}d",
741 mcc.c_str(), value, slotId);
742 }
743
744 countryCode = Str8ToStr16(iso);
745 return TELEPHONY_ERR_SUCCESS;
746 }
747
GetPreferredNetwork(int32_t slotId,NSCALLBACK & callback)748 int32_t NetworkSearchManager::GetPreferredNetwork(int32_t slotId, NSCALLBACK &callback)
749 {
750 if (eventSender_ == nullptr) {
751 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
752 return TELEPHONY_ERR_LOCAL_PTR_NULL;
753 }
754 if (!eventSender_->SendCallback(slotId, RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE, &callback)) {
755 TELEPHONY_LOGE("slotId:%{public}d GetPreferredNetwork SendCallback failed.", slotId);
756 return CORE_SERVICE_SEND_CALLBACK_FAILED;
757 }
758 return TELEPHONY_ERR_SUCCESS;
759 }
760
SetPreferredNetwork(int32_t slotId,int32_t networkMode,NSCALLBACK & callback)761 int32_t NetworkSearchManager::SetPreferredNetwork(int32_t slotId, int32_t networkMode, NSCALLBACK &callback)
762 {
763 if (simManager_ == nullptr) {
764 TELEPHONY_LOGE("SetPreferredNetwork simManager_ is nullptr");
765 return TELEPHONY_ERR_LOCAL_PTR_NULL;
766 }
767 if (eventSender_ == nullptr) {
768 TELEPHONY_LOGE("eventSender_ is nullptr");
769 return TELEPHONY_ERR_LOCAL_PTR_NULL;
770 }
771
772 int32_t modemRaf = simManager_->GetRadioProtocolTech(slotId);
773 int32_t raf = NetworkUtils::GetRafFromNetworkMode(static_cast<PreferredNetworkMode>(networkMode));
774 if (modemRaf == static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN)) {
775 TELEPHONY_LOGE("SetPreferredNetwork failed modemRaf:%{public}d slotId:%{public}d", modemRaf, slotId);
776 return CORE_SERVICE_RADIO_PROTOCOL_TECH_UNKNOWN;
777 }
778 if (raf == static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN)) {
779 TELEPHONY_LOGE("SetPreferredNetwork failed raf:%{public}d slotId:%{public}d", raf, slotId);
780 return TELEPHONY_ERR_ARGUMENT_INVALID;
781 }
782 int32_t filterMode = static_cast<int32_t>(NetworkUtils::GetNetworkModeFromRaf(modemRaf & raf));
783 TELEPHONY_LOGI("filterMode:%{public}d slotId:%{public}d", filterMode, slotId);
784 SetCachePreferredNetworkValue(slotId, filterMode);
785 if (!eventSender_->SendCallbackEx(slotId, RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE, &callback, filterMode)) {
786 TELEPHONY_LOGE("slotId:%{public}d SetPreferredNetwork SendCallback failed.", slotId);
787 return CORE_SERVICE_SEND_CALLBACK_FAILED;
788 }
789 return TELEPHONY_ERR_SUCCESS;
790 }
791
GetPreferredNetwork(int32_t slotId)792 int32_t NetworkSearchManager::GetPreferredNetwork(int32_t slotId)
793 {
794 TELEPHONY_LOGD("NetworkSearchManager GetPreferredNetwork slotId:%{public}d", slotId);
795 if (eventSender_ == nullptr) {
796 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
797 return TELEPHONY_ERR_LOCAL_PTR_NULL;
798 }
799 if (!eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE)) {
800 TELEPHONY_LOGE("slotId:%{public}d GetPreferredNetwork SendCallback failed.", slotId);
801 return CORE_SERVICE_SEND_CALLBACK_FAILED;
802 }
803 return TELEPHONY_ERR_SUCCESS;
804 }
805
SetCachePreferredNetworkValue(int32_t slotId,int32_t networkMode)806 int32_t NetworkSearchManager::SetCachePreferredNetworkValue(int32_t slotId, int32_t networkMode)
807 {
808 TELEPHONY_LOGD("SetCachePreferredNetworkValue slotId:%{public}d", slotId);
809 auto inner = FindManagerInner(slotId);
810 if (inner == nullptr) {
811 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
812 return TELEPHONY_ERR_LOCAL_PTR_NULL;
813 }
814 inner->preferredNetworkValue_ = networkMode;
815 return TELEPHONY_ERR_SUCCESS;
816 }
817
GetCachePreferredNetworkValue(int32_t slotId,int32_t & networkMode)818 int32_t NetworkSearchManager::GetCachePreferredNetworkValue(int32_t slotId, int32_t &networkMode)
819 {
820 TELEPHONY_LOGD("GetCachePreferredNetworkValue slotId:%{public}d", slotId);
821 auto inner = FindManagerInner(slotId);
822 if (inner == nullptr) {
823 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
824 return TELEPHONY_ERR_LOCAL_PTR_NULL;
825 }
826 networkMode = inner->preferredNetworkValue_;
827 return TELEPHONY_ERR_SUCCESS;
828 }
829
SetPreferredNetwork(int32_t slotId,int32_t networkMode)830 bool NetworkSearchManager::SetPreferredNetwork(int32_t slotId, int32_t networkMode)
831 {
832 if (simManager_ == nullptr || eventSender_ == nullptr) {
833 TELEPHONY_LOGE("simManager_ or eventSender_ is nullptr");
834 return false;
835 }
836
837 int32_t modemRaf = simManager_->GetRadioProtocolTech(slotId);
838 int32_t raf = NetworkUtils::GetRafFromNetworkMode(static_cast<PreferredNetworkMode>(networkMode));
839 if (modemRaf == static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN) ||
840 raf == static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN)) {
841 TELEPHONY_LOGE(
842 "SetPreferredNetwork failed modemRaf:%{public}d raf:%{public}d slotId:%{public}d", modemRaf, raf, slotId);
843 return false;
844 }
845 int32_t filterMode = static_cast<int32_t>(NetworkUtils::GetNetworkModeFromRaf(modemRaf & raf));
846 TELEPHONY_LOGI("modemRaf:%{public}d, raf:%{public}d, filterMode:%{public}d slotId:%{public}d", modemRaf, raf,
847 filterMode, slotId);
848 SetCachePreferredNetworkValue(slotId, filterMode);
849 return eventSender_->SendBase(slotId, RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE, filterMode);
850 }
851
SavePreferredNetworkValue(int32_t slotId,int32_t networkMode)852 void NetworkSearchManager::SavePreferredNetworkValue(int32_t slotId, int32_t networkMode)
853 {
854 TELEPHONY_LOGD("NetworkSearchManager SavePreferredNetworkValue slotId:%{public}d, networkMode:%{public}d", slotId,
855 networkMode);
856 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
857 if (settingHelper == nullptr) {
858 TELEPHONY_LOGE("settingHelper is null");
859 return;
860 }
861
862 Uri uri(SettingUtils::NETWORK_SEARCH_SETTING_PREFERRED_NETWORK_MODE_URI);
863 std::string key = SettingUtils::SETTINGS_NETWORK_SEARCH_PREFERRED_NETWORK_MODE + "_" + std::to_string(slotId);
864 std::string value = std::to_string(networkMode);
865 if (settingHelper->Update(uri, key, value) != TELEPHONY_SUCCESS) {
866 TELEPHONY_LOGE("Update %{public}s fail", key.c_str());
867 }
868 }
869
UpdateRadioOn(int32_t slotId)870 int32_t NetworkSearchManager::UpdateRadioOn(int32_t slotId)
871 {
872 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
873 if (settingHelper == nullptr) {
874 TELEPHONY_LOGE("settingHelper is null");
875 return TELEPHONY_ERR_LOCAL_PTR_NULL;
876 }
877
878 Uri uri(SettingUtils::NETWORK_SEARCH_SETTING_AIRPLANE_MODE_URI);
879 std::string key = SettingUtils::SETTINGS_NETWORK_SEARCH_AIRPLANE_MODE;
880 int32_t airplaneModeOff = 0;
881 std::string value = std::to_string(airplaneModeOff);
882 int32_t ret = settingHelper->Update(uri, key, value);
883 if (ret != TELEPHONY_SUCCESS) {
884 TELEPHONY_LOGE("NetworkSearchManager::UpdateRadioOn Update fail");
885 return ret;
886 }
887 SetRadioState(slotId, CORE_SERVICE_POWER_ON, 0);
888 AAFwk::Want want;
889 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_AIRPLANE_MODE_CHANGED);
890 want.SetParam("state", false);
891 EventFwk::CommonEventData data;
892 data.SetWant(want);
893 EventFwk::CommonEventPublishInfo publishInfo;
894 if (!EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr)) {
895 TELEPHONY_LOGE("PublishCommonEvent fail");
896 return TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL;
897 }
898 return TELEPHONY_SUCCESS;
899 }
900
GetPreferredNetworkValue(int32_t slotId) const901 int32_t NetworkSearchManager::GetPreferredNetworkValue(int32_t slotId) const
902 {
903 int32_t networkMode = PREFERRED_NETWORK_TYPE;
904 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
905 if (settingHelper == nullptr) {
906 TELEPHONY_LOGE("settingHelper is null");
907 return networkMode;
908 }
909
910 Uri uri(SettingUtils::NETWORK_SEARCH_SETTING_PREFERRED_NETWORK_MODE_URI);
911 std::string key = SettingUtils::SETTINGS_NETWORK_SEARCH_PREFERRED_NETWORK_MODE + "_" + std::to_string(slotId);
912 std::string value = "";
913 if (settingHelper->Query(uri, key, value) != TELEPHONY_SUCCESS) {
914 TELEPHONY_LOGI("Query %{public}s fail", key.c_str());
915 return networkMode;
916 }
917
918 bool succ = StrToInt(value, networkMode);
919 TELEPHONY_LOGD("NetworkSearchManager GetPreferredNetworkValue succ:%{public}d, slotId:%{public}d, "
920 "networkMode:%{public}d",
921 slotId, succ, networkMode);
922 return networkMode;
923 }
924
UpdatePhone(int32_t slotId,RadioTech csRadioTech,const RadioTech & psRadioTech)925 void NetworkSearchManager::UpdatePhone(int32_t slotId, RadioTech csRadioTech, const RadioTech &psRadioTech)
926 {
927 auto inner = FindManagerInner(slotId);
928 if (inner != nullptr) {
929 if (inner->networkSearchHandler_ != nullptr) {
930 inner->networkSearchHandler_->UpdatePhone(csRadioTech, psRadioTech);
931 }
932 }
933 }
934
GetImsRegStatus(int32_t slotId,ImsServiceType imsSrvType,ImsRegInfo & info)935 int32_t NetworkSearchManager::GetImsRegStatus(int32_t slotId, ImsServiceType imsSrvType, ImsRegInfo &info)
936 {
937 TELEPHONY_LOGD("slotId:%{public}d, imsSrvType:%{public}d", slotId, imsSrvType);
938 auto inner = FindManagerInner(slotId);
939 if (inner == nullptr) {
940 TELEPHONY_LOGE("NetworkSearchManagerInner is nullptr!");
941 return TELEPHONY_ERR_LOCAL_PTR_NULL;
942 }
943 if (inner->networkSearchState_ == nullptr) {
944 TELEPHONY_LOGE("networkSearchState is nullptr!");
945 return TELEPHONY_ERR_LOCAL_PTR_NULL;
946 }
947 return inner->networkSearchState_->GetImsStatus(imsSrvType, info);
948 }
949
SetImei(int32_t slotId,std::u16string imei)950 void NetworkSearchManager::SetImei(int32_t slotId, std::u16string imei)
951 {
952 auto inner = FindManagerInner(slotId);
953 if (inner != nullptr) {
954 inner->imei_ = imei;
955 }
956 }
957
GetImei(int32_t slotId,std::u16string & imei)958 int32_t NetworkSearchManager::GetImei(int32_t slotId, std::u16string &imei)
959 {
960 TELEPHONY_LOGD("NetworkSearchManager::GetImei start slotId:%{public}d", slotId);
961 imei = u"";
962 auto inner = FindManagerInner(slotId);
963 if (inner == nullptr || eventSender_ == nullptr) {
964 TELEPHONY_LOGE("slotId:%{public}d inner or eventSender_ is null", slotId);
965 return TELEPHONY_ERR_LOCAL_PTR_NULL;
966 }
967 std::shared_ptr<SatelliteServiceClient> satelliteClient = DelayedSingleton<SatelliteServiceClient>::GetInstance();
968 if (IsSatelliteEnabled()) {
969 imei = Str8ToStr16(satelliteClient->GetImei());
970 return TELEPHONY_ERR_SUCCESS;
971 }
972 if (inner->imei_.empty()) {
973 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_IMEI);
974 return TELEPHONY_ERR_LOCAL_PTR_NULL;
975 }
976 imei = inner->imei_;
977 return TELEPHONY_ERR_SUCCESS;
978 }
979
GetCellInfoList(int32_t slotId,std::vector<sptr<CellInformation>> & cellInfo)980 int32_t NetworkSearchManager::GetCellInfoList(int32_t slotId, std::vector<sptr<CellInformation>> &cellInfo)
981 {
982 auto inner = FindManagerInner(slotId);
983 if (inner != nullptr) {
984 if (inner->networkSearchHandler_ != nullptr) {
985 inner->networkSearchHandler_->GetCellInfoList(cellInfo);
986 if (TELEPHONY_EXT_WRAPPER.getCellInfoList_ != nullptr) {
987 TELEPHONY_EXT_WRAPPER.getCellInfoList_(slotId, cellInfo);
988 }
989 return TELEPHONY_ERR_SUCCESS;
990 }
991 }
992 return TELEPHONY_ERR_LOCAL_PTR_NULL;
993 }
994
SendUpdateCellLocationRequest(int32_t slotId)995 int32_t NetworkSearchManager::SendUpdateCellLocationRequest(int32_t slotId)
996 {
997 auto inner = FindManagerInner(slotId);
998 if (inner != nullptr) {
999 if (inner->networkSearchHandler_ == nullptr || GetRadioState(slotId) == CORE_SERVICE_POWER_OFF) {
1000 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1001 }
1002 return inner->networkSearchHandler_->SendUpdateCellLocationRequest();
1003 }
1004 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1005 }
1006
UpdateCellLocation(int32_t slotId,int32_t techType,int32_t cellId,int32_t lac)1007 void NetworkSearchManager::UpdateCellLocation(int32_t slotId, int32_t techType, int32_t cellId, int32_t lac)
1008 {
1009 auto inner = FindManagerInner(slotId);
1010 if (inner != nullptr) {
1011 if (inner->networkSearchHandler_ != nullptr) {
1012 inner->networkSearchHandler_->UpdateCellLocation(techType, cellId, lac);
1013 }
1014 }
1015 }
1016
GetCellLocation(int32_t slotId)1017 sptr<CellLocation> NetworkSearchManager::GetCellLocation(int32_t slotId)
1018 {
1019 auto inner = FindManagerInner(slotId);
1020 if (inner != nullptr) {
1021 if (inner->networkSearchHandler_ != nullptr) {
1022 return inner->networkSearchHandler_->GetCellLocation();
1023 }
1024 }
1025 return nullptr;
1026 }
1027
SetMeid(int32_t slotId,std::u16string meid)1028 void NetworkSearchManager::SetMeid(int32_t slotId, std::u16string meid)
1029 {
1030 auto inner = FindManagerInner(slotId);
1031 if (inner != nullptr) {
1032 inner->meid_ = meid;
1033 }
1034 }
1035
GetMeid(int32_t slotId,std::u16string & meid)1036 int32_t NetworkSearchManager::GetMeid(int32_t slotId, std::u16string &meid)
1037 {
1038 TELEPHONY_LOGD("NetworkSearchManager::GetMeid start slotId:%{public}d", slotId);
1039 meid = u"";
1040 auto inner = FindManagerInner(slotId);
1041 if (inner == nullptr || eventSender_ == nullptr) {
1042 TELEPHONY_LOGE("slotId:%{public}d inner or eventSender_ is null", slotId);
1043 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1044 }
1045 if (inner->meid_.empty()) {
1046 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_MEID);
1047 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1048 }
1049 meid = inner->meid_;
1050 return TELEPHONY_ERR_SUCCESS;
1051 }
1052
SetLocateUpdate(int32_t slotId)1053 void NetworkSearchManager::SetLocateUpdate(int32_t slotId)
1054 {
1055 TELEPHONY_LOGD("NetworkSearchManager::SetLocateUpdate start slotId:%{public}d", slotId);
1056 auto inner = FindManagerInner(slotId);
1057 if (inner == nullptr) {
1058 TELEPHONY_LOGI("NetworkSearchManager::SetLocateUpdate inner null slotId:%{public}d", slotId);
1059 return;
1060 }
1061
1062 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_LOCATION_UPDATE);
1063 if (event != nullptr && inner->networkSearchHandler_ != nullptr) {
1064 event->SetOwner(inner->networkSearchHandler_);
1065 telRilManager_->SetLocateUpdates(slotId, HRilRegNotifyMode::REG_NOTIFY_STAT_LAC_CELLID, event);
1066 }
1067 }
1068
GetUniqueDeviceId(int32_t slotId,std::u16string & deviceId)1069 int32_t NetworkSearchManager::GetUniqueDeviceId(int32_t slotId, std::u16string &deviceId)
1070 {
1071 TELEPHONY_LOGD("NetworkSearchManager::GetUniqueDeviceId start slotId:%{public}d", slotId);
1072 deviceId = u"";
1073 auto inner = FindManagerInner(slotId);
1074 if (inner == nullptr) {
1075 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1076 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1077 }
1078 if (GetPhoneType(slotId) == PhoneType::PHONE_TYPE_IS_GSM) {
1079 if (!inner->imei_.empty()) {
1080 deviceId = inner->imei_;
1081 return TELEPHONY_ERR_SUCCESS;
1082 }
1083 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1084 } else {
1085 if (!inner->meid_.empty()) {
1086 deviceId = inner->meid_;
1087 return TELEPHONY_ERR_SUCCESS;
1088 }
1089 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1090 }
1091 }
1092
FactoryReset(int32_t slotId)1093 int32_t NetworkSearchManager::FactoryReset(int32_t slotId)
1094 {
1095 bool ret = SetNetworkSelectionMode(slotId, static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO), nullptr, true);
1096 if (!ret) {
1097 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1098 }
1099 int32_t networkMode = PREFERRED_NETWORK_TYPE;
1100 ret = SetPreferredNetwork(slotId, networkMode);
1101 if (!ret) {
1102 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1103 }
1104 NotifyFactoryReset(slotId);
1105 return TELEPHONY_ERR_SUCCESS;
1106 }
1107
GetPhoneType(int32_t slotId)1108 PhoneType NetworkSearchManager::GetPhoneType(int32_t slotId)
1109 {
1110 PhoneType phoneType = PhoneType::PHONE_TYPE_IS_NONE;
1111 auto inner = FindManagerInner(slotId);
1112 if (inner != nullptr) {
1113 if (inner->networkSearchHandler_ != nullptr) {
1114 phoneType = inner->networkSearchHandler_->GetPhoneType();
1115 }
1116 }
1117 TELEPHONY_LOGI("NetworkSearchManager::GetPhoneType type:%{public}d start slotId:%{public}d", phoneType, slotId);
1118 return phoneType;
1119 }
1120
GetVoiceTech(int32_t slotId)1121 void NetworkSearchManager::GetVoiceTech(int32_t slotId)
1122 {
1123 if (eventSender_ == nullptr) {
1124 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
1125 return;
1126 }
1127 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_VOICE_TECH);
1128 eventSender_->SendCallback(
1129 slotId, RadioEvent::RADIO_OPERATOR, nullptr, NetworkSearchManagerInner::SERIAL_NUMBER_EXEMPT);
1130 }
1131
IsNrSupported(int32_t slotId)1132 bool NetworkSearchManager::IsNrSupported(int32_t slotId)
1133 {
1134 if (simManager_ == nullptr) {
1135 TELEPHONY_LOGE("simManager_ is nullptr");
1136 return false;
1137 }
1138 int32_t modemRaf = simManager_->GetRadioProtocolTech(slotId);
1139 if (TELEPHONY_EXT_WRAPPER.isNrSupportedNative_ != nullptr) {
1140 return TELEPHONY_EXT_WRAPPER.isNrSupportedNative_(modemRaf);
1141 }
1142 return (static_cast<uint32_t>(modemRaf) & static_cast<uint32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_NR)) ==
1143 static_cast<uint32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_NR);
1144 }
1145
IsSatelliteEnabled()1146 bool NetworkSearchManager::IsSatelliteEnabled()
1147 {
1148 std::shared_ptr<SatelliteServiceClient> satelliteClient = DelayedSingleton<SatelliteServiceClient>::GetInstance();
1149 if (satelliteClient == nullptr) {
1150 TELEPHONY_LOGE("satelliteClient is nullptr");
1151 return false;
1152 }
1153 return satelliteClient->IsSatelliteEnabled();
1154 }
1155
HandleRrcStateChanged(int32_t slotId,int32_t status)1156 int32_t NetworkSearchManager::HandleRrcStateChanged(int32_t slotId, int32_t status)
1157 {
1158 auto inner = FindManagerInner(slotId);
1159 if (inner == nullptr) {
1160 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1161 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1162 }
1163 if (inner->rrcConnectionStatus_ == status) {
1164 TELEPHONY_LOGI("slotId:%{public}d rrc state is not change.", slotId);
1165 return TELEPHONY_ERR_FAIL;
1166 }
1167 inner->rrcConnectionStatus_ = status;
1168 if (status == RRC_CONNECTED_STATUS || status == RRC_IDLE_STATUS) {
1169 inner->networkSearchHandler_->HandleRrcStateChanged(status);
1170 }
1171 return TELEPHONY_ERR_SUCCESS;
1172 }
1173
RevertLastTechnology(int32_t slotId)1174 int32_t NetworkSearchManager::RevertLastTechnology(int32_t slotId)
1175 {
1176 auto inner = FindManagerInner(slotId);
1177 if (inner == nullptr || inner->networkSearchHandler_ == nullptr) {
1178 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1179 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1180 }
1181 return inner->networkSearchHandler_->RevertLastTechnology();
1182 }
1183
GetRrcConnectionState(int32_t slotId,int32_t & status)1184 int32_t NetworkSearchManager::GetRrcConnectionState(int32_t slotId, int32_t &status)
1185 {
1186 auto inner = FindManagerInner(slotId);
1187 if (inner == nullptr || eventSender_ == nullptr) {
1188 TELEPHONY_LOGE("slotId:%{public}d inner or eventSender_ is null", slotId);
1189 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1190 }
1191 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_RRC_CONNECTION_STATE);
1192 status = inner->rrcConnectionStatus_;
1193 return TELEPHONY_ERR_SUCCESS;
1194 }
1195
UpdateRrcConnectionState(int32_t slotId,int32_t & status)1196 int32_t NetworkSearchManager::UpdateRrcConnectionState(int32_t slotId, int32_t &status)
1197 {
1198 auto inner = FindManagerInner(slotId);
1199 if (inner == nullptr) {
1200 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1201 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1202 }
1203 status = inner->rrcConnectionStatus_;
1204 return TELEPHONY_ERR_SUCCESS;
1205 }
1206
GetNrOptionMode(int32_t slotId,NrMode & mode)1207 int32_t NetworkSearchManager::GetNrOptionMode(int32_t slotId, NrMode &mode)
1208 {
1209 auto inner = FindManagerInner(slotId);
1210 if (inner == nullptr || eventSender_ == nullptr) {
1211 TELEPHONY_LOGE("slotId:%{public}d inner or eventSender_ is null", slotId);
1212 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1213 }
1214 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_NR_OPTION_MODE);
1215 mode = inner->nrMode_;
1216 if (TELEPHONY_EXT_WRAPPER.getNrOptionModeExtend_ != nullptr) {
1217 TELEPHONY_EXT_WRAPPER.getNrOptionModeExtend_(slotId, mode);
1218 }
1219 return TELEPHONY_ERR_SUCCESS;
1220 }
1221
GetNrOptionMode(int32_t slotId,NSCALLBACK & callback)1222 int32_t NetworkSearchManager::GetNrOptionMode(int32_t slotId, NSCALLBACK &callback)
1223 {
1224 if (eventSender_ == nullptr) {
1225 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
1226 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1227 }
1228 if (!eventSender_->SendCallback(slotId, RadioEvent::RADIO_GET_NR_OPTION_MODE, &callback)) {
1229 TELEPHONY_LOGE("slotId:%{public}d GetNrOptionMode SendCallback failed.", slotId);
1230 return CORE_SERVICE_SEND_CALLBACK_FAILED;
1231 }
1232 return TELEPHONY_ERR_SUCCESS;
1233 }
1234
UpdateNrOptionMode(int32_t slotId,NrMode mode)1235 int32_t NetworkSearchManager::UpdateNrOptionMode(int32_t slotId, NrMode mode)
1236 {
1237 auto inner = FindManagerInner(slotId);
1238 if (inner == nullptr) {
1239 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1240 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1241 }
1242 inner->nrMode_ = mode;
1243 return TELEPHONY_ERR_SUCCESS;
1244 }
1245
SetNrOptionMode(int32_t slotId,int32_t mode)1246 int32_t NetworkSearchManager::SetNrOptionMode(int32_t slotId, int32_t mode)
1247 {
1248 TELEPHONY_LOGD("NetworkSearchManager SetNrOptionMode mode:%{public}d slotId:%{public}d", mode, slotId);
1249 if (mode < static_cast<int32_t>(NrMode::NR_MODE_UNKNOWN) ||
1250 mode > static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA)) {
1251 return TELEPHONY_ERR_ARGUMENT_INVALID;
1252 }
1253 if (eventSender_ == nullptr) {
1254 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
1255 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1256 }
1257 eventSender_->SendBase(slotId, RadioEvent::RADIO_SET_NR_OPTION_MODE, mode);
1258 return TELEPHONY_ERR_SUCCESS;
1259 }
1260
SetNrOptionMode(int32_t slotId,int32_t mode,NSCALLBACK & callback)1261 int32_t NetworkSearchManager::SetNrOptionMode(int32_t slotId, int32_t mode, NSCALLBACK &callback)
1262 {
1263 TELEPHONY_LOGD("NetworkSearchManager SetNrOptionMode mode:%{public}d slotId:%{public}d", mode, slotId);
1264 if (mode < static_cast<int32_t>(NrMode::NR_MODE_UNKNOWN) ||
1265 mode > static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA)) {
1266 return TELEPHONY_ERR_ARGUMENT_INVALID;
1267 }
1268 if (eventSender_ == nullptr) {
1269 TELEPHONY_LOGE("slotId:%{public}d eventSender_ is null", slotId);
1270 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1271 }
1272 if (!eventSender_->SendCallbackEx(slotId, RadioEvent::RADIO_SET_NR_OPTION_MODE, &callback, mode)) {
1273 TELEPHONY_LOGE("slotId:%{public}d SetNrOptionMode SendCallback failed.", slotId);
1274 return CORE_SERVICE_SEND_CALLBACK_FAILED;
1275 }
1276 return TELEPHONY_ERR_SUCCESS;
1277 }
1278
SetFrequencyType(int32_t slotId,FrequencyType type)1279 void NetworkSearchManager::SetFrequencyType(int32_t slotId, FrequencyType type)
1280 {
1281 auto inner = FindManagerInner(slotId);
1282 if (inner != nullptr) {
1283 std::lock_guard<std::mutex> lock(inner->mutex_);
1284 inner->freqType_ = type;
1285 }
1286 }
1287
GetFrequencyType(int32_t slotId)1288 FrequencyType NetworkSearchManager::GetFrequencyType(int32_t slotId)
1289 {
1290 auto inner = FindManagerInner(slotId);
1291 if (inner != nullptr) {
1292 std::lock_guard<std::mutex> lock(inner->mutex_);
1293 return inner->freqType_;
1294 }
1295 return FrequencyType::FREQ_TYPE_UNKNOWN;
1296 }
1297
GetNrState(int32_t slotId)1298 NrState NetworkSearchManager::GetNrState(int32_t slotId)
1299 {
1300 auto inner = FindManagerInner(slotId);
1301 if (inner != nullptr) {
1302 if (inner->networkSearchState_ != nullptr && inner->networkSearchState_->GetNetworkStatus() != nullptr) {
1303 auto event = inner->networkSearchState_->GetNetworkStatus()->GetNrState();
1304 TELEPHONY_LOGI("NetworkSearchManager::GetNrState result=%{public}d slotId:%{public}d", event, slotId);
1305 return event;
1306 }
1307 TELEPHONY_LOGE("NetworkSearchManager::GetNrState failed due to nullptr!");
1308 }
1309 TELEPHONY_LOGE("NetworkSearchManager::GetNrState Failed slotId:%{public}d", slotId);
1310 return NrState::NR_STATE_NOT_SUPPORT;
1311 }
1312
DcPhysicalLinkActiveUpdate(int32_t slotId,bool isActive)1313 void NetworkSearchManager::DcPhysicalLinkActiveUpdate(int32_t slotId, bool isActive)
1314 {
1315 auto inner = FindManagerInner(slotId);
1316 if (inner != nullptr) {
1317 if (inner->networkSearchHandler_ != nullptr) {
1318 int active = isActive ? 1 : 0;
1319 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_SET_DATA_CONNECT_ACTIVE, active);
1320 inner->networkSearchHandler_->SendEvent(event);
1321 }
1322 }
1323 }
1324
NotifyCallStatusToNetworkSearch(int32_t slotId,int32_t callStatus)1325 int32_t NetworkSearchManager::NotifyCallStatusToNetworkSearch(int32_t slotId, int32_t callStatus)
1326 {
1327 auto inner = FindManagerInner(slotId);
1328 if (inner == nullptr) {
1329 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1330 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1331 }
1332 switch (callStatus) {
1333 case static_cast<int32_t>(TelephonyCallState::CALL_STATUS_ACTIVE):
1334 case static_cast<int32_t>(TelephonyCallState::CALL_STATUS_HOLDING):
1335 case static_cast<int32_t>(TelephonyCallState::CALL_STATUS_DIALING):
1336 case static_cast<int32_t>(TelephonyCallState::CALL_STATUS_INCOMING):
1337 case static_cast<int32_t>(TelephonyCallState::CALL_STATUS_WAITING):
1338 inner->hasCall_ = true;
1339 break;
1340 default:
1341 inner->hasCall_ = false;
1342 break;
1343 }
1344 TELEPHONY_LOGI("slotId:%{public}d callStatus:%{public}d hasCall:%{public}d", slotId, callStatus, inner->hasCall_);
1345 return TELEPHONY_ERR_SUCCESS;
1346 }
1347
GetDelayNotifyTime()1348 int32_t NetworkSearchManager::GetDelayNotifyTime()
1349 {
1350 char param[SYS_PARAMETER_SIZE] = { 0 };
1351 int32_t delayTime = 0;
1352 int32_t code = GetParameter(CFG_TECH_UPDATE_TIME, NO_DELAY_TIME__CONFIG, param, SYS_PARAMETER_SIZE);
1353 std::string time = param;
1354 if (code <= 0 || !IsValidDecValue(time)) {
1355 delayTime = std::stoi(NO_DELAY_TIME__CONFIG);
1356 } else {
1357 delayTime = std::stoi(time);
1358 }
1359 return delayTime;
1360 }
1361
HandleNotifyStateChangeWithDelay(int32_t slotId,bool isNeedDelay)1362 int32_t NetworkSearchManager::HandleNotifyStateChangeWithDelay(int32_t slotId, bool isNeedDelay)
1363 {
1364 auto inner = FindManagerInner(slotId);
1365 if (inner == nullptr || inner->networkSearchHandler_ == nullptr) {
1366 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1367 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1368 }
1369
1370 auto delayEvent = AppExecFwk::InnerEvent::Get(RadioEvent::DELAY_NOTIFY_STATE_CHANGE);
1371 uint32_t delayEventId = static_cast<uint32_t>(RadioEvent::DELAY_NOTIFY_STATE_CHANGE);
1372 if (isNeedDelay) {
1373 if (inner->networkSearchHandler_->HasInnerEvent(delayEventId)) {
1374 TELEPHONY_LOGI("Has delay event, return. slotId:%{public}d", slotId);
1375 } else {
1376 inner->networkSearchHandler_->SendEvent(delayEvent, delayTime_);
1377 TELEPHONY_LOGI("Need delay, delayTime:%{public}d slotId:%{public}d", delayTime_, slotId);
1378 }
1379 } else {
1380 TELEPHONY_LOGI("Do not need delay, slotId:%{public}d", slotId);
1381 if (inner->networkSearchHandler_->HasInnerEvent(delayEventId)) {
1382 TELEPHONY_LOGI("Remove delay event, slotId:%{public}d", slotId);
1383 inner->networkSearchHandler_->RemoveEvent(delayEventId);
1384 }
1385 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::NOTIFY_STATE_CHANGE);
1386 inner->networkSearchHandler_->SendEvent(event);
1387 }
1388 return TELEPHONY_ERR_SUCCESS;
1389 }
1390
IsNeedDelayNotify(int32_t slotId)1391 bool NetworkSearchManager::IsNeedDelayNotify(int32_t slotId)
1392 {
1393 auto inner = FindManagerInner(slotId);
1394 if (inner == nullptr || inner->networkSearchHandler_ == nullptr) {
1395 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1396 return false;
1397 }
1398 if ((inner->networkSearchState_ == nullptr) || (inner->networkSearchState_->GetNetworkStatus() == nullptr)) {
1399 TELEPHONY_LOGE("NetworkSearchManager::IsNeedDelayNotify failed due to nullptr!");
1400 return false;
1401 }
1402 if (delayTime_ <= INVALID_DELAY_TIME) {
1403 TELEPHONY_LOGI("The system properties are not configured with a valid delay time.");
1404 return false;
1405 }
1406 int32_t networkCapabilityState = 0;
1407 GetNetworkCapability(slotId, SERVICE_TYPE_NR, networkCapabilityState);
1408 if (networkCapabilityState == SERVICE_ABILITY_OFF) {
1409 TELEPHONY_LOGI("The NR switch is closed.");
1410 return false;
1411 }
1412 RegServiceState regState = RegServiceState::REG_STATE_UNKNOWN;
1413 inner->networkSearchHandler_->GetRegServiceState(regState);
1414 if (regState == RegServiceState::REG_STATE_NO_SERVICE) {
1415 TELEPHONY_LOGI("The reg state is no service.");
1416 return false;
1417 }
1418 RadioTech cfgTech = inner->networkSearchState_->GetNetworkStatus()->GetCfgTech();
1419 if ((cfgTech != RadioTech::RADIO_TECHNOLOGY_LTE) && (cfgTech != RadioTech::RADIO_TECHNOLOGY_LTE_CA)) {
1420 TELEPHONY_LOGI("The cfgTech[%{public}d] is not LTE, slotId:%{public}d", cfgTech, slotId);
1421 return false;
1422 }
1423 if (inner->hasCall_) {
1424 TELEPHONY_LOGI("Has call, slotId:%{public}d", slotId);
1425 return false;
1426 }
1427 RadioTech lastCfgTech = inner->networkSearchState_->GetNetworkStatus()->GetLastCfgTech();
1428 RadioTech lastPsRadioTech = inner->networkSearchState_->GetNetworkStatus()->GetLastPsRadioTech();
1429 if ((lastCfgTech == RadioTech::RADIO_TECHNOLOGY_NR) && (lastPsRadioTech != RadioTech::RADIO_TECHNOLOGY_NR) &&
1430 (cfgTech == RadioTech::RADIO_TECHNOLOGY_LTE || (cfgTech == RadioTech::RADIO_TECHNOLOGY_LTE_CA))) {
1431 TELEPHONY_LOGI(
1432 "lastCfgTech:%{public}d lastPsTech:%{public}d slotId:%{public}d", lastCfgTech, lastPsRadioTech, slotId);
1433 return true;
1434 }
1435 return false;
1436 }
1437
ProcessNotifyStateChangeEvent(int32_t slotId)1438 int32_t NetworkSearchManager::ProcessNotifyStateChangeEvent(int32_t slotId)
1439 {
1440 TELEPHONY_LOGI("Start process network state notify event, slotId:%{public}d", slotId);
1441 auto inner = FindManagerInner(slotId);
1442 if (inner == nullptr || inner->networkSearchHandler_ == nullptr) {
1443 TELEPHONY_LOGE("slotId:%{public}d inner is null", slotId);
1444 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1445 }
1446 bool isNeedDelay = IsNeedDelayNotify(slotId);
1447 if (isNeedDelay) {
1448 TELEPHONY_LOGI("revert last tech. slotId:%{public}d", slotId);
1449 inner->networkSearchHandler_->RevertLastTechnology();
1450 }
1451 return HandleNotifyStateChangeWithDelay(slotId, isNeedDelay);
1452 }
1453
IsRadioFirstPowerOn(int32_t slotId)1454 bool NetworkSearchManager::IsRadioFirstPowerOn(int32_t slotId)
1455 {
1456 auto inner = FindManagerInner(slotId);
1457 if (inner != nullptr) {
1458 std::lock_guard<std::mutex> lock(inner->mutex_);
1459 return inner->isRadioFirstPowerOn_;
1460 }
1461 return false;
1462 }
1463
SetRadioFirstPowerOn(int32_t slotId,bool isFirstPowerOn)1464 void NetworkSearchManager::SetRadioFirstPowerOn(int32_t slotId, bool isFirstPowerOn)
1465 {
1466 auto inner = FindManagerInner(slotId);
1467 if (inner != nullptr) {
1468 std::lock_guard<std::mutex> lock(inner->mutex_);
1469 inner->isRadioFirstPowerOn_ = isFirstPowerOn;
1470 }
1471 }
1472
FindManagerInner(int32_t slotId)1473 std::shared_ptr<NetworkSearchManagerInner> NetworkSearchManager::FindManagerInner(int32_t slotId)
1474 {
1475 {
1476 std::lock_guard<std::mutex> lock(mutexInner_);
1477 auto iter = mapManagerInner_.find(slotId);
1478 if (iter != mapManagerInner_.end()) {
1479 return iter->second;
1480 }
1481 }
1482 TELEPHONY_LOGE("NetworkSearchManager::FindManagerInner not find inner object. slotId:%{public}d", slotId);
1483 return nullptr;
1484 }
1485
ClearManagerInner()1486 void NetworkSearchManager::ClearManagerInner()
1487 {
1488 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
1489 auto inner = FindManagerInner(slotId);
1490 if (inner != nullptr) {
1491 std::lock_guard<std::mutex> lock(inner->mutex_);
1492 inner->networkSearchHandler_->UnregisterEvents();
1493 }
1494 }
1495 std::lock_guard<std::mutex> lock(mutexInner_);
1496 mapManagerInner_.clear();
1497 }
1498
AddManagerInner(int32_t slotId,const std::shared_ptr<NetworkSearchManagerInner> & inner)1499 void NetworkSearchManager::AddManagerInner(int32_t slotId, const std::shared_ptr<NetworkSearchManagerInner> &inner)
1500 {
1501 if (inner != nullptr) {
1502 std::lock_guard<std::mutex> lock(mutexInner_);
1503 mapManagerInner_.emplace(slotId, inner);
1504 TELEPHONY_LOGE("NetworkSearchManager::AddManagerInner %{public}d %{public}zu", slotId, mapManagerInner_.size());
1505 }
1506 }
1507
RemoveManagerInner(int32_t slotId)1508 bool NetworkSearchManager::RemoveManagerInner(int32_t slotId)
1509 {
1510 std::lock_guard<std::mutex> lock(mutexInner_);
1511 bool ret = (mapManagerInner_.erase(slotId) != 0);
1512 TELEPHONY_LOGE("NetworkSearchManager::RemoveManagerInner %{public}d %{public}zu", slotId, mapManagerInner_.size());
1513 return ret;
1514 }
1515
TriggerSimRefresh(int32_t slotId)1516 void NetworkSearchManager::TriggerSimRefresh(int32_t slotId)
1517 {
1518 TELEPHONY_LOGD("NetworkSearchManager::TriggerSimRefresh %{public}d", slotId);
1519 auto inner = FindManagerInner(slotId);
1520 if (inner != nullptr && simManager_ != nullptr) {
1521 if (inner->networkSearchHandler_ != nullptr) {
1522 simManager_->RegisterCoreNotify(slotId, inner->networkSearchHandler_, RadioEvent::RADIO_IMSI_LOADED_READY);
1523 }
1524 }
1525 }
1526
TriggerTimezoneRefresh(int32_t slotId)1527 void NetworkSearchManager::TriggerTimezoneRefresh(int32_t slotId)
1528 {
1529 auto inner = FindManagerInner(slotId);
1530 if (inner != nullptr) {
1531 if (inner->networkSearchHandler_ != nullptr) {
1532 inner->networkSearchHandler_->TimezoneRefresh();
1533 }
1534 }
1535 TELEPHONY_LOGE("NetworkSearchManager::TriggerTimezoneRefresh slotId:%{public}d", slotId);
1536 }
1537
GetAirplaneMode(bool & airplaneMode)1538 int32_t NetworkSearchManager::GetAirplaneMode(bool &airplaneMode)
1539 {
1540 std::shared_ptr<SettingUtils> settingHelper = SettingUtils::GetInstance();
1541 if (settingHelper == nullptr) {
1542 TELEPHONY_LOGI("settingHelper is null");
1543 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1544 }
1545
1546 Uri uri(SettingUtils::NETWORK_SEARCH_SETTING_AIRPLANE_MODE_URI);
1547 std::string value = "";
1548 std::string key = SettingUtils::SETTINGS_NETWORK_SEARCH_AIRPLANE_MODE;
1549 if (settingHelper->Query(uri, key, value) != TELEPHONY_SUCCESS) {
1550 TELEPHONY_LOGI("Query airplane mode fail");
1551 return TELEPHONY_ERR_DATABASE_READ_FAIL;
1552 }
1553 airplaneMode = value == "1";
1554 TELEPHONY_LOGI("Get airplane mode:%{public}d", airplaneMode);
1555 return TELEPHONY_SUCCESS;
1556 }
1557
RegisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType,const std::string & bundleName,const sptr<ImsRegInfoCallback> & callback)1558 int32_t NetworkSearchManager::RegisterImsRegInfoCallback(
1559 int32_t slotId, ImsServiceType imsSrvType, const std::string &bundleName, const sptr<ImsRegInfoCallback> &callback)
1560 {
1561 if (callback == nullptr) {
1562 TELEPHONY_LOGE("[slot%{public}d] callback is nullptr", slotId);
1563 return TELEPHONY_ERR_ARGUMENT_NULL;
1564 }
1565 bool isExisted = false;
1566 std::lock_guard<std::mutex> lock(mutexIms_);
1567 for (auto iter : listImsRegInfoCallbackRecord_) {
1568 if ((iter.slotId == slotId) && (iter.imsSrvType == imsSrvType) && (iter.bundleName == bundleName)) {
1569 isExisted = true;
1570 break;
1571 }
1572 }
1573 if (isExisted) {
1574 TELEPHONY_LOGI("[slot%{public}d] Ignore register action, since callback is existent", slotId);
1575 return TELEPHONY_SUCCESS;
1576 }
1577
1578 ImsRegInfoCallbackRecord imsRecord;
1579 imsRecord.slotId = slotId;
1580 imsRecord.imsSrvType = imsSrvType;
1581 imsRecord.bundleName = bundleName;
1582 imsRecord.imsCallback = callback;
1583 listImsRegInfoCallbackRecord_.push_back(imsRecord);
1584 TELEPHONY_LOGD("[slot%{public}d] Register successfully, callback list size is %{public}zu", slotId,
1585 listImsRegInfoCallbackRecord_.size());
1586 return TELEPHONY_SUCCESS;
1587 }
1588
UnregisterImsRegInfoCallback(int32_t slotId,ImsServiceType imsSrvType,const std::string & bundleName)1589 int32_t NetworkSearchManager::UnregisterImsRegInfoCallback(
1590 int32_t slotId, ImsServiceType imsSrvType, const std::string &bundleName)
1591 {
1592 bool isSuccess = false;
1593 std::lock_guard<std::mutex> lock(mutexIms_);
1594 auto iter = listImsRegInfoCallbackRecord_.begin();
1595 for (; iter != listImsRegInfoCallbackRecord_.end(); ++iter) {
1596 if ((iter->slotId == slotId) && (iter->imsSrvType == imsSrvType) && (iter->bundleName == bundleName)) {
1597 listImsRegInfoCallbackRecord_.erase(iter);
1598 isSuccess = true;
1599 break;
1600 }
1601 }
1602 if (!isSuccess) {
1603 TELEPHONY_LOGI("[slot%{public}d] Ignore unregister action, since callback is nonexistent", slotId);
1604 return TELEPHONY_SUCCESS;
1605 }
1606 TELEPHONY_LOGD("[slot%{public}d] Unregister successfully, callback list size is %{public}zu", slotId,
1607 listImsRegInfoCallbackRecord_.size());
1608 return TELEPHONY_SUCCESS;
1609 }
1610
NotifyImsRegInfoChanged(int32_t slotId,ImsServiceType imsSrvType,const ImsRegInfo & info)1611 void NetworkSearchManager::NotifyImsRegInfoChanged(int32_t slotId, ImsServiceType imsSrvType, const ImsRegInfo &info)
1612 {
1613 TELEPHONY_LOGD(
1614 "slotId:%{public}d, ImsRegState:%{public}d, ImsRegTech:%{public}d", slotId, info.imsRegState, info.imsRegTech);
1615 bool isExisted = false;
1616 std::lock_guard<std::mutex> lock(mutexIms_);
1617 for (auto iter : listImsRegInfoCallbackRecord_) {
1618 if ((iter.slotId == slotId) && (iter.imsSrvType == imsSrvType)) {
1619 if (iter.imsCallback == nullptr) {
1620 TELEPHONY_LOGE("imsCallback is nullptr from listImsRegInfoCallbackRecord_");
1621 continue;
1622 }
1623 iter.imsCallback->OnImsRegInfoChanged(slotId, imsSrvType, info);
1624 isExisted = true;
1625 }
1626 }
1627 if (!isExisted) {
1628 TELEPHONY_LOGI("this slot id %{public}d, ims service type %{public}d is not registered", slotId, imsSrvType);
1629 }
1630 }
1631
InitSimRadioProtocol(int32_t slotId)1632 void NetworkSearchManager::InitSimRadioProtocol(int32_t slotId)
1633 {
1634 if (simManager_ == nullptr) {
1635 TELEPHONY_LOGE("NetworkSearchManager::InitSimRadioProtocol simManager_ is nullptr");
1636 return;
1637 }
1638 simManager_->GetRadioProtocol(slotId);
1639 }
1640
SetLocalAirplaneMode(int32_t slotId,bool state)1641 int32_t NetworkSearchManager::SetLocalAirplaneMode(int32_t slotId, bool state)
1642 {
1643 auto inner = FindManagerInner(slotId);
1644 if (inner == nullptr) {
1645 TELEPHONY_LOGE("SetLocalAirplaneMode inner is nullptr, slotId:%{public}d", slotId);
1646 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1647 }
1648 inner->airplaneMode_ = state;
1649 TELEPHONY_LOGD("SetLocalAirplaneMode slotId:%{public}d state:%{public}d", slotId, state);
1650 return TELEPHONY_SUCCESS;
1651 }
1652
GetLocalAirplaneMode(int32_t slotId,bool & state)1653 int32_t NetworkSearchManager::GetLocalAirplaneMode(int32_t slotId, bool &state)
1654 {
1655 auto inner = FindManagerInner(slotId);
1656 if (inner == nullptr) {
1657 TELEPHONY_LOGE("GetLocalAirplaneMode inner is nullptr, slotId:%{public}d", slotId);
1658 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1659 }
1660 state = inner->airplaneMode_;
1661 TELEPHONY_LOGD("GetLocalAirplaneMode slotId:%{public}d state:%{public}d", slotId, state);
1662 return TELEPHONY_ERR_SUCCESS;
1663 }
1664
SetBasebandVersion(int32_t slotId,std::string version)1665 void NetworkSearchManager::SetBasebandVersion(int32_t slotId, std::string version)
1666 {
1667 auto inner = FindManagerInner(slotId);
1668 if (inner == nullptr) {
1669 TELEPHONY_LOGE("NetworkSearchManager::SetBasebandVersion slotId:%{public}d", slotId);
1670 return;
1671 }
1672 inner->basebandVersion_ = version;
1673 }
1674
GetBasebandVersion(int32_t slotId,std::string & version)1675 int32_t NetworkSearchManager::GetBasebandVersion(int32_t slotId, std::string &version)
1676 {
1677 TELEPHONY_LOGI("NetworkSearchManager::GetBasebandVersion start slotId:%{public}d", slotId);
1678 auto inner = FindManagerInner(slotId);
1679 if (inner == nullptr || eventSender_ == nullptr) {
1680 TELEPHONY_LOGE("slotId:%{public}d inner or eventSender_ is null", slotId);
1681 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1682 }
1683 if (inner->basebandVersion_.empty()) {
1684 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_BASEBAND_VERSION);
1685 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1686 }
1687 version = inner->basebandVersion_;
1688 return TELEPHONY_ERR_SUCCESS;
1689 }
1690
GetNetworkCapability(int32_t slotId,int32_t networkCapabilityType,int32_t & networkCapabilityState)1691 int32_t NetworkSearchManager::GetNetworkCapability(
1692 int32_t slotId, int32_t networkCapabilityType, int32_t &networkCapabilityState)
1693 {
1694 TelephonyConfig telephonyConfig;
1695 bool isNrSupported =
1696 telephonyConfig.IsCapabilitySupport(static_cast<int32_t>(TelephonyConfig::ConfigType::MODEM_CAP_SUPPORT_NR));
1697 if (networkCapabilityType == SERVICE_TYPE_NR && !isNrSupported) {
1698 TELEPHONY_LOGE(
1699 "switch type and nr capability no match, networkCapabilityType:%{public}d isNrSupported:%{public}d",
1700 networkCapabilityType, isNrSupported);
1701 return TELEPHONY_ERR_FAIL;
1702 }
1703 int32_t preferredNetwork = GetPreferredNetworkValue(slotId);
1704 int32_t convertedType = ConvertNetworkModeToCapabilityType(preferredNetwork);
1705 if (networkCapabilityType == SERVICE_TYPE_NR && convertedType == SERVICE_TYPE_NR) {
1706 networkCapabilityState = SERVICE_ABILITY_ON;
1707 } else if (networkCapabilityType == SERVICE_TYPE_LTE &&
1708 (convertedType == SERVICE_TYPE_NR || convertedType == SERVICE_TYPE_LTE)) {
1709 networkCapabilityState = SERVICE_ABILITY_ON;
1710 } else {
1711 networkCapabilityState = SERVICE_ABILITY_OFF;
1712 }
1713 if (TELEPHONY_EXT_WRAPPER.getNetworkCapabilityExt_ != nullptr) {
1714 TELEPHONY_EXT_WRAPPER.getNetworkCapabilityExt_(slotId, networkCapabilityType, networkCapabilityState);
1715 return TELEPHONY_ERR_SUCCESS;
1716 }
1717 return TELEPHONY_ERR_SUCCESS;
1718 }
1719
SetNetworkCapability(int32_t slotId,int32_t networkCapabilityType,int32_t networkCapabilityState)1720 int32_t NetworkSearchManager::SetNetworkCapability(
1721 int32_t slotId, int32_t networkCapabilityType, int32_t networkCapabilityState)
1722 {
1723 TelephonyConfig telephonyConfig;
1724 bool isNrSupported =
1725 telephonyConfig.IsCapabilitySupport(static_cast<int32_t>(TelephonyConfig::ConfigType::MODEM_CAP_SUPPORT_NR));
1726 if (networkCapabilityType == SERVICE_TYPE_NR && !isNrSupported) {
1727 TELEPHONY_LOGE(
1728 "switch type and nr capability no match, networkCapabilityType:%{public}d isNrSupported:%{public}d",
1729 networkCapabilityType, isNrSupported);
1730 return TELEPHONY_ERR_FAIL;
1731 }
1732 bool ret = false;
1733 if ((networkCapabilityType == SERVICE_TYPE_LTE && networkCapabilityState == SERVICE_ABILITY_ON) ||
1734 (networkCapabilityType == SERVICE_TYPE_NR && networkCapabilityState == SERVICE_ABILITY_OFF)) {
1735 ret = SetPreferredNetwork(
1736 slotId, static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM));
1737 } else if (networkCapabilityType == SERVICE_TYPE_NR && networkCapabilityState == SERVICE_ABILITY_ON) {
1738 ret = SetPreferredNetwork(
1739 slotId, static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM));
1740 } else if (networkCapabilityType == SERVICE_TYPE_LTE && networkCapabilityState == SERVICE_ABILITY_OFF) {
1741 ret = SetPreferredNetwork(
1742 slotId, static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA));
1743 }
1744 if (!ret) {
1745 TELEPHONY_LOGE(
1746 "set preferred Network failed, networkCapabilityType:%{public}d networkCapabilityState:%{public}d",
1747 networkCapabilityType, networkCapabilityState);
1748 return TELEPHONY_ERR_FAIL;
1749 }
1750 return TELEPHONY_ERR_SUCCESS;
1751 }
1752
ConvertNetworkModeToCapabilityType(int32_t preferredNetwork)1753 int32_t NetworkSearchManager::ConvertNetworkModeToCapabilityType(int32_t preferredNetwork)
1754 {
1755 int32_t capabilityType = SERVICE_TYPE_UNKNOWN;
1756 switch (preferredNetwork) {
1757 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE):
1758 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA):
1759 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM):
1760 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_EVDO_CDMA):
1761 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA):
1762 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA):
1763 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_GSM):
1764 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA):
1765 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM):
1766 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA):
1767 capabilityType = SERVICE_TYPE_LTE;
1768 break;
1769 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR):
1770 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE):
1771 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA):
1772 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM):
1773 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_EVDO_CDMA):
1774 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA):
1775 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA):
1776 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_GSM):
1777 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA):
1778 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM):
1779 case static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA):
1780 capabilityType = SERVICE_TYPE_NR;
1781 break;
1782 default:
1783 break;
1784 }
1785 return capabilityType;
1786 }
1787
GetNrSsbId(int32_t slotId,const std::shared_ptr<NrSsbInformation> & nrSsbInformation)1788 int32_t NetworkSearchManager::GetNrSsbId(int32_t slotId, const std::shared_ptr<NrSsbInformation> &nrSsbInformation)
1789 {
1790 TELEPHONY_LOGD("Start slotId:%{public}d", slotId);
1791 auto inner = FindManagerInner(slotId);
1792 if (inner == nullptr) {
1793 TELEPHONY_LOGE("inner is null");
1794 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1795 }
1796 std::unique_lock<std::mutex> lck(ctx_);
1797 ssbResponseReady_ = false;
1798 eventSender_->SendBase(slotId, RadioEvent::RADIO_GET_NR_SSBID_INFO);
1799 while (!ssbResponseReady_) {
1800 TELEPHONY_LOGD("Wait(), response = false");
1801 if (cv_.wait_for(lck, std::chrono::seconds(GET_SSB_WAIT_TIME_SECOND)) == std::cv_status::timeout) {
1802 break;
1803 }
1804 }
1805 if (!ssbResponseReady_) {
1806 TELEPHONY_LOGE("Wait() is timeout");
1807 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1808 }
1809 if (inner->networkSearchHandler_ != nullptr) {
1810 TELEPHONY_LOGE("Start to get ssbid's response");
1811 inner->networkSearchHandler_->GetNrSsbId(nrSsbInformation);
1812 return TELEPHONY_ERR_SUCCESS;
1813 }
1814 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1815 }
1816 } // namespace Telephony
1817 } // namespace OHOS
1818