1 /*
2 * Copyright (c) 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 "napi_radio_types.h"
17 #include "observer_event_handler.h"
18 #include "telephony_errors.h"
19 #include "telephony_observer_impl.h"
20 #include "telephony_state_manager.h"
21
22 namespace OHOS {
23 namespace Telephony {
24 namespace {
WrapRegState(int32_t nativeState)25 int32_t WrapRegState(int32_t nativeState)
26 {
27 RegServiceState state = static_cast<RegServiceState>(nativeState);
28 switch (state) {
29 case RegServiceState::REG_STATE_NO_SERVICE:
30 case RegServiceState::REG_STATE_SEARCH: {
31 return RegStatus::REGISTRATION_STATE_NO_SERVICE;
32 }
33 case RegServiceState::REG_STATE_IN_SERVICE: {
34 return RegStatus::REGISTRATION_STATE_IN_SERVICE;
35 }
36 case RegServiceState::REG_STATE_EMERGENCY_ONLY: {
37 return RegStatus::REGISTRATION_STATE_EMERGENCY_CALL_ONLY;
38 }
39 case RegServiceState::REG_STATE_UNKNOWN: {
40 return RegStatus::REGISTRATION_STATE_POWER_OFF;
41 }
42 default:
43 return RegStatus::REGISTRATION_STATE_POWER_OFF;
44 }
45 }
46
WrapCallState(int32_t callState)47 int32_t WrapCallState(int32_t callState)
48 {
49 switch (callState) {
50 case (int32_t)Telephony::CallStatus::CALL_STATUS_ACTIVE:
51 case (int32_t)Telephony::CallStatus::CALL_STATUS_HOLDING:
52 case (int32_t)Telephony::CallStatus::CALL_STATUS_DIALING:
53 case (int32_t)Telephony::CallStatus::CALL_STATUS_ALERTING:
54 return static_cast<int32_t>(CallState::CALL_STATE_OFFHOOK);
55 case (int32_t)Telephony::CallStatus::CALL_STATUS_WAITING:
56 case (int32_t)Telephony::CallStatus::CALL_STATUS_INCOMING:
57 return static_cast<int32_t>(CallState::CALL_STATE_RINGING);
58 case (int32_t)Telephony::CallStatus::CALL_STATUS_DISCONNECTING:
59 case (int32_t)Telephony::CallStatus::CALL_STATUS_DISCONNECTED:
60 case (int32_t)Telephony::CallStatus::CALL_STATUS_IDLE:
61 return static_cast<int32_t>(CallState::CALL_STATE_IDLE);
62 case (int32_t)Telephony::CallStatus::CALL_STATUS_ANSWERED:
63 return static_cast<int32_t>(CallState::CALL_STATE_ANSWERED);
64 default:
65 return static_cast<int32_t>(CallState::CALL_STATE_UNKNOWN);
66 }
67 }
68
WrapNetworkType(SignalInformation::NetworkType nativeNetworkType)69 int32_t WrapNetworkType(SignalInformation::NetworkType nativeNetworkType)
70 {
71 NetworkType jsNetworkType = NetworkType::NETWORK_TYPE_UNKNOWN;
72 switch (nativeNetworkType) {
73 case SignalInformation::NetworkType::GSM: {
74 jsNetworkType = NetworkType::NETWORK_TYPE_GSM;
75 break;
76 }
77 case SignalInformation::NetworkType::CDMA: {
78 jsNetworkType = NetworkType::NETWORK_TYPE_CDMA;
79 break;
80 }
81 case SignalInformation::NetworkType::LTE: {
82 jsNetworkType = NetworkType::NETWORK_TYPE_LTE;
83 break;
84 }
85 case SignalInformation::NetworkType::TDSCDMA: {
86 jsNetworkType = NetworkType::NETWORK_TYPE_TDSCDMA;
87 break;
88 }
89 case SignalInformation::NetworkType::WCDMA: {
90 jsNetworkType = NetworkType::NETWORK_TYPE_WCDMA;
91 break;
92 }
93 default: {
94 jsNetworkType = NetworkType::NETWORK_TYPE_UNKNOWN;
95 }
96 }
97 return static_cast<int32_t>(jsNetworkType);
98 }
99
WrapRadioTech(int32_t radioTechType)100 int32_t WrapRadioTech(int32_t radioTechType)
101 {
102 RadioTech techType = static_cast<RadioTech>(radioTechType);
103 switch (techType) {
104 case RadioTech::RADIO_TECHNOLOGY_GSM:
105 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_GSM);
106 case RadioTech::RADIO_TECHNOLOGY_LTE:
107 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE);
108 case RadioTech::RADIO_TECHNOLOGY_WCDMA:
109 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_WCDMA);
110 case RadioTech::RADIO_TECHNOLOGY_1XRTT:
111 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_1XRTT);
112 case RadioTech::RADIO_TECHNOLOGY_HSPA:
113 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPA);
114 case RadioTech::RADIO_TECHNOLOGY_HSPAP:
115 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_HSPAP);
116 case RadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
117 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_TD_SCDMA);
118 case RadioTech::RADIO_TECHNOLOGY_EVDO:
119 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EVDO);
120 case RadioTech::RADIO_TECHNOLOGY_EHRPD:
121 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_EHRPD);
122 case RadioTech::RADIO_TECHNOLOGY_LTE_CA:
123 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_LTE_CA);
124 case RadioTech::RADIO_TECHNOLOGY_IWLAN:
125 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_IWLAN);
126 case RadioTech::RADIO_TECHNOLOGY_NR:
127 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_NR);
128 default:
129 return static_cast<int32_t>(RatType::RADIO_TECHNOLOGY_UNKNOWN);
130 }
131 }
132 } // namespace
133
134 std::mutex ObserverEventHandler::operatorMutex_;
135
ObserverEventHandler()136 ObserverEventHandler::ObserverEventHandler() : AppExecFwk::EventHandler(AppExecFwk::EventRunner::Create())
137 {
138 }
139
~ObserverEventHandler()140 ObserverEventHandler::~ObserverEventHandler()
141 {
142 listenerList_.clear();
143 }
144
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)145 void ObserverEventHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
146 {
147 auto eventId = static_cast<TelephonyCallbackEventId>(event->GetInnerEventId());
148 switch (eventId) {
149 case TelephonyCallbackEventId::EVENT_ON_CALL_STATE_UPDATE:
150 HandleCallbackInfoUpdate<CallStateUpdateInfo,
151 TelephonyUpdateEventType::EVENT_CALL_STATE_UPDATE>(event);
152 break;
153 case TelephonyCallbackEventId::EVENT_ON_SIM_STATE_UPDATE:
154 HandleCallbackInfoUpdate<SimStateUpdateInfo,
155 TelephonyUpdateEventType::EVENT_SIM_STATE_UPDATE>(event);
156 break;
157 case TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_CONNECTION_UPDATE:
158 HandleCallbackInfoUpdate<CellularDataConnectState,
159 TelephonyUpdateEventType::EVENT_DATA_CONNECTION_UPDATE>(event);
160 break;
161 case TelephonyCallbackEventId::EVENT_ON_CELLULAR_DATA_FLOW_UPDATE:
162 HandleCallbackInfoUpdate<CellularDataFlowUpdate,
163 TelephonyUpdateEventType::EVENT_CELLULAR_DATA_FLOW_UPDATE>(event);
164 break;
165 case TelephonyCallbackEventId::EVENT_ON_CFU_INDICATOR_UPDATE:
166 HandleCallbackInfoUpdate<CfuIndicatorUpdate,
167 TelephonyUpdateEventType::EVENT_CFU_INDICATOR_UPDATE>(event);
168 break;
169 case TelephonyCallbackEventId::EVENT_ON_VOICE_MAIL_MSG_INDICATOR_UPDATE:
170 HandleCallbackInfoUpdate<VoiceMailMsgIndicatorUpdate,
171 TelephonyUpdateEventType::EVENT_VOICE_MAIL_MSG_INDICATOR_UPDATE>(event);
172 break;
173 case TelephonyCallbackEventId::EVENT_ON_ICC_ACCOUNT_UPDATE:
174 HandleCallbackVoidUpdate<TelephonyUpdateEventType::EVENT_ICC_ACCOUNT_CHANGE>(event);
175 break;
176 case TelephonyCallbackEventId::EVENT_ON_SIGNAL_INFO_UPDATE:
177 HandleCallbackInfoUpdate<SignalUpdateInfo,
178 TelephonyUpdateEventType::EVENT_SIGNAL_STRENGTHS_UPDATE>(event);
179 break;
180 case TelephonyCallbackEventId::EVENT_ON_NETWORK_STATE_UPDATE:
181 HandleCallbackInfoUpdate<NetworkStateUpdateInfo,
182 TelephonyUpdateEventType::EVENT_NETWORK_STATE_UPDATE>(event);
183 break;
184 case TelephonyCallbackEventId::EVENT_ON_CELL_INFOMATION_UPDATE:
185 HandleCallbackInfoUpdate<CellInfomationUpdate,
186 TelephonyUpdateEventType::EVENT_CELL_INFO_UPDATE>(event);
187 break;
188 default:
189 TELEPHONY_LOGE("ObserverEventHandler::ProcessEvent Unkonw Telephony CallbackEventId");
190 return;
191 }
192 }
193
CheckEventListenerRegister(EventListener & eventListener)194 int32_t ObserverEventHandler::CheckEventListenerRegister(EventListener &eventListener)
195 {
196 int32_t flag = EVENT_LISTENER_DIFF;
197 for (auto &listen : listenerList_) {
198 if (eventListener.slotId == listen.slotId &&
199 eventListener.eventType == listen.eventType &&
200 eventListener.funcId == listen.funcId) {
201 flag = EVENT_LISTENER_SAME;
202 return flag;
203 }
204 if (eventListener.slotId == listen.slotId && eventListener.eventType == listen.eventType) {
205 flag = EVENT_LISTENER_SLOTID_AND_EVENTTYPE_SAME;
206 }
207 }
208 return flag;
209 }
210
RegisterEventListener(EventListener & eventListener)211 int32_t ObserverEventHandler::RegisterEventListener(EventListener &eventListener)
212 {
213 std::unique_lock<std::mutex> lock(operatorMutex_);
214 int32_t registerStatus = CheckEventListenerRegister(eventListener);
215 if (registerStatus == EVENT_LISTENER_SAME) {
216 TELEPHONY_LOGE(" ObserverEventHandler::RegisterEventListener CALLBACK ALREADY REGISTERED");
217 return TELEPHONY_ERR_CALLBACK_ALREADY_REGISTERED;
218 }
219 if (registerStatus != EVENT_LISTENER_SLOTID_AND_EVENTTYPE_SAME) {
220 FfiTelephonyObserver *telephonyObserver = std::make_unique<FfiTelephonyObserver>().release();
221 if (telephonyObserver == nullptr) {
222 TELEPHONY_LOGE("error by telephonyObserver nullptr");
223 return TELEPHONY_ERR_LOCAL_PTR_NULL;
224 }
225 sptr<TelephonyObserverBroker> observer(telephonyObserver);
226 if (observer == nullptr) {
227 TELEPHONY_LOGE("error by observer nullptr");
228 return TELEPHONY_ERR_LOCAL_PTR_NULL;
229 }
230 int32_t addResult = TelephonyStateManager::AddStateObserver(
231 observer, eventListener.slotId, static_cast<uint32_t>(eventListener.eventType),
232 eventListener.eventType == TelephonyUpdateEventType::EVENT_CALL_STATE_UPDATE);
233 if (addResult != TELEPHONY_SUCCESS) {
234 TELEPHONY_LOGE("AddStateObserver failed, ret=%{public}d!", addResult);
235 return addResult;
236 }
237 }
238 listenerList_.push_back(eventListener);
239 TELEPHONY_LOGI("ObserverEventHandler::RegisterEventListener listenerList_ size=%{public}d",
240 static_cast<int32_t>(listenerList_.size()));
241 return TELEPHONY_SUCCESS;
242 }
243
SetEventListenerDeleting(std::shared_ptr<bool> isDeleting)244 void ObserverEventHandler::SetEventListenerDeleting(std::shared_ptr<bool> isDeleting)
245 {
246 if (isDeleting == nullptr) {
247 TELEPHONY_LOGE("isDeleting is nullptr");
248 return;
249 }
250 *isDeleting = true;
251 }
252
RemoveEventListenerRegister(const TelephonyUpdateEventType eventType,int64_t funcId,std::set<int32_t> & soltIdSet)253 void ObserverEventHandler::RemoveEventListenerRegister(const TelephonyUpdateEventType eventType, int64_t funcId,
254 std::set<int32_t> &soltIdSet)
255 {
256 std::list<EventListener>::iterator it = listenerList_.begin();
257 while (it != listenerList_.end()) {
258 if (eventType == it->eventType && ((it->funcId == funcId) || (funcId == -1))) {
259 SetEventListenerDeleting(it->isDeleting);
260 soltIdSet.insert(it->slotId);
261 it = listenerList_.erase(it);
262 } else {
263 ++it;
264 }
265 }
266 }
267
CheckEventTypeExist(int32_t slotId,TelephonyUpdateEventType eventType)268 bool ObserverEventHandler::CheckEventTypeExist(int32_t slotId, TelephonyUpdateEventType eventType)
269 {
270 for (auto &listen : listenerList_) {
271 if (slotId == listen.slotId && eventType == listen.eventType) {
272 return true;
273 }
274 }
275 return false;
276 }
277
CheckRemoveStateObserver(TelephonyUpdateEventType eventType,int32_t slotId,int32_t & result)278 void ObserverEventHandler::CheckRemoveStateObserver(TelephonyUpdateEventType eventType, int32_t slotId, int32_t &result)
279 {
280 if (!CheckEventTypeExist(slotId, eventType)) {
281 int32_t removeRet = TelephonyStateManager::RemoveStateObserver(slotId, static_cast<uint32_t>(eventType));
282 if (removeRet != TELEPHONY_SUCCESS) {
283 TELEPHONY_LOGE("ObserverEventHandler::RemoveStateObserver slotId %{public}d, eventType %{public}d fail!",
284 slotId, static_cast<int32_t>(eventType));
285 result = removeRet;
286 }
287 }
288 }
289
UnregisterEventListener(const TelephonyUpdateEventType eventType,int64_t funcId)290 int32_t ObserverEventHandler::UnregisterEventListener(
291 const TelephonyUpdateEventType eventType, int64_t funcId)
292 {
293 std::unique_lock<std::mutex> lock(operatorMutex_);
294 if (listenerList_.empty()) {
295 TELEPHONY_LOGI("UnregisterEventListener listener list is empty.");
296 return TELEPHONY_SUCCESS;
297 }
298
299 std::set<int32_t> soltIdSet;
300 RemoveEventListenerRegister(eventType, funcId, soltIdSet);
301 int32_t result = TELEPHONY_SUCCESS;
302 for (int32_t slotId : soltIdSet) {
303 CheckRemoveStateObserver(eventType, slotId, result);
304 }
305 TELEPHONY_LOGI("ObserverEventHandler::UnregisterEventListener listenerList_ size=%{public}d",
306 static_cast<int32_t>(listenerList_.size()));
307 return result;
308 }
309
310 template<typename D, TelephonyUpdateEventType eventType>
HandleCallbackInfoUpdate(const AppExecFwk::InnerEvent::Pointer & event)311 void ObserverEventHandler::HandleCallbackInfoUpdate(const AppExecFwk::InnerEvent::Pointer &event)
312 {
313 if (event == nullptr) {
314 TELEPHONY_LOGE("event nullptr");
315 return;
316 }
317
318 std::unique_ptr<D> info = event->GetUniqueObject<D>();
319 if (info == nullptr) {
320 TELEPHONY_LOGE("update info nullptr");
321 return;
322 }
323
324 std::unique_lock<std::mutex> lock(operatorMutex_);
325 for (const EventListener &listen : listenerList_) {
326 if ((listen.eventType == eventType) && (listen.slotId == info->slotId_)) {
327 uv_work_t *work = std::make_unique<uv_work_t>().release();
328 if (work == nullptr) {
329 TELEPHONY_LOGE("make work failed");
330 break;
331 }
332 std::unique_ptr<D> context = std::move(info);
333 D* data = context.release();
334 if (data == nullptr) {
335 TELEPHONY_LOGE("make work failed");
336 break;
337 }
338 work->data = static_cast<void *>(data);
339 WorkUpdated(listen, work, lock);
340 delete work;
341 work = nullptr;
342 }
343 }
344 }
345
346 template<TelephonyUpdateEventType eventType>
HandleCallbackVoidUpdate(const AppExecFwk::InnerEvent::Pointer & event)347 void ObserverEventHandler::HandleCallbackVoidUpdate(const AppExecFwk::InnerEvent::Pointer &event)
348 {
349 if (event == nullptr) {
350 TELEPHONY_LOGE("event nullptr");
351 return;
352 }
353 std::unique_lock<std::mutex> lock(operatorMutex_);
354 for (const EventListener &listen : listenerList_) {
355 if ((listen.eventType == eventType)) {
356 uv_work_t *work = std::make_unique<uv_work_t>().release();
357 if (work == nullptr) {
358 TELEPHONY_LOGE("make work failed");
359 break;
360 }
361 EventListener *listener = new EventListener();
362 listener->eventType = listen.eventType;
363 listener->slotId = listen.slotId;
364 listener->funcId = listen.funcId;
365 listener->callbackRef = listen.callbackRef;
366 listener->isDeleting = listen.isDeleting;
367 work->data = static_cast<void *>(listener);
368 WorkUpdated(listen, work, lock);
369 delete listener;
370 delete work;
371 }
372 }
373 }
374
WorkUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)375 void ObserverEventHandler::WorkUpdated(const EventListener &listener,
376 uv_work_t *work, std::unique_lock<std::mutex> &lock)
377 {
378 TELEPHONY_LOGD("ObserverEventHandler::WorkUpdated eventType is %{public}d", listener.eventType);
379 if (listener.isDeleting == nullptr || *(listener.isDeleting)) {
380 TELEPHONY_LOGI("listener is deleting");
381 return;
382 }
383
384 switch (listener.eventType) {
385 case TelephonyUpdateEventType::EVENT_CALL_STATE_UPDATE:
386 WorkCallStateUpdated(listener, work, lock);
387 break;
388 case TelephonyUpdateEventType::EVENT_SIGNAL_STRENGTHS_UPDATE:
389 WorkSignalUpdated(listener, work, lock);
390 break;
391 case TelephonyUpdateEventType::EVENT_NETWORK_STATE_UPDATE:
392 WorkNetworkStateUpdated(listener, work, lock);
393 break;
394 case TelephonyUpdateEventType::EVENT_SIM_STATE_UPDATE:
395 WorkSimStateUpdated(listener, work, lock);
396 break;
397 case TelephonyUpdateEventType::EVENT_CELL_INFO_UPDATE:
398 WorkCellInfomationUpdated(listener, work, lock);
399 break;
400 case TelephonyUpdateEventType::EVENT_DATA_CONNECTION_UPDATE:
401 WorkCellularDataConnectStateUpdated(listener, work, lock);
402 break;
403 case TelephonyUpdateEventType::EVENT_CELLULAR_DATA_FLOW_UPDATE:
404 WorkCellularDataFlowUpdated(listener, work, lock);
405 break;
406 case TelephonyUpdateEventType::EVENT_CFU_INDICATOR_UPDATE:
407 WorkCfuIndicatorUpdated(listener, work, lock);
408 break;
409 case TelephonyUpdateEventType::EVENT_VOICE_MAIL_MSG_INDICATOR_UPDATE:
410 WorkVoiceMailMsgIndicatorUpdated(listener, work, lock);
411 break;
412 case TelephonyUpdateEventType::EVENT_ICC_ACCOUNT_CHANGE:
413 WorkIccAccountUpdated(listener, work, lock);
414 break;
415 default:
416 TELEPHONY_LOGE("ObserverEventHandler::WorkUpdated Unkonw Telephony UpdateEventType");
417 return;
418 }
419 }
420
WorkCallStateUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)421 void ObserverEventHandler::WorkCallStateUpdated(const EventListener &listener,
422 uv_work_t *work, std::unique_lock<std::mutex> &lock)
423 {
424 if (work == nullptr) {
425 TELEPHONY_LOGE("work is null");
426 return;
427 }
428 std::unique_ptr<CallStateUpdateInfo> callStateInfo(static_cast<CallStateUpdateInfo *>(work->data));
429 std::string phoneNumber = ToUtf8(callStateInfo->phoneNumber_);
430 CCallStateInfo callbackValue = {
431 .state = WrapCallState(callStateInfo->callState_),
432 .number = MallocCString(phoneNumber)
433 };
434 lock.unlock();
435 void* argv = &(callbackValue);
436 listener.callbackRef(argv);
437 }
438
WorkSignalUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)439 void ObserverEventHandler::WorkSignalUpdated(const EventListener &listener,
440 uv_work_t *work, std::unique_lock<std::mutex> &lock)
441 {
442 if (work == nullptr) {
443 TELEPHONY_LOGE("work is null");
444 return;
445 }
446 std::unique_ptr<SignalUpdateInfo> infoListUpdateInfo(static_cast<SignalUpdateInfo *>(work->data));
447 size_t infoSize = infoListUpdateInfo->signalInfoList_.size();
448 if (infoSize <= 0) {
449 TELEPHONY_LOGE("signalInfoList_ size error");
450 return;
451 }
452 CSignalInformation* head =
453 reinterpret_cast<CSignalInformation *>(malloc(sizeof(CSignalInformation) * infoSize));
454 if (head == nullptr) {
455 TELEPHONY_LOGE("ObserverEventHandler::WorkSignalUpdated malloc CSignalInformation failed.");
456 return;
457 }
458 CArraySignalInformation signalInformations = { .head = nullptr, .size = 0 };
459 for (size_t i = 0; i < infoSize; i++) {
460 sptr<SignalInformation> infoItem = infoListUpdateInfo->signalInfoList_[i];
461 head[i].signalType = WrapNetworkType(infoItem->GetNetworkType());
462 head[i].signalLevel = infoItem->GetSignalLevel();
463 head[i].dBm = infoItem->GetSignalIntensity();
464 }
465 signalInformations.size = static_cast<int64_t>(infoSize);
466 signalInformations.head = head;
467 lock.unlock();
468 void* argv = &(signalInformations);
469 listener.callbackRef(argv);
470 }
471
WorkNetworkStateUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)472 void ObserverEventHandler::WorkNetworkStateUpdated(const EventListener &listener,
473 uv_work_t *work, std::unique_lock<std::mutex> &lock)
474 {
475 if (work == nullptr) {
476 TELEPHONY_LOGE("work is null");
477 return;
478 }
479 std::unique_ptr<NetworkStateUpdateInfo> networkStateUpdateInfo(static_cast<NetworkStateUpdateInfo *>(work->data));
480 const sptr<NetworkState> &networkState = networkStateUpdateInfo->networkState_;
481 std::string longOperatorName = networkState->GetLongOperatorName();
482 std::string shortOperatorName = networkState->GetShortOperatorName();
483 std::string plmnNumeric = networkState->GetPlmnNumeric();
484 bool isRoaming = networkState->IsRoaming();
485 int32_t regStatus = static_cast<int32_t>(networkState->GetRegStatus());
486 bool isEmergency = networkState->IsEmergency();
487 int32_t cfgTech = static_cast<int32_t>(networkState->GetCfgTech());
488 int32_t nsaState = static_cast<int32_t>(networkState->GetNrState());
489 CNetworkState callbackValue = {
490 .longOperatorName = MallocCString(longOperatorName),
491 .shortOperatorName = MallocCString(shortOperatorName),
492 .plmnNumeric = MallocCString(plmnNumeric),
493 .isRoaming = isRoaming,
494 .regState = WrapRegState(regStatus),
495 .cfgTech = WrapRadioTech(cfgTech),
496 .nsaState = nsaState,
497 .isCaActive = false,
498 .isEmergency = isEmergency
499 };
500 lock.unlock();
501 void* argv = &(callbackValue);
502 listener.callbackRef(argv);
503 }
504
WorkSimStateUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)505 void ObserverEventHandler::WorkSimStateUpdated(const EventListener &listener,
506 uv_work_t *work, std::unique_lock<std::mutex> &lock)
507 {
508 if (work == nullptr) {
509 TELEPHONY_LOGE("work is null");
510 return;
511 }
512 std::unique_ptr<SimStateUpdateInfo> simStateUpdateInfo(static_cast<SimStateUpdateInfo *>(work->data));
513 int32_t cardType = static_cast<int32_t>(simStateUpdateInfo->type_);
514 int32_t simState = static_cast<int32_t>(simStateUpdateInfo->state_);
515 int32_t lockReason = static_cast<int32_t>(simStateUpdateInfo->reason_);
516 CSimStateData callbackValue = {
517 .cardType = cardType,
518 .state = simState,
519 .reason = lockReason
520 };
521 lock.unlock();
522 void* argv = &(callbackValue);
523 listener.callbackRef(argv);
524 }
525
WorkCellInfomationUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)526 void ObserverEventHandler::WorkCellInfomationUpdated(const EventListener &listener,
527 uv_work_t *work, std::unique_lock<std::mutex> &lock)
528 {
529 if (work == nullptr) {
530 TELEPHONY_LOGE("work is null");
531 return;
532 }
533 }
534
WorkCellularDataConnectStateUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)535 void ObserverEventHandler::WorkCellularDataConnectStateUpdated(const EventListener &listener,
536 uv_work_t *work, std::unique_lock<std::mutex> &lock)
537 {
538 if (work == nullptr) {
539 TELEPHONY_LOGE("work is null");
540 return;
541 }
542 std::unique_ptr<CellularDataConnectState> context(
543 static_cast<CellularDataConnectState *>(work->data));
544 CDataConnectionStateInfo callbackValue = {
545 .state = context->dataState_,
546 .network = context->networkType_
547 };
548 lock.unlock();
549 void* argv = &(callbackValue);
550 listener.callbackRef(argv);
551 }
552
WorkCellularDataFlowUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)553 void ObserverEventHandler::WorkCellularDataFlowUpdated(const EventListener &listener,
554 uv_work_t *work, std::unique_lock<std::mutex> &lock)
555 {
556 if (work == nullptr) {
557 TELEPHONY_LOGE("work is null");
558 return;
559 }
560 std::unique_ptr<CellularDataFlowUpdate> dataFlowInfo(static_cast<CellularDataFlowUpdate *>(work->data));
561 lock.unlock();
562 void* argv = &(dataFlowInfo->flowType_);
563 listener.callbackRef(argv);
564 }
565
WorkCfuIndicatorUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)566 void ObserverEventHandler::WorkCfuIndicatorUpdated(const EventListener &listener,
567 uv_work_t *work, std::unique_lock<std::mutex> &lock)
568 {
569 if (work == nullptr) {
570 TELEPHONY_LOGE("work is null");
571 return;
572 }
573 }
574
WorkVoiceMailMsgIndicatorUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)575 void ObserverEventHandler::WorkVoiceMailMsgIndicatorUpdated(const EventListener &listener,
576 uv_work_t *work, std::unique_lock<std::mutex> &lock)
577 {
578 if (work == nullptr) {
579 TELEPHONY_LOGE("work is null");
580 return;
581 }
582 }
583
WorkIccAccountUpdated(const EventListener & listener,uv_work_t * work,std::unique_lock<std::mutex> & lock)584 void ObserverEventHandler::WorkIccAccountUpdated(const EventListener &listener,
585 uv_work_t *work, std::unique_lock<std::mutex> &lock)
586 {
587 lock.unlock();
588 void* argv = nullptr;
589 listener.callbackRef(argv);
590 }
591 }
592 }
593