1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "call_status_manager.h"
17
18 #include <securec.h>
19
20 #include "audio_control_manager.h"
21 #include "bluetooth_call_service.h"
22 #include "call_control_manager.h"
23 #include "call_manager_errors.h"
24 #include "call_manager_hisysevent.h"
25 #include "call_number_utils.h"
26 #include "core_service_client.h"
27 #include "cs_call.h"
28 #include "datashare_predicates.h"
29 #include "hitrace_meter.h"
30 #include "ims_call.h"
31 #include "ott_call.h"
32 #include "report_call_info_handler.h"
33 #include "satellite_call.h"
34 #include "telephony_log_wrapper.h"
35 #include "voip_call.h"
36
37 namespace OHOS {
38 namespace Telephony {
39 constexpr int32_t INIT_INDEX = 0;
CallStatusManager()40 CallStatusManager::CallStatusManager()
41 {
42 (void)memset_s(&callReportInfo_, sizeof(CallDetailInfo), 0, sizeof(CallDetailInfo));
43 for (int32_t i = 0; i < SLOT_NUM; i++) {
44 (void)memset_s(&callDetailsInfo_[i], sizeof(CallDetailsInfo), 0, sizeof(CallDetailsInfo));
45 }
46 }
47
~CallStatusManager()48 CallStatusManager::~CallStatusManager()
49 {
50 UnInit();
51 }
52
Init()53 int32_t CallStatusManager::Init()
54 {
55 for (int32_t i = 0; i < SLOT_NUM; i++) {
56 callDetailsInfo_[i].callVec.clear();
57 }
58 for (int32_t i = 0; i < SLOT_NUM; i++) {
59 priorVideoState_[i] = VideoStateType::TYPE_VOICE;
60 }
61 mEventIdTransferMap_.clear();
62 mOttEventIdTransferMap_.clear();
63 InitCallBaseEvent();
64 CallIncomingFilterManagerPtr_ = (std::make_unique<CallIncomingFilterManager>()).release();
65 return TELEPHONY_SUCCESS;
66 }
67
InitCallBaseEvent()68 void CallStatusManager::InitCallBaseEvent()
69 {
70 mEventIdTransferMap_[RequestResultEventId::RESULT_DIAL_NO_CARRIER] = CallAbilityEventId::EVENT_DIAL_NO_CARRIER;
71 mEventIdTransferMap_[RequestResultEventId::RESULT_HOLD_SEND_FAILED] = CallAbilityEventId::EVENT_HOLD_CALL_FAILED;
72 mEventIdTransferMap_[RequestResultEventId::RESULT_SWAP_SEND_FAILED] = CallAbilityEventId::EVENT_SWAP_CALL_FAILED;
73 mOttEventIdTransferMap_[OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED] =
74 CallAbilityEventId::EVENT_OTT_FUNCTION_UNSUPPORTED;
75 mEventIdTransferMap_[RequestResultEventId::RESULT_COMBINE_SEND_FAILED] =
76 CallAbilityEventId::EVENT_COMBINE_CALL_FAILED;
77 mEventIdTransferMap_[RequestResultEventId::RESULT_SPLIT_SEND_FAILED] =
78 CallAbilityEventId::EVENT_SPLIT_CALL_FAILED;
79 }
80
UnInit()81 int32_t CallStatusManager::UnInit()
82 {
83 for (int32_t i = 0; i < SLOT_NUM; i++) {
84 callDetailsInfo_[i].callVec.clear();
85 }
86 mEventIdTransferMap_.clear();
87 mOttEventIdTransferMap_.clear();
88 return TELEPHONY_SUCCESS;
89 }
90
HandleCallReportInfo(const CallDetailInfo & info)91 int32_t CallStatusManager::HandleCallReportInfo(const CallDetailInfo &info)
92 {
93 int32_t ret = TELEPHONY_ERR_FAIL;
94 callReportInfo_ = info;
95 if (info.callType == CallType::TYPE_VOIP) {
96 ret = HandleVoipCallReportInfo(info);
97 return ret;
98 }
99 switch (info.state) {
100 case TelCallState::CALL_STATUS_ACTIVE:
101 ret = ActiveHandle(info);
102 break;
103 case TelCallState::CALL_STATUS_HOLDING:
104 ret = HoldingHandle(info);
105 break;
106 case TelCallState::CALL_STATUS_DIALING: {
107 ret = DialingHandle(info);
108 FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
109 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingDialTimeOut(
110 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
111 break;
112 }
113 case TelCallState::CALL_STATUS_ALERTING:
114 ret = AlertHandle(info);
115 break;
116 case TelCallState::CALL_STATUS_INCOMING: {
117 ret = IncomingHandle(info);
118 FinishAsyncTrace(HITRACE_TAG_OHOS, "InComingCall", getpid());
119 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingIncomingTimeOut(
120 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
121 break;
122 }
123 case TelCallState::CALL_STATUS_WAITING:
124 ret = WaitingHandle(info);
125 break;
126 case TelCallState::CALL_STATUS_DISCONNECTED:
127 ret = DisconnectedHandle(info);
128 break;
129 case TelCallState::CALL_STATUS_DISCONNECTING:
130 ret = DisconnectingHandle(info);
131 break;
132 default:
133 TELEPHONY_LOGE("Invalid call state!");
134 break;
135 }
136 TELEPHONY_LOGI("Entry CallStatusManager HandleCallReportInfo");
137 HandleDsdaInfo(info.accountId);
138 DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
139 return ret;
140 }
141
HandleDsdaInfo(int32_t slotId)142 void CallStatusManager::HandleDsdaInfo(int32_t slotId)
143 {
144 int32_t dsdsMode = DSDS_MODE_V2;
145 bool noOtherCall = true;
146 std::list<int32_t> callIdList;
147 GetCarrierCallList(callIdList);
148 int32_t currentCallNum = GetCurrentCallNum();
149 DelayedSingleton<CallRequestProcess>::GetInstance()->IsExistCallOtherSlot(callIdList, slotId, noOtherCall);
150 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
151 if ((dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
152 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) &&
153 !noOtherCall) {
154 TELEPHONY_LOGI("Handle DsdaCallInfo");
155 sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
156 if (holdCall != nullptr && currentCallNum > CALL_NUMBER) {
157 holdCall->SetCanUnHoldState(false);
158 }
159 }
160 }
161
162 // handle call state changes, incoming call, outgoing call.
HandleCallsReportInfo(const CallDetailsInfo & info)163 int32_t CallStatusManager::HandleCallsReportInfo(const CallDetailsInfo &info)
164 {
165 bool flag = false;
166 TELEPHONY_LOGI("call list size:%{public}zu,slotId:%{public}d", info.callVec.size(), info.slotId);
167 int32_t curSlotId = info.slotId;
168 if (!DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(curSlotId)) {
169 TELEPHONY_LOGE("invalid slotId!");
170 return CALL_ERR_INVALID_SLOT_ID;
171 }
172 for (auto &it : info.callVec) {
173 for (const auto &it1 : callDetailsInfo_[curSlotId].callVec) {
174 if (it.index == it1.index) {
175 // call state changes
176 if (it.state != it1.state || it.mpty != it1.mpty ||
177 it.callType != it1.callType || it.callMode != it1.callMode) {
178 TELEPHONY_LOGI("handle updated call state:%{public}d", it.state);
179 HandleCallReportInfo(it);
180 }
181 flag = true;
182 break;
183 }
184 }
185 // incoming/outgoing call handle
186 if (!flag || callDetailsInfo_[curSlotId].callVec.empty()) {
187 TELEPHONY_LOGI("handle new call state:%{public}d", it.state);
188 HandleCallReportInfo(it);
189 }
190 flag = false;
191 }
192 // disconnected calls handle
193 for (auto &it2 : callDetailsInfo_[curSlotId].callVec) {
194 for (const auto &it3 : info.callVec) {
195 if (it2.index == it3.index) {
196 TELEPHONY_LOGI("state:%{public}d", it2.state);
197 flag = true;
198 break;
199 }
200 }
201 if (!flag) {
202 it2.state = TelCallState::CALL_STATUS_DISCONNECTED;
203 HandleCallReportInfo(it2);
204 }
205 flag = false;
206 }
207 callDetailsInfo_[curSlotId].callVec.clear();
208 callDetailsInfo_[curSlotId] = info;
209 return TELEPHONY_SUCCESS;
210 }
211
HandleVoipCallReportInfo(const CallDetailInfo & info)212 int32_t CallStatusManager::HandleVoipCallReportInfo(const CallDetailInfo &info)
213 {
214 TELEPHONY_LOGI("Entry CallStatusManager HandleVoipCallReportInfo");
215 int32_t ret = TELEPHONY_ERR_FAIL;
216 switch (info.state) {
217 case TelCallState::CALL_STATUS_ACTIVE:
218 ret = ActiveVoipCallHandle(info);
219 break;
220 case TelCallState::CALL_STATUS_INCOMING: {
221 ret = IncomingVoipCallHandle(info);
222 break;
223 }
224 case TelCallState::CALL_STATUS_DISCONNECTED:
225 ret = DisconnectedVoipCallHandle(info);
226 break;
227 default:
228 TELEPHONY_LOGE("Invalid call state!");
229 break;
230 }
231 DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
232 return ret;
233 }
234
HandleDisconnectedCause(const DisconnectedDetails & details)235 int32_t CallStatusManager::HandleDisconnectedCause(const DisconnectedDetails &details)
236 {
237 bool ret = DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallDestroyed(details);
238 if (!ret) {
239 TELEPHONY_LOGI("NotifyCallDestroyed failed!");
240 return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
241 }
242 return TELEPHONY_SUCCESS;
243 }
244
HandleEventResultReportInfo(const CellularCallEventInfo & info)245 int32_t CallStatusManager::HandleEventResultReportInfo(const CellularCallEventInfo &info)
246 {
247 if (info.eventType != CellularCallEventType::EVENT_REQUEST_RESULT_TYPE) {
248 TELEPHONY_LOGE("unexpected type event occurs, eventId:%{public}d", info.eventId);
249 return CALL_ERR_PHONE_TYPE_UNEXPECTED;
250 }
251 TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.eventId);
252 sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
253 if (call != nullptr) {
254 int32_t ret = DealFailDial(call);
255 TELEPHONY_LOGI("DealFailDial ret:%{public}d", ret);
256 }
257 CallEventInfo eventInfo;
258 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
259 if (mEventIdTransferMap_.find(info.eventId) != mEventIdTransferMap_.end()) {
260 eventInfo.eventId = mEventIdTransferMap_[info.eventId];
261 DialParaInfo dialInfo;
262 if (eventInfo.eventId == CallAbilityEventId::EVENT_DIAL_NO_CARRIER) {
263 DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(dialInfo);
264 if (dialInfo.number.length() > static_cast<size_t>(kMaxNumberLen)) {
265 TELEPHONY_LOGE("Number out of limit!");
266 return CALL_ERR_NUMBER_OUT_OF_RANGE;
267 }
268 if (memcpy_s(eventInfo.phoneNum, kMaxNumberLen, dialInfo.number.c_str(), dialInfo.number.length()) != EOK) {
269 TELEPHONY_LOGE("memcpy_s failed!");
270 return TELEPHONY_ERR_MEMCPY_FAIL;
271 }
272 } else if (eventInfo.eventId == CallAbilityEventId::EVENT_COMBINE_CALL_FAILED) {
273 sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
274 if (activeCall != nullptr) {
275 activeCall->HandleCombineConferenceFailEvent();
276 }
277 } else if (eventInfo.eventId == CallAbilityEventId::EVENT_HOLD_CALL_FAILED) {
278 needWaitHold_ = false;
279 }
280 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
281 } else {
282 TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.eventId);
283 }
284 return TELEPHONY_SUCCESS;
285 }
286
HandleOttEventReportInfo(const OttCallEventInfo & info)287 int32_t CallStatusManager::HandleOttEventReportInfo(const OttCallEventInfo &info)
288 {
289 TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.ottCallEventId);
290 CallEventInfo eventInfo;
291 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
292 if (mOttEventIdTransferMap_.find(info.ottCallEventId) != mOttEventIdTransferMap_.end()) {
293 eventInfo.eventId = mOttEventIdTransferMap_[info.ottCallEventId];
294 if (strlen(info.bundleName) > static_cast<size_t>(kMaxNumberLen)) {
295 TELEPHONY_LOGE("Number out of limit!");
296 return CALL_ERR_NUMBER_OUT_OF_RANGE;
297 }
298 if (memcpy_s(eventInfo.bundleName, kMaxNumberLen, info.bundleName, strlen(info.bundleName)) != EOK) {
299 TELEPHONY_LOGE("memcpy_s failed!");
300 return TELEPHONY_ERR_MEMCPY_FAIL;
301 }
302 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
303 } else {
304 TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.ottCallEventId);
305 }
306 return TELEPHONY_SUCCESS;
307 }
308
IncomingHandle(const CallDetailInfo & info)309 int32_t CallStatusManager::IncomingHandle(const CallDetailInfo &info)
310 {
311 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
312 if (call != nullptr && (call->GetCallType() != info.callType || call->GetTelCallState() != info.state)) {
313 call = RefreshCallIfNecessary(call, info);
314 if (call->GetCallType() != info.callType) {
315 return UpdateCallState(call, info.state);
316 }
317 return TELEPHONY_SUCCESS;
318 }
319 int32_t ret = IncomingHandlePolicy(info);
320 if (ret != TELEPHONY_SUCCESS) {
321 TELEPHONY_LOGE("IncomingHandlePolicy failed!");
322 if (info.state == TelCallState::CALL_STATUS_INCOMING) {
323 CallManagerHisysevent::WriteIncomingCallFaultEvent(info.accountId, static_cast<int32_t>(info.callType),
324 static_cast<int32_t>(info.callMode), ret, "IncomingHandlePolicy failed");
325 }
326 return ret;
327 }
328 if (info.callType == CallType::TYPE_CS || info.callType == CallType::TYPE_IMS ||
329 info.callType == CallType::TYPE_SATELLITE) {
330 ret = IncomingFilterPolicy(info);
331 if (ret != TELEPHONY_SUCCESS) {
332 return ret;
333 }
334 }
335 call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
336 if (call == nullptr) {
337 TELEPHONY_LOGE("CreateNewCall failed!");
338 return CALL_ERR_CALL_OBJECT_IS_NULL;
339 }
340
341 BuildAndQueryCallerInfo(call, info);
342
343 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
344 ret = UpdateCallState(call, info.state);
345 if (ret != TELEPHONY_SUCCESS) {
346 TELEPHONY_LOGE("UpdateCallState failed!");
347 return ret;
348 }
349 ret = FilterResultsDispose(call);
350 if (ret != TELEPHONY_SUCCESS) {
351 TELEPHONY_LOGE("FilterResultsDispose failed!");
352 }
353 return ret;
354 }
355
BuildAndQueryCallerInfo(sptr<CallBase> & call,const CallDetailInfo & info)356 void CallStatusManager::BuildAndQueryCallerInfo(sptr<CallBase> &call, const CallDetailInfo &info)
357 {
358 // allow list filtering
359 // Get the contact data from the database
360 ContactInfo contactInfo = {
361 .name = "",
362 .number = "",
363 .isContacterExists = false,
364 .ringtonePath = "",
365 .isSendToVoicemail = false,
366 .isEcc = false,
367 .isVoiceMail = false,
368 };
369 QueryCallerInfo(contactInfo, std::string(info.phoneNum));
370 call->SetCallerInfo(contactInfo);
371 }
372
IncomingVoipCallHandle(const CallDetailInfo & info)373 int32_t CallStatusManager::IncomingVoipCallHandle(const CallDetailInfo &info)
374 {
375 int32_t ret = TELEPHONY_ERROR;
376 sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
377 if (call != nullptr) {
378 return TELEPHONY_SUCCESS;
379 }
380 call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
381 if (call == nullptr) {
382 TELEPHONY_LOGE("CreateVoipCall failed!");
383 return CALL_ERR_CALL_OBJECT_IS_NULL;
384 }
385 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
386 ret = UpdateCallState(call, info.state);
387 if (ret != TELEPHONY_SUCCESS) {
388 TELEPHONY_LOGE("UpdateCallState failed!");
389 return ret;
390 }
391 return ret;
392 }
393
QueryCallerInfo(ContactInfo & contactInfo,std::string phoneNum)394 void CallStatusManager::QueryCallerInfo(ContactInfo &contactInfo, std::string phoneNum)
395 {
396 TELEPHONY_LOGI("Entry CallStatusManager QueryCallerInfo");
397 std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
398 if (callDataPtr == nullptr) {
399 TELEPHONY_LOGE("callDataPtr is nullptr!");
400 return;
401 }
402 DataShare::DataSharePredicates predicates;
403 predicates.EqualTo(DETAIL_INFO, phoneNum);
404 predicates.And();
405 predicates.EqualTo(CONTENT_TYPE, PHONE);
406 bool ret = callDataPtr->Query(contactInfo, predicates);
407 if (!ret) {
408 TELEPHONY_LOGE("Query contact database fail!");
409 }
410 }
411
IncomingFilterPolicy(const CallDetailInfo & info)412 int32_t CallStatusManager::IncomingFilterPolicy(const CallDetailInfo &info)
413 {
414 if (CallIncomingFilterManagerPtr_ == nullptr) {
415 TELEPHONY_LOGE("CallIncomingFilterManagerPtr_ is null");
416 return TELEPHONY_ERR_LOCAL_PTR_NULL;
417 }
418 return CallIncomingFilterManagerPtr_->DoIncomingFilter(info);
419 }
420
CallFilterCompleteResult(const CallDetailInfo & info)421 void CallStatusManager::CallFilterCompleteResult(const CallDetailInfo &info)
422 {
423 int32_t ret = TELEPHONY_ERR_FAIL;
424 sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
425 if (call == nullptr) {
426 TELEPHONY_LOGE("CreateNewCall failed!");
427 return;
428 }
429 #ifdef ABILITY_DATABASE_SUPPORT
430 // allow list filtering
431 // Get the contact data from the database
432 GetCallerInfoDate(ContactInfo);
433 SetCallerInfo(contactInfo);
434 #endif
435 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
436 ret = UpdateCallState(call, info.state);
437 if (ret != TELEPHONY_SUCCESS) {
438 TELEPHONY_LOGE("UpdateCallState failed!");
439 return;
440 }
441 ret = FilterResultsDispose(call);
442 if (ret != TELEPHONY_SUCCESS) {
443 TELEPHONY_LOGE("FilterResultsDispose failed!");
444 return;
445 }
446 }
447
UpdateDialingCallInfo(const CallDetailInfo & info)448 int32_t CallStatusManager::UpdateDialingCallInfo(const CallDetailInfo &info)
449 {
450 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
451 if (call != nullptr) {
452 call = RefreshCallIfNecessary(call, info);
453 return TELEPHONY_SUCCESS;
454 }
455 call = GetOneCallObjectByIndex(INIT_INDEX);
456 if (call == nullptr) {
457 TELEPHONY_LOGE("call is nullptr");
458 return TELEPHONY_ERR_LOCAL_PTR_NULL;
459 }
460
461 std::string oriNum = call->GetAccountNumber();
462 call = RefreshCallIfNecessary(call, info);
463 call->SetCallIndex(info.index);
464 call->SetBundleName(info.bundleName);
465 call->SetSlotId(info.accountId);
466 call->SetTelCallState(info.state);
467 call->SetVideoStateType(info.callMode);
468 call->SetCallType(info.callType);
469 call->SetAccountNumber(oriNum);
470 return TELEPHONY_SUCCESS;
471 }
472
DialingHandle(const CallDetailInfo & info)473 int32_t CallStatusManager::DialingHandle(const CallDetailInfo &info)
474 {
475 TELEPHONY_LOGI("handle dialing state");
476 if (info.index > 0) {
477 TELEPHONY_LOGI("need update call info");
478 return UpdateDialingCallInfo(info);
479 }
480 sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
481 if (call == nullptr) {
482 TELEPHONY_LOGE("CreateNewCall failed!");
483 return TELEPHONY_ERR_LOCAL_PTR_NULL;
484 }
485 int32_t ret = call->DialingProcess();
486 if (ret != TELEPHONY_SUCCESS) {
487 return ret;
488 }
489 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
490 ret = UpdateCallState(call, TelCallState::CALL_STATUS_DIALING);
491 if (ret != TELEPHONY_SUCCESS) {
492 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
493 }
494 return ret;
495 }
496
ActiveHandle(const CallDetailInfo & info)497 int32_t CallStatusManager::ActiveHandle(const CallDetailInfo &info)
498 {
499 TELEPHONY_LOGI("handle active state");
500 std::string tmpStr(info.phoneNum);
501 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
502 if (call == nullptr) {
503 TELEPHONY_LOGE("Call is NULL");
504 return TELEPHONY_ERR_LOCAL_PTR_NULL;
505 }
506 call = RefreshCallIfNecessary(call, info);
507 SetOriginalCallTypeForActiveState(call);
508 // call state change active, need to judge if launching a conference
509 if (info.mpty == 1) {
510 int32_t mainCallId = ERR_ID;
511 call->LaunchConference();
512 call->GetMainCallId(mainCallId);
513 sptr<CallBase> mainCall = GetOneCallObject(mainCallId);
514 if (mainCall != nullptr) {
515 mainCall->SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_ACTIVE);
516 }
517 } else if (call->ExitConference() == TELEPHONY_SUCCESS) {
518 TELEPHONY_LOGI("SubCallSeparateFromConference success!");
519 } else {
520 TELEPHONY_LOGI("SubCallSeparateFromConference fail!");
521 }
522 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
523 if (ret != TELEPHONY_SUCCESS) {
524 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
525 return ret;
526 }
527 sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
528 if (holdCall != nullptr) {
529 holdCall->SetCanSwitchCallState(true);
530 TELEPHONY_LOGI("holdcall:%{public}d can swap", holdCall->GetCallID());
531 }
532 #ifdef AUDIO_SUPPORT
533 ToSpeakerPhone(call);
534 DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
535 #endif
536 TELEPHONY_LOGI("handle active state success");
537 return ret;
538 }
539
ActiveVoipCallHandle(const CallDetailInfo & info)540 int32_t CallStatusManager::ActiveVoipCallHandle(const CallDetailInfo &info)
541 {
542 TELEPHONY_LOGI("handle active state");
543 sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
544 if (call == nullptr) {
545 TELEPHONY_LOGE("voip Call is NULL");
546 return TELEPHONY_ERR_LOCAL_PTR_NULL;
547 }
548 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
549 if (ret != TELEPHONY_SUCCESS) {
550 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
551 return ret;
552 }
553 TELEPHONY_LOGI("handle active state success");
554 return ret;
555 }
556
HoldingHandle(const CallDetailInfo & info)557 int32_t CallStatusManager::HoldingHandle(const CallDetailInfo &info)
558 {
559 TELEPHONY_LOGI("handle holding state");
560 std::string tmpStr(info.phoneNum);
561 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
562 if (call == nullptr) {
563 TELEPHONY_LOGE("Call is NULL");
564 return TELEPHONY_ERR_LOCAL_PTR_NULL;
565 }
566 // if the call is in a conference, it will exit, otherwise just set it holding
567 call = RefreshCallIfNecessary(call, info);
568 if (info.mpty == 1) {
569 int32_t ret = call->HoldConference();
570 if (ret == TELEPHONY_SUCCESS) {
571 TELEPHONY_LOGI("HoldConference success");
572 }
573 }
574 TelCallState priorState = call->GetTelCallState();
575 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_HOLDING);
576 if (ret != TELEPHONY_SUCCESS) {
577 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
578 }
579 int32_t callId = call->GetCallID();
580 int32_t dsdsMode = DSDS_MODE_V2;
581 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
582 TELEPHONY_LOGE("HoldingHandle dsdsMode:%{public}d", dsdsMode);
583 bool canSwitchCallState = call->GetCanSwitchCallState();
584 if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
585 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
586 int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
587 if (needWaitHold_ && activeCallNum == 0) {
588 needWaitHold_ = false;
589 int32_t result = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(GetDialCallInfo());
590 sptr<CallBase> dialCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
591 if (result != TELEPHONY_SUCCESS && dialCall != nullptr) {
592 DealFailDial(call);
593 TELEPHONY_LOGI("Dial call fail");
594 }
595 } else {
596 TelConferenceState confState = call->GetTelConferenceState();
597 int32_t conferenceId = ERR_ID;
598 call->GetMainCallId(conferenceId);
599 if (confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == callId) {
600 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
601 } else if (confState == TelConferenceState::TEL_CONFERENCE_IDLE) {
602 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
603 }
604 }
605 }
606 return ret;
607 }
608
WaitingHandle(const CallDetailInfo & info)609 int32_t CallStatusManager::WaitingHandle(const CallDetailInfo &info)
610 {
611 return IncomingHandle(info);
612 }
613
AlertHandle(const CallDetailInfo & info)614 int32_t CallStatusManager::AlertHandle(const CallDetailInfo &info)
615 {
616 TELEPHONY_LOGI("handle alerting state");
617 std::string tmpStr(info.phoneNum);
618 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
619 if (call == nullptr) {
620 TELEPHONY_LOGE("Call is NULL");
621 return TELEPHONY_ERR_LOCAL_PTR_NULL;
622 }
623 call = RefreshCallIfNecessary(call, info);
624 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ALERTING);
625 if (ret != TELEPHONY_SUCCESS) {
626 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
627 return ret;
628 }
629 #ifdef AUDIO_SUPPORT
630 ToSpeakerPhone(call);
631 TurnOffMute(call);
632 DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
633 #endif
634 return ret;
635 }
636
DisconnectingHandle(const CallDetailInfo & info)637 int32_t CallStatusManager::DisconnectingHandle(const CallDetailInfo &info)
638 {
639 TELEPHONY_LOGI("handle disconnecting state");
640 std::string tmpStr(info.phoneNum);
641 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
642 if (call == nullptr) {
643 TELEPHONY_LOGE("Call is NULL");
644 return TELEPHONY_ERR_LOCAL_PTR_NULL;
645 }
646 call = RefreshCallIfNecessary(call, info);
647 SetOriginalCallTypeForDisconnectState(call);
648 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
649 if (ret != TELEPHONY_SUCCESS) {
650 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
651 }
652 return ret;
653 }
654
DisconnectedVoipCallHandle(const CallDetailInfo & info)655 int32_t CallStatusManager::DisconnectedVoipCallHandle(const CallDetailInfo &info)
656 {
657 TELEPHONY_LOGI("handle disconnected voip call state");
658 sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallInfo.voipCallId);
659 if (call == nullptr) {
660 TELEPHONY_LOGE("voip Call is NULL");
661 return TELEPHONY_ERR_LOCAL_PTR_NULL;
662 }
663 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
664 if (ret != TELEPHONY_SUCCESS) {
665 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
666 return ret;
667 }
668 DeleteOneCallObject(call->GetCallID());
669 TELEPHONY_LOGI("handle disconnected voip call state success");
670 return ret;
671 }
672
DisconnectedHandle(const CallDetailInfo & info)673 int32_t CallStatusManager::DisconnectedHandle(const CallDetailInfo &info)
674 {
675 TELEPHONY_LOGI("handle disconnected state");
676 std::string tmpStr(info.phoneNum);
677 sptr<CallBase> call = GetOneCallObjectByIndexAndSlotId(info.index, info.accountId);
678 if (call == nullptr) {
679 TELEPHONY_LOGE("call is null");
680 return TELEPHONY_ERR_LOCAL_PTR_NULL;
681 }
682 call = RefreshCallIfNecessary(call, info);
683 SetOriginalCallTypeForDisconnectState(call);
684 std::vector<std::u16string> callIdList;
685 call->GetSubCallIdList(callIdList);
686 CallRunningState previousState = call->GetCallRunningState();
687 int32_t ret = call->ExitConference();
688 if (ret == TELEPHONY_SUCCESS) {
689 TELEPHONY_LOGI("SubCallSeparateFromConference success");
690 }
691 TelCallState priorState = call->GetTelCallState();
692 ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
693 if (ret != TELEPHONY_SUCCESS) {
694 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
695 return ret;
696 }
697 HandleHoldCallOrAutoAnswerCall(call, callIdList, previousState, priorState);
698 return ret;
699 }
700
HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,std::vector<std::u16string> callIdList,CallRunningState previousState,TelCallState priorState)701 void CallStatusManager::HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,
702 std::vector<std::u16string> callIdList, CallRunningState previousState, TelCallState priorState)
703 {
704 if (call == nullptr) {
705 TELEPHONY_LOGE("call is null");
706 return;
707 }
708 bool canUnHold = false;
709 size_t size = callIdList.size();
710 int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
711 int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
712 IsCanUnHold(activeCallNum, waitingCallNum, size, canUnHold);
713 sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
714 if (previousState != CallRunningState::CALL_RUNNING_STATE_HOLD &&
715 previousState != CallRunningState::CALL_RUNNING_STATE_ACTIVE &&
716 priorState == TelCallState::CALL_STATUS_DISCONNECTING) {
717 if (holdCall != nullptr && canUnHold && holdCall->GetCanUnHoldState()) {
718 if (holdCall->GetSlotId() == call->GetSlotId()) {
719 TELEPHONY_LOGI("release call and recover the held call");
720 holdCall->UnHoldCall();
721 }
722 }
723 }
724 DeleteOneCallObject(call->GetCallID());
725 int32_t dsdsMode = DSDS_MODE_V2;
726 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
727 if (dsdsMode == DSDS_MODE_V3) {
728 AutoAnswer(activeCallNum, waitingCallNum);
729 } else if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
730 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
731 bool canSwitchCallState = call->GetCanSwitchCallState();
732 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), true);
733 }
734 }
735
IsCanUnHold(int32_t activeCallNum,int32_t waitingCallNum,int32_t size,bool & canUnHold)736 void CallStatusManager::IsCanUnHold(int32_t activeCallNum, int32_t waitingCallNum, int32_t size, bool &canUnHold)
737 {
738 int32_t incomingCallNum = GetCallNum(TelCallState::CALL_STATUS_INCOMING);
739 int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
740 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
741 if (answeredCallNum == 0 && incomingCallNum == 0 && (size == 0 || size == 1) && activeCallNum == 0 &&
742 waitingCallNum == 0 && dialingCallNum == 0) {
743 canUnHold = true;
744 }
745 TELEPHONY_LOGI("CanUnHold state: %{public}d", canUnHold);
746 }
747
AutoHandleForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId,bool continueAnswer)748 void CallStatusManager::AutoHandleForDsda(
749 bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId, bool continueAnswer)
750 {
751 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
752 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
753 std::list<int32_t> callIdList;
754 GetCarrierCallList(callIdList);
755 for (int32_t ringCallId : callIdList) {
756 sptr<CallBase> ringCall = GetOneCallObject(ringCallId);
757 if (ringCall != nullptr && ringCall->GetAutoAnswerState()) {
758 TELEPHONY_LOGI("ringCall is not nullptr");
759 int32_t videoState = static_cast<int32_t>(ringCall->GetVideoStateType());
760 if (videoState == static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
761 TELEPHONY_LOGI("AutoAnswer VideoCall for Dsda");
762 AutoAnswerForVideoCall(activeCallNum);
763 return;
764 }
765 if (dialingCallNum == 0 && alertingCallNum == 0 && activeCallNum == 0 &&
766 ringCall->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
767 AutoAnswerForVoiceCall(ringCall, slotId, continueAnswer);
768 return;
769 }
770 }
771 }
772 AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
773 }
774
AutoUnHoldForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId)775 void CallStatusManager::AutoUnHoldForDsda(
776 bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId)
777 {
778 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
779 int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
780 int32_t callNum = 2;
781 std::list<int32_t> callIdList;
782 GetCarrierCallList(callIdList);
783 int32_t currentCallNum = GetCurrentCallNum();
784 for (int32_t otherCallId : callIdList) {
785 sptr<CallBase> otherCall = GetOneCallObject(otherCallId);
786 TelCallState state = otherCall->GetTelCallState();
787 TelConferenceState confState = otherCall->GetTelConferenceState();
788 int32_t conferenceId = ERR_ID;
789 otherCall->GetMainCallId(conferenceId);
790 if (otherCall != nullptr && slotId != otherCall->GetSlotId() && state == TelCallState::CALL_STATUS_HOLDING &&
791 otherCall->GetCanUnHoldState() && activeCallNum == 0 && waitingCallNum == 0 &&
792 dialingCallNum == 0 &&
793 ((confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == otherCallId) ||
794 confState == TelConferenceState::TEL_CONFERENCE_IDLE)) {
795 // Actively hang up the processing unhold state or exchange call
796 if (priorState == TelCallState::CALL_STATUS_DISCONNECTING ||
797 (!canSwitchCallState && currentCallNum == callNum)) {
798 otherCall->UnHoldCall();
799 return;
800 }
801 }
802 }
803 for (int32_t otherCallId : callIdList) {
804 sptr<CallBase> holdCall = GetOneCallObject(otherCallId);
805 if (holdCall != nullptr && holdCall->GetTelCallState() == TelCallState::CALL_STATUS_HOLDING) {
806 if (currentCallNum == callNum) {
807 holdCall->SetCanUnHoldState(true);
808 }
809 }
810 }
811 }
812
AutoAnswerForVoiceCall(sptr<CallBase> ringCall,int32_t slotId,bool continueAnswer)813 void CallStatusManager::AutoAnswerForVoiceCall(sptr<CallBase> ringCall, int32_t slotId, bool continueAnswer)
814 {
815 /* Need to check whether the autoAnswer call and the holding call are on the same slotid
816 * To prevent repeated AT command delivery.
817 */
818 if (continueAnswer || slotId != ringCall->GetSlotId()) {
819 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
820 ringCall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
821 int ret = ringCall->AnswerCall(ringCall->GetAnswerVideoState());
822 if (ret == TELEPHONY_SUCCESS) {
823 DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(ringCall);
824 }
825 TELEPHONY_LOGI("ret = %{public}d", ret);
826 }
827 ringCall->SetAutoAnswerState(false);
828 }
829
AutoAnswerForVideoCall(int32_t activeCallNum)830 void CallStatusManager::AutoAnswerForVideoCall(int32_t activeCallNum)
831 {
832 int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
833 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
834 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
835 if (activeCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 && alertingCallNum == 0) {
836 std::list<int32_t> ringCallIdList;
837 GetCarrierCallList(ringCallIdList);
838 for (int32_t ringingCallId : ringCallIdList) {
839 sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
840 CallRunningState ringingCallState = ringingCall->GetCallRunningState();
841 if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
842 (ringingCall->GetAutoAnswerState()))) {
843 ringingCall->SetAutoAnswerState(false);
844 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
845 TELEPHONY_LOGI("ret = %{public}d", ret);
846 break;
847 }
848 }
849 }
850 }
851
AutoAnswer(int32_t activeCallNum,int32_t waitingCallNum)852 void CallStatusManager::AutoAnswer(int32_t activeCallNum, int32_t waitingCallNum)
853 {
854 int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
855 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
856 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
857 if (activeCallNum == 0 && waitingCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 &&
858 alertingCallNum == 0) {
859 std::list<int32_t> ringCallIdList;
860 GetCarrierCallList(ringCallIdList);
861 for (int32_t ringingCallId : ringCallIdList) {
862 sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
863 CallRunningState ringingCallState = ringingCall->GetCallRunningState();
864 if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
865 (ringingCall->GetAutoAnswerState()))) {
866 ringingCall->SetAutoAnswerState(false);
867 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
868 TELEPHONY_LOGI("ret = %{public}d", ret);
869 break;
870 }
871 }
872 }
873 }
874
UpdateCallState(sptr<CallBase> & call,TelCallState nextState)875 int32_t CallStatusManager::UpdateCallState(sptr<CallBase> &call, TelCallState nextState)
876 {
877 TELEPHONY_LOGI("UpdateCallState start");
878 if (call == nullptr) {
879 TELEPHONY_LOGE("Call is NULL");
880 return TELEPHONY_ERR_LOCAL_PTR_NULL;
881 }
882 TelCallState priorState = call->GetTelCallState();
883 VideoStateType videoState = call->GetVideoStateType();
884 TELEPHONY_LOGI(
885 "callIndex:%{public}d, callId:%{public}d, priorState:%{public}d, nextState:%{public}d, videoState:%{public}d",
886 call->GetCallIndex(), call->GetCallID(), priorState, nextState, videoState);
887 if (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE) {
888 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingAnswerTimeOut(
889 call->GetSlotId(), call->GetCallID(), static_cast<int32_t>(call->GetVideoStateType()));
890 }
891 // need DTMF judge
892 int32_t ret = call->SetTelCallState(nextState);
893 if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
894 TELEPHONY_LOGE("SetTelCallState failed");
895 return TELEPHONY_ERR_LOCAL_PTR_NULL;
896 }
897 // notify state changed
898 if (!DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(call, priorState, nextState)) {
899 TELEPHONY_LOGE(
900 "NotifyCallStateUpdated failed! priorState:%{public}d,nextState:%{public}d", priorState, nextState);
901 if (nextState == TelCallState::CALL_STATUS_INCOMING) {
902 CallManagerHisysevent::WriteIncomingCallFaultEvent(call->GetSlotId(),
903 static_cast<int32_t>(call->GetCallType()), static_cast<int32_t>(call->GetVideoStateType()), ret,
904 "NotifyCallStateUpdated failed");
905 }
906 return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
907 }
908 int slotId = call->GetSlotId();
909 bool isSlotIdValid = false;
910 if (slotId < SLOT_NUM && slotId >= 0) {
911 isSlotIdValid = true;
912 }
913 TELEPHONY_LOGI("nextVideoState:%{public}d, priorVideoState:%{public}d, isSlotIdValid:%{public}d", videoState,
914 priorVideoState_[slotId], isSlotIdValid);
915 if (isSlotIdValid && (priorVideoState_[slotId] != videoState)) {
916 DelayedSingleton<AudioControlManager>::GetInstance()->VideoStateUpdated(
917 call, priorVideoState_[slotId], videoState);
918 priorVideoState_[slotId] = videoState;
919 }
920 if (isSlotIdValid && (nextState == TelCallState::CALL_STATUS_DISCONNECTED)) {
921 priorVideoState_[slotId] = VideoStateType::TYPE_VOICE;
922 }
923 return TELEPHONY_SUCCESS;
924 }
925
RefreshCallIfNecessary(const sptr<CallBase> & call,const CallDetailInfo & info)926 sptr<CallBase> CallStatusManager::RefreshCallIfNecessary(const sptr<CallBase> &call, const CallDetailInfo &info)
927 {
928 TELEPHONY_LOGI("RefreshCallIfNecessary");
929 if (call->GetCallType() == CallType::TYPE_IMS && call->GetVideoStateType() != info.callMode) {
930 call->SetVideoStateType(info.callMode);
931 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
932 imsCall->InitVideoCall();
933 }
934 if (call->GetCallType() == CallType::TYPE_IMS) {
935 call->SetCrsType(info.crsType);
936 }
937 if (call->GetCallType() == info.callType) {
938 TELEPHONY_LOGI("RefreshCallIfNecessary not need Refresh");
939 return call;
940 }
941 TelCallState priorState = call->GetTelCallState();
942 CallAttributeInfo attrInfo;
943 (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
944 call->GetCallAttributeBaseInfo(attrInfo);
945 sptr<CallBase> newCall = CreateNewCall(info, attrInfo.callDirection);
946 if (newCall == nullptr) {
947 TELEPHONY_LOGE("RefreshCallIfNecessary createCallFail");
948 return call;
949 }
950 newCall->SetCallRunningState(call->GetCallRunningState());
951 newCall->SetTelConferenceState(call->GetTelConferenceState());
952 newCall->SetStartTime(attrInfo.startTime);
953 newCall->SetPolicyFlag(PolicyFlag(call->GetPolicyFlag()));
954 newCall->SetSpeakerphoneOn(call->IsSpeakerphoneOn());
955 newCall->SetCallEndedType(call->GetCallEndedType());
956 newCall->SetCallBeginTime(attrInfo.callBeginTime);
957 newCall->SetCallEndTime(attrInfo.callEndTime);
958 newCall->SetRingBeginTime(attrInfo.ringBeginTime);
959 newCall->SetRingEndTime(attrInfo.ringEndTime);
960 newCall->SetAnswerType(attrInfo.answerType);
961 newCall->SetMicPhoneState(call->IsMuted());
962 DeleteOneCallObject(call->GetCallID());
963 newCall->SetCallId(call->GetCallID());
964 newCall->SetTelCallState(priorState);
965 return newCall;
966 }
967
SetOriginalCallTypeForActiveState(sptr<CallBase> & call)968 void CallStatusManager::SetOriginalCallTypeForActiveState(sptr<CallBase> &call)
969 {
970 if (call == nullptr) {
971 TELEPHONY_LOGE("Call is NULL");
972 return;
973 }
974 TelCallState priorState = call->GetTelCallState();
975 VideoStateType videoState = call->GetVideoStateType();
976 int32_t videoStateHistory = call->GetOriginalCallType();
977 if (priorState == TelCallState::CALL_STATUS_ALERTING || priorState == TelCallState::CALL_STATUS_INCOMING ||
978 priorState == TelCallState::CALL_STATUS_WAITING) {
979 // outgoing/incoming video call, but accepted/answered with voice call
980 if (videoStateHistory != static_cast<int32_t>(videoState)) {
981 TELEPHONY_LOGD("set videoState:%{public}d as original call type", static_cast<int32_t>(videoState));
982 call->SetOriginalCallType(static_cast<int32_t>(videoState));
983 }
984 } else if (priorState == TelCallState::CALL_STATUS_ACTIVE || priorState == TelCallState::CALL_STATUS_HOLDING) {
985 int32_t videoStateCurrent = videoStateHistory | static_cast<int32_t>(videoState);
986 TELEPHONY_LOGD("maybe upgrade/downgrade operation, keep video record always, videoStateCurrent:%{public}d",
987 videoStateCurrent);
988 call->SetOriginalCallType(videoStateCurrent);
989 }
990 }
991
SetOriginalCallTypeForDisconnectState(sptr<CallBase> & call)992 void CallStatusManager::SetOriginalCallTypeForDisconnectState(sptr<CallBase> &call)
993 {
994 if (call == nullptr) {
995 TELEPHONY_LOGE("Call is NULL");
996 return;
997 }
998 TelCallState priorState = call->GetTelCallState();
999 CallAttributeInfo attrInfo;
1000 (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1001 call->GetCallAttributeBaseInfo(attrInfo);
1002 if (priorState == TelCallState::CALL_STATUS_DIALING || priorState == TelCallState::CALL_STATUS_ALERTING ||
1003 ((priorState == TelCallState::CALL_STATUS_INCOMING || priorState == TelCallState::CALL_STATUS_WAITING) &&
1004 attrInfo.answerType != CallAnswerType::CALL_ANSWER_REJECT)) {
1005 // outgoing/incoming video call, but canceled or missed
1006 TELEPHONY_LOGD("canceled or missed call, set voice type as original call type");
1007 call->SetOriginalCallType(static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1008 }
1009 }
1010
ToSpeakerPhone(sptr<CallBase> & call)1011 int32_t CallStatusManager::ToSpeakerPhone(sptr<CallBase> &call)
1012 {
1013 int32_t ret = TELEPHONY_ERR_FAIL;
1014 if (call == nullptr) {
1015 TELEPHONY_LOGE("Call is NULL");
1016 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1017 }
1018 if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_DIALING) {
1019 TELEPHONY_LOGI("Call is CALL_STATUS_DIALING");
1020 return ret;
1021 }
1022 if (call->IsSpeakerphoneOn()) {
1023 AudioDevice device = {
1024 .deviceType = AudioDeviceType::DEVICE_SPEAKER,
1025 .address = { 0 },
1026 };
1027 DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(device);
1028 ret = call->SetSpeakerphoneOn(false);
1029 }
1030 return ret;
1031 }
1032
TurnOffMute(sptr<CallBase> & call)1033 int32_t CallStatusManager::TurnOffMute(sptr<CallBase> &call)
1034 {
1035 bool enabled = true;
1036 if (HasEmergencyCall(enabled) != TELEPHONY_SUCCESS) {
1037 TELEPHONY_LOGI("CallStatusManager::TurnOffMute HasEmergencyCall failed.");
1038 }
1039 if (call->GetEmergencyState() || enabled) {
1040 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(false);
1041 } else {
1042 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1043 }
1044 return TELEPHONY_SUCCESS;
1045 }
1046
CreateNewCall(const CallDetailInfo & info,CallDirection dir)1047 sptr<CallBase> CallStatusManager::CreateNewCall(const CallDetailInfo &info, CallDirection dir)
1048 {
1049 DialParaInfo paraInfo;
1050 AppExecFwk::PacMap extras;
1051 extras.Clear();
1052 PackParaInfo(paraInfo, info, dir, extras);
1053
1054 sptr<CallBase> callPtr = CreateNewCallByCallType(paraInfo, info, dir, extras);
1055 if (callPtr == nullptr) {
1056 TELEPHONY_LOGE("CreateNewCall failed!");
1057 return nullptr;
1058 }
1059 callPtr->SetOriginalCallType(info.originalCallType);
1060 TELEPHONY_LOGD("originalCallType:%{public}d", info.originalCallType);
1061 AddOneCallObject(callPtr);
1062 return callPtr;
1063 }
1064
CreateNewCallByCallType(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1065 sptr<CallBase> CallStatusManager::CreateNewCallByCallType(
1066 DialParaInfo ¶Info, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1067 {
1068 sptr<CallBase> callPtr = nullptr;
1069 switch (info.callType) {
1070 case CallType::TYPE_CS: {
1071 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1072 callPtr = (std::make_unique<CSCall>(paraInfo, extras)).release();
1073 } else {
1074 callPtr = (std::make_unique<CSCall>(paraInfo)).release();
1075 }
1076 break;
1077 }
1078 case CallType::TYPE_IMS: {
1079 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1080 callPtr = (std::make_unique<IMSCall>(paraInfo, extras)).release();
1081 } else {
1082 callPtr = (std::make_unique<IMSCall>(paraInfo)).release();
1083 }
1084 if (callPtr->GetCallType() == CallType::TYPE_IMS) {
1085 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(callPtr.GetRefPtr());
1086 imsCall->InitVideoCall();
1087 }
1088 break;
1089 }
1090 case CallType::TYPE_OTT: {
1091 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1092 callPtr = (std::make_unique<OTTCall>(paraInfo, extras)).release();
1093 } else {
1094 callPtr = (std::make_unique<OTTCall>(paraInfo)).release();
1095 }
1096 break;
1097 }
1098 case CallType::TYPE_VOIP: {
1099 callPtr = (std::make_unique<VoIPCall>(paraInfo)).release();
1100 break;
1101 }
1102 case CallType::TYPE_SATELLITE: {
1103 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1104 callPtr = (std::make_unique<SatelliteCall>(paraInfo, extras)).release();
1105 } else {
1106 callPtr = (std::make_unique<SatelliteCall>(paraInfo)).release();
1107 }
1108 break;
1109 }
1110 default:
1111 return nullptr;
1112 }
1113 return callPtr;
1114 }
1115
PackParaInfo(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1116 void CallStatusManager::PackParaInfo(
1117 DialParaInfo ¶Info, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1118 {
1119 paraInfo.isEcc = false;
1120 paraInfo.dialType = DialType::DIAL_CARRIER_TYPE;
1121 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1122 DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(paraInfo, extras);
1123 }
1124 if (info.callType == CallType::TYPE_VOIP) {
1125 paraInfo.voipCallInfo.voipCallId = info.voipCallInfo.voipCallId;
1126 paraInfo.voipCallInfo.userName = info.voipCallInfo.userName;
1127 (paraInfo.voipCallInfo.userProfile).assign(
1128 (info.voipCallInfo.userProfile).begin(), (info.voipCallInfo.userProfile).end());
1129 paraInfo.voipCallInfo.abilityName = info.voipCallInfo.abilityName;
1130 paraInfo.voipCallInfo.extensionId = info.voipCallInfo.extensionId;
1131 paraInfo.voipCallInfo.voipBundleName = info.voipCallInfo.voipBundleName;
1132 }
1133 paraInfo.number = info.phoneNum;
1134 paraInfo.callId = GetNewCallId();
1135 paraInfo.index = info.index;
1136 paraInfo.videoState = info.callMode;
1137 paraInfo.accountId = info.accountId;
1138 paraInfo.callType = info.callType;
1139 paraInfo.callState = info.state;
1140 paraInfo.bundleName = info.bundleName;
1141 paraInfo.crsType = info.crsType;
1142 paraInfo.originalCallType = info.originalCallType;
1143 }
1144 } // namespace Telephony
1145 } // namespace OHOS
1146