1 /*
2 * Copyright (C) 2021 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 "cellular_call_handler.h"
17
18 #include "hril_call_parcel.h"
19
20 #include "cellular_call_config.h"
21 #include "cellular_call_service.h"
22 #include "radio_event.h"
23
24 namespace OHOS {
25 namespace Telephony {
CellularCallHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner)26 CellularCallHandler::CellularCallHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner)
27 : AppExecFwk::EventHandler(runner)
28 {
29 InitBasicFuncMap();
30 InitConfigFuncMap();
31 InitSupplementFuncMap();
32 InitActiveReportFuncMap();
33 }
34
InitBasicFuncMap()35 void CellularCallHandler::InitBasicFuncMap()
36 {
37 requestFuncMap_[RadioEvent::RADIO_DIAL] = &CellularCallHandler::DialResponse;
38 requestFuncMap_[RadioEvent::RADIO_HANGUP_CONNECT] = &CellularCallHandler::CommonResultResponse;
39 requestFuncMap_[RadioEvent::RADIO_REJECT_CALL] = &CellularCallHandler::CommonResultResponse;
40 requestFuncMap_[RadioEvent::RADIO_ACCEPT_CALL] = &CellularCallHandler::CommonResultResponse;
41 requestFuncMap_[RadioEvent::RADIO_HOLD_CALL] = &CellularCallHandler::CommonResultResponse;
42 requestFuncMap_[RadioEvent::RADIO_ACTIVE_CALL] = &CellularCallHandler::CommonResultResponse;
43 requestFuncMap_[RadioEvent::RADIO_SWAP_CALL] = &CellularCallHandler::CommonResultResponse;
44 requestFuncMap_[RadioEvent::RADIO_JOIN_CALL] = &CellularCallHandler::CommonResultResponse;
45 requestFuncMap_[RadioEvent::RADIO_SPLIT_CALL] = &CellularCallHandler::CommonResultResponse;
46 requestFuncMap_[RadioEvent::RADIO_CALL_SUPPLEMENT] = &CellularCallHandler::CommonResultResponse;
47 requestFuncMap_[RadioEvent::RADIO_SEND_DTMF] = &CellularCallHandler::SendDtmfResponse;
48 requestFuncMap_[RadioEvent::RADIO_START_DTMF] = &CellularCallHandler::StartDtmfResponse;
49 requestFuncMap_[RadioEvent::RADIO_STOP_DTMF] = &CellularCallHandler::StopDtmfResponse;
50 requestFuncMap_[RadioEvent::RADIO_CURRENT_CALLS] = &CellularCallHandler::GetCsCallsDataResponse;
51 requestFuncMap_[RadioEvent::RADIO_GET_IMS_CALL_LIST] = &CellularCallHandler::GetImsCallsDataResponse;
52 requestFuncMap_[RadioEvent::RADIO_GET_CALL_FAIL_REASON] = &CellularCallHandler::GetCallFailReasonResponse;
53
54 requestFuncMap_[GET_CS_CALL_DATA_ID] = &CellularCallHandler::GetCsCallsDataRequest;
55 requestFuncMap_[GET_IMS_CALL_DATA_ID] = &CellularCallHandler::GetImsCallsDataRequest;
56 requestFuncMap_[REGISTER_HANDLER_ID] = &CellularCallHandler::RegisterHandler;
57 requestFuncMap_[REGISTER_IMS_CALLBACK_ID] = &CellularCallHandler::RegisterImsCallback;
58 requestFuncMap_[MMIHandlerId::EVENT_MMI_Id] = &CellularCallHandler::GetMMIResponse;
59 }
60
InitConfigFuncMap()61 void CellularCallHandler::InitConfigFuncMap()
62 {
63 requestFuncMap_[RadioEvent::RADIO_SET_CMUT] = &CellularCallHandler::SetMuteResponse;
64 requestFuncMap_[RadioEvent::RADIO_GET_CMUT] = &CellularCallHandler::GetMuteResponse;
65 requestFuncMap_[RadioEvent::RADIO_SET_CALL_PREFERENCE_MODE] = &CellularCallHandler::SetDomainPreferenceModeResponse;
66 requestFuncMap_[RadioEvent::RADIO_GET_CALL_PREFERENCE_MODE] = &CellularCallHandler::GetDomainPreferenceModeResponse;
67 requestFuncMap_[RadioEvent::RADIO_SET_LTE_IMS_SWITCH_STATUS] = &CellularCallHandler::SetLteImsSwitchStatusResponse;
68 requestFuncMap_[RadioEvent::RADIO_GET_LTE_IMS_SWITCH_STATUS] = &CellularCallHandler::GetLteImsSwitchStatusResponse;
69 requestFuncMap_[RadioEvent::RADIO_GET_EMERGENCY_CALL_LIST] = &CellularCallHandler::GetEmergencyCallListResponse;
70 }
71
InitSupplementFuncMap()72 void CellularCallHandler::InitSupplementFuncMap()
73 {
74 requestFuncMap_[RadioEvent::RADIO_GET_CALL_WAIT] = &CellularCallHandler::GetCallWaitingResponse;
75 requestFuncMap_[RadioEvent::RADIO_SET_CALL_WAIT] = &CellularCallHandler::SetCallWaitingResponse;
76 requestFuncMap_[RadioEvent::RADIO_GET_CALL_FORWARD] = &CellularCallHandler::GetCallTransferResponse;
77 requestFuncMap_[RadioEvent::RADIO_SET_CALL_FORWARD] = &CellularCallHandler::SetCallTransferInfoResponse;
78 requestFuncMap_[RadioEvent::RADIO_GET_CALL_CLIP] = &CellularCallHandler::GetClipResponse;
79 requestFuncMap_[RadioEvent::RADIO_GET_CALL_CLIR] = &CellularCallHandler::GetClirResponse;
80 requestFuncMap_[RadioEvent::RADIO_SET_CALL_CLIR] = &CellularCallHandler::SetClirResponse;
81 requestFuncMap_[RadioEvent::RADIO_GET_CALL_RESTRICTION] = &CellularCallHandler::GetCallRestrictionResponse;
82 requestFuncMap_[RadioEvent::RADIO_SET_CALL_RESTRICTION] = &CellularCallHandler::SetCallRestrictionResponse;
83 requestFuncMap_[RadioEvent::RADIO_SET_USSD] = &CellularCallHandler::SendUssdResponse;
84 }
85
InitActiveReportFuncMap()86 void CellularCallHandler::InitActiveReportFuncMap()
87 {
88 requestFuncMap_[RadioEvent::RADIO_CALL_STATUS_INFO] = &CellularCallHandler::CallStatusInfoResponse;
89 requestFuncMap_[RadioEvent::RADIO_CALL_IMS_SERVICE_STATUS] = &CellularCallHandler::CallImsServiceStatusResponse;
90 requestFuncMap_[RadioEvent::RADIO_AVAIL] = &CellularCallHandler::GetCsCallData;
91 requestFuncMap_[RadioEvent::RADIO_NOT_AVAIL] = &CellularCallHandler::GetCsCallData;
92 requestFuncMap_[RadioEvent::RADIO_CALL_USSD_NOTICE] = &CellularCallHandler::UssdNotifyResponse;
93 requestFuncMap_[RadioEvent::RADIO_CALL_RINGBACK_VOICE] = &CellularCallHandler::CallRingBackVoiceResponse;
94 requestFuncMap_[RadioEvent::RADIO_CALL_SRVCC_STATUS] = &CellularCallHandler::UpdateSrvccStateReport;
95 }
96
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)97 void CellularCallHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
98 {
99 if (event == nullptr) {
100 TELEPHONY_LOGE("CellularCallHandler::ProcessEvent, event is nullptr");
101 return;
102 }
103 auto itFunc = requestFuncMap_.find(event->GetInnerEventId());
104 if (itFunc != requestFuncMap_.end()) {
105 auto requestFunc = itFunc->second;
106 if (requestFunc != nullptr) {
107 return (this->*requestFunc)(event);
108 }
109 }
110 TELEPHONY_LOGI("CellularCallHandler::ProcessEvent, default case, need check.");
111 }
112
GetCsCallData(const AppExecFwk::InnerEvent::Pointer & event)113 void CellularCallHandler::GetCsCallData(const AppExecFwk::InnerEvent::Pointer &event)
114 {
115 if (event == nullptr) {
116 TELEPHONY_LOGE("GetCsCallData return, event is nullptr");
117 return;
118 }
119 TELEPHONY_LOGI("GetCsCallData event id: %{public}d", event->GetInnerEventId());
120 this->SendEvent(GET_CS_CALL_DATA_ID, delayTime_, Priority::HIGH);
121 }
122
GetImsCallData(const AppExecFwk::InnerEvent::Pointer & event)123 void CellularCallHandler::GetImsCallData(const AppExecFwk::InnerEvent::Pointer &event)
124 {
125 if (event == nullptr) {
126 TELEPHONY_LOGE("GetImsCallData return, event is nullptr");
127 return;
128 }
129 TELEPHONY_LOGI("GetImsCallData event id: %{public}d", event->GetInnerEventId());
130 this->SendEvent(GET_IMS_CALL_DATA_ID, delayTime_, Priority::HIGH);
131 }
132
ReportCsCallsData(const CallInfoList & callInfoList)133 void CellularCallHandler::ReportCsCallsData(const CallInfoList &callInfoList)
134 {
135 auto serviceInstance_ = DelayedSingleton<CellularCallService>::GetInstance();
136 if (serviceInstance_ == nullptr) {
137 TELEPHONY_LOGE("ReportCsCallsData return, GetInstance is nullptr");
138 return;
139 }
140 auto csControl = serviceInstance_->GetCsControl(slotId_);
141 if (callInfoList.callSize == 0) {
142 callType_ = CallType::TYPE_ERR_CALL;
143 if (csControl == nullptr) {
144 TELEPHONY_LOGE("ReportCsCallsData return, cs_control is nullptr");
145 return;
146 }
147 csControl->ReportCallsData(slotId_, callInfoList);
148 serviceInstance_->CleanControlMap();
149 return;
150 }
151 if (callInfoList.callSize == 1) {
152 if (csControl == nullptr) {
153 csControl = std::make_shared<CSControl>();
154 serviceInstance_->SetCsControl(slotId_, csControl);
155 }
156 }
157 if (csControl == nullptr) {
158 TELEPHONY_LOGE("ReportCsCallsData return, cs_control is nullptr");
159 return;
160 }
161 csControl->ReportCallsData(slotId_, callInfoList);
162 }
163
ReportImsCallsData(const CallInfoList & imsCallInfoList)164 void CellularCallHandler::ReportImsCallsData(const CallInfoList &imsCallInfoList)
165 {
166 auto serviceInstance_ = DelayedSingleton<CellularCallService>::GetInstance();
167 if (serviceInstance_ == nullptr) {
168 TELEPHONY_LOGE("ReportImsCallsData return, serviceInstance_ is nullptr");
169 return;
170 }
171 TELEPHONY_LOGI("ReportImsCallsData, imsCallInfoList.callSize:%{public}d", imsCallInfoList.callSize);
172 auto imsControl = serviceInstance_->GetImsControl(slotId_);
173 if (imsCallInfoList.callSize == 0) {
174 callType_ = CallType::TYPE_ERR_CALL;
175 if (imsControl == nullptr) {
176 TELEPHONY_LOGE("ReportImsCallsData return, ims_control is nullptr");
177 return;
178 }
179 imsControl->ReportCallsData(slotId_, imsCallInfoList);
180 serviceInstance_->CleanControlMap();
181 return;
182 }
183 if (imsCallInfoList.callSize == 1) {
184 if (imsControl == nullptr) {
185 imsControl = std::make_shared<IMSControl>();
186 TELEPHONY_LOGI("ReportImsCallsData, make control");
187 serviceInstance_->SetImsControl(slotId_, imsControl);
188 }
189 }
190 if (imsControl == nullptr) {
191 TELEPHONY_LOGE("ReportImsCallsData return, ims_control is nullptr");
192 return;
193 }
194 imsControl->ReportCallsData(slotId_, imsCallInfoList);
195 }
196
GetCsCallsDataResponse(const AppExecFwk::InnerEvent::Pointer & event)197 void CellularCallHandler::GetCsCallsDataResponse(const AppExecFwk::InnerEvent::Pointer &event)
198 {
199 if (event == nullptr) {
200 TELEPHONY_LOGE("GetCsCallsDataResponse return, event is nullptr");
201 return;
202 }
203 // Returns list of current calls of ME. If command succeeds but no calls are available,
204 // no information response is sent to TE. Refer subclause 9.2 for possible <err> values.
205 auto callInfoList = event->GetSharedObject<CallInfoList>();
206 if (callInfoList == nullptr) {
207 TELEPHONY_LOGE("GetCsCallsDataResponse, Cannot get the callInfoList, need to get rilResponseInfo");
208 auto rilResponseInfo = event->GetSharedObject<HRilRadioResponseInfo>();
209 if (rilResponseInfo == nullptr) {
210 TELEPHONY_LOGE("GetCsCallsDataResponse return, callInfoList and rilResponseInfo is nullptr");
211 return;
212 }
213 if (rilResponseInfo->error == HRilErrType::NONE) {
214 TELEPHONY_LOGE("GetCsCallsDataResponse return, failed to query the call list but no reason!");
215 return;
216 }
217 TELEPHONY_LOGE("GetCsCallsDataResponse error, report to call_manager");
218 CellularCallEventInfo eventInfo;
219 eventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
220 eventInfo.eventId = RequestResultEventId::RESULT_GET_CURRENT_CALLS_FAILED;
221 if (registerInstance_ == nullptr) {
222 TELEPHONY_LOGE("GetCsCallsDataResponse return, GetInstance is nullptr");
223 return;
224 }
225 registerInstance_->ReportEventResultInfo(eventInfo);
226 return;
227 }
228 ReportCsCallsData(*callInfoList);
229 }
230
GetImsCallsDataResponse(const AppExecFwk::InnerEvent::Pointer & event)231 void CellularCallHandler::GetImsCallsDataResponse(const AppExecFwk::InnerEvent::Pointer &event)
232 {
233 if (event == nullptr) {
234 TELEPHONY_LOGE("GetImsCallsDataResponse return, event is nullptr");
235 return;
236 }
237 // Returns list of current calls of ME. If command succeeds but no calls are available,
238 // no information response is sent to TE. Refer subclause 9.2 for possible <err> values.
239 auto imsCallInfoList = event->GetSharedObject<CallInfoList>();
240 if (imsCallInfoList == nullptr) {
241 TELEPHONY_LOGE("GetImsCallsDataResponse, Cannot get the imsCallInfoList, need to get rilResponseInfo");
242 auto rilResponseInfo = event->GetSharedObject<HRilRadioResponseInfo>();
243 if (rilResponseInfo == nullptr) {
244 TELEPHONY_LOGE("GetImsCallsDataResponse return, callInfoList and rilResponseInfo is nullptr");
245 return;
246 }
247 if (rilResponseInfo->error == HRilErrType::NONE) {
248 TELEPHONY_LOGE("GetImsCallsDataResponse return, failed to query the call list but no reason!");
249 return;
250 }
251 TELEPHONY_LOGE("GetImsCallsDataResponse error, report to call_manager");
252 if (registerInstance_ == nullptr) {
253 TELEPHONY_LOGE("GetImsCallsDataResponse return, GetInstance is nullptr");
254 return;
255 }
256 registerInstance_->ReportGetCallDataResult(static_cast<int32_t>(rilResponseInfo->error));
257 return;
258 }
259 ReportImsCallsData(*imsCallInfoList);
260 }
261
DialResponse(const AppExecFwk::InnerEvent::Pointer & event)262 void CellularCallHandler::DialResponse(const AppExecFwk::InnerEvent::Pointer &event)
263 {
264 if (event == nullptr) {
265 TELEPHONY_LOGE("DialResponse return, event is nullptr");
266 return;
267 }
268 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
269 if (result == nullptr) {
270 TELEPHONY_LOGE("DialResponse return, result is nullptr");
271 return;
272 }
273 if (result->error != HRilErrType::NONE) {
274 TELEPHONY_LOGI("DialResponse, dial return error, report to call_manager");
275 CellularCallEventInfo eventInfo;
276 eventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
277
278 /*
279 * 3GPP TS 27.007 V3.9.0 (2001-06)
280 * If ME has succeeded in establishing a logical link between application protocols and external interface,
281 * it will send CONNECT message to the TE. Otherwise, the NO CARRIER response will be returned.
282 */
283 if (result->error == HRilErrType::HRIL_ERR_CMD_NO_CARRIER) {
284 eventInfo.eventId = RequestResultEventId::RESULT_DIAL_NO_CARRIER;
285 } else {
286 eventInfo.eventId = RequestResultEventId::RESULT_DIAL_SEND_FAILED;
287 }
288 if (registerInstance_ == nullptr) {
289 TELEPHONY_LOGE("DialResponse return, GetInstance is nullptr");
290 return;
291 }
292 registerInstance_->ReportEventResultInfo(eventInfo);
293 }
294 }
295
CommonResultResponse(const AppExecFwk::InnerEvent::Pointer & event)296 void CellularCallHandler::CommonResultResponse(const AppExecFwk::InnerEvent::Pointer &event)
297 {
298 if (event == nullptr) {
299 TELEPHONY_LOGE("CommonResultResponse return, event is nullptr");
300 return;
301 }
302 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
303 if (result == nullptr) {
304 TELEPHONY_LOGE("CommonResultResponse return, result is nullptr");
305 return;
306 }
307 if (result->error != HRilErrType::NONE) {
308 CellularCallEventInfo eventInfo;
309 eventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
310 switch (event->GetInnerEventId()) {
311 case RadioEvent::RADIO_HANGUP_CONNECT:
312 eventInfo.eventId = RequestResultEventId::RESULT_END_SEND_FAILED;
313 break;
314 case RadioEvent::RADIO_REJECT_CALL:
315 eventInfo.eventId = RequestResultEventId::RESULT_REJECT_SEND_FAILED;
316 break;
317 case RadioEvent::RADIO_ACCEPT_CALL:
318 eventInfo.eventId = RequestResultEventId::RESULT_ACCEPT_SEND_FAILED;
319 break;
320 case RadioEvent::RADIO_HOLD_CALL:
321 eventInfo.eventId = RequestResultEventId::RESULT_HOLD_SEND_FAILED;
322 break;
323 case RadioEvent::RADIO_ACTIVE_CALL:
324 eventInfo.eventId = RequestResultEventId::RESULT_ACTIVE_SEND_FAILED;
325 break;
326 case RadioEvent::RADIO_SWAP_CALL:
327 eventInfo.eventId = RequestResultEventId::RESULT_SWAP_SEND_FAILED;
328 break;
329 case RadioEvent::RADIO_JOIN_CALL:
330 eventInfo.eventId = RequestResultEventId::RESULT_JOIN_SEND_FAILED;
331 break;
332 case RadioEvent::RADIO_SPLIT_CALL:
333 eventInfo.eventId = RequestResultEventId::RESULT_SPLIT_SEND_FAILED;
334 break;
335 case RadioEvent::RADIO_CALL_SUPPLEMENT:
336 eventInfo.eventId = RequestResultEventId::RESULT_SUPPLEMENT_SEND_FAILED;
337 break;
338 default:
339 break;
340 }
341 if (registerInstance_ == nullptr) {
342 TELEPHONY_LOGE("CommonResultResponse return, registerInstance_ is nullptr");
343 return;
344 }
345 registerInstance_->ReportEventResultInfo(eventInfo);
346 return;
347 }
348 }
349
SendDtmfResponse(const AppExecFwk::InnerEvent::Pointer & event)350 void CellularCallHandler::SendDtmfResponse(const AppExecFwk::InnerEvent::Pointer &event)
351 {
352 if (event == nullptr) {
353 TELEPHONY_LOGE("SendDtmfResponse return, event is nullptr");
354 return;
355 }
356 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
357 if (result == nullptr) {
358 TELEPHONY_LOGE("SendDtmfResponse return, result is nullptr");
359 return;
360 }
361 CellularCallEventInfo eventInfo;
362 eventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
363 if (result->error != HRilErrType::NONE) {
364 eventInfo.eventId = RequestResultEventId::RESULT_SEND_DTMF_FAILED;
365 } else {
366 eventInfo.eventId = RequestResultEventId::RESULT_SEND_DTMF_SUCCESS;
367 }
368 if (registerInstance_ == nullptr) {
369 TELEPHONY_LOGE("SendDtmfResponse return, GetInstance is nullptr");
370 return;
371 }
372 TELEPHONY_LOGI("SendDtmfResponse: report to call manager");
373 registerInstance_->ReportEventResultInfo(eventInfo);
374 }
375
StartDtmfResponse(const AppExecFwk::InnerEvent::Pointer & event)376 void CellularCallHandler::StartDtmfResponse(const AppExecFwk::InnerEvent::Pointer &event)
377 {
378 if (event == nullptr) {
379 TELEPHONY_LOGE("StartDtmfResponse return, event is nullptr");
380 return;
381 }
382 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
383 if (result == nullptr) {
384 TELEPHONY_LOGE("StartDtmfResponse return, result is nullptr");
385 return;
386 }
387
388 if (registerInstance_ == nullptr) {
389 TELEPHONY_LOGE("StartDtmfResponse return, GetInstance is nullptr");
390 return;
391 }
392 TELEPHONY_LOGI("StartDtmfResponse: report to call manager");
393 registerInstance_->ReportStartDtmfResult(static_cast<int32_t>(result->error));
394 }
395
StopDtmfResponse(const AppExecFwk::InnerEvent::Pointer & event)396 void CellularCallHandler::StopDtmfResponse(const AppExecFwk::InnerEvent::Pointer &event)
397 {
398 if (event == nullptr) {
399 TELEPHONY_LOGE("StopDtmfResponse return, event is nullptr");
400 return;
401 }
402 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
403 if (result == nullptr) {
404 TELEPHONY_LOGE("StopDtmfResponse return, result is nullptr");
405 return;
406 }
407
408 if (registerInstance_ == nullptr) {
409 TELEPHONY_LOGE("StopDtmfResponse return, GetInstance is nullptr");
410 return;
411 }
412 TELEPHONY_LOGI("StopDtmfResponse: report to call manager");
413 registerInstance_->ReportStopDtmfResult(static_cast<int32_t>(result->error));
414 }
415
SetSlotId(int32_t id)416 void CellularCallHandler::SetSlotId(int32_t id)
417 {
418 slotId_ = id;
419 }
420
GetSlotId()421 int32_t CellularCallHandler::GetSlotId()
422 {
423 return slotId_;
424 }
425
CurrentTimeMillis()426 int64_t CellularCallHandler::CurrentTimeMillis()
427 {
428 int64_t timems =
429 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
430 .count();
431 return timems;
432 }
433
IsCanRequestCallsData()434 bool CellularCallHandler::IsCanRequestCallsData()
435 {
436 int64_t timems = CurrentTimeMillis();
437 if ((timems - lastTime_) < FAST_DELAY_TIME) {
438 return false;
439 }
440 lastTime_ = timems;
441 return true;
442 }
443
GetCsCallsDataRequest(const AppExecFwk::InnerEvent::Pointer & event)444 void CellularCallHandler::GetCsCallsDataRequest(const AppExecFwk::InnerEvent::Pointer &event)
445 {
446 if (!IsCanRequestCallsData()) {
447 TELEPHONY_LOGE("GetCsCallsDataRequest return, IsCanRequestCallsData false");
448 }
449 lastCallsDataFlag_ = CurrentTimeMillis();
450 CellularCallConnectionCS connectionCs;
451 connectionCs.GetCsCallsDataRequest(slotId_, lastCallsDataFlag_);
452 }
453
GetImsCallsDataRequest(const AppExecFwk::InnerEvent::Pointer & event)454 void CellularCallHandler::GetImsCallsDataRequest(const AppExecFwk::InnerEvent::Pointer &event)
455 {
456 if (!IsCanRequestCallsData()) {
457 TELEPHONY_LOGE("GetImsCallsDataRequest return, IsCanRequestCallsData false");
458 }
459 lastCallsDataFlag_ = CurrentTimeMillis();
460 CellularCallConnectionIMS connectionIms;
461 connectionIms.GetImsCallsDataRequest(slotId_, lastCallsDataFlag_);
462 }
463
RegisterHandler(const AppExecFwk::InnerEvent::Pointer & event)464 void CellularCallHandler::RegisterHandler(const AppExecFwk::InnerEvent::Pointer &event)
465 {
466 CellularCallConnectionCS connectionCs;
467 connectionCs.RegisterHandler();
468 }
469
RegisterImsCallback(const AppExecFwk::InnerEvent::Pointer & event)470 void CellularCallHandler::RegisterImsCallback(const AppExecFwk::InnerEvent::Pointer &event)
471 {
472 TELEPHONY_LOGI("RegisterImsCallback entry");
473 if (registerInstance_ == nullptr) {
474 TELEPHONY_LOGE("RegisterImsCallback return, GetInstance is nullptr");
475 return;
476 }
477 registerInstance_->RegisterImsCallBack();
478 }
479
SetDomainPreferenceModeResponse(const AppExecFwk::InnerEvent::Pointer & event)480 void CellularCallHandler::SetDomainPreferenceModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
481 {
482 TELEPHONY_LOGI("SetDomainPreferenceModeResponse entry");
483 if (event == nullptr) {
484 TELEPHONY_LOGE("SetDomainPreferenceModeResponse return, event is nullptr");
485 return;
486 }
487 auto info = event->GetSharedObject<HRilRadioResponseInfo>();
488 if (info == nullptr) {
489 TELEPHONY_LOGE("SetDomainPreferenceModeResponse return, info is nullptr");
490 return;
491 }
492 CellularCallEventInfo eventInfo;
493 eventInfo.eventType = CellularCallEventType::EVENT_REQUEST_RESULT_TYPE;
494 if (info->error != HRilErrType::NONE) {
495 eventInfo.eventId = RequestResultEventId::RESULT_SET_CALL_PREFERENCE_MODE_FAILED;
496 } else {
497 eventInfo.eventId = RequestResultEventId::RESULT_SET_CALL_PREFERENCE_MODE_SUCCESS;
498
499 CellularCallConfig config;
500 config.SetTempMode(slotId_);
501 }
502 if (registerInstance_ == nullptr) {
503 TELEPHONY_LOGE("SetDomainPreferenceModeResponse return, GetInstance is nullptr");
504 return;
505 }
506 registerInstance_->ReportEventResultInfo(eventInfo);
507 }
508
GetDomainPreferenceModeResponse(const AppExecFwk::InnerEvent::Pointer & event)509 void CellularCallHandler::GetDomainPreferenceModeResponse(const AppExecFwk::InnerEvent::Pointer &event)
510 {
511 TELEPHONY_LOGE("GetDomainPreferenceModeResponse entry");
512 if (event == nullptr) {
513 TELEPHONY_LOGE("GetDomainPreferenceModeResponse return, event is nullptr");
514 return;
515 }
516 auto mode = event->GetSharedObject<int32_t>();
517 if (mode == nullptr) {
518 TELEPHONY_LOGI("GetDomainPreferenceModeResponse return, mode is nullptr");
519 return;
520 }
521 CellularCallConfig config;
522 config.GetDomainPreferenceModeResponse(slotId_, *mode);
523 }
524
SetLteImsSwitchStatusResponse(const AppExecFwk::InnerEvent::Pointer & event)525 void CellularCallHandler::SetLteImsSwitchStatusResponse(const AppExecFwk::InnerEvent::Pointer &event)
526 {
527 TELEPHONY_LOGI("SetLteImsSwitchStatusResponse entry");
528 if (event == nullptr) {
529 TELEPHONY_LOGE("SetLteImsSwitchStatusResponse return, event is nullptr");
530 return;
531 }
532 auto info = event->GetSharedObject<HRilRadioResponseInfo>();
533 if (info == nullptr) {
534 TELEPHONY_LOGE("SetLteImsSwitchStatusResponse return, info is nullptr");
535 return;
536 }
537 if (registerInstance_ == nullptr) {
538 TELEPHONY_LOGE("SetLteImsSwitchStatusResponse return, GetInstance is nullptr");
539 return;
540 }
541 registerInstance_->ReportSetLteImsSwitchResult(static_cast<int32_t>(info->error));
542 }
543
GetLteImsSwitchStatusResponse(const AppExecFwk::InnerEvent::Pointer & event)544 void CellularCallHandler::GetLteImsSwitchStatusResponse(const AppExecFwk::InnerEvent::Pointer &event)
545 {
546 TELEPHONY_LOGI("GetLteImsSwitchStatusResponse entry");
547 if (event == nullptr) {
548 TELEPHONY_LOGE("GetLteImsSwitchStatusResponse return, event is nullptr");
549 return;
550 }
551 LteImsSwitchResponse lteImsSwitch;
552 auto active = event->GetSharedObject<int32_t>();
553 if (active == nullptr) {
554 TELEPHONY_LOGI("GetLteImsSwitchStatusResponse, Cannot get the active, need to get rilResponseInfo");
555 auto info = event->GetSharedObject<HRilRadioResponseInfo>();
556 if (info == nullptr) {
557 TELEPHONY_LOGE("GetLteImsSwitchStatusResponse return, info is nullptr");
558 return;
559 }
560 lteImsSwitch.result = static_cast<int32_t>(info->error);
561 } else {
562 CellularCallConfig config;
563 config.GetLteImsSwitchStatusResponse(slotId_, *active);
564 lteImsSwitch.result = static_cast<int32_t>(HRilErrType::NONE);
565 lteImsSwitch.active = *active;
566 }
567 if (registerInstance_ == nullptr) {
568 TELEPHONY_LOGE("GetLteImsSwitchStatusResponse return, GetInstance is nullptr");
569 return;
570 }
571 registerInstance_->ReportGetLteImsSwitchResult(lteImsSwitch);
572 }
573
CallStatusInfoResponse(const AppExecFwk::InnerEvent::Pointer & event)574 void CellularCallHandler::CallStatusInfoResponse(const AppExecFwk::InnerEvent::Pointer &event)
575 {
576 if (event == nullptr) {
577 TELEPHONY_LOGE("CallStatusInfoResponse return, event is nullptr");
578 return;
579 }
580 auto serviceInstance_ = DelayedSingleton<CellularCallService>::GetInstance();
581 if (serviceInstance_ == nullptr) {
582 TELEPHONY_LOGE("CallStatusInfoResponse return, GetInstance is nullptr");
583 return;
584 }
585 if (callType_ == CallType::TYPE_ERR_CALL) {
586 TELEPHONY_LOGI("CallStatusInfoResponse, default call type");
587 if (serviceInstance_->IsNeedIms(slotId_)) {
588 GetImsCallData(event);
589 } else {
590 GetCsCallData(event);
591 }
592 } else if (callType_ == CallType::TYPE_CS) {
593 GetCsCallData(event);
594 } else if (callType_ == CallType::TYPE_IMS) {
595 GetImsCallData(event);
596 }
597 }
598
CallImsServiceStatusResponse(const AppExecFwk::InnerEvent::Pointer & event)599 void CellularCallHandler::CallImsServiceStatusResponse(const AppExecFwk::InnerEvent::Pointer &event)
600 {
601 TELEPHONY_LOGI("CellularCallHandler::CallImsServiceStatusResponse entry");
602 }
603
SetCallType(CallType callType)604 void CellularCallHandler::SetCallType(CallType callType)
605 {
606 callType_ = callType;
607 }
608
UssdNotifyResponse(const AppExecFwk::InnerEvent::Pointer & event)609 void CellularCallHandler::UssdNotifyResponse(const AppExecFwk::InnerEvent::Pointer &event)
610 {
611 TELEPHONY_LOGI("CellularCallHandler::UssdNotifyResponse entry");
612 }
613
SetMuteResponse(const AppExecFwk::InnerEvent::Pointer & event)614 void CellularCallHandler::SetMuteResponse(const AppExecFwk::InnerEvent::Pointer &event)
615 {
616 TELEPHONY_LOGI("CellularCallHandler::SetMuteResponse entry");
617 if (event == nullptr) {
618 TELEPHONY_LOGE("SetMuteResponse return, event is nullptr");
619 return;
620 }
621 auto info = event->GetSharedObject<HRilRadioResponseInfo>();
622 if (info == nullptr) {
623 TELEPHONY_LOGE("SetMuteResponse return, info is nullptr");
624 return;
625 }
626 MuteControlResponse response;
627 if (registerInstance_ == nullptr) {
628 TELEPHONY_LOGE("SetMuteResponse return, registerInstance_ is nullptr");
629 return;
630 }
631 response.result = static_cast<int32_t>(info->error);
632 TELEPHONY_LOGI("SetMuteResponse: report to call manager");
633 registerInstance_->ReportSetMuteResult(response);
634 }
635
GetMuteResponse(const AppExecFwk::InnerEvent::Pointer & event)636 void CellularCallHandler::GetMuteResponse(const AppExecFwk::InnerEvent::Pointer &event)
637 {
638 TELEPHONY_LOGI("CellularCallHandler::GetMuteResponse entry");
639 if (event == nullptr) {
640 TELEPHONY_LOGE("GetMuteResponse return, event is nullptr");
641 return;
642 }
643 MuteControlResponse response;
644 auto mute = event->GetSharedObject<int32_t>();
645 if (mute == nullptr) {
646 TELEPHONY_LOGI("GetMuteResponse, mute is nullptr");
647 auto info = event->GetSharedObject<HRilRadioResponseInfo>();
648 if (info == nullptr) {
649 TELEPHONY_LOGE("GetMuteResponse return, info is nullptr");
650 return;
651 }
652 response.result = static_cast<int32_t>(info->error);
653 } else {
654 response.result = static_cast<int32_t>(HRilErrType::NONE);
655 response.value = *mute;
656 }
657 if (registerInstance_ == nullptr) {
658 TELEPHONY_LOGE("GetMuteResponse return, registerInstance_ is nullptr");
659 return;
660 }
661 TELEPHONY_LOGI("GetMuteResponse: report to call manager");
662 registerInstance_->ReportGetMuteResult(response);
663 }
664
GetEmergencyCallListResponse(const AppExecFwk::InnerEvent::Pointer & event)665 void CellularCallHandler::GetEmergencyCallListResponse(const AppExecFwk::InnerEvent::Pointer &event)
666 {
667 TELEPHONY_LOGI("CellularCallHandler::GetEmergencyCallListResponse entry");
668 if (event == nullptr) {
669 TELEPHONY_LOGE("GetEmergencyCallListResponse return, event is nullptr");
670 return;
671 }
672 auto eccList = event->GetSharedObject<EmergencyInfoList>();
673 if (eccList == nullptr) {
674 TELEPHONY_LOGE("GetEmergencyCallListResponse return, eccList is nullptr");
675 return;
676 }
677 CellularCallConfig config;
678 config.GetEmergencyCallListResponse(slotId_, *eccList);
679 }
680
CallRingBackVoiceResponse(const AppExecFwk::InnerEvent::Pointer & event)681 void CellularCallHandler::CallRingBackVoiceResponse(const AppExecFwk::InnerEvent::Pointer &event)
682 {
683 TELEPHONY_LOGI("CellularCallHandler::CallRingBackVoiceResponse entry");
684 if (event == nullptr) {
685 TELEPHONY_LOGE("CallRingBackVoiceResponse return, event is nullptr");
686 return;
687 }
688 auto ringBackVoice = event->GetSharedObject<RingbackVoice>();
689 if (ringBackVoice == nullptr) {
690 TELEPHONY_LOGE("CallRingBackVoiceResponse return, ringBackVoice is nullptr");
691 return;
692 }
693 if (registerInstance_ == nullptr) {
694 TELEPHONY_LOGE("CallRingBackVoiceResponse return, registerInstance_ is nullptr");
695 return;
696 }
697 TELEPHONY_LOGI("CallRingBackVoiceResponse: report to call manager");
698 registerInstance_->ReportCallRingBackResult(ringBackVoice->status);
699 }
700
GetCallFailReasonResponse(const AppExecFwk::InnerEvent::Pointer & event)701 void CellularCallHandler::GetCallFailReasonResponse(const AppExecFwk::InnerEvent::Pointer &event)
702 {
703 TELEPHONY_LOGI("CellularCallHandler::GetCallFailReasonResponse entry");
704 if (event == nullptr) {
705 TELEPHONY_LOGE("GetCallFailReasonResponse return, event is nullptr");
706 return;
707 }
708 auto reason = event->GetSharedObject<int32_t>();
709 if (reason == nullptr) {
710 TELEPHONY_LOGE("GetCallFailReasonResponse return, reason is nullptr");
711 return;
712 }
713 if (registerInstance_ == nullptr) {
714 TELEPHONY_LOGE("GetCallFailReasonResponse return, registerInstance_ is nullptr");
715 return;
716 }
717 TELEPHONY_LOGI("GetCallFailReasonResponse: %{public}d, report to call manager", *reason);
718 registerInstance_->ReportCallFailReason(*reason);
719 }
720
UpdateSrvccStateReport(const AppExecFwk::InnerEvent::Pointer & event)721 void CellularCallHandler::UpdateSrvccStateReport(const AppExecFwk::InnerEvent::Pointer &event)
722 {
723 TELEPHONY_LOGI("CellularCallHandler::UpdateSrvccStateReport entry");
724 if (event == nullptr) {
725 TELEPHONY_LOGE("UpdateSrvccStateReport return, event is nullptr");
726 return;
727 }
728 auto srvccStatus = event->GetSharedObject<HRilCallSrvccStatus>();
729 if (srvccStatus == nullptr) {
730 TELEPHONY_LOGE("UpdateSrvccStateReport return, srvccStatus is nullptr");
731 return;
732 }
733 srvccState_ = srvccStatus->status;
734 if (srvccState_ != SrvccState::COMPLETED) {
735 TELEPHONY_LOGE("UpdateSrvccStateReport return, srvccState_ != SrvccState::COMPLETED");
736 return;
737 }
738 SrvccStateCompleted();
739 }
740
SrvccStateCompleted()741 void CellularCallHandler::SrvccStateCompleted()
742 {
743 if (srvccState_ != SrvccState::COMPLETED) {
744 TELEPHONY_LOGE("SrvccStateCompleted return, srvccState_ != SrvccState::COMPLETED");
745 return;
746 }
747 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CALL_STATUS_INFO);
748 CallStatusInfoResponse(event);
749 srvccState_ = SrvccState::SRVCC_NONE;
750 }
751
GetMMIResponse(const AppExecFwk::InnerEvent::Pointer & event)752 void CellularCallHandler::GetMMIResponse(const AppExecFwk::InnerEvent::Pointer &event)
753 {
754 if (event == nullptr) {
755 TELEPHONY_LOGE("GetMMIResponse, event is nullptr");
756 return;
757 }
758 std::unique_ptr<MMICodeUtils> mmiCodeUtils = event->GetUniqueObject<MMICodeUtils>();
759 if (mmiCodeUtils == nullptr) {
760 TELEPHONY_LOGE("CellularCallHandler::GetMMIResponse, mmiCodeUtils is nullptr");
761 return;
762 }
763 mmiCodeUtils->ExecuteMmiCode(slotId_);
764 }
765
GetCallWaitingResponse(const AppExecFwk::InnerEvent::Pointer & event)766 void CellularCallHandler::GetCallWaitingResponse(const AppExecFwk::InnerEvent::Pointer &event)
767 {
768 TELEPHONY_LOGI("CellularCallHandler::GetCallWaitingResponse entry");
769 if (event == nullptr) {
770 TELEPHONY_LOGE("GetCallWaitingResponse, event is nullptr");
771 return;
772 }
773 auto result = event->GetSharedObject<CallWaitResult>();
774 if (result == nullptr) {
775 TELEPHONY_LOGE("CellularCallHandler::GetCallWaitingResponse, result is nullptr");
776 return;
777 }
778 CellularCallSupplement supplement;
779 supplement.EventGetCallWaiting(*result);
780 }
781
SetCallWaitingResponse(const AppExecFwk::InnerEvent::Pointer & event)782 void CellularCallHandler::SetCallWaitingResponse(const AppExecFwk::InnerEvent::Pointer &event)
783 {
784 TELEPHONY_LOGI("SetCallWaitingResponse entry");
785 if (event == nullptr) {
786 TELEPHONY_LOGE("SetCallWaitingResponse, event is nullptr");
787 return;
788 }
789 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
790 if (result == nullptr) {
791 TELEPHONY_LOGE("SetCallWaitingResponse, result is nullptr");
792 return;
793 }
794 CellularCallSupplement supplement;
795 supplement.EventSetCallWaiting(*result);
796 }
797
GetClirResponse(const AppExecFwk::InnerEvent::Pointer & event)798 void CellularCallHandler::GetClirResponse(const AppExecFwk::InnerEvent::Pointer &event)
799 {
800 TELEPHONY_LOGI("GetClirResponse entry");
801 if (event == nullptr) {
802 TELEPHONY_LOGE("GetClirResponse, event is nullptr");
803 return;
804 }
805 auto getClirResult = event->GetSharedObject<GetClirResult>();
806 if (getClirResult == nullptr) {
807 TELEPHONY_LOGE("GetClirResponse, getClirResult is nullptr");
808 return;
809 }
810 CellularCallSupplement supplement;
811 supplement.EventGetClir(*getClirResult);
812 }
813
SetClirResponse(const AppExecFwk::InnerEvent::Pointer & event)814 void CellularCallHandler::SetClirResponse(const AppExecFwk::InnerEvent::Pointer &event)
815 {
816 TELEPHONY_LOGI("SetClirResponse entry");
817 if (event == nullptr) {
818 TELEPHONY_LOGE("SetClirResponse, event is nullptr");
819 return;
820 }
821 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
822 if (result == nullptr) {
823 TELEPHONY_LOGE("SetClirResponse, result is nullptr");
824 return;
825 }
826 CellularCallSupplement supplement;
827 supplement.EventSetClir(*result);
828 }
829
GetClipResponse(const AppExecFwk::InnerEvent::Pointer & event)830 void CellularCallHandler::GetClipResponse(const AppExecFwk::InnerEvent::Pointer &event)
831 {
832 TELEPHONY_LOGI("GetClipResponse entry");
833 if (event == nullptr) {
834 TELEPHONY_LOGE("GetClipResponse, event is nullptr");
835 return;
836 }
837 auto getClipResult = event->GetSharedObject<GetClipResult>();
838 if (getClipResult == nullptr) {
839 TELEPHONY_LOGE("GetClipResponse, getClipResult is nullptr");
840 return;
841 }
842 CellularCallSupplement supplement;
843 supplement.EventGetClip(*getClipResult);
844 }
845
GetCallTransferResponse(const AppExecFwk::InnerEvent::Pointer & event)846 void CellularCallHandler::GetCallTransferResponse(const AppExecFwk::InnerEvent::Pointer &event)
847 {
848 TELEPHONY_LOGI("GetCallTransferResponse entry");
849 if (event == nullptr) {
850 TELEPHONY_LOGE("GetCallTransferResponse, event is nullptr");
851 return;
852 }
853 auto cFQueryResult = event->GetSharedObject<CallForwardQueryResult>();
854 if (cFQueryResult == nullptr) {
855 TELEPHONY_LOGE("GetCallTransferResponse, cFQueryResult is nullptr");
856 return;
857 }
858 CellularCallSupplement supplement;
859 supplement.EventGetCallTransferInfo(*cFQueryResult);
860 }
861
SetCallTransferInfoResponse(const AppExecFwk::InnerEvent::Pointer & event)862 void CellularCallHandler::SetCallTransferInfoResponse(const AppExecFwk::InnerEvent::Pointer &event)
863 {
864 TELEPHONY_LOGI("SetCallTransferInfoResponse entry");
865 if (event == nullptr) {
866 TELEPHONY_LOGE("SetCallTransferInfoResponse, event is nullptr");
867 return;
868 }
869 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
870 if (result == nullptr) {
871 TELEPHONY_LOGE("SetCallTransferInfoResponse, result is nullptr");
872 return;
873 }
874 CellularCallSupplement supplement;
875 supplement.EventSetCallTransferInfo(*result);
876 }
877
GetCallRestrictionResponse(const AppExecFwk::InnerEvent::Pointer & event)878 void CellularCallHandler::GetCallRestrictionResponse(const AppExecFwk::InnerEvent::Pointer &event)
879 {
880 TELEPHONY_LOGI("GetCallRestrictionResponse entry");
881 if (event == nullptr) {
882 TELEPHONY_LOGE("GetCallRestrictionResponse, event is nullptr");
883 return;
884 }
885 auto result = event->GetSharedObject<CallRestrictionResult>();
886 if (result == nullptr) {
887 TELEPHONY_LOGE("GetCallRestrictionResponse, result is nullptr");
888 return;
889 }
890 CellularCallSupplement supplement;
891 supplement.EventGetCallRestriction(*result);
892 }
893
SetCallRestrictionResponse(const AppExecFwk::InnerEvent::Pointer & event)894 void CellularCallHandler::SetCallRestrictionResponse(const AppExecFwk::InnerEvent::Pointer &event)
895 {
896 TELEPHONY_LOGI("SetCallRestrictionResponse entry");
897 if (event == nullptr) {
898 TELEPHONY_LOGE("SetCallRestrictionResponse, event is nullptr");
899 return;
900 }
901 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
902 if (result == nullptr) {
903 TELEPHONY_LOGE("SetCallRestrictionResponse, result is nullptr");
904 return;
905 }
906 CellularCallSupplement supplement;
907 supplement.EventSetCallRestriction(*result);
908 }
909
SendUssdResponse(const AppExecFwk::InnerEvent::Pointer & event)910 void CellularCallHandler::SendUssdResponse(const AppExecFwk::InnerEvent::Pointer &event)
911 {
912 if (event == nullptr) {
913 TELEPHONY_LOGE("SendUssdResponse, event is nullptr");
914 return;
915 }
916 auto result = event->GetSharedObject<HRilRadioResponseInfo>();
917 if (result == nullptr) {
918 TELEPHONY_LOGE("SendUssdResponse, result is nullptr");
919 return;
920 }
921 CellularCallSupplement supplement;
922 supplement.EventSendUssd(*result);
923 }
924 } // namespace Telephony
925 } // namespace OHOS