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