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_handler.h"
17
18 #include "core_service_errors.h"
19 #include "core_manager_inner.h"
20 #include "ims_core_service_client.h"
21 #include "mcc_pool.h"
22 #include "network_search_manager.h"
23 #include "resource_utils.h"
24 #include "satellite_service_client.h"
25 #include "telephony_ext_wrapper.h"
26 #include "telephony_log_wrapper.h"
27
28 namespace OHOS {
29 namespace Telephony {
30 std::mutex NetworkSearchManager::ctx_;
31 bool NetworkSearchManager::ssbResponseReady_ = false;
32 std::condition_variable NetworkSearchManager::cv_;
33 static const int32_t REQ_INTERVAL = 30;
34 const int32_t SATELLITE_STATUS_ON = 1;
35 const size_t MCC_LEN = 3;
36 const std::string PERMISSION_PUBLISH_SYSTEM_EVENT = "ohos.permission.PUBLISH_SYSTEM_COMMON_EVENT";
37 const std::map<uint32_t, NetworkSearchHandler::NsHandlerFunc> NetworkSearchHandler::memberFuncMap_ = {
38 { RadioEvent::RADIO_SIM_STATE_CHANGE,
__anon920b72690102() 39 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
40 handler->SimStateChange(event);
41 } },
42 { RadioEvent::RADIO_IMSI_LOADED_READY,
__anon920b72690202() 43 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
44 handler->ImsiLoadedReady(event);
45 } },
46 { RadioEvent::RADIO_SIM_RECORDS_LOADED,
__anon920b72690302() 47 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
48 handler->SimRecordsLoaded(event);
49 } },
50 { RadioEvent::RADIO_STATE_CHANGED,
__anon920b72690402() 51 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
52 handler->RadioStateChange(event);
53 } },
54 { RadioEvent::RADIO_NETWORK_STATE,
__anon920b72690502() 55 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
56 handler->GetNetworkStateInfo(event);
57 } },
58 { RadioEvent::RADIO_RESTRICTED_STATE,
__anon920b72690602() 59 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
60 handler->RadioRestrictedState(event);
61 } },
62 { RadioEvent::RADIO_DATA_REG_STATE,
__anon920b72690702() 63 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
64 handler->RadioRilDataRegState(event);
65 } },
66 { RadioEvent::RADIO_VOICE_REG_STATE,
__anon920b72690802() 67 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
68 handler->RadioRilVoiceRegState(event);
69 } },
70 { RadioEvent::RADIO_GET_SIGNAL_STRENGTH,
__anon920b72690902() 71 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
72 handler->RadioSignalStrength(event);
73 } },
74 { RadioEvent::RADIO_SIGNAL_STRENGTH_UPDATE,
__anon920b72690a02() 75 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
76 handler->RadioSignalStrength(event);
77 } },
78 { RadioEvent::RADIO_OPERATOR,
__anon920b72690b02() 79 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
80 handler->RadioRilOperator(event);
81 } },
82 { RadioEvent::RADIO_NETWORK_SEARCH_RESULT,
__anon920b72690c02() 83 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
84 handler->NetworkSearchResult(event);
85 } },
86 { RadioEvent::RADIO_GET_NETWORK_SELECTION_MODE,
__anon920b72690d02() 87 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
88 handler->GetNetworkSelectionModeResponse(event);
89 } },
90 { RadioEvent::RADIO_SET_NETWORK_SELECTION_MODE,
__anon920b72690e02() 91 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
92 handler->SetNetworkSelectionModeResponse(event);
93 } },
94 { RadioEvent::RADIO_GET_STATUS,
__anon920b72690f02() 95 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
96 handler->GetRadioStateResponse(event);
97 } },
98 { RadioEvent::RADIO_SET_STATUS,
__anon920b72691002() 99 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
100 handler->SetRadioStateResponse(event);
101 } },
102 { RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE,
__anon920b72691102() 103 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
104 handler->SetPreferredNetworkResponse(event);
105 } },
106 { RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE,
__anon920b72691202() 107 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
108 handler->GetPreferredNetworkResponse(event);
109 } },
110 { RadioEvent::RADIO_NETWORK_TIME_UPDATE,
__anon920b72691302() 111 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
112 handler->RadioNitzUpdate(event);
113 } },
114 { RadioEvent::RADIO_IMS_SERVICE_STATUS_UPDATE,
__anon920b72691402() 115 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
116 handler->UpdateImsServiceStatus(event);
117 } },
118 { RadioEvent::RADIO_IMS_REGISTER_STATE_UPDATE,
__anon920b72691502() 119 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
120 handler->UpdateImsRegisterState(event);
121 } },
122 { RadioEvent::RADIO_GET_IMEI,
__anon920b72691602() 123 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
124 handler->RadioGetImei(event);
125 } },
126 { RadioEvent::RADIO_GET_IMEISV,
__anon920b72691702() 127 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
128 handler->RadioGetImeiSv(event);
129 } },
130 { RadioEvent::RADIO_GET_MEID,
__anon920b72691802() 131 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
132 handler->RadioGetMeid(event);
133 } },
134 { RadioEvent::RADIO_GET_NEIGHBORING_CELL_INFO,
__anon920b72691902() 135 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
136 handler->RadioGetNeighboringCellInfo(event);
137 } },
138 { RadioEvent::RADIO_GET_CURRENT_CELL_INFO,
__anon920b72691a02() 139 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
140 handler->RadioGetCurrentCellInfo(event);
141 } },
142 { RadioEvent::RADIO_CURRENT_CELL_UPDATE,
__anon920b72691b02() 143 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
144 handler->RadioCurrentCellInfoUpdate(event);
145 } },
146 { RadioEvent::RADIO_CHANNEL_CONFIG_UPDATE,
__anon920b72691c02() 147 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
148 handler->RadioChannelConfigInfo(event);
149 } },
150 { RadioEvent::RADIO_VOICE_TECH_CHANGED,
__anon920b72691d02() 151 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
152 handler->RadioVoiceTechChange(event);
153 } },
154 { RadioEvent::RADIO_GET_VOICE_TECH,
__anon920b72691e02() 155 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
156 handler->RadioVoiceTechChange(event);
157 } },
158 { RadioEvent::RADIO_SET_DATA_CONNECT_ACTIVE,
__anon920b72691f02() 159 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
160 handler->DcPhysicalLinkActiveUpdate(event);
161 } },
162 { RadioEvent::RADIO_GET_BASEBAND_VERSION,
__anon920b72692002() 163 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
164 handler->RadioGetBasebandVersion(event);
165 } },
166 { RadioEvent::RADIO_SET_NR_OPTION_MODE,
__anon920b72692102() 167 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
168 handler->SetNrOptionModeResponse(event);
169 } },
170 { RadioEvent::RADIO_GET_NR_OPTION_MODE,
__anon920b72692202() 171 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
172 handler->GetNrOptionModeResponse(event);
173 } },
174 { RadioEvent::RADIO_GET_RRC_CONNECTION_STATE,
__anon920b72692302() 175 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
176 handler->RadioGetRrcConnectionState(event);
177 } },
178 { RadioEvent::RADIO_RRC_CONNECTION_STATE_UPDATE,
__anon920b72692402() 179 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
180 handler->RadioGetRrcConnectionState(event);
181 } },
182 { RadioEvent::NOTIFY_STATE_CHANGE,
__anon920b72692502() 183 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
184 handler->NotifyStateChange(event);
185 } },
186 { RadioEvent::DELAY_NOTIFY_STATE_CHANGE,
__anon920b72692602() 187 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
188 handler->HandleDelayNotifyEvent(event);
189 } },
190 { RadioEvent::RADIO_RESIDENT_NETWORK_CHANGE,
__anon920b72692702() 191 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
192 handler->RadioResidentNetworkChange(event);
193 } },
194 { RadioEvent::RADIO_GET_NR_SSBID_INFO,
__anon920b72692802() 195 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
196 handler->GetNrSsbIdResponse(event);
197 } },
198 { SettingEventCode::MSG_AUTO_TIME,
__anon920b72692902() 199 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
200 handler->AutoTimeChange(event);
201 } },
202 { SettingEventCode::MSG_AUTO_TIMEZONE,
__anon920b72692a02() 203 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
204 handler->AutoTimeZoneChange(event);
205 } },
206 { SettingEventCode::MSG_AUTO_AIRPLANE_MODE,
__anon920b72692b02() 207 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
208 handler->AirplaneModeChange(event);
209 } },
210 { RadioEvent::SATELLITE_STATUS_CHANGED,
__anon920b72692c02() 211 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
212 handler->SatelliteStatusChanged(event);
213 } }
214 };
215
NetworkSearchHandler(const std::weak_ptr<NetworkSearchManager> & networkSearchManager,const std::weak_ptr<ITelRilManager> & telRilManager,const std::weak_ptr<ISimManager> & simManager,int32_t slotId)216 NetworkSearchHandler::NetworkSearchHandler(const std::weak_ptr<NetworkSearchManager> &networkSearchManager,
217 const std::weak_ptr<ITelRilManager> &telRilManager, const std::weak_ptr<ISimManager> &simManager, int32_t slotId)
218 : TelEventHandler("NetworkSearchManager_" + std::to_string(slotId)), networkSearchManager_(networkSearchManager),
219 telRilManager_(telRilManager), simManager_(simManager), slotId_(slotId)
220 {}
221
~NetworkSearchHandler()222 NetworkSearchHandler::~NetworkSearchHandler()
223 {
224 if (statusChangeListener_ != nullptr) {
225 statusChangeListener_.clear();
226 statusChangeListener_ = nullptr;
227 }
228 }
229
Init()230 bool NetworkSearchHandler::Init()
231 {
232 ResourceUtils::Get().GetBooleanValueByName(ResourceUtils::IS_CS_CAPABLE, isCsCapable_);
233 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
234 if (nsm == nullptr) {
235 TELEPHONY_LOGE("failed to get NetworkSearchManager");
236 return false;
237 }
238 networkRegister_ = std::make_unique<NetworkRegister>(nsm->GetNetworkSearchState(slotId_), nsm, slotId_);
239 if (networkRegister_ == nullptr) {
240 TELEPHONY_LOGE("failed to create new networkRegister slotId:%{public}d", slotId_);
241 return false;
242 }
243 networkRegister_->InitNrConversionConfig();
244 if (!InitOperatorName() || !InitSettingUtils()) {
245 return false;
246 }
247 SubscribeSystemAbility();
248 radioInfo_ = std::make_unique<RadioInfo>(nsm, slotId_);
249 if (radioInfo_ == nullptr) {
250 TELEPHONY_LOGE("failed to create new radioInfo slotId:%{public}d", slotId_);
251 return false;
252 }
253 signalInfo_ = std::make_unique<SignalInfo>();
254 if (signalInfo_ == nullptr) {
255 TELEPHONY_LOGE("failed to create new signalInfo slotId:%{public}d", slotId_);
256 return false;
257 }
258 networkSelection_ = std::make_unique<NetworkSelection>(networkSearchManager_, slotId_);
259 if (networkSelection_ == nullptr) {
260 TELEPHONY_LOGE("failed to create new networkSelection slotId:%{public}d", slotId_);
261 return false;
262 }
263 networkType_ = std::make_unique<NetworkType>(nsm, slotId_);
264 if (networkType_ == nullptr) {
265 TELEPHONY_LOGE("failed to create new networkType slotId:%{public}d", slotId_);
266 return false;
267 }
268 nitzUpdate_ = std::make_unique<NitzUpdate>(networkSearchManager_, slotId_);
269 if (nitzUpdate_ == nullptr) {
270 TELEPHONY_LOGE("failed to create new nitzUpdate slotId:%{public}d", slotId_);
271 return false;
272 }
273 if (!SubModuleInit()) {
274 return false;
275 }
276 signalInfo_->InitSignalBar();
277 RegisterEvents();
278 return true;
279 }
280
SubModuleInit()281 bool NetworkSearchHandler::SubModuleInit()
282 {
283 cellInfo_ = std::make_unique<CellInfo>(networkSearchManager_, slotId_);
284 if (cellInfo_ == nullptr) {
285 TELEPHONY_LOGE("failed to create new CellInfo slotId:%{public}d", slotId_);
286 return false;
287 }
288 nrSsbInfo_ = std::make_unique<NrSsbInfo>(networkSearchManager_, slotId_);
289 if (nrSsbInfo_ == nullptr) {
290 TELEPHONY_LOGE("failed to create new NrSsbInfo slotId:%{public}d", slotId_);
291 return false;
292 }
293 return true;
294 }
295
InitOperatorName()296 bool NetworkSearchHandler::InitOperatorName()
297 {
298 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
299 EventFwk::MatchingSkills matchingSkills;
300 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
301 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_LOCALE_CHANGED);
302 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
303 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
304 operatorName_ = std::make_shared<OperatorName>(
305 subscriberInfo, nsm->GetNetworkSearchState(slotId_), nsm->GetSimManager(), networkSearchManager_, slotId_);
306 if (operatorName_ == nullptr) {
307 TELEPHONY_LOGE("failed to create new operatorName slotId:%{public}d", slotId_);
308 return false;
309 }
310 return true;
311 }
312
InitSettingUtils()313 bool NetworkSearchHandler::InitSettingUtils()
314 {
315 EventFwk::MatchingSkills matchingSkills;
316 matchingSkills.AddEvent(SettingUtils::COMMON_EVENT_DATA_SHARE_READY);
317 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
318 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
319 subscriberInfo.SetPermission(PERMISSION_PUBLISH_SYSTEM_EVENT);
320 SettingUtils::GetInstance()->SetCommonEventSubscribeInfo(subscriberInfo);
321 if (SettingUtils::GetInstance()->GetCommonEventSubscriber() == nullptr) {
322 TELEPHONY_LOGE("InitSettingUtils fail! slotId:%{public}d", slotId_);
323 return false;
324 }
325 return true;
326 }
327
SubscribeSystemAbility()328 void NetworkSearchHandler::SubscribeSystemAbility()
329 {
330 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
331 statusChangeListener_ = new (std::nothrow) SystemAbilityStatusChangeListener(operatorName_);
332 if (samgrProxy == nullptr || statusChangeListener_ == nullptr) {
333 TELEPHONY_LOGE("SubscribeSystemAbility samgrProxy or statusChangeListener_ is nullptr");
334 } else {
335 int32_t commonEventResult = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
336 int32_t DataShareResult = samgrProxy->SubscribeSystemAbility(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID,
337 statusChangeListener_);
338 TELEPHONY_LOGI("SubscribeSystemAbility COMMON_EVENT_SERVICE_ID result:%{public}d"
339 "DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID result:%{public}d.", commonEventResult, DataShareResult);
340 }
341 }
342
RegisterEvents()343 void NetworkSearchHandler::RegisterEvents()
344 {
345 TELEPHONY_LOGD("NetworkSearchHandler::RegisterEvents start slotId:%{public}d", slotId_);
346 // Register SIM
347 {
348 std::shared_ptr<ISimManager> simManager = simManager_.lock();
349 if (simManager != nullptr) {
350 simManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
351 simManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_IMSI_LOADED_READY);
352 simManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIM_RECORDS_LOADED);
353 }
354 }
355 // unsol RIL
356 {
357 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
358 if (telRilManager != nullptr) {
359 telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STATE_CHANGED, nullptr);
360 telRilManager->RegisterCoreNotify(
361 slotId_, shared_from_this(), RadioEvent::RADIO_SIGNAL_STRENGTH_UPDATE, nullptr);
362 telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_NETWORK_STATE, nullptr);
363 telRilManager->RegisterCoreNotify(
364 slotId_, shared_from_this(), RadioEvent::RADIO_NETWORK_TIME_UPDATE, nullptr);
365 telRilManager->RegisterCoreNotify(
366 slotId_, shared_from_this(), RadioEvent::RADIO_CHANNEL_CONFIG_UPDATE, nullptr);
367 telRilManager->RegisterCoreNotify(
368 slotId_, shared_from_this(), RadioEvent::RADIO_VOICE_TECH_CHANGED, nullptr);
369 telRilManager->RegisterCoreNotify(
370 slotId_, shared_from_this(), RadioEvent::RADIO_CURRENT_CELL_UPDATE, nullptr);
371 telRilManager->RegisterCoreNotify(
372 slotId_, shared_from_this(), RadioEvent::RADIO_RRC_CONNECTION_STATE_UPDATE, nullptr);
373 telRilManager->RegisterCoreNotify(
374 slotId_, shared_from_this(), RadioEvent::RADIO_RESIDENT_NETWORK_CHANGE, nullptr);
375 }
376 }
377 {
378 if (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED)) {
379 std::shared_ptr<SatelliteServiceClient> satelliteClient =
380 DelayedSingleton<SatelliteServiceClient>::GetInstance();
381 satelliteClient->AddNetworkHandler(slotId_, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
382 }
383 }
384 // Register IMS
385 {
386 std::shared_ptr<ImsCoreServiceClient> imsCoreServiceClient =
387 DelayedSingleton<ImsCoreServiceClient>::GetInstance();
388 if (imsCoreServiceClient != nullptr) {
389 imsCoreServiceClient->RegisterImsCoreServiceCallbackHandler(slotId_, shared_from_this());
390 }
391 }
392 }
393
RegisterSatelliteCallback()394 void NetworkSearchHandler::RegisterSatelliteCallback()
395 {
396 if (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED)) {
397 satelliteCallback_ =
398 std::make_unique<SatelliteCoreCallback>(std::static_pointer_cast<TelEventHandler>(shared_from_this()))
399 .release();
400 std::shared_ptr<SatelliteServiceClient> satelliteClient =
401 DelayedSingleton<SatelliteServiceClient>::GetInstance();
402 satelliteClient->RegisterCoreNotify(slotId_, RadioEvent::RADIO_SET_STATUS, satelliteCallback_);
403 satelliteClient->RegisterCoreNotify(slotId_, RadioEvent::RADIO_STATE_CHANGED, satelliteCallback_);
404 satelliteClient->RegisterCoreNotify(slotId_, RadioEvent::SATELLITE_STATUS_CHANGED, satelliteCallback_);
405 }
406 }
407
UnregisterSatelliteCallback()408 void NetworkSearchHandler::UnregisterSatelliteCallback()
409 {
410 if (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED)) {
411 satelliteCallback_ = nullptr;
412 }
413 }
414
UnregisterEvents()415 void NetworkSearchHandler::UnregisterEvents()
416 {
417 {
418 std::shared_ptr<ISimManager> simManager = simManager_.lock();
419 if (simManager != nullptr) {
420 simManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
421 simManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_IMSI_LOADED_READY);
422 simManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIM_RECORDS_LOADED);
423 }
424 }
425 // unsol
426 {
427 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
428 if (telRilManager != nullptr) {
429 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STATE_CHANGED);
430 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIGNAL_STRENGTH_UPDATE);
431 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_NETWORK_STATE);
432 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_NETWORK_TIME_UPDATE);
433 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_CHANNEL_CONFIG_UPDATE);
434 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_VOICE_TECH_CHANGED);
435 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_CURRENT_CELL_UPDATE);
436 telRilManager->UnRegisterCoreNotify(
437 slotId_, shared_from_this(), RadioEvent::RADIO_RRC_CONNECTION_STATE_UPDATE);
438 telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_RESIDENT_NETWORK_CHANGE);
439 }
440 }
441 if (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED) &&
442 satelliteCallback_ != nullptr) {
443 std::shared_ptr<SatelliteServiceClient> satelliteClient =
444 DelayedSingleton<SatelliteServiceClient>::GetInstance();
445 satelliteClient->UnRegisterCoreNotify(slotId_, RadioEvent::RADIO_STATE_CHANGED);
446 satelliteClient->UnRegisterCoreNotify(slotId_, RadioEvent::RADIO_SET_STATUS);
447 satelliteClient->UnRegisterCoreNotify(slotId_, RadioEvent::SATELLITE_STATUS_CHANGED);
448 }
449 }
450
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)451 void NetworkSearchHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
452 {
453 if (event == nullptr) {
454 return;
455 }
456 auto msgType = event->GetInnerEventId();
457 TELEPHONY_LOGD(
458 "NetworkSearchHandler::ProcessEvent received event slotId:%{public}d msgType:%{public}d", slotId_, msgType);
459 auto itFunc = memberFuncMap_.find(static_cast<RadioEvent>(msgType));
460 if (itFunc != memberFuncMap_.end()) {
461 auto memberFunc = itFunc->second;
462 if (memberFunc != nullptr) {
463 memberFunc(this, event);
464 }
465 }
466 }
467
SimStateChange(const AppExecFwk::InnerEvent::Pointer &)468 void NetworkSearchHandler::SimStateChange(const AppExecFwk::InnerEvent::Pointer &)
469 {
470 std::shared_ptr<ISimManager> simManager = simManager_.lock();
471 if (simManager != nullptr) {
472 simManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_IMSI_LOADED_READY);
473 simManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_SIM_RECORDS_LOADED);
474 }
475 }
476
ImsiLoadedReady(const AppExecFwk::InnerEvent::Pointer & event)477 void NetworkSearchHandler::ImsiLoadedReady(const AppExecFwk::InnerEvent::Pointer &event)
478 {
479 SendUpdateCellLocationRequest();
480 InitGetNetworkSelectionMode();
481 GetNetworkStateInfo(event);
482 }
483
SimRecordsLoaded(const AppExecFwk::InnerEvent::Pointer &)484 void NetworkSearchHandler::SimRecordsLoaded(const AppExecFwk::InnerEvent::Pointer &)
485 {
486 auto networkSearchManager = networkSearchManager_.lock();
487 if (networkSearchManager != nullptr) {
488 int32_t csRadioTech = 0;
489 int32_t psRadioTech = 0;
490 networkSearchManager->GetCsRadioTech(slotId_, csRadioTech);
491 networkSearchManager->GetPsRadioTech(slotId_, psRadioTech);
492 UpdatePhone(static_cast<RadioTech>(csRadioTech), static_cast<RadioTech>(psRadioTech));
493 }
494
495 if (operatorName_ != nullptr) {
496 operatorName_->NotifySpnChanged();
497 }
498 }
499
GetDeviceId()500 void NetworkSearchHandler::GetDeviceId()
501 {
502 auto networkSearchManager = networkSearchManager_.lock();
503 if (networkSearchManager == nullptr) {
504 TELEPHONY_LOGE("NetworkSearchHandler::GetDeviceId failed to get NetworkSearchManager");
505 return;
506 }
507 networkSearchManager->UpdateDeviceId(slotId_);
508 }
509
RadioStateChange(const AppExecFwk::InnerEvent::Pointer & event)510 void NetworkSearchHandler::RadioStateChange(const AppExecFwk::InnerEvent::Pointer &event)
511 {
512 if (event == nullptr) {
513 return;
514 }
515 std::shared_ptr<Int32Parcel> object = event->GetSharedObject<Int32Parcel>();
516 if (object == nullptr) {
517 TELEPHONY_LOGE("NetworkSearchHandler::RadioStateChange object is nullptr!");
518 return;
519 }
520 auto networkSearchManager = networkSearchManager_.lock();
521 if (networkSearchManager == nullptr) {
522 TELEPHONY_LOGE("NetworkSearchHandler::RadioStateChange failed to get NetworkSearchManager");
523 return;
524 }
525 int32_t radioState = object->data;
526 TELEPHONY_LOGI("NetworkSearchHandler::RadioState change: %{public}d, slotId: %{public}d", radioState, slotId_);
527 switch (radioState) {
528 case CORE_SERVICE_POWER_NOT_AVAILABLE:
529 case CORE_SERVICE_POWER_OFF: {
530 RadioOffOrUnavailableState(radioState);
531 break;
532 }
533 case CORE_SERVICE_POWER_ON: {
534 firstInit_ = false;
535 InitGetNetworkSelectionMode();
536 SetRadioOffWhenAirplaneIsOn();
537 SetRadioOffWhenSimDeactive();
538 RadioOnState();
539 break;
540 }
541 default:
542 TELEPHONY_LOGI("Unhandled message with number: %{public}d", radioState);
543 break;
544 }
545 if (radioState == CORE_SERVICE_POWER_ON || radioState == CORE_SERVICE_POWER_OFF) {
546 networkSearchManager->SetRadioStateValue(slotId_, (ModemPowerState)radioState);
547 auto inner = networkSearchManager->FindManagerInner(slotId_);
548 if (inner != nullptr && inner->deviceStateHandler_ != nullptr) {
549 inner->deviceStateHandler_->ProcessRadioState();
550 }
551 networkSearchManager->InitSimRadioProtocol(slotId_);
552 GetDeviceId();
553 } else {
554 networkSearchManager->SetRadioStateValue(slotId_, CORE_SERVICE_POWER_NOT_AVAILABLE);
555 }
556 if (operatorName_ != nullptr) {
557 operatorName_->NotifySpnChanged();
558 }
559 }
560
SetRadioOffWhenAirplaneIsOn()561 void NetworkSearchHandler::SetRadioOffWhenAirplaneIsOn()
562 {
563 bool isAirplaneMode = false;
564 auto networkSearchManager = networkSearchManager_.lock();
565 if (networkSearchManager == nullptr) {
566 TELEPHONY_LOGE("NetworkSearchHandler::SetRadioOffWhenAirplaneIsOn failed to get NetworkSearchManager");
567 return;
568 }
569 if (networkSearchManager->GetAirplaneMode(isAirplaneMode) == TELEPHONY_SUCCESS && isAirplaneMode) {
570 networkSearchManager->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_OFF), 0);
571 }
572 }
573
SetRadioOffWhenSimDeactive()574 void NetworkSearchHandler::SetRadioOffWhenSimDeactive()
575 {
576 auto networkSearchManager = networkSearchManager_.lock();
577 if (networkSearchManager == nullptr) {
578 TELEPHONY_LOGE("NetworkSearchHandler::SetRadioOffWhenSimDeactive failed to get NetworkSearchManager");
579 return;
580 }
581 auto simManager = networkSearchManager->GetSimManager();
582 if (simManager == nullptr) {
583 return;
584 }
585 bool hasSim = false;
586 simManager->HasSimCard(slotId_, hasSim);
587 TELEPHONY_LOGI("SetRadioOffWhenSimDeactive slotId: %{public}d, IsSetActiveSimInProgress: %{public}d, IsSimActive:"
588 " %{public}d, IsPowerOnPrimaryRadioWhenNoSim: %{public}d",
589 slotId_, simManager->IsSetActiveSimInProgress(slotId_),
590 simManager->IsSimActive(slotId_), IsPowerOnPrimaryRadioWhenNoSim());
591 if (TELEPHONY_EXT_WRAPPER.isVSimEnabled_ && TELEPHONY_EXT_WRAPPER.isVSimEnabled_()
592 && slotId_ == static_cast<int>(SimSlotType::VSIM_SLOT_ID)) {
593 TELEPHONY_LOGI("vsim not handle power Radio");
594 return;
595 }
596 if (hasSim && !IsPowerOnPrimaryRadioWhenNoSim()
597 && !simManager->IsSetActiveSimInProgress(slotId_) && !simManager->IsSimActive(slotId_)) {
598 networkSearchManager->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_OFF), 0);
599 }
600 }
601
RadioRestrictedState(const AppExecFwk::InnerEvent::Pointer & event)602 void NetworkSearchHandler::RadioRestrictedState(const AppExecFwk::InnerEvent::Pointer &event)
603 {
604 if (event == nullptr) {
605 TELEPHONY_LOGE("NetworkSearchHandler::RadioRestrictedState event is nullptr!");
606 return;
607 }
608 if (networkRegister_ != nullptr) {
609 networkRegister_->ProcessRestrictedState(event);
610 }
611 TELEPHONY_LOGD("NetworkSearchHandler::RadioRestrictedState slotId:%{public}d", slotId_);
612 }
613
RadioRilDataRegState(const AppExecFwk::InnerEvent::Pointer & event)614 void NetworkSearchHandler::RadioRilDataRegState(const AppExecFwk::InnerEvent::Pointer &event)
615 {
616 if (event == nullptr) {
617 TELEPHONY_LOGE("NetworkSearchHandler::RadioRilDataRegState event is nullptr!");
618 return;
619 }
620 auto networkSearchManager = networkSearchManager_.lock();
621 if (networkSearchManager == nullptr ||
622 networkSearchManager->GetRadioState(slotId_) == static_cast<int>(ModemPowerState::CORE_SERVICE_POWER_OFF)) {
623 TELEPHONY_LOGI("radio is power off, no need update data reg state");
624 return;
625 }
626 std::lock_guard<std::mutex> lock(mutex_);
627 psRegStatusResultInfo_ = event->GetSharedObject<PsRegStatusResultInfo>();
628 if (psRegStatusResultInfo_ == nullptr) {
629 TELEPHONY_LOGE("psRegStatusResult is nullptr slotId:%{public}d", slotId_);
630 return;
631 }
632 if (psRegStatusResultInfo_->flag != networkSearchManager->GetSerialNum(slotId_)) {
633 TELEPHONY_LOGI("Aborting outdated ps registration event slotId:%{public}d", slotId_);
634 return;
635 }
636 networkSearchManager->decMsgNum(slotId_);
637 TelRilRegStatus regStatus = psRegStatusResultInfo_->regStatus;
638 bool isEmergency = (regStatus == TelRilRegStatus::REG_MT_EMERGENCY) && isCsCapable_;
639 if (networkSearchManager->CheckIsNeedNotify(slotId_) || isEmergency) {
640 UpdateNetworkState();
641 }
642 TELEPHONY_LOGD("NetworkSearchHandler::RadioRilDataRegState slotId:%{public}d", slotId_);
643 }
644
RadioRilVoiceRegState(const AppExecFwk::InnerEvent::Pointer & event)645 void NetworkSearchHandler::RadioRilVoiceRegState(const AppExecFwk::InnerEvent::Pointer &event)
646 {
647 if (event == nullptr) {
648 TELEPHONY_LOGE("NetworkSearchHandler::RadioRilVoiceRegState event is nullptr!");
649 return;
650 }
651 auto networkSearchManager = networkSearchManager_.lock();
652 if (networkSearchManager == nullptr ||
653 networkSearchManager->GetRadioState(slotId_) == static_cast<int>(ModemPowerState::CORE_SERVICE_POWER_OFF)) {
654 TELEPHONY_LOGI("radio is power off, no need update voice reg state");
655 return;
656 }
657 std::lock_guard<std::mutex> lock(mutex_);
658 csRegStatusInfo_ = event->GetSharedObject<CsRegStatusInfo>();
659 if (csRegStatusInfo_ == nullptr) {
660 TELEPHONY_LOGE("csRegStatusResult is nullptr slotId:%{public}d", slotId_);
661 return;
662 }
663 if (csRegStatusInfo_->flag != networkSearchManager->GetSerialNum(slotId_)) {
664 TELEPHONY_LOGI("Aborting outdated cs registration event slotId:%{public}d", slotId_);
665 return;
666 }
667 networkSearchManager->decMsgNum(slotId_);
668 TelRilRegStatus regStatus = csRegStatusInfo_->regStatus;
669 bool isEmergency = (regStatus == TelRilRegStatus::REG_MT_EMERGENCY) && isCsCapable_;
670 if (networkSearchManager->CheckIsNeedNotify(slotId_) || isEmergency) {
671 UpdateNetworkState();
672 }
673 TELEPHONY_LOGD("NetworkSearchHandler::RadioRilVoiceRegState slotId:%{public}d", slotId_);
674 }
675
RadioSignalStrength(const AppExecFwk::InnerEvent::Pointer & event)676 void NetworkSearchHandler::RadioSignalStrength(const AppExecFwk::InnerEvent::Pointer &event)
677 {
678 if (event == nullptr) {
679 TELEPHONY_LOGE("NetworkSearchHandler::RadioSignalStrength event is nullptr!");
680 return;
681 }
682 auto networkSearchManager = networkSearchManager_.lock();
683 if (networkSearchManager == nullptr ||
684 networkSearchManager->GetRadioState(slotId_) == static_cast<int>(ModemPowerState::CORE_SERVICE_POWER_OFF)) {
685 TELEPHONY_LOGI("radio is power off, no need update signal strength");
686 return;
687 }
688 if (signalInfo_ != nullptr) {
689 signalInfo_->ProcessSignalIntensity(slotId_, event);
690 }
691 TELEPHONY_LOGD("NetworkSearchHandler::RadioSignalStrength slotId:%{public}d", slotId_);
692 }
693
RadioRilOperator(const AppExecFwk::InnerEvent::Pointer & event)694 void NetworkSearchHandler::RadioRilOperator(const AppExecFwk::InnerEvent::Pointer &event)
695 {
696 if (event == nullptr) {
697 TELEPHONY_LOGE("NetworkSearchHandler::RadioRilOperator event is nullptr!");
698 return;
699 }
700 auto networkSearchManager = networkSearchManager_.lock();
701 if (networkSearchManager == nullptr ||
702 networkSearchManager->GetRadioState(slotId_) == static_cast<int>(ModemPowerState::CORE_SERVICE_POWER_OFF)) {
703 TELEPHONY_LOGI("radio is power off, no need update operator info");
704 return;
705 }
706 std::lock_guard<std::mutex> lock(mutex_);
707 operatorInfoResult_ = event->GetSharedObject<OperatorInfoResult>();
708 if (operatorInfoResult_ == nullptr) {
709 TELEPHONY_LOGE("operatorInfoResult is nullptr slotId:%{public}d", slotId_);
710 return;
711 }
712 if (operatorInfoResult_->flag == networkSearchManager->GetSerialNum(slotId_)) {
713 networkSearchManager->decMsgNum(slotId_);
714 if (networkSearchManager->CheckIsNeedNotify(slotId_)) {
715 UpdateNetworkState();
716 }
717 } else if (operatorInfoResult_->flag == NetworkSearchManagerInner::SERIAL_NUMBER_EXEMPT) {
718 if (operatorName_ != nullptr) {
719 operatorName_->HandleOperatorInfo(operatorInfoResult_);
720 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
721 }
722 } else {
723 TELEPHONY_LOGI("Aborting outdated operator info event slotId:%{public}d", slotId_);
724 }
725 TELEPHONY_LOGD("NetworkSearchHandler::RadioRilOperator slotId:%{public}d", slotId_);
726 }
727
UpdateNetworkState()728 void NetworkSearchHandler::UpdateNetworkState()
729 {
730 if (networkRegister_ != nullptr) {
731 networkRegister_->ProcessPsRegister(psRegStatusResultInfo_);
732 networkRegister_->ProcessCsRegister(csRegStatusInfo_);
733 }
734 if (operatorName_ != nullptr) {
735 operatorName_->HandleOperatorInfo(operatorInfoResult_);
736 operatorName_->TrySetLongOperatorNameWithTranslation();
737 }
738 auto networkSearchManager = networkSearchManager_.lock();
739 if (networkSearchManager == nullptr) {
740 return;
741 }
742 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
743 if (networkSearchManager->GetSkipUnsolRptFlag(slotId_) && networkSearchManager->CheckIsNeedNotify(slotId_)) {
744 TELEPHONY_LOGI("Re-trigger RadioOnState slotId:%{public}d", slotId_);
745 RadioOnState();
746 networkSearchManager->SetSkipUnsolRptFlag(slotId_, false);
747 }
748 TELEPHONY_LOGI("NetworkSearchHandler::UpdateNetworkState slotId:%{public}d", slotId_);
749 }
750
GetRilSignalIntensity(bool checkTime)751 void NetworkSearchHandler::GetRilSignalIntensity(bool checkTime)
752 {
753 TELEPHONY_LOGD("NetworkSearchHandler::GetRilSignalIntensity start...... slotId:%{public}d", slotId_);
754 if (!TimeOutCheck(lastTimeSignalReq_, checkTime)) {
755 return;
756 }
757
758 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_SIGNAL_STRENGTH);
759 if (event != nullptr) {
760 event->SetOwner(shared_from_this());
761 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
762 if (telRilManager != nullptr) {
763 telRilManager->GetSignalStrength(slotId_, event);
764 }
765 }
766 }
767
GetNetworkStateInfo(const AppExecFwk::InnerEvent::Pointer &)768 void NetworkSearchHandler::GetNetworkStateInfo(const AppExecFwk::InnerEvent::Pointer &)
769 {
770 auto networkSearchManager = networkSearchManager_.lock();
771 if (networkSearchManager == nullptr) {
772 TELEPHONY_LOGE("failed to get NetworkSearchManager RadioState slotId:%{public}d", slotId_);
773 return;
774 }
775 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
776 if (networkSearchState == nullptr) {
777 TELEPHONY_LOGE("networkSearchState is null slotId:%{public}d", slotId_);
778 return;
779 }
780
781 ModemPowerState radioState = static_cast<ModemPowerState>(networkSearchManager->GetRadioState(slotId_));
782 TELEPHONY_LOGI("NetworkSearchHandler GetRadioState : %{public}d slotId:%{public}d", radioState, slotId_);
783 switch (radioState) {
784 case CORE_SERVICE_POWER_NOT_AVAILABLE:
785 case CORE_SERVICE_POWER_OFF:
786 RadioOffOrUnavailableState(radioState);
787 break;
788 case CORE_SERVICE_POWER_ON: {
789 firstInit_ = false;
790 RadioOnState(false);
791 break;
792 }
793 default:
794 TELEPHONY_LOGI("Unhandled message with number: %{public}d slotId:%{public}d", radioState, slotId_);
795 break;
796 }
797 }
798
RadioOnWhenHasSim(std::shared_ptr<NetworkSearchManager> & networkSearchManager,int32_t radioState) const799 void NetworkSearchHandler::RadioOnWhenHasSim(std::shared_ptr<NetworkSearchManager> &networkSearchManager,
800 int32_t radioState) const
801 {
802 bool isAirplaneMode = false;
803 if (networkSearchManager->GetAirplaneMode(isAirplaneMode) != TELEPHONY_SUCCESS) {
804 TELEPHONY_LOGE("RadioOffOrUnavailableState GetAirplaneMode fail slotId: %{public}d", slotId_);
805 }
806 auto simManager = networkSearchManager->GetSimManager();
807 if (simManager == nullptr) {
808 return;
809 }
810 bool hasSim = false;
811 simManager->HasSimCard(slotId_, hasSim);
812 bool isInModem2Optimization = TELEPHONY_EXT_WRAPPER.isInModem2Optimization_ != nullptr &&
813 TELEPHONY_EXT_WRAPPER.isInModem2Optimization_(slotId_);
814 TELEPHONY_LOGI("soltid: %{public}d, IsSimActive: %{public}d, hasSim: %{public}d, isAirplaneMode: "
815 "%{public}d, IsSetActiveSimInProgress: %{public}d, IsPowerOnPrimaryRadioWhenNoSim: %{public}d"
816 "isInModem2Optimization: %{public}d",
817 slotId_, simManager->IsSimActive(slotId_), hasSim, isAirplaneMode,
818 simManager->IsSetActiveSimInProgress(slotId_), IsPowerOnPrimaryRadioWhenNoSim(), isInModem2Optimization);
819 bool hasSimAndActive =
820 (hasSim && (!simManager->IsSetActiveSimInProgress(slotId_) && simManager->IsSimActive(slotId_)));
821 bool primarySimNoSim = (!hasSim && IsPowerOnPrimaryRadioWhenNoSim());
822 if (!isAirplaneMode && (!GetDynamicPowerOffModeSwitch()) && (hasSimAndActive || primarySimNoSim) &&
823 radioState == CORE_SERVICE_POWER_OFF && !IsSatelliteOn() && !isInModem2Optimization) {
824 networkSearchManager->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
825 }
826 }
827
RadioOffOrUnavailableState(int32_t radioState) const828 void NetworkSearchHandler::RadioOffOrUnavailableState(int32_t radioState) const
829 {
830 TELEPHONY_LOGD("RadioOffOrUnavailableState enter... slotId:%{public}d", slotId_);
831 auto networkSearchManager = networkSearchManager_.lock();
832 if (networkSearchManager == nullptr) {
833 TELEPHONY_LOGE("RadioOffOrUnavailableState NetworkSearchHandler is null slotId:%{public}d", slotId_);
834 return;
835 }
836 networkSearchManager->SetResidentNetworkNumeric(slotId_, "");
837 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
838 if (networkSearchState == nullptr) {
839 TELEPHONY_LOGE("networkSearchState is null slotId:%{public}d", slotId_);
840 return;
841 }
842 networkSearchState->SetInitial();
843 RegServiceState regState = radioState == CORE_SERVICE_POWER_OFF ?
844 RegServiceState::REG_STATE_POWER_OFF : RegServiceState::REG_STATE_NO_SERVICE;
845 networkSearchState->SetNetworkState(regState, DomainType::DOMAIN_TYPE_CS);
846 networkSearchState->SetNetworkState(regState, DomainType::DOMAIN_TYPE_PS);
847 ClearSignalAndCellInfoList();
848 networkSearchState->NotifyStateChange();
849 networkSearchManager->UpdateNrOptionMode(slotId_, NrMode::NR_MODE_UNKNOWN);
850
851 if (!TELEPHONY_EXT_WRAPPER.isInEnaDisableVSim_ || !TELEPHONY_EXT_WRAPPER.isInEnaDisableVSim_()) {
852 RadioOnWhenHasSim(networkSearchManager, radioState);
853 }
854
855 sptr<NetworkSearchCallBackBase> cellularData = networkSearchManager->GetCellularDataCallBack();
856 if (cellularData) {
857 cellularData->ClearCellularDataConnections(slotId_);
858 TELEPHONY_LOGD("RadioOffOrUnavailableState ClearCellularDataConnections");
859 }
860 sptr<NetworkSearchCallBackBase> cellularCall = networkSearchManager->GetCellularCallCallBack();
861 if (cellularCall) {
862 cellularCall->ClearCellularCallList(slotId_);
863 TELEPHONY_LOGD("RadioOffOrUnavailableState ClearCellularCallList");
864 }
865 }
866
RadioOnState(bool forceNotify)867 void NetworkSearchHandler::RadioOnState(bool forceNotify)
868 {
869 auto networkSearchManager = networkSearchManager_.lock();
870 int64_t serialNum = NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT;
871 if (networkSearchManager != nullptr) {
872 if (!networkSearchManager->CheckIsNeedNotify(slotId_) && !forceNotify) {
873 networkSearchManager->SetSkipUnsolRptFlag(slotId_, true);
874 TELEPHONY_LOGI("Last request not finish slotId:%{public}d", slotId_);
875 return;
876 }
877 networkSearchManager->InitMsgNum(slotId_);
878 serialNum = networkSearchManager->IncreaseSerialNum(slotId_);
879 if (serialNum == NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT) {
880 TELEPHONY_LOGE("Invalid serial number slotId:%{public}d", slotId_);
881 return;
882 }
883 }
884 GetRilOperatorInfo(serialNum, false);
885 GetRilPsRegistration(serialNum, false);
886 GetRilCsRegistration(serialNum, false);
887 SendUpdateCellLocationRequest();
888 GetRilSignalIntensity(false);
889 }
890
GetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer & event)891 void NetworkSearchHandler::GetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer &event)
892 {
893 if (event == nullptr) {
894 TELEPHONY_LOGE("NetworkSearchHandler::GetRadioStateResponse event is nullptr!");
895 return;
896 }
897 if (radioInfo_ == nullptr) {
898 TELEPHONY_LOGE("RadioInfo is null slotId:%{public}d", slotId_);
899 return;
900 }
901 radioInfo_->ProcessGetRadioState(event);
902 }
903
SetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer & event)904 void NetworkSearchHandler::SetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer &event)
905 {
906 if (event == nullptr) {
907 TELEPHONY_LOGE("NetworkSearchHandler::SetRadioStateResponse event is nullptr!");
908 return;
909 }
910 if (radioInfo_ == nullptr) {
911 TELEPHONY_LOGE("RadioInfo is null slotId:%{public}d", slotId_);
912 return;
913 }
914 radioInfo_->ProcessSetRadioState(event);
915 }
916
GetRilOperatorInfo(int64_t serialNum,bool checkTime)917 void NetworkSearchHandler::GetRilOperatorInfo(int64_t serialNum, bool checkTime)
918 {
919 TELEPHONY_LOGD("NetworkSearchHandler::GetOperatorInfo start slotId:%{public}d", slotId_);
920 if (!TimeOutCheck(lastTimeOperatorReq_, checkTime)) {
921 return;
922 }
923
924 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_OPERATOR, serialNum);
925 if (event != nullptr) {
926 event->SetOwner(shared_from_this());
927 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
928 if (telRilManager != nullptr) {
929 telRilManager->GetOperatorInfo(slotId_, event);
930 }
931 }
932 }
933
GetRilPsRegistration(int64_t serialNum,bool checkTime)934 void NetworkSearchHandler::GetRilPsRegistration(int64_t serialNum, bool checkTime)
935 {
936 TELEPHONY_LOGD("NetworkSearchHandler::GetPsRegStatus start slotId:%{public}d", slotId_);
937 if (!TimeOutCheck(lastTimePsRegistrationReq_, checkTime)) {
938 return;
939 }
940
941 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_REG_STATE, serialNum);
942 if (event != nullptr) {
943 event->SetOwner(shared_from_this());
944 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
945 if (telRilManager != nullptr) {
946 telRilManager->GetPsRegStatus(slotId_, event);
947 }
948 }
949 }
950
InitGetNetworkSelectionMode()951 void NetworkSearchHandler::InitGetNetworkSelectionMode()
952 {
953 auto networkSearchManager = networkSearchManager_.lock();
954 if (networkSearchManager == nullptr) {
955 TELEPHONY_LOGE("InitGetNetworkSelectionMode networkSearchManager is null slotId:%{public}d", slotId_);
956 return;
957 }
958 networkSearchManager->GetNetworkSelectionMode(slotId_);
959 }
960
GetRilCsRegistration(int64_t serialNum,bool checkTime)961 void NetworkSearchHandler::GetRilCsRegistration(int64_t serialNum, bool checkTime)
962 {
963 TELEPHONY_LOGD("NetworkSearchHandler::GetCsRegStatus start slotId:%{public}d", slotId_);
964 if (!TimeOutCheck(lastTimeCsRegistrationReq_, checkTime)) {
965 return;
966 }
967
968 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_VOICE_REG_STATE, serialNum);
969 if (event != nullptr) {
970 event->SetOwner(shared_from_this());
971 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
972 if (telRilManager != nullptr) {
973 telRilManager->GetCsRegStatus(slotId_, event);
974 }
975 }
976 }
977
NetworkSearchResult(const AppExecFwk::InnerEvent::Pointer & event)978 void NetworkSearchHandler::NetworkSearchResult(const AppExecFwk::InnerEvent::Pointer &event)
979 {
980 if (event == nullptr) {
981 TELEPHONY_LOGE("NetworkSearchHandler::NetworkSearchResult event is nullptr!");
982 return;
983 }
984 if (networkSelection_ == nullptr) {
985 TELEPHONY_LOGE("NetworkSearchResult NetworkSelection is null slotId:%{public}d", slotId_);
986 return;
987 }
988 networkSelection_->ProcessNetworkSearchResult(event);
989 }
990
SetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)991 void NetworkSearchHandler::SetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
992 {
993 if (event == nullptr) {
994 TELEPHONY_LOGE("NetworkSearchHandler::SetNetworkSelectionModeResponse event is nullptr!");
995 return;
996 }
997 if (networkSelection_ == nullptr) {
998 TELEPHONY_LOGE("SetNetworkSelectionModeResponse NetworkSelection is null slotId:%{public}d", slotId_);
999 return;
1000 }
1001 networkSelection_->ProcessSetNetworkSelectionMode(event);
1002 }
1003
GetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)1004 void NetworkSearchHandler::GetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
1005 {
1006 if (event == nullptr) {
1007 TELEPHONY_LOGE("NetworkSearchHandler::GetNetworkSelectionModeResponse event is nullptr!");
1008 return;
1009 }
1010 if (networkSelection_ == nullptr) {
1011 TELEPHONY_LOGE("GetNetworkSelectionModeResponse NetworkSelection is null slotId:%{public}d", slotId_);
1012 return;
1013 }
1014 networkSelection_->ProcessGetNetworkSelectionMode(event);
1015 }
1016
GetSignalInfo(std::vector<sptr<SignalInformation>> & signals)1017 void NetworkSearchHandler::GetSignalInfo(std::vector<sptr<SignalInformation>> &signals)
1018 {
1019 if (signalInfo_ != nullptr) {
1020 signalInfo_->GetSignalInfoList(signals);
1021 }
1022 }
1023
TimeOutCheck(int64_t & lastTime,bool checkTime)1024 bool NetworkSearchHandler::TimeOutCheck(int64_t &lastTime, bool checkTime)
1025 {
1026 int64_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
1027 if (!checkTime || (now - lastTime) > REQ_INTERVAL) {
1028 lastTime = now;
1029 return true;
1030 }
1031 return false;
1032 }
1033
GetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer & event)1034 void NetworkSearchHandler::GetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer &event)
1035 {
1036 if (event == nullptr) {
1037 TELEPHONY_LOGE("NetworkSearchHandler::GetPreferredNetworkResponse event is nullptr!");
1038 return;
1039 }
1040 if (networkType_ != nullptr) {
1041 networkType_->ProcessGetPreferredNetwork(event);
1042 } else {
1043 TELEPHONY_LOGE("GetPreferredNetworkResponse NetworkType is null slotId:%{public}d", slotId_);
1044 }
1045 }
1046
SetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer & event)1047 void NetworkSearchHandler::SetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer &event)
1048 {
1049 if (event == nullptr) {
1050 TELEPHONY_LOGE("NetworkSearchHandler::SetPreferredNetworkResponse event is nullptr!");
1051 return;
1052 }
1053 if (networkType_ != nullptr) {
1054 networkType_->ProcessSetPreferredNetwork(event);
1055 } else {
1056 TELEPHONY_LOGE("SetPreferredNetworkResponse NetworkType is null slotId:%{public}d", slotId_);
1057 }
1058 }
1059
RadioNitzUpdate(const AppExecFwk::InnerEvent::Pointer & event)1060 void NetworkSearchHandler::RadioNitzUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1061 {
1062 if (event == nullptr) {
1063 TELEPHONY_LOGE("NetworkSearchHandler::RadioNitzUpdate event is nullptr!");
1064 return;
1065 }
1066 if (nitzUpdate_ != nullptr) {
1067 nitzUpdate_->ProcessNitzUpdate(event);
1068 } else {
1069 TELEPHONY_LOGE("RadioNitzUpdate nitzUpdate is null slotId:%{public}d", slotId_);
1070 }
1071 }
1072
RadioGetImei(const AppExecFwk::InnerEvent::Pointer & event)1073 void NetworkSearchHandler::RadioGetImei(const AppExecFwk::InnerEvent::Pointer &event)
1074 {
1075 if (event == nullptr) {
1076 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetImei event is nullptr!");
1077 return;
1078 }
1079 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetImei start slotId:%{public}d", slotId_);
1080 if (radioInfo_ != nullptr) {
1081 radioInfo_->ProcessGetImei(event);
1082 } else {
1083 TELEPHONY_LOGE("RadioGetImei radioInfo_ is null slotId:%{public}d", slotId_);
1084 }
1085 }
1086
RadioGetImeiSv(const AppExecFwk::InnerEvent::Pointer & event)1087 void NetworkSearchHandler::RadioGetImeiSv(const AppExecFwk::InnerEvent::Pointer &event)
1088 {
1089 if (event == nullptr) {
1090 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetImeiSv event is nullptr!");
1091 return;
1092 }
1093 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetImeiSv start slotId:%{public}d", slotId_);
1094 if (radioInfo_ != nullptr) {
1095 radioInfo_->ProcessGetImeiSv(event);
1096 } else {
1097 TELEPHONY_LOGE("RadioGetImeiSv radioInfo_ is null slotId:%{public}d", slotId_);
1098 }
1099 }
1100
RadioGetMeid(const AppExecFwk::InnerEvent::Pointer & event)1101 void NetworkSearchHandler::RadioGetMeid(const AppExecFwk::InnerEvent::Pointer &event)
1102 {
1103 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetMeid start slotId:%{public}d", slotId_);
1104 if (event == nullptr) {
1105 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetMeid event is nullptr!");
1106 return;
1107 }
1108 if (radioInfo_ != nullptr) {
1109 radioInfo_->ProcessGetMeid(event);
1110 } else {
1111 TELEPHONY_LOGE("RadioGetMeid radioInfo_ is null slotId:%{public}d", slotId_);
1112 }
1113 }
1114
UpdatePhone(RadioTech csRadioTech,const RadioTech & psRadioTech) const1115 void NetworkSearchHandler::UpdatePhone(RadioTech csRadioTech, const RadioTech &psRadioTech) const
1116 {
1117 if (radioInfo_ != nullptr) {
1118 radioInfo_->UpdatePhone(csRadioTech, psRadioTech);
1119 } else {
1120 TELEPHONY_LOGE("UpdatePhone networkType is null slotId:%{public}d", slotId_);
1121 }
1122 }
1123
RadioGetCurrentCellInfo(const AppExecFwk::InnerEvent::Pointer & event)1124 void NetworkSearchHandler::RadioGetCurrentCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
1125 {
1126 if (event == nullptr) {
1127 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetCurrentCellInfo event is nullptr!");
1128 return;
1129 }
1130 if (cellInfo_ != nullptr) {
1131 cellInfo_->ProcessCurrentCellInfo(event);
1132 }
1133 }
1134
RadioCurrentCellInfoUpdate(const AppExecFwk::InnerEvent::Pointer & event)1135 void NetworkSearchHandler::RadioCurrentCellInfoUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1136 {
1137 if (event == nullptr) {
1138 TELEPHONY_LOGE("NetworkSearchHandler::RadioCurrentCellInfoUpdate event is nullptr!");
1139 return;
1140 }
1141 if (cellInfo_ != nullptr) {
1142 cellInfo_->ProcessCurrentCellInfo(event);
1143 }
1144 }
1145
RadioGetNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer & event)1146 void NetworkSearchHandler::RadioGetNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
1147 {
1148 if (event == nullptr) {
1149 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetNeighboringCellInfo event is nullptr!");
1150 return;
1151 }
1152 if (cellInfo_ != nullptr) {
1153 cellInfo_->ProcessNeighboringCellInfo(event);
1154 }
1155 }
1156
GetCellInfoList(std::vector<sptr<CellInformation>> & cells)1157 int32_t NetworkSearchHandler::GetCellInfoList(std::vector<sptr<CellInformation>> &cells)
1158 {
1159 TELEPHONY_LOGD("NetworkSearchHandler::GetCellInfoList slotId:%{public}d", slotId_);
1160 if (cellInfo_ != nullptr) {
1161 cellInfo_->GetCellInfoList(cells);
1162 return TELEPHONY_ERR_SUCCESS;
1163 }
1164 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1165 }
1166
GetNeighboringCellInfoList(std::vector<sptr<CellInformation>> & cells)1167 int32_t NetworkSearchHandler::GetNeighboringCellInfoList(std::vector<sptr<CellInformation>> &cells)
1168 {
1169 TELEPHONY_LOGD("NetworkSearchHandler::GetNeighboringCellInfoList slotId:%{public}d", slotId_);
1170 if (cellInfo_ != nullptr) {
1171 cellInfo_->GetNeighboringCellInfoList(cells);
1172 return TELEPHONY_ERR_SUCCESS;
1173 }
1174 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1175 }
1176
GetCellLocation()1177 sptr<CellLocation> NetworkSearchHandler::GetCellLocation()
1178 {
1179 TELEPHONY_LOGD("NetworkSearchHandler::GetCellLocation slotId:%{public}d", slotId_);
1180 if (cellInfo_ != nullptr) {
1181 return cellInfo_->GetCellLocation();
1182 }
1183 return nullptr;
1184 }
1185
TimezoneRefresh()1186 void NetworkSearchHandler::TimezoneRefresh()
1187 {
1188 TELEPHONY_LOGD("NetworkSearchHandler::TimezoneRefresh slotId:%{public}d", slotId_);
1189 if (nitzUpdate_ != nullptr) {
1190 nitzUpdate_->ProcessTimeZone();
1191 }
1192 }
1193
SendUpdateCellLocationRequest()1194 int32_t NetworkSearchHandler::SendUpdateCellLocationRequest()
1195 {
1196 std::vector<sptr<CellInformation>> cells;
1197 if (cellInfo_ != nullptr) {
1198 cellInfo_->GetCellInfoList(cells);
1199 }
1200 uint32_t curTime = static_cast<uint32_t>(time(0));
1201 if ((curTime < cellRequestMinInterval_ + lastCellRequestTime_) && cells.size() != 0) {
1202 TELEPHONY_LOGE("NetworkSearchHandler::SendUpdateCellLocationRequest interval is too short");
1203 return TELEPHONY_ERR_SUCCESS;
1204 }
1205 TELEPHONY_LOGD("NetworkSearchHandler::SendUpdateCellLocationRequest slotId:%{public}d", slotId_);
1206 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
1207 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CURRENT_CELL_INFO);
1208 if (event != nullptr && telRilManager != nullptr) {
1209 lastCellRequestTime_ = curTime;
1210 event->SetOwner(shared_from_this());
1211 telRilManager->GetCurrentCellInfo(slotId_, event);
1212 }
1213 auto event2 = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_NEIGHBORING_CELL_INFO);
1214 if (event2 != nullptr && telRilManager != nullptr) {
1215 event2->SetOwner(shared_from_this());
1216 telRilManager->GetNeighboringCellInfoList(slotId_, event2);
1217 }
1218 return TELEPHONY_ERR_SUCCESS;
1219 }
1220
UpdateCellLocation(int32_t techType,int32_t cellId,int32_t lac)1221 void NetworkSearchHandler::UpdateCellLocation(int32_t techType, int32_t cellId, int32_t lac)
1222 {
1223 TELEPHONY_LOGD("NetworkSearchHandler::UpdateCellLocation slotId:%{public}d", slotId_);
1224 if (cellInfo_ != nullptr) {
1225 cellInfo_->UpdateCellLocation(techType, cellId, lac);
1226 }
1227 }
1228
GetPhoneType()1229 PhoneType NetworkSearchHandler::GetPhoneType()
1230 {
1231 TELEPHONY_LOGD("NetworkSearchHandler::GetPhoneType");
1232 if (radioInfo_ != nullptr) {
1233 return radioInfo_->GetPhoneType();
1234 }
1235 return PhoneType::PHONE_TYPE_IS_NONE;
1236 }
1237
RadioChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer & event)1238 void NetworkSearchHandler::RadioChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer &event)
1239 {
1240 if (event == nullptr) {
1241 TELEPHONY_LOGE("NetworkSearchHandler::RadioChannelConfigInfo event is nullptr!");
1242 return;
1243 }
1244 if (networkRegister_ != nullptr) {
1245 networkRegister_->ProcessChannelConfigInfo(event);
1246 }
1247 TELEPHONY_LOGD("NetworkSearchHandler::RadioChannelConfigInfo slotId:%{public}d", slotId_);
1248 }
1249
DcPhysicalLinkActiveUpdate(const AppExecFwk::InnerEvent::Pointer & event)1250 void NetworkSearchHandler::DcPhysicalLinkActiveUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1251 {
1252 if (event == nullptr) {
1253 return;
1254 }
1255 bool isActive = (event->GetParam() == 1);
1256 if (networkRegister_ != nullptr) {
1257 networkRegister_->DcPhysicalLinkActiveUpdate(isActive);
1258 }
1259 TELEPHONY_LOGI("NetworkSearchHandler::DcPhysicalLinkActiveUpdate slotId:%{public}d active:%{public}s", slotId_,
1260 isActive ? "true" : "false");
1261 }
1262
NotifyStateChange(const AppExecFwk::InnerEvent::Pointer & event)1263 void NetworkSearchHandler::NotifyStateChange(const AppExecFwk::InnerEvent::Pointer &event)
1264 {
1265 TELEPHONY_LOGI("NetworkSearchHandler::NotifyStateChange slotId:%{public}d", slotId_);
1266 if (event == nullptr) {
1267 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange event is nullptr!");
1268 return;
1269 }
1270 if (networkRegister_ == nullptr) {
1271 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange networkRegister_ is nullptr!");
1272 return;
1273 }
1274 networkRegister_->NotifyStateChange();
1275 }
1276
HandleDelayNotifyEvent(const AppExecFwk::InnerEvent::Pointer & event)1277 void NetworkSearchHandler::HandleDelayNotifyEvent(const AppExecFwk::InnerEvent::Pointer &event)
1278 {
1279 TELEPHONY_LOGI("NetworkSearchHandler::HandleDelayNotifyEvent slotId:%{public}d", slotId_);
1280 if (event == nullptr) {
1281 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange event is nullptr!");
1282 return;
1283 }
1284 if (networkRegister_ == nullptr) {
1285 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange networkRegister_ is nullptr!");
1286 return;
1287 }
1288 RevertLastTechnology();
1289 RadioOnState();
1290 }
1291
HandleRrcStateChanged(int32_t status)1292 int32_t NetworkSearchHandler::HandleRrcStateChanged(int32_t status)
1293 {
1294 TELEPHONY_LOGI("NetworkSearchHandler::HandleRrcStateChanged slotId:%{public}d", slotId_);
1295 if (networkRegister_ == nullptr) {
1296 TELEPHONY_LOGE("NetworkSearchHandler::HandleRrcStateChanged networkRegister_ is nullptr!");
1297 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1298 }
1299 networkRegister_->HandleRrcStateChanged(status);
1300 return TELEPHONY_ERR_SUCCESS;
1301 }
1302
RevertLastTechnology()1303 int32_t NetworkSearchHandler::RevertLastTechnology()
1304 {
1305 TELEPHONY_LOGI("NetworkSearchHandler::RevertLastTechnology slotId:%{public}d", slotId_);
1306 if (networkRegister_ == nullptr) {
1307 TELEPHONY_LOGE("NetworkSearchHandler::RevertLastTechnology networkRegister_ is nullptr!");
1308 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1309 }
1310 networkRegister_->RevertLastTechnology();
1311 return TELEPHONY_ERR_SUCCESS;
1312 }
1313
UpdateImsServiceStatus(const AppExecFwk::InnerEvent::Pointer & event)1314 void NetworkSearchHandler::UpdateImsServiceStatus(const AppExecFwk::InnerEvent::Pointer &event)
1315 {
1316 auto networkSearchManager = networkSearchManager_.lock();
1317 if (event == nullptr) {
1318 TELEPHONY_LOGE("UpdateImsServiceStatus event is null slotId:%{public}d", slotId_);
1319 return;
1320 }
1321 std::shared_ptr<ImsServiceStatus> imsServiceStatus = event->GetSharedObject<ImsServiceStatus>();
1322 if (imsServiceStatus == nullptr) {
1323 TELEPHONY_LOGE("UpdateImsServiceStatus imsServiceStatus is null slotId:%{public}d", slotId_);
1324 return;
1325 }
1326 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
1327 if (networkSearchState != nullptr) {
1328 networkSearchState->SetImsServiceStatus(*imsServiceStatus);
1329 }
1330 TELEPHONY_LOGD("NetworkSearchHandler::UpdateImsServiceStatus slotId:%{public}d", slotId_);
1331 }
1332
UpdateImsRegisterState(const AppExecFwk::InnerEvent::Pointer & event)1333 void NetworkSearchHandler::UpdateImsRegisterState(const AppExecFwk::InnerEvent::Pointer &event)
1334 {
1335 auto networkSearchManager = networkSearchManager_.lock();
1336 if (event == nullptr) {
1337 TELEPHONY_LOGE("UpdateImsRegisterState event is null slotId:%{public}d", slotId_);
1338 return;
1339 }
1340 auto registerInfo = event->GetSharedObject<int32_t>();
1341 if (registerInfo == nullptr) {
1342 TELEPHONY_LOGE("UpdateImsRegisterState registerInfo is null slotId:%{public}d", slotId_);
1343 return;
1344 }
1345 bool isRegister = (*registerInfo == 1);
1346 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
1347 if (networkSearchState != nullptr) {
1348 networkSearchState->SetImsStatus(isRegister);
1349 }
1350 TELEPHONY_LOGI("NetworkSearchHandler::UpdateImsRegisterState slotId:%{public}d isRegister:%{public}s", slotId_,
1351 isRegister ? "true" : "false");
1352 }
1353
RadioGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer & event)1354 void NetworkSearchHandler::RadioGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer &event)
1355 {
1356 if (event == nullptr) {
1357 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetBasebandVersion event is nullptr!");
1358 return;
1359 }
1360 TELEPHONY_LOGD("RadioGetBasebandVersion start slotId:%{public}d", slotId_);
1361 if (radioInfo_ == nullptr) {
1362 TELEPHONY_LOGE("RadioGetBasebandVersion RadioInfo is null slotId:%{public}d", slotId_);
1363 return;
1364 }
1365 radioInfo_->ProcessGetBasebandVersion(event);
1366 }
1367
SetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)1368 void NetworkSearchHandler::SetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
1369 {
1370 if (event == nullptr) {
1371 TELEPHONY_LOGE("NetworkSearchHandler::SetNrOptionModeResponse event is nullptr!");
1372 return;
1373 }
1374 TELEPHONY_LOGD("SetNrOptionModeResponse start slotId:%{public}d", slotId_);
1375 if (radioInfo_ == nullptr) {
1376 TELEPHONY_LOGE("SetNrOptionModeResponse RadioInfo is null slotId:%{public}d", slotId_);
1377 return;
1378 }
1379 radioInfo_->ProcessSetNrOptionMode(event);
1380 }
1381
GetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)1382 void NetworkSearchHandler::GetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
1383 {
1384 if (event == nullptr) {
1385 TELEPHONY_LOGE("NetworkSearchHandler::GetNrOptionModeResponse event is nullptr!");
1386 return;
1387 }
1388 TELEPHONY_LOGD("GetNrOptionModeResponse start slotId:%{public}d", slotId_);
1389 if (radioInfo_ == nullptr) {
1390 TELEPHONY_LOGE("GetNrOptionModeResponse RadioInfo is null slotId:%{public}d", slotId_);
1391 return;
1392 }
1393 radioInfo_->ProcessGetNrOptionMode(event);
1394 }
1395
RadioGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer & event)1396 void NetworkSearchHandler::RadioGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer &event)
1397 {
1398 if (event == nullptr) {
1399 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetRrcConnectionState event is nullptr!");
1400 return;
1401 }
1402 TELEPHONY_LOGD("RadioGetRrcConnectionState start slotId:%{public}d", slotId_);
1403 if (radioInfo_ == nullptr) {
1404 TELEPHONY_LOGE("RadioGetRrcConnectionState RadioInfo is null slotId:%{public}d", slotId_);
1405 return;
1406 }
1407 radioInfo_->ProcessGetRrcConnectionState(event);
1408 }
1409
RadioVoiceTechChange(const AppExecFwk::InnerEvent::Pointer & event)1410 void NetworkSearchHandler::RadioVoiceTechChange(const AppExecFwk::InnerEvent::Pointer &event)
1411 {
1412 if (event == nullptr) {
1413 TELEPHONY_LOGE("NetworkSearchHandler::RadioVoiceTechChange event is nullptr!");
1414 return;
1415 }
1416 if (radioInfo_ != nullptr) {
1417 radioInfo_->ProcessVoiceTechChange(event);
1418 }
1419 TELEPHONY_LOGD("NetworkSearchHandler::RadioVoiceTechChange");
1420 }
1421
GetNrSsbIdResponse(const AppExecFwk::InnerEvent::Pointer & event)1422 void NetworkSearchHandler::GetNrSsbIdResponse(const AppExecFwk::InnerEvent::Pointer &event)
1423 {
1424 TELEPHONY_LOGD("Start slotId:%{public}d", slotId_);
1425 if (event == nullptr) {
1426 TELEPHONY_LOGE("Event is nullptr!");
1427 return;
1428 }
1429 if (nrSsbInfo_ == nullptr) {
1430 TELEPHONY_LOGE("NrSsbInfo is null");
1431 return;
1432 }
1433 if (nrSsbInfo_->ProcessGetNrSsbId(event)) {
1434 SyncGetSsbInfoResponse();
1435 }
1436 }
1437
SyncGetSsbInfoResponse()1438 void NetworkSearchHandler::SyncGetSsbInfoResponse()
1439 {
1440 std::unique_lock<std::mutex> lck(NetworkSearchManager::ctx_);
1441 NetworkSearchManager::ssbResponseReady_ = true;
1442 TELEPHONY_LOGD("ssbResponseReady_ = %{public}d", NetworkSearchManager::ssbResponseReady_);
1443 NetworkSearchManager::cv_.notify_one();
1444 }
1445
GetNrSsbId(const std::shared_ptr<NrSsbInformation> & nrCellSsbIdsInfo)1446 int32_t NetworkSearchHandler::GetNrSsbId(const std::shared_ptr<NrSsbInformation> &nrCellSsbIdsInfo)
1447 {
1448 TELEPHONY_LOGI("SlotId:%{public}d", slotId_);
1449 if (nrSsbInfo_ != nullptr) {
1450 if (nrSsbInfo_->FillNrSsbIdInformation(nrCellSsbIdsInfo)) {
1451 return TELEPHONY_ERR_SUCCESS;
1452 }
1453 }
1454 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1455 }
1456
AutoTimeChange(const AppExecFwk::InnerEvent::Pointer &)1457 void NetworkSearchHandler::AutoTimeChange(const AppExecFwk::InnerEvent::Pointer &)
1458 {
1459 TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeChange");
1460 if (nitzUpdate_ != nullptr) {
1461 nitzUpdate_->AutoTimeChange();
1462 }
1463 }
1464
AutoTimeZoneChange(const AppExecFwk::InnerEvent::Pointer &)1465 void NetworkSearchHandler::AutoTimeZoneChange(const AppExecFwk::InnerEvent::Pointer &)
1466 {
1467 TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeZoneChange");
1468 if (nitzUpdate_ != nullptr) {
1469 nitzUpdate_->AutoTimeZoneChange();
1470 }
1471 }
1472
AirplaneModeChange(const AppExecFwk::InnerEvent::Pointer &)1473 void NetworkSearchHandler::AirplaneModeChange(const AppExecFwk::InnerEvent::Pointer &)
1474 {
1475 TELEPHONY_LOGD("NetworkSearchHandler::AirplaneModeChange");
1476 if (radioInfo_ != nullptr) {
1477 radioInfo_->AirplaneModeChange();
1478 }
1479 }
1480
RadioResidentNetworkChange(const AppExecFwk::InnerEvent::Pointer & event)1481 void NetworkSearchHandler::RadioResidentNetworkChange(const AppExecFwk::InnerEvent::Pointer &event)
1482 {
1483 if (event == nullptr) {
1484 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange event is nullptr!");
1485 return;
1486 }
1487 auto networkSearchManager = networkSearchManager_.lock();
1488 if (networkSearchManager == nullptr) {
1489 TELEPHONY_LOGE("RadioResidentNetworkChange networkSearchManager is nullptr");
1490 return;
1491 }
1492 auto object = event->GetSharedObject<std::string>();
1493 if (object == nullptr) {
1494 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange object is nullptr!");
1495 networkSearchManager->SetResidentNetworkNumeric(slotId_, "");
1496 return;
1497 }
1498 std::string plmn = *object;
1499 networkSearchManager->SetResidentNetworkNumeric(slotId_, plmn);
1500 if (TELEPHONY_EXT_WRAPPER.updatePlmnExt_ != nullptr) {
1501 TELEPHONY_EXT_WRAPPER.updatePlmnExt_(slotId_, plmn);
1502 }
1503 if (CheckRegistrationState(networkSearchManager)) {
1504 TELEPHONY_LOGE("RadioResidentNetworkChange RegState is in service");
1505 return;
1506 }
1507 std::string countryCode = "";
1508 if (plmn.length() >= MCC_LEN) {
1509 std::string mcc = plmn.substr(0, MCC_LEN);
1510 int32_t value = 0;
1511 if (StrToInt(mcc, value)) {
1512 countryCode = MccPool::MccCountryCode(value);
1513 } else {
1514 TELEPHONY_LOGE("RadioResidentNetworkChange parse Failed!! slotId:%{public}d", slotId_);
1515 }
1516 }
1517 if (countryCode.empty()) {
1518 TELEPHONY_LOGE("RadioResidentNetworkChange countryCode is empty");
1519 return;
1520 }
1521 TELEPHONY_LOGI("RadioResidentNetworkChange: update countryCode[%{public}s]", countryCode.c_str());
1522 if (TELEPHONY_EXT_WRAPPER.updateCountryCodeExt_ != nullptr) {
1523 TELEPHONY_EXT_WRAPPER.updateCountryCodeExt_(slotId_, countryCode.c_str());
1524 } else {
1525 if (nitzUpdate_ != nullptr) {
1526 nitzUpdate_->UpdateCountryCode(countryCode);
1527 }
1528 }
1529 }
1530
CheckRegistrationState(const std::shared_ptr<NetworkSearchManager> & networkSearchManager)1531 bool NetworkSearchHandler::CheckRegistrationState(const std::shared_ptr<NetworkSearchManager> &networkSearchManager)
1532 {
1533 if (networkSearchManager == nullptr) {
1534 TELEPHONY_LOGE("NetworkSearchHandler::CheckRegistrationState manager is nullptr!");
1535 return false;
1536 }
1537 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
1538 if (networkSearchManager->GetCsRegState(slotId) ==
1539 static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE) ||
1540 networkSearchManager->GetPsRegState(slotId) ==
1541 static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE)) {
1542 return true;
1543 }
1544 }
1545 return false;
1546 }
1547
SatelliteStatusChanged(const AppExecFwk::InnerEvent::Pointer & event)1548 void NetworkSearchHandler::SatelliteStatusChanged(const AppExecFwk::InnerEvent::Pointer &event)
1549 {
1550 if (event == nullptr) {
1551 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange event is nullptr!");
1552 return;
1553 }
1554 auto satelliteStatus = event->GetSharedObject<SatelliteStatus>();
1555 if (satelliteStatus == nullptr) {
1556 TELEPHONY_LOGE("NetworkSearchHandler::satelliteStatus is nullptr!");
1557 return;
1558 }
1559 if (satelliteStatus->mode == SATELLITE_STATUS_ON) {
1560 std::shared_ptr<SatelliteServiceClient> satelliteClient =
1561 DelayedSingleton<SatelliteServiceClient>::GetInstance();
1562 satelliteClient->SetRadioState(
1563 satelliteStatus->slotId, static_cast<int32_t>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
1564 }
1565 }
1566
SetCellRequestMinInterval(uint32_t minInterval)1567 void NetworkSearchHandler::SetCellRequestMinInterval(uint32_t minInterval)
1568 {
1569 cellRequestMinInterval_ = minInterval;
1570 }
1571
IsSatelliteSupported() const1572 int32_t NetworkSearchHandler::IsSatelliteSupported() const
1573 {
1574 char satelliteSupported[SYSPARA_SIZE] = { 0 };
1575 GetParameter(TEL_SATELLITE_SUPPORTED, SATELLITE_DEFAULT_VALUE, satelliteSupported, SYSPARA_SIZE);
1576 TELEPHONY_LOGI("satelliteSupported is %{public}s", satelliteSupported);
1577 return std::atoi(satelliteSupported);
1578 }
1579
IsSatelliteOn() const1580 bool NetworkSearchHandler::IsSatelliteOn() const
1581 {
1582 bool isSatelliteOn = CoreManagerInner::GetInstance().IsSatelliteEnabled();
1583 bool isSupportSatellite = (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED));
1584 bool isSatelliteState = isSatelliteOn && isSupportSatellite;
1585 TELEPHONY_LOGI("NetworkSearchHandler::IsSatelliteOn %{public}d", isSatelliteState);
1586 return isSatelliteState;
1587 }
1588
ClearSignalAndCellInfoList() const1589 void NetworkSearchHandler::ClearSignalAndCellInfoList() const
1590 {
1591 if (signalInfo_ != nullptr) {
1592 TELEPHONY_LOGD("reset signal info slotId: %{public}d", slotId_);
1593 signalInfo_->Reset();
1594 std::vector<sptr<SignalInformation>> signals;
1595 signalInfo_->GetSignalInfoList(signals);
1596 if (TELEPHONY_EXT_WRAPPER.sortSignalInfoListExt_ != nullptr) {
1597 TELEPHONY_EXT_WRAPPER.sortSignalInfoListExt_(slotId_, signals);
1598 }
1599 DelayedSingleton<NetworkSearchNotify>::GetInstance()->NotifySignalInfoUpdated(slotId_, signals);
1600 }
1601 if (cellInfo_ != nullptr) {
1602 cellInfo_->ClearCellInfoList();
1603 }
1604 }
1605
SystemAbilityStatusChangeListener(std::shared_ptr<OperatorName> & operatorName)1606 NetworkSearchHandler::SystemAbilityStatusChangeListener::SystemAbilityStatusChangeListener(
1607 std::shared_ptr<OperatorName> &operatorName) : opName_(operatorName)
1608 {}
1609
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1610 void NetworkSearchHandler::SystemAbilityStatusChangeListener::OnAddSystemAbility(
1611 int32_t systemAbilityId, const std::string& deviceId)
1612 {
1613 switch (systemAbilityId) {
1614 case COMMON_EVENT_SERVICE_ID: {
1615 if (opName_ == nullptr) {
1616 TELEPHONY_LOGE("OnAddSystemAbility COMMON_EVENT_SERVICE_ID opName_ is nullptr");
1617 return;
1618 }
1619 opName_->NotifySpnChanged(true);
1620 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(opName_);
1621 bool settingsResult = EventFwk::CommonEventManager::SubscribeCommonEvent(
1622 SettingUtils::GetInstance()->GetCommonEventSubscriber());
1623 TELEPHONY_LOGI("NetworkSearchHandler::OnAddSystemAbility subscribeResult = %{public}d, %{public}d",
1624 subscribeResult, settingsResult);
1625 break;
1626 }
1627 case DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID:
1628 TELEPHONY_LOGI("NetworkSearchHandler::OnAddSystemAbility DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID");
1629 SettingUtils::GetInstance()->UpdateDdsState(true);
1630 break;
1631 default:
1632 TELEPHONY_LOGE("NetworkSearchHandler::OnAddSystemAbility unknown sa id %{public}d", systemAbilityId);
1633 }
1634 }
1635
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1636 void NetworkSearchHandler::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
1637 int32_t systemAbilityId, const std::string& deviceId)
1638 {
1639 if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1640 TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1641 return;
1642 }
1643 if (opName_ == nullptr) {
1644 TELEPHONY_LOGE("OnRemoveSystemAbility COMMON_EVENT_SERVICE_ID opName_ is nullptr");
1645 return;
1646 }
1647 bool subscribeResult = CommonEventManager::UnSubscribeCommonEvent(opName_);
1648 TELEPHONY_LOGI("NetworkSearchHandler::OnRemoveSystemAbility subscribeResult = %{public}d", subscribeResult);
1649 }
1650
IsPowerOnPrimaryRadioWhenNoSim() const1651 bool NetworkSearchHandler::IsPowerOnPrimaryRadioWhenNoSim() const
1652 {
1653 TELEPHONY_LOGD("Start to check if power on primary modem's radio when sim slots are empty");
1654 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
1655 if (nsm == nullptr) {
1656 TELEPHONY_LOGE("get networkSearchManager is failed");
1657 return false;
1658 }
1659 auto simManager = nsm->GetSimManager();
1660 if (simManager == nullptr) {
1661 TELEPHONY_LOGE("get simManager failed");
1662 return false;
1663 }
1664 int32_t primarySlotId = INVALID_SLOT_ID;
1665 simManager->GetPrimarySlotId(primarySlotId);
1666 if (primarySlotId != INVALID_SLOT_ID && primarySlotId == slotId_) {
1667 TELEPHONY_LOGD("primarySlotId = %{public}d, send radio on request", primarySlotId);
1668 return true;
1669 }
1670 return false;
1671 }
1672
ProcessSignalIntensity(int32_t slotId,const Rssi & signalIntensity)1673 void NetworkSearchHandler::ProcessSignalIntensity(int32_t slotId, const Rssi &signalIntensity)
1674 {
1675 Rssi *s = const_cast<Rssi*>(&signalIntensity);
1676 if (signalInfo_ != nullptr) {
1677 signalInfo_->ProcessSignalIntensity(slotId, s);
1678 }
1679 }
1680
UpdateOperatorName()1681 void NetworkSearchHandler::UpdateOperatorName()
1682 {
1683 if (operatorName_ != nullptr) {
1684 operatorName_->NotifySpnChanged(true);
1685 }
1686 }
1687 } // namespace Telephony
1688 } // namespace OHOS
1689