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,
__anondd103d070102() 39 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
40 handler->SimStateChange(event);
41 } },
42 { RadioEvent::RADIO_IMSI_LOADED_READY,
__anondd103d070202() 43 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
44 handler->ImsiLoadedReady(event);
45 } },
46 { RadioEvent::RADIO_SIM_RECORDS_LOADED,
__anondd103d070302() 47 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
48 handler->SimRecordsLoaded(event);
49 } },
50 { RadioEvent::RADIO_STATE_CHANGED,
__anondd103d070402() 51 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
52 handler->RadioStateChange(event);
53 } },
54 { RadioEvent::RADIO_NETWORK_STATE,
__anondd103d070502() 55 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
56 handler->GetNetworkStateInfo(event);
57 } },
58 { RadioEvent::RADIO_RESTRICTED_STATE,
__anondd103d070602() 59 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
60 handler->RadioRestrictedState(event);
61 } },
62 { RadioEvent::RADIO_DATA_REG_STATE,
__anondd103d070702() 63 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
64 handler->RadioRilDataRegState(event);
65 } },
66 { RadioEvent::RADIO_VOICE_REG_STATE,
__anondd103d070802() 67 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
68 handler->RadioRilVoiceRegState(event);
69 } },
70 { RadioEvent::RADIO_GET_SIGNAL_STRENGTH,
__anondd103d070902() 71 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
72 handler->RadioSignalStrength(event);
73 } },
74 { RadioEvent::RADIO_SIGNAL_STRENGTH_UPDATE,
__anondd103d070a02() 75 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
76 handler->RadioSignalStrength(event);
77 } },
78 { RadioEvent::RADIO_OPERATOR,
__anondd103d070b02() 79 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
80 handler->RadioRilOperator(event);
81 } },
82 { RadioEvent::RADIO_NETWORK_SEARCH_RESULT,
__anondd103d070c02() 83 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
84 handler->NetworkSearchResult(event);
85 } },
86 { RadioEvent::RADIO_GET_NETWORK_SELECTION_MODE,
__anondd103d070d02() 87 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
88 handler->GetNetworkSelectionModeResponse(event);
89 } },
90 { RadioEvent::RADIO_SET_NETWORK_SELECTION_MODE,
__anondd103d070e02() 91 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
92 handler->SetNetworkSelectionModeResponse(event);
93 } },
94 { RadioEvent::RADIO_GET_STATUS,
__anondd103d070f02() 95 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
96 handler->GetRadioStateResponse(event);
97 } },
98 { RadioEvent::RADIO_SET_STATUS,
__anondd103d071002() 99 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
100 handler->SetRadioStateResponse(event);
101 } },
102 { RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE,
__anondd103d071102() 103 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
104 handler->SetPreferredNetworkResponse(event);
105 } },
106 { RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE,
__anondd103d071202() 107 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
108 handler->GetPreferredNetworkResponse(event);
109 } },
110 { RadioEvent::RADIO_NETWORK_TIME_UPDATE,
__anondd103d071302() 111 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
112 handler->RadioNitzUpdate(event);
113 } },
114 { RadioEvent::RADIO_IMS_SERVICE_STATUS_UPDATE,
__anondd103d071402() 115 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
116 handler->UpdateImsServiceStatus(event);
117 } },
118 { RadioEvent::RADIO_IMS_REGISTER_STATE_UPDATE,
__anondd103d071502() 119 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
120 handler->UpdateImsRegisterState(event);
121 } },
122 { RadioEvent::RADIO_GET_IMEI,
__anondd103d071602() 123 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
124 handler->RadioGetImei(event);
125 } },
126 { RadioEvent::RADIO_GET_IMEISV,
__anondd103d071702() 127 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
128 handler->RadioGetImeiSv(event);
129 } },
130 { RadioEvent::RADIO_GET_MEID,
__anondd103d071802() 131 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
132 handler->RadioGetMeid(event);
133 } },
134 { RadioEvent::RADIO_GET_NEIGHBORING_CELL_INFO,
__anondd103d071902() 135 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
136 handler->RadioGetNeighboringCellInfo(event);
137 } },
138 { RadioEvent::RADIO_GET_CURRENT_CELL_INFO,
__anondd103d071a02() 139 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
140 handler->RadioGetCurrentCellInfo(event);
141 } },
142 { RadioEvent::RADIO_CURRENT_CELL_UPDATE,
__anondd103d071b02() 143 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
144 handler->RadioCurrentCellInfoUpdate(event);
145 } },
146 { RadioEvent::RADIO_CHANNEL_CONFIG_UPDATE,
__anondd103d071c02() 147 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
148 handler->RadioChannelConfigInfo(event);
149 } },
150 { RadioEvent::RADIO_VOICE_TECH_CHANGED,
__anondd103d071d02() 151 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
152 handler->RadioVoiceTechChange(event);
153 } },
154 { RadioEvent::RADIO_GET_VOICE_TECH,
__anondd103d071e02() 155 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
156 handler->RadioVoiceTechChange(event);
157 } },
158 { RadioEvent::RADIO_SET_DATA_CONNECT_ACTIVE,
__anondd103d071f02() 159 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
160 handler->DcPhysicalLinkActiveUpdate(event);
161 } },
162 { RadioEvent::RADIO_GET_BASEBAND_VERSION,
__anondd103d072002() 163 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
164 handler->RadioGetBasebandVersion(event);
165 } },
166 { RadioEvent::RADIO_SET_NR_OPTION_MODE,
__anondd103d072102() 167 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
168 handler->SetNrOptionModeResponse(event);
169 } },
170 { RadioEvent::RADIO_GET_NR_OPTION_MODE,
__anondd103d072202() 171 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
172 handler->GetNrOptionModeResponse(event);
173 } },
174 { RadioEvent::RADIO_GET_RRC_CONNECTION_STATE,
__anondd103d072302() 175 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
176 handler->RadioGetRrcConnectionState(event);
177 } },
178 { RadioEvent::RADIO_RRC_CONNECTION_STATE_UPDATE,
__anondd103d072402() 179 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
180 handler->RadioGetRrcConnectionState(event);
181 } },
182 { RadioEvent::NOTIFY_STATE_CHANGE,
__anondd103d072502() 183 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
184 handler->NotifyStateChange(event);
185 } },
186 { RadioEvent::DELAY_NOTIFY_STATE_CHANGE,
__anondd103d072602() 187 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
188 handler->HandleDelayNotifyEvent(event);
189 } },
190 { RadioEvent::RADIO_RESIDENT_NETWORK_CHANGE,
__anondd103d072702() 191 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
192 handler->RadioResidentNetworkChange(event);
193 } },
194 { RadioEvent::RADIO_GET_NR_SSBID_INFO,
__anondd103d072802() 195 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
196 handler->GetNrSsbIdResponse(event);
197 } },
198 { SettingEventCode::MSG_AUTO_TIME,
__anondd103d072902() 199 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
200 handler->AutoTimeChange(event);
201 } },
202 { SettingEventCode::MSG_AUTO_TIMEZONE,
__anondd103d072a02() 203 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
204 handler->AutoTimeZoneChange(event);
205 } },
206 { SettingEventCode::MSG_AUTO_AIRPLANE_MODE,
__anondd103d072b02() 207 [](NetworkSearchHandler *handler, const AppExecFwk::InnerEvent::Pointer &event) {
208 handler->AirplaneModeChange(event);
209 } },
210 { RadioEvent::SATELLITE_STATUS_CHANGED,
__anondd103d072c02() 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 if (signalInfo_ != nullptr) {
683 signalInfo_->ProcessSignalIntensity(slotId_, event);
684 }
685 TELEPHONY_LOGD("NetworkSearchHandler::RadioSignalStrength slotId:%{public}d", slotId_);
686 }
687
RadioRilOperator(const AppExecFwk::InnerEvent::Pointer & event)688 void NetworkSearchHandler::RadioRilOperator(const AppExecFwk::InnerEvent::Pointer &event)
689 {
690 if (event == nullptr) {
691 TELEPHONY_LOGE("NetworkSearchHandler::RadioRilOperator event is nullptr!");
692 return;
693 }
694 auto networkSearchManager = networkSearchManager_.lock();
695 if (networkSearchManager == nullptr ||
696 networkSearchManager->GetRadioState(slotId_) == static_cast<int>(ModemPowerState::CORE_SERVICE_POWER_OFF)) {
697 TELEPHONY_LOGI("radio is power off, no need update operator info");
698 return;
699 }
700 std::lock_guard<std::mutex> lock(mutex_);
701 operatorInfoResult_ = event->GetSharedObject<OperatorInfoResult>();
702 if (operatorInfoResult_ == nullptr) {
703 TELEPHONY_LOGE("operatorInfoResult is nullptr slotId:%{public}d", slotId_);
704 return;
705 }
706 if (operatorInfoResult_->flag == networkSearchManager->GetSerialNum(slotId_)) {
707 networkSearchManager->decMsgNum(slotId_);
708 if (networkSearchManager->CheckIsNeedNotify(slotId_)) {
709 UpdateNetworkState();
710 }
711 } else if (operatorInfoResult_->flag == NetworkSearchManagerInner::SERIAL_NUMBER_EXEMPT) {
712 if (operatorName_ != nullptr) {
713 operatorName_->HandleOperatorInfo(operatorInfoResult_);
714 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
715 }
716 } else {
717 TELEPHONY_LOGI("Aborting outdated operator info event slotId:%{public}d", slotId_);
718 }
719 TELEPHONY_LOGD("NetworkSearchHandler::RadioRilOperator slotId:%{public}d", slotId_);
720 }
721
UpdateNetworkState()722 void NetworkSearchHandler::UpdateNetworkState()
723 {
724 if (networkRegister_ != nullptr) {
725 networkRegister_->ProcessPsRegister(psRegStatusResultInfo_);
726 networkRegister_->ProcessCsRegister(csRegStatusInfo_);
727 }
728 if (operatorName_ != nullptr) {
729 operatorName_->HandleOperatorInfo(operatorInfoResult_);
730 operatorName_->TrySetLongOperatorNameWithTranslation();
731 }
732 auto networkSearchManager = networkSearchManager_.lock();
733 if (networkSearchManager != nullptr) {
734 networkSearchManager->ProcessNotifyStateChangeEvent(slotId_);
735 }
736 TELEPHONY_LOGI("NetworkSearchHandler::UpdateNetworkState slotId:%{public}d", slotId_);
737 }
738
GetRilSignalIntensity(bool checkTime)739 void NetworkSearchHandler::GetRilSignalIntensity(bool checkTime)
740 {
741 TELEPHONY_LOGD("NetworkSearchHandler::GetRilSignalIntensity start...... slotId:%{public}d", slotId_);
742 if (!TimeOutCheck(lastTimeSignalReq_, checkTime)) {
743 return;
744 }
745
746 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_SIGNAL_STRENGTH);
747 if (event != nullptr) {
748 event->SetOwner(shared_from_this());
749 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
750 if (telRilManager != nullptr) {
751 telRilManager->GetSignalStrength(slotId_, event);
752 }
753 }
754 }
755
GetNetworkStateInfo(const AppExecFwk::InnerEvent::Pointer &)756 void NetworkSearchHandler::GetNetworkStateInfo(const AppExecFwk::InnerEvent::Pointer &)
757 {
758 auto networkSearchManager = networkSearchManager_.lock();
759 if (networkSearchManager == nullptr) {
760 TELEPHONY_LOGE("failed to get NetworkSearchManager RadioState slotId:%{public}d", slotId_);
761 return;
762 }
763 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
764 if (networkSearchState == nullptr) {
765 TELEPHONY_LOGE("networkSearchState is null slotId:%{public}d", slotId_);
766 return;
767 }
768
769 ModemPowerState radioState = static_cast<ModemPowerState>(networkSearchManager->GetRadioState(slotId_));
770 TELEPHONY_LOGI("NetworkSearchHandler GetRadioState : %{public}d slotId:%{public}d", radioState, slotId_);
771 switch (radioState) {
772 case CORE_SERVICE_POWER_NOT_AVAILABLE:
773 case CORE_SERVICE_POWER_OFF:
774 RadioOffOrUnavailableState(radioState);
775 break;
776 case CORE_SERVICE_POWER_ON: {
777 firstInit_ = false;
778 RadioOnState();
779 break;
780 }
781 default:
782 TELEPHONY_LOGI("Unhandled message with number: %{public}d slotId:%{public}d", radioState, slotId_);
783 break;
784 }
785 }
786
RadioOnWhenHasSim(std::shared_ptr<NetworkSearchManager> & networkSearchManager,int32_t radioState) const787 void NetworkSearchHandler::RadioOnWhenHasSim(std::shared_ptr<NetworkSearchManager> &networkSearchManager,
788 int32_t radioState) const
789 {
790 bool isAirplaneMode = false;
791 if (networkSearchManager->GetAirplaneMode(isAirplaneMode) != TELEPHONY_SUCCESS) {
792 TELEPHONY_LOGE("RadioOffOrUnavailableState GetAirplaneMode fail slotId: %{public}d", slotId_);
793 }
794 auto simManager = networkSearchManager->GetSimManager();
795 if (simManager == nullptr) {
796 return;
797 }
798 bool hasSim = false;
799 simManager->HasSimCard(slotId_, hasSim);
800 TELEPHONY_LOGI("soltid: %{public}d, IsSimActive: %{public}d, hasSim: %{public}d, isAirplaneMode: "
801 "%{public}d, IsSetActiveSimInProgress: %{public}d, IsPowerOnPrimaryRadioWhenNoSim: %{public}d",
802 slotId_, simManager->IsSimActive(slotId_), hasSim, isAirplaneMode,
803 simManager->IsSetActiveSimInProgress(slotId_), IsPowerOnPrimaryRadioWhenNoSim());
804 bool hasSimAndActive =
805 (hasSim && (!simManager->IsSetActiveSimInProgress(slotId_) && simManager->IsSimActive(slotId_)));
806 bool primarySimNoSim = (!hasSim && IsPowerOnPrimaryRadioWhenNoSim());
807 if (!isAirplaneMode && (!GetDynamicPowerOffModeSwitch()) && (hasSimAndActive || primarySimNoSim)
808 && radioState == CORE_SERVICE_POWER_OFF && !IsSatelliteOn()) {
809 networkSearchManager->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
810 }
811 }
812
RadioOffOrUnavailableState(int32_t radioState) const813 void NetworkSearchHandler::RadioOffOrUnavailableState(int32_t radioState) const
814 {
815 TELEPHONY_LOGD("RadioOffOrUnavailableState enter... slotId:%{public}d", slotId_);
816 auto networkSearchManager = networkSearchManager_.lock();
817 if (networkSearchManager == nullptr) {
818 TELEPHONY_LOGE("RadioOffOrUnavailableState NetworkSearchHandler is null slotId:%{public}d", slotId_);
819 return;
820 }
821 networkSearchManager->SetResidentNetworkNumeric(slotId_, "");
822 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
823 if (networkSearchState == nullptr) {
824 TELEPHONY_LOGE("networkSearchState is null slotId:%{public}d", slotId_);
825 return;
826 }
827 networkSearchState->SetInitial();
828 RegServiceState regState = radioState == CORE_SERVICE_POWER_OFF ?
829 RegServiceState::REG_STATE_POWER_OFF : RegServiceState::REG_STATE_NO_SERVICE;
830 networkSearchState->SetNetworkState(regState, DomainType::DOMAIN_TYPE_CS);
831 networkSearchState->SetNetworkState(regState, DomainType::DOMAIN_TYPE_PS);
832 ClearSignalAndCellInfoList();
833 networkSearchState->NotifyStateChange();
834 networkSearchManager->UpdateNrOptionMode(slotId_, NrMode::NR_MODE_UNKNOWN);
835
836 if (!TELEPHONY_EXT_WRAPPER.isInEnaDisableVSim_ || !TELEPHONY_EXT_WRAPPER.isInEnaDisableVSim_()) {
837 RadioOnWhenHasSim(networkSearchManager, radioState);
838 }
839
840 sptr<NetworkSearchCallBackBase> cellularData = networkSearchManager->GetCellularDataCallBack();
841 if (cellularData) {
842 cellularData->ClearCellularDataConnections(slotId_);
843 TELEPHONY_LOGD("RadioOffOrUnavailableState ClearCellularDataConnections");
844 }
845 sptr<NetworkSearchCallBackBase> cellularCall = networkSearchManager->GetCellularCallCallBack();
846 if (cellularCall) {
847 cellularCall->ClearCellularCallList(slotId_);
848 TELEPHONY_LOGD("RadioOffOrUnavailableState ClearCellularCallList");
849 }
850 }
851
RadioOnState()852 void NetworkSearchHandler::RadioOnState()
853 {
854 auto networkSearchManager = networkSearchManager_.lock();
855 int64_t serialNum = NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT;
856 if (networkSearchManager != nullptr) {
857 networkSearchManager->InitMsgNum(slotId_);
858 serialNum = networkSearchManager->IncreaseSerialNum(slotId_);
859 if (serialNum == NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT) {
860 TELEPHONY_LOGE("Invalid serial number slotId:%{public}d", slotId_);
861 return;
862 }
863 }
864 GetRilOperatorInfo(serialNum, false);
865 GetRilPsRegistration(serialNum, false);
866 GetRilCsRegistration(serialNum, false);
867 SendUpdateCellLocationRequest();
868 GetRilSignalIntensity(false);
869 }
870
GetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer & event)871 void NetworkSearchHandler::GetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer &event)
872 {
873 if (event == nullptr) {
874 TELEPHONY_LOGE("NetworkSearchHandler::GetRadioStateResponse event is nullptr!");
875 return;
876 }
877 if (radioInfo_ == nullptr) {
878 TELEPHONY_LOGE("RadioInfo is null slotId:%{public}d", slotId_);
879 return;
880 }
881 radioInfo_->ProcessGetRadioState(event);
882 }
883
SetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer & event)884 void NetworkSearchHandler::SetRadioStateResponse(const AppExecFwk::InnerEvent::Pointer &event)
885 {
886 if (event == nullptr) {
887 TELEPHONY_LOGE("NetworkSearchHandler::SetRadioStateResponse event is nullptr!");
888 return;
889 }
890 if (radioInfo_ == nullptr) {
891 TELEPHONY_LOGE("RadioInfo is null slotId:%{public}d", slotId_);
892 return;
893 }
894 radioInfo_->ProcessSetRadioState(event);
895 }
896
GetRilOperatorInfo(int64_t serialNum,bool checkTime)897 void NetworkSearchHandler::GetRilOperatorInfo(int64_t serialNum, bool checkTime)
898 {
899 TELEPHONY_LOGD("NetworkSearchHandler::GetOperatorInfo start slotId:%{public}d", slotId_);
900 if (!TimeOutCheck(lastTimeOperatorReq_, checkTime)) {
901 return;
902 }
903
904 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_OPERATOR, serialNum);
905 if (event != nullptr) {
906 event->SetOwner(shared_from_this());
907 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
908 if (telRilManager != nullptr) {
909 telRilManager->GetOperatorInfo(slotId_, event);
910 }
911 }
912 }
913
GetRilPsRegistration(int64_t serialNum,bool checkTime)914 void NetworkSearchHandler::GetRilPsRegistration(int64_t serialNum, bool checkTime)
915 {
916 TELEPHONY_LOGD("NetworkSearchHandler::GetPsRegStatus start slotId:%{public}d", slotId_);
917 if (!TimeOutCheck(lastTimePsRegistrationReq_, checkTime)) {
918 return;
919 }
920
921 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_REG_STATE, serialNum);
922 if (event != nullptr) {
923 event->SetOwner(shared_from_this());
924 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
925 if (telRilManager != nullptr) {
926 telRilManager->GetPsRegStatus(slotId_, event);
927 }
928 }
929 }
930
InitGetNetworkSelectionMode()931 void NetworkSearchHandler::InitGetNetworkSelectionMode()
932 {
933 auto networkSearchManager = networkSearchManager_.lock();
934 if (networkSearchManager == nullptr) {
935 TELEPHONY_LOGE("InitGetNetworkSelectionMode networkSearchManager is null slotId:%{public}d", slotId_);
936 return;
937 }
938 networkSearchManager->GetNetworkSelectionMode(slotId_);
939 }
940
GetRilCsRegistration(int64_t serialNum,bool checkTime)941 void NetworkSearchHandler::GetRilCsRegistration(int64_t serialNum, bool checkTime)
942 {
943 TELEPHONY_LOGD("NetworkSearchHandler::GetCsRegStatus start slotId:%{public}d", slotId_);
944 if (!TimeOutCheck(lastTimeCsRegistrationReq_, checkTime)) {
945 return;
946 }
947
948 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_VOICE_REG_STATE, serialNum);
949 if (event != nullptr) {
950 event->SetOwner(shared_from_this());
951 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
952 if (telRilManager != nullptr) {
953 telRilManager->GetCsRegStatus(slotId_, event);
954 }
955 }
956 }
957
NetworkSearchResult(const AppExecFwk::InnerEvent::Pointer & event)958 void NetworkSearchHandler::NetworkSearchResult(const AppExecFwk::InnerEvent::Pointer &event)
959 {
960 if (event == nullptr) {
961 TELEPHONY_LOGE("NetworkSearchHandler::NetworkSearchResult event is nullptr!");
962 return;
963 }
964 if (networkSelection_ == nullptr) {
965 TELEPHONY_LOGE("NetworkSearchResult NetworkSelection is null slotId:%{public}d", slotId_);
966 return;
967 }
968 networkSelection_->ProcessNetworkSearchResult(event);
969 }
970
SetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)971 void NetworkSearchHandler::SetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
972 {
973 if (event == nullptr) {
974 TELEPHONY_LOGE("NetworkSearchHandler::SetNetworkSelectionModeResponse event is nullptr!");
975 return;
976 }
977 if (networkSelection_ == nullptr) {
978 TELEPHONY_LOGE("SetNetworkSelectionModeResponse NetworkSelection is null slotId:%{public}d", slotId_);
979 return;
980 }
981 networkSelection_->ProcessSetNetworkSelectionMode(event);
982 }
983
GetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)984 void NetworkSearchHandler::GetNetworkSelectionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
985 {
986 if (event == nullptr) {
987 TELEPHONY_LOGE("NetworkSearchHandler::GetNetworkSelectionModeResponse event is nullptr!");
988 return;
989 }
990 if (networkSelection_ == nullptr) {
991 TELEPHONY_LOGE("GetNetworkSelectionModeResponse NetworkSelection is null slotId:%{public}d", slotId_);
992 return;
993 }
994 networkSelection_->ProcessGetNetworkSelectionMode(event);
995 }
996
GetSignalInfo(std::vector<sptr<SignalInformation>> & signals)997 void NetworkSearchHandler::GetSignalInfo(std::vector<sptr<SignalInformation>> &signals)
998 {
999 if (signalInfo_ != nullptr) {
1000 signalInfo_->GetSignalInfoList(signals);
1001 }
1002 }
1003
TimeOutCheck(int64_t & lastTime,bool checkTime)1004 bool NetworkSearchHandler::TimeOutCheck(int64_t &lastTime, bool checkTime)
1005 {
1006 int64_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
1007 if (!checkTime || (now - lastTime) > REQ_INTERVAL) {
1008 lastTime = now;
1009 return true;
1010 }
1011 return false;
1012 }
1013
GetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer & event)1014 void NetworkSearchHandler::GetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer &event)
1015 {
1016 if (event == nullptr) {
1017 TELEPHONY_LOGE("NetworkSearchHandler::GetPreferredNetworkResponse event is nullptr!");
1018 return;
1019 }
1020 if (networkType_ != nullptr) {
1021 networkType_->ProcessGetPreferredNetwork(event);
1022 } else {
1023 TELEPHONY_LOGE("GetPreferredNetworkResponse NetworkType is null slotId:%{public}d", slotId_);
1024 }
1025 }
1026
SetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer & event)1027 void NetworkSearchHandler::SetPreferredNetworkResponse(const AppExecFwk::InnerEvent::Pointer &event)
1028 {
1029 if (event == nullptr) {
1030 TELEPHONY_LOGE("NetworkSearchHandler::SetPreferredNetworkResponse event is nullptr!");
1031 return;
1032 }
1033 if (networkType_ != nullptr) {
1034 networkType_->ProcessSetPreferredNetwork(event);
1035 } else {
1036 TELEPHONY_LOGE("SetPreferredNetworkResponse NetworkType is null slotId:%{public}d", slotId_);
1037 }
1038 }
1039
RadioNitzUpdate(const AppExecFwk::InnerEvent::Pointer & event)1040 void NetworkSearchHandler::RadioNitzUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1041 {
1042 if (event == nullptr) {
1043 TELEPHONY_LOGE("NetworkSearchHandler::RadioNitzUpdate event is nullptr!");
1044 return;
1045 }
1046 if (nitzUpdate_ != nullptr) {
1047 nitzUpdate_->ProcessNitzUpdate(event);
1048 } else {
1049 TELEPHONY_LOGE("RadioNitzUpdate nitzUpdate is null slotId:%{public}d", slotId_);
1050 }
1051 }
1052
RadioGetImei(const AppExecFwk::InnerEvent::Pointer & event)1053 void NetworkSearchHandler::RadioGetImei(const AppExecFwk::InnerEvent::Pointer &event)
1054 {
1055 if (event == nullptr) {
1056 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetImei event is nullptr!");
1057 return;
1058 }
1059 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetImei start slotId:%{public}d", slotId_);
1060 if (radioInfo_ != nullptr) {
1061 radioInfo_->ProcessGetImei(event);
1062 } else {
1063 TELEPHONY_LOGE("RadioGetImei radioInfo_ is null slotId:%{public}d", slotId_);
1064 }
1065 }
1066
RadioGetImeiSv(const AppExecFwk::InnerEvent::Pointer & event)1067 void NetworkSearchHandler::RadioGetImeiSv(const AppExecFwk::InnerEvent::Pointer &event)
1068 {
1069 if (event == nullptr) {
1070 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetImeiSv event is nullptr!");
1071 return;
1072 }
1073 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetImeiSv start slotId:%{public}d", slotId_);
1074 if (radioInfo_ != nullptr) {
1075 radioInfo_->ProcessGetImeiSv(event);
1076 } else {
1077 TELEPHONY_LOGE("RadioGetImeiSv radioInfo_ is null slotId:%{public}d", slotId_);
1078 }
1079 }
1080
RadioGetMeid(const AppExecFwk::InnerEvent::Pointer & event)1081 void NetworkSearchHandler::RadioGetMeid(const AppExecFwk::InnerEvent::Pointer &event)
1082 {
1083 TELEPHONY_LOGD("NetworkSearchHandler::RadioGetMeid start slotId:%{public}d", slotId_);
1084 if (event == nullptr) {
1085 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetMeid event is nullptr!");
1086 return;
1087 }
1088 if (radioInfo_ != nullptr) {
1089 radioInfo_->ProcessGetMeid(event);
1090 } else {
1091 TELEPHONY_LOGE("RadioGetMeid radioInfo_ is null slotId:%{public}d", slotId_);
1092 }
1093 }
1094
UpdatePhone(RadioTech csRadioTech,const RadioTech & psRadioTech) const1095 void NetworkSearchHandler::UpdatePhone(RadioTech csRadioTech, const RadioTech &psRadioTech) const
1096 {
1097 if (radioInfo_ != nullptr) {
1098 radioInfo_->UpdatePhone(csRadioTech, psRadioTech);
1099 } else {
1100 TELEPHONY_LOGE("UpdatePhone networkType is null slotId:%{public}d", slotId_);
1101 }
1102 }
1103
RadioGetCurrentCellInfo(const AppExecFwk::InnerEvent::Pointer & event)1104 void NetworkSearchHandler::RadioGetCurrentCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
1105 {
1106 if (event == nullptr) {
1107 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetCurrentCellInfo event is nullptr!");
1108 return;
1109 }
1110 if (cellInfo_ != nullptr) {
1111 cellInfo_->ProcessCurrentCellInfo(event);
1112 }
1113 }
1114
RadioCurrentCellInfoUpdate(const AppExecFwk::InnerEvent::Pointer & event)1115 void NetworkSearchHandler::RadioCurrentCellInfoUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1116 {
1117 if (event == nullptr) {
1118 TELEPHONY_LOGE("NetworkSearchHandler::RadioCurrentCellInfoUpdate event is nullptr!");
1119 return;
1120 }
1121 if (cellInfo_ != nullptr) {
1122 cellInfo_->ProcessCurrentCellInfo(event);
1123 }
1124 }
1125
RadioGetNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer & event)1126 void NetworkSearchHandler::RadioGetNeighboringCellInfo(const AppExecFwk::InnerEvent::Pointer &event)
1127 {
1128 if (event == nullptr) {
1129 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetNeighboringCellInfo event is nullptr!");
1130 return;
1131 }
1132 if (cellInfo_ != nullptr) {
1133 cellInfo_->ProcessNeighboringCellInfo(event);
1134 }
1135 }
1136
GetCellInfoList(std::vector<sptr<CellInformation>> & cells)1137 int32_t NetworkSearchHandler::GetCellInfoList(std::vector<sptr<CellInformation>> &cells)
1138 {
1139 TELEPHONY_LOGD("NetworkSearchHandler::GetCellInfoList slotId:%{public}d", slotId_);
1140 if (cellInfo_ != nullptr) {
1141 cellInfo_->GetCellInfoList(cells);
1142 return TELEPHONY_ERR_SUCCESS;
1143 }
1144 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1145 }
1146
GetNeighboringCellInfoList(std::vector<sptr<CellInformation>> & cells)1147 int32_t NetworkSearchHandler::GetNeighboringCellInfoList(std::vector<sptr<CellInformation>> &cells)
1148 {
1149 TELEPHONY_LOGD("NetworkSearchHandler::GetNeighboringCellInfoList slotId:%{public}d", slotId_);
1150 if (cellInfo_ != nullptr) {
1151 cellInfo_->GetNeighboringCellInfoList(cells);
1152 return TELEPHONY_ERR_SUCCESS;
1153 }
1154 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1155 }
1156
GetCellLocation()1157 sptr<CellLocation> NetworkSearchHandler::GetCellLocation()
1158 {
1159 TELEPHONY_LOGD("NetworkSearchHandler::GetCellLocation slotId:%{public}d", slotId_);
1160 if (cellInfo_ != nullptr) {
1161 return cellInfo_->GetCellLocation();
1162 }
1163 return nullptr;
1164 }
1165
TimezoneRefresh()1166 void NetworkSearchHandler::TimezoneRefresh()
1167 {
1168 TELEPHONY_LOGD("NetworkSearchHandler::TimezoneRefresh slotId:%{public}d", slotId_);
1169 if (nitzUpdate_ != nullptr) {
1170 nitzUpdate_->ProcessTimeZone();
1171 }
1172 }
1173
SendUpdateCellLocationRequest()1174 int32_t NetworkSearchHandler::SendUpdateCellLocationRequest()
1175 {
1176 std::vector<sptr<CellInformation>> cells;
1177 if (cellInfo_ != nullptr) {
1178 cellInfo_->GetCellInfoList(cells);
1179 }
1180 uint32_t curTime = static_cast<uint32_t>(time(0));
1181 if ((curTime < cellRequestMinInterval_ + lastCellRequestTime_) && cells.size() != 0) {
1182 TELEPHONY_LOGE("NetworkSearchHandler::SendUpdateCellLocationRequest interval is too short");
1183 return TELEPHONY_ERR_SUCCESS;
1184 }
1185 TELEPHONY_LOGD("NetworkSearchHandler::SendUpdateCellLocationRequest slotId:%{public}d", slotId_);
1186 std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
1187 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_CURRENT_CELL_INFO);
1188 if (event != nullptr && telRilManager != nullptr) {
1189 lastCellRequestTime_ = curTime;
1190 event->SetOwner(shared_from_this());
1191 telRilManager->GetCurrentCellInfo(slotId_, event);
1192 }
1193 auto event2 = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_GET_NEIGHBORING_CELL_INFO);
1194 if (event2 != nullptr && telRilManager != nullptr) {
1195 event2->SetOwner(shared_from_this());
1196 telRilManager->GetNeighboringCellInfoList(slotId_, event2);
1197 }
1198 return TELEPHONY_ERR_SUCCESS;
1199 }
1200
UpdateCellLocation(int32_t techType,int32_t cellId,int32_t lac)1201 void NetworkSearchHandler::UpdateCellLocation(int32_t techType, int32_t cellId, int32_t lac)
1202 {
1203 TELEPHONY_LOGD("NetworkSearchHandler::UpdateCellLocation slotId:%{public}d", slotId_);
1204 if (cellInfo_ != nullptr) {
1205 cellInfo_->UpdateCellLocation(techType, cellId, lac);
1206 }
1207 }
1208
GetPhoneType()1209 PhoneType NetworkSearchHandler::GetPhoneType()
1210 {
1211 TELEPHONY_LOGD("NetworkSearchHandler::GetPhoneType");
1212 if (radioInfo_ != nullptr) {
1213 return radioInfo_->GetPhoneType();
1214 }
1215 return PhoneType::PHONE_TYPE_IS_NONE;
1216 }
1217
RadioChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer & event)1218 void NetworkSearchHandler::RadioChannelConfigInfo(const AppExecFwk::InnerEvent::Pointer &event)
1219 {
1220 if (event == nullptr) {
1221 TELEPHONY_LOGE("NetworkSearchHandler::RadioChannelConfigInfo event is nullptr!");
1222 return;
1223 }
1224 if (networkRegister_ != nullptr) {
1225 networkRegister_->ProcessChannelConfigInfo(event);
1226 }
1227 TELEPHONY_LOGD("NetworkSearchHandler::RadioChannelConfigInfo slotId:%{public}d", slotId_);
1228 }
1229
DcPhysicalLinkActiveUpdate(const AppExecFwk::InnerEvent::Pointer & event)1230 void NetworkSearchHandler::DcPhysicalLinkActiveUpdate(const AppExecFwk::InnerEvent::Pointer &event)
1231 {
1232 if (event == nullptr) {
1233 return;
1234 }
1235 bool isActive = (event->GetParam() == 1);
1236 if (networkRegister_ != nullptr) {
1237 networkRegister_->DcPhysicalLinkActiveUpdate(isActive);
1238 }
1239 TELEPHONY_LOGI("NetworkSearchHandler::DcPhysicalLinkActiveUpdate slotId:%{public}d active:%{public}s", slotId_,
1240 isActive ? "true" : "false");
1241 }
1242
NotifyStateChange(const AppExecFwk::InnerEvent::Pointer & event)1243 void NetworkSearchHandler::NotifyStateChange(const AppExecFwk::InnerEvent::Pointer &event)
1244 {
1245 TELEPHONY_LOGI("NetworkSearchHandler::NotifyStateChange slotId:%{public}d", slotId_);
1246 if (event == nullptr) {
1247 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange event is nullptr!");
1248 return;
1249 }
1250 if (networkRegister_ == nullptr) {
1251 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange networkRegister_ is nullptr!");
1252 return;
1253 }
1254 networkRegister_->NotifyStateChange();
1255 }
1256
HandleDelayNotifyEvent(const AppExecFwk::InnerEvent::Pointer & event)1257 void NetworkSearchHandler::HandleDelayNotifyEvent(const AppExecFwk::InnerEvent::Pointer &event)
1258 {
1259 TELEPHONY_LOGI("NetworkSearchHandler::HandleDelayNotifyEvent slotId:%{public}d", slotId_);
1260 if (event == nullptr) {
1261 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange event is nullptr!");
1262 return;
1263 }
1264 if (networkRegister_ == nullptr) {
1265 TELEPHONY_LOGE("NetworkSearchHandler::NotifyStateChange networkRegister_ is nullptr!");
1266 return;
1267 }
1268 RevertLastTechnology();
1269 RadioOnState();
1270 }
1271
HandleRrcStateChanged(int32_t status)1272 int32_t NetworkSearchHandler::HandleRrcStateChanged(int32_t status)
1273 {
1274 TELEPHONY_LOGI("NetworkSearchHandler::HandleRrcStateChanged slotId:%{public}d", slotId_);
1275 if (networkRegister_ == nullptr) {
1276 TELEPHONY_LOGE("NetworkSearchHandler::HandleRrcStateChanged networkRegister_ is nullptr!");
1277 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1278 }
1279 networkRegister_->HandleRrcStateChanged(status);
1280 return TELEPHONY_ERR_SUCCESS;
1281 }
1282
RevertLastTechnology()1283 int32_t NetworkSearchHandler::RevertLastTechnology()
1284 {
1285 TELEPHONY_LOGI("NetworkSearchHandler::RevertLastTechnology slotId:%{public}d", slotId_);
1286 if (networkRegister_ == nullptr) {
1287 TELEPHONY_LOGE("NetworkSearchHandler::RevertLastTechnology networkRegister_ is nullptr!");
1288 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1289 }
1290 networkRegister_->RevertLastTechnology();
1291 return TELEPHONY_ERR_SUCCESS;
1292 }
1293
UpdateImsServiceStatus(const AppExecFwk::InnerEvent::Pointer & event)1294 void NetworkSearchHandler::UpdateImsServiceStatus(const AppExecFwk::InnerEvent::Pointer &event)
1295 {
1296 auto networkSearchManager = networkSearchManager_.lock();
1297 if (event == nullptr) {
1298 TELEPHONY_LOGE("UpdateImsServiceStatus event is null slotId:%{public}d", slotId_);
1299 return;
1300 }
1301 std::shared_ptr<ImsServiceStatus> imsServiceStatus = event->GetSharedObject<ImsServiceStatus>();
1302 if (imsServiceStatus == nullptr) {
1303 TELEPHONY_LOGE("UpdateImsServiceStatus imsServiceStatus is null slotId:%{public}d", slotId_);
1304 return;
1305 }
1306 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
1307 if (networkSearchState != nullptr) {
1308 networkSearchState->SetImsServiceStatus(*imsServiceStatus);
1309 }
1310 TELEPHONY_LOGD("NetworkSearchHandler::UpdateImsServiceStatus slotId:%{public}d", slotId_);
1311 }
1312
UpdateImsRegisterState(const AppExecFwk::InnerEvent::Pointer & event)1313 void NetworkSearchHandler::UpdateImsRegisterState(const AppExecFwk::InnerEvent::Pointer &event)
1314 {
1315 auto networkSearchManager = networkSearchManager_.lock();
1316 if (event == nullptr) {
1317 TELEPHONY_LOGE("UpdateImsRegisterState event is null slotId:%{public}d", slotId_);
1318 return;
1319 }
1320 auto registerInfo = event->GetSharedObject<int32_t>();
1321 if (registerInfo == nullptr) {
1322 TELEPHONY_LOGE("UpdateImsRegisterState registerInfo is null slotId:%{public}d", slotId_);
1323 return;
1324 }
1325 bool isRegister = (*registerInfo == 1);
1326 std::shared_ptr<NetworkSearchState> networkSearchState = networkSearchManager->GetNetworkSearchState(slotId_);
1327 if (networkSearchState != nullptr) {
1328 networkSearchState->SetImsStatus(isRegister);
1329 }
1330 TELEPHONY_LOGI("NetworkSearchHandler::UpdateImsRegisterState slotId:%{public}d isRegister:%{public}s", slotId_,
1331 isRegister ? "true" : "false");
1332 }
1333
RadioGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer & event)1334 void NetworkSearchHandler::RadioGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer &event)
1335 {
1336 if (event == nullptr) {
1337 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetBasebandVersion event is nullptr!");
1338 return;
1339 }
1340 TELEPHONY_LOGD("RadioGetBasebandVersion start slotId:%{public}d", slotId_);
1341 if (radioInfo_ == nullptr) {
1342 TELEPHONY_LOGE("RadioGetBasebandVersion RadioInfo is null slotId:%{public}d", slotId_);
1343 return;
1344 }
1345 radioInfo_->ProcessGetBasebandVersion(event);
1346 }
1347
SetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)1348 void NetworkSearchHandler::SetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
1349 {
1350 if (event == nullptr) {
1351 TELEPHONY_LOGE("NetworkSearchHandler::SetNrOptionModeResponse event is nullptr!");
1352 return;
1353 }
1354 TELEPHONY_LOGD("SetNrOptionModeResponse start slotId:%{public}d", slotId_);
1355 if (radioInfo_ == nullptr) {
1356 TELEPHONY_LOGE("SetNrOptionModeResponse RadioInfo is null slotId:%{public}d", slotId_);
1357 return;
1358 }
1359 radioInfo_->ProcessSetNrOptionMode(event);
1360 }
1361
GetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer & event)1362 void NetworkSearchHandler::GetNrOptionModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
1363 {
1364 if (event == nullptr) {
1365 TELEPHONY_LOGE("NetworkSearchHandler::GetNrOptionModeResponse event is nullptr!");
1366 return;
1367 }
1368 TELEPHONY_LOGD("GetNrOptionModeResponse start slotId:%{public}d", slotId_);
1369 if (radioInfo_ == nullptr) {
1370 TELEPHONY_LOGE("GetNrOptionModeResponse RadioInfo is null slotId:%{public}d", slotId_);
1371 return;
1372 }
1373 radioInfo_->ProcessGetNrOptionMode(event);
1374 }
1375
RadioGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer & event)1376 void NetworkSearchHandler::RadioGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer &event)
1377 {
1378 if (event == nullptr) {
1379 TELEPHONY_LOGE("NetworkSearchHandler::RadioGetRrcConnectionState event is nullptr!");
1380 return;
1381 }
1382 TELEPHONY_LOGD("RadioGetRrcConnectionState start slotId:%{public}d", slotId_);
1383 if (radioInfo_ == nullptr) {
1384 TELEPHONY_LOGE("RadioGetRrcConnectionState RadioInfo is null slotId:%{public}d", slotId_);
1385 return;
1386 }
1387 radioInfo_->ProcessGetRrcConnectionState(event);
1388 }
1389
RadioVoiceTechChange(const AppExecFwk::InnerEvent::Pointer & event)1390 void NetworkSearchHandler::RadioVoiceTechChange(const AppExecFwk::InnerEvent::Pointer &event)
1391 {
1392 if (event == nullptr) {
1393 TELEPHONY_LOGE("NetworkSearchHandler::RadioVoiceTechChange event is nullptr!");
1394 return;
1395 }
1396 if (radioInfo_ != nullptr) {
1397 radioInfo_->ProcessVoiceTechChange(event);
1398 }
1399 TELEPHONY_LOGD("NetworkSearchHandler::RadioVoiceTechChange");
1400 }
1401
GetNrSsbIdResponse(const AppExecFwk::InnerEvent::Pointer & event)1402 void NetworkSearchHandler::GetNrSsbIdResponse(const AppExecFwk::InnerEvent::Pointer &event)
1403 {
1404 TELEPHONY_LOGD("Start slotId:%{public}d", slotId_);
1405 if (event == nullptr) {
1406 TELEPHONY_LOGE("Event is nullptr!");
1407 return;
1408 }
1409 if (nrSsbInfo_ == nullptr) {
1410 TELEPHONY_LOGE("NrSsbInfo is null");
1411 return;
1412 }
1413 if (nrSsbInfo_->ProcessGetNrSsbId(event)) {
1414 SyncGetSsbInfoResponse();
1415 }
1416 }
1417
SyncGetSsbInfoResponse()1418 void NetworkSearchHandler::SyncGetSsbInfoResponse()
1419 {
1420 std::unique_lock<std::mutex> lck(NetworkSearchManager::ctx_);
1421 NetworkSearchManager::ssbResponseReady_ = true;
1422 TELEPHONY_LOGD("ssbResponseReady_ = %{public}d", NetworkSearchManager::ssbResponseReady_);
1423 NetworkSearchManager::cv_.notify_one();
1424 }
1425
GetNrSsbId(const std::shared_ptr<NrSsbInformation> & nrCellSsbIdsInfo)1426 int32_t NetworkSearchHandler::GetNrSsbId(const std::shared_ptr<NrSsbInformation> &nrCellSsbIdsInfo)
1427 {
1428 TELEPHONY_LOGI("SlotId:%{public}d", slotId_);
1429 if (nrSsbInfo_ != nullptr) {
1430 if (nrSsbInfo_->FillNrSsbIdInformation(nrCellSsbIdsInfo)) {
1431 return TELEPHONY_ERR_SUCCESS;
1432 }
1433 }
1434 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1435 }
1436
AutoTimeChange(const AppExecFwk::InnerEvent::Pointer &)1437 void NetworkSearchHandler::AutoTimeChange(const AppExecFwk::InnerEvent::Pointer &)
1438 {
1439 TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeChange");
1440 if (nitzUpdate_ != nullptr) {
1441 nitzUpdate_->AutoTimeChange();
1442 }
1443 }
1444
AutoTimeZoneChange(const AppExecFwk::InnerEvent::Pointer &)1445 void NetworkSearchHandler::AutoTimeZoneChange(const AppExecFwk::InnerEvent::Pointer &)
1446 {
1447 TELEPHONY_LOGD("NetworkSearchHandler::AutoTimeZoneChange");
1448 if (nitzUpdate_ != nullptr) {
1449 nitzUpdate_->AutoTimeZoneChange();
1450 }
1451 }
1452
AirplaneModeChange(const AppExecFwk::InnerEvent::Pointer &)1453 void NetworkSearchHandler::AirplaneModeChange(const AppExecFwk::InnerEvent::Pointer &)
1454 {
1455 TELEPHONY_LOGD("NetworkSearchHandler::AirplaneModeChange");
1456 if (radioInfo_ != nullptr) {
1457 radioInfo_->AirplaneModeChange();
1458 }
1459 }
1460
RadioResidentNetworkChange(const AppExecFwk::InnerEvent::Pointer & event)1461 void NetworkSearchHandler::RadioResidentNetworkChange(const AppExecFwk::InnerEvent::Pointer &event)
1462 {
1463 if (event == nullptr) {
1464 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange event is nullptr!");
1465 return;
1466 }
1467 auto networkSearchManager = networkSearchManager_.lock();
1468 if (networkSearchManager == nullptr) {
1469 TELEPHONY_LOGE("RadioResidentNetworkChange networkSearchManager is nullptr");
1470 return;
1471 }
1472 auto object = event->GetSharedObject<std::string>();
1473 if (object == nullptr) {
1474 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange object is nullptr!");
1475 networkSearchManager->SetResidentNetworkNumeric(slotId_, "");
1476 return;
1477 }
1478 std::string plmn = *object;
1479 networkSearchManager->SetResidentNetworkNumeric(slotId_, plmn);
1480 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
1481 if (networkSearchManager->GetCsRegState(slotId) ==
1482 static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE) ||
1483 networkSearchManager->GetPsRegState(slotId) ==
1484 static_cast<int32_t>(RegServiceState::REG_STATE_IN_SERVICE)) {
1485 TELEPHONY_LOGE("RadioResidentNetworkChange RegState is in service");
1486 return;
1487 }
1488 }
1489 std::string countryCode = "";
1490 if (plmn.length() >= MCC_LEN) {
1491 std::string mcc = plmn.substr(0, MCC_LEN);
1492 int32_t value = 0;
1493 if (StrToInt(mcc, value)) {
1494 countryCode = MccPool::MccCountryCode(value);
1495 } else {
1496 TELEPHONY_LOGE("RadioResidentNetworkChange parse Failed!! slotId:%{public}d", slotId_);
1497 }
1498 }
1499 if (countryCode.empty()) {
1500 TELEPHONY_LOGE("RadioResidentNetworkChange countryCode is empty");
1501 return;
1502 }
1503 TELEPHONY_LOGI("RadioResidentNetworkChange: update countryCode[%{public}s]", countryCode.c_str());
1504 if (TELEPHONY_EXT_WRAPPER.updateCountryCodeExt_ != nullptr) {
1505 TELEPHONY_EXT_WRAPPER.updateCountryCodeExt_(slotId_, countryCode.c_str());
1506 } else {
1507 if (nitzUpdate_ != nullptr) {
1508 nitzUpdate_->UpdateCountryCode(countryCode);
1509 }
1510 }
1511 }
1512
SatelliteStatusChanged(const AppExecFwk::InnerEvent::Pointer & event)1513 void NetworkSearchHandler::SatelliteStatusChanged(const AppExecFwk::InnerEvent::Pointer &event)
1514 {
1515 if (event == nullptr) {
1516 TELEPHONY_LOGE("NetworkSearchHandler::RadioResidentNetworkChange event is nullptr!");
1517 return;
1518 }
1519 auto satelliteStatus = event->GetSharedObject<SatelliteStatus>();
1520 if (satelliteStatus == nullptr) {
1521 TELEPHONY_LOGE("NetworkSearchHandler::satelliteStatus is nullptr!");
1522 return;
1523 }
1524 if (satelliteStatus->mode == SATELLITE_STATUS_ON) {
1525 std::shared_ptr<SatelliteServiceClient> satelliteClient =
1526 DelayedSingleton<SatelliteServiceClient>::GetInstance();
1527 satelliteClient->SetRadioState(
1528 satelliteStatus->slotId, static_cast<int32_t>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
1529 }
1530 }
1531
SetCellRequestMinInterval(uint32_t minInterval)1532 void NetworkSearchHandler::SetCellRequestMinInterval(uint32_t minInterval)
1533 {
1534 cellRequestMinInterval_ = minInterval;
1535 }
1536
IsSatelliteSupported() const1537 int32_t NetworkSearchHandler::IsSatelliteSupported() const
1538 {
1539 char satelliteSupported[SYSPARA_SIZE] = { 0 };
1540 GetParameter(TEL_SATELLITE_SUPPORTED, SATELLITE_DEFAULT_VALUE, satelliteSupported, SYSPARA_SIZE);
1541 TELEPHONY_LOGI("satelliteSupported is %{public}s", satelliteSupported);
1542 return std::atoi(satelliteSupported);
1543 }
1544
IsSatelliteOn() const1545 bool NetworkSearchHandler::IsSatelliteOn() const
1546 {
1547 bool isSatelliteOn = CoreManagerInner::GetInstance().IsSatelliteEnabled();
1548 bool isSupportSatellite = (IsSatelliteSupported() == static_cast<int32_t>(SatelliteValue::SATELLITE_SUPPORTED));
1549 bool isSatelliteState = isSatelliteOn && isSupportSatellite;
1550 TELEPHONY_LOGI("NetworkSearchHandler::IsSatelliteOn %{public}d", isSatelliteState);
1551 return isSatelliteState;
1552 }
1553
ClearSignalAndCellInfoList() const1554 void NetworkSearchHandler::ClearSignalAndCellInfoList() const
1555 {
1556 if (signalInfo_ != nullptr) {
1557 TELEPHONY_LOGD("reset signal info slotId: %{public}d", slotId_);
1558 signalInfo_->Reset();
1559 std::vector<sptr<SignalInformation>> signals;
1560 signalInfo_->GetSignalInfoList(signals);
1561 if (TELEPHONY_EXT_WRAPPER.sortSignalInfoListExt_ != nullptr) {
1562 TELEPHONY_EXT_WRAPPER.sortSignalInfoListExt_(slotId_, signals);
1563 }
1564 DelayedSingleton<NetworkSearchNotify>::GetInstance()->NotifySignalInfoUpdated(slotId_, signals);
1565 }
1566 if (cellInfo_ != nullptr) {
1567 cellInfo_->ClearCellInfoList();
1568 }
1569 }
1570
SystemAbilityStatusChangeListener(std::shared_ptr<OperatorName> & operatorName)1571 NetworkSearchHandler::SystemAbilityStatusChangeListener::SystemAbilityStatusChangeListener(
1572 std::shared_ptr<OperatorName> &operatorName) : opName_(operatorName)
1573 {}
1574
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1575 void NetworkSearchHandler::SystemAbilityStatusChangeListener::OnAddSystemAbility(
1576 int32_t systemAbilityId, const std::string& deviceId)
1577 {
1578 switch (systemAbilityId) {
1579 case COMMON_EVENT_SERVICE_ID: {
1580 if (opName_ == nullptr) {
1581 TELEPHONY_LOGE("OnAddSystemAbility COMMON_EVENT_SERVICE_ID opName_ is nullptr");
1582 return;
1583 }
1584 opName_->NotifySpnChanged(true);
1585 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(opName_);
1586 bool settingsResult = EventFwk::CommonEventManager::SubscribeCommonEvent(
1587 SettingUtils::GetInstance()->GetCommonEventSubscriber());
1588 TELEPHONY_LOGI("NetworkSearchHandler::OnAddSystemAbility subscribeResult = %{public}d, %{public}d",
1589 subscribeResult, settingsResult);
1590 break;
1591 }
1592 case DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID:
1593 TELEPHONY_LOGI("NetworkSearchHandler::OnAddSystemAbility DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID");
1594 SettingUtils::GetInstance()->UpdateDdsState(true);
1595 break;
1596 default:
1597 TELEPHONY_LOGE("NetworkSearchHandler::OnAddSystemAbility unknown sa id %{public}d", systemAbilityId);
1598 }
1599 }
1600
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1601 void NetworkSearchHandler::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(
1602 int32_t systemAbilityId, const std::string& deviceId)
1603 {
1604 if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1605 TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1606 return;
1607 }
1608 if (opName_ == nullptr) {
1609 TELEPHONY_LOGE("OnRemoveSystemAbility COMMON_EVENT_SERVICE_ID opName_ is nullptr");
1610 return;
1611 }
1612 bool subscribeResult = CommonEventManager::UnSubscribeCommonEvent(opName_);
1613 TELEPHONY_LOGI("NetworkSearchHandler::OnRemoveSystemAbility subscribeResult = %{public}d", subscribeResult);
1614 }
1615
IsPowerOnPrimaryRadioWhenNoSim() const1616 bool NetworkSearchHandler::IsPowerOnPrimaryRadioWhenNoSim() const
1617 {
1618 TELEPHONY_LOGD("Start to check if power on primary modem's radio when sim slots are empty");
1619 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
1620 if (nsm == nullptr) {
1621 TELEPHONY_LOGE("get networkSearchManager is failed");
1622 return false;
1623 }
1624 auto simManager = nsm->GetSimManager();
1625 if (simManager == nullptr) {
1626 TELEPHONY_LOGE("get simManager failed");
1627 return false;
1628 }
1629 int32_t primarySlotId = INVALID_SLOT_ID;
1630 simManager->GetPrimarySlotId(primarySlotId);
1631 if (primarySlotId != INVALID_SLOT_ID && primarySlotId == slotId_) {
1632 TELEPHONY_LOGD("primarySlotId = %{public}d, send radio on request", primarySlotId);
1633 return true;
1634 }
1635 return false;
1636 }
1637
ProcessSignalIntensity(int32_t slotId,const Rssi & signalIntensity)1638 void NetworkSearchHandler::ProcessSignalIntensity(int32_t slotId, const Rssi &signalIntensity)
1639 {
1640 Rssi *s = const_cast<Rssi*>(&signalIntensity);
1641 if (signalInfo_ != nullptr) {
1642 signalInfo_->ProcessSignalIntensity(slotId, s);
1643 }
1644 }
1645
UpdateOperatorName()1646 void NetworkSearchHandler::UpdateOperatorName()
1647 {
1648 if (operatorName_ != nullptr) {
1649 operatorName_->NotifySpnChanged(true);
1650 }
1651 }
1652 } // namespace Telephony
1653 } // namespace OHOS
1654