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