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 "antifraud_service.h"
21 #include "audio_control_manager.h"
22 #include "bluetooth_call.h"
23 #include "bluetooth_call_connection.h"
24 #include "bluetooth_call_service.h"
25 #include "bool_wrapper.h"
26 #include "call_ability_report_proxy.h"
27 #include "call_control_manager.h"
28 #include "call_earthquake_alarm_locator.h"
29 #include "call_manager_errors.h"
30 #include "call_manager_hisysevent.h"
31 #include "call_number_utils.h"
32 #include "call_request_event_handler_helper.h"
33 #include "call_superprivacy_control_manager.h"
34 #include "call_voice_assistant_manager.h"
35 #include "cs_call.h"
36 #include "core_service_client.h"
37 #include "datashare_predicates.h"
38 #include "distributed_communication_manager.h"
39 #include "ffrt.h"
40 #include "hitrace_meter.h"
41 #include "ims_call.h"
42 #include "notification_helper.h"
43 #include "motion_recognition.h"
44 #include "os_account_manager.h"
45 #include "ott_call.h"
46 #include "parameters.h"
47 #include "report_call_info_handler.h"
48 #include "satellite_call.h"
49 #include "satellite_call_control.h"
50 #include "screen_sensor_plugin.h"
51 #include "settings_datashare_helper.h"
52 #include "spam_call_adapter.h"
53 #include "telephony_log_wrapper.h"
54 #include "uri.h"
55 #include "voip_call.h"
56 #include "want_params_wrapper.h"
57
58 namespace OHOS {
59 namespace Telephony {
60 constexpr int32_t INIT_INDEX = 0;
61 constexpr int32_t PRESENTATION_RESTRICTED = 3;
62
CallStatusManager()63 CallStatusManager::CallStatusManager()
64 {
65 (void)memset_s(&callReportInfo_, sizeof(CallDetailInfo), 0, sizeof(CallDetailInfo));
66 for (int32_t i = 0; i < SLOT_NUM; i++) {
67 (void)memset_s(&callDetailsInfo_[i], sizeof(CallDetailsInfo), 0, sizeof(CallDetailsInfo));
68 }
69 }
70
~CallStatusManager()71 CallStatusManager::~CallStatusManager()
72 {
73 UnInit();
74 }
75
Init()76 int32_t CallStatusManager::Init()
77 {
78 for (int32_t i = 0; i < SLOT_NUM; i++) {
79 callDetailsInfo_[i].callVec.clear();
80 tmpCallDetailsInfo_[i].callVec.clear();
81 }
82 for (int32_t i = 0; i < SLOT_NUM; i++) {
83 priorVideoState_[i] = VideoStateType::TYPE_VOICE;
84 }
85 mEventIdTransferMap_.clear();
86 mOttEventIdTransferMap_.clear();
87 InitCallBaseEvent();
88 CallIncomingFilterManagerPtr_ = (std::make_unique<CallIncomingFilterManager>()).release();
89 return TELEPHONY_SUCCESS;
90 }
91
InitCallBaseEvent()92 void CallStatusManager::InitCallBaseEvent()
93 {
94 mEventIdTransferMap_[RequestResultEventId::RESULT_DIAL_NO_CARRIER] = CallAbilityEventId::EVENT_DIAL_NO_CARRIER;
95 mEventIdTransferMap_[RequestResultEventId::RESULT_HOLD_SEND_FAILED] = CallAbilityEventId::EVENT_HOLD_CALL_FAILED;
96 mEventIdTransferMap_[RequestResultEventId::RESULT_SWAP_SEND_FAILED] = CallAbilityEventId::EVENT_SWAP_CALL_FAILED;
97 mOttEventIdTransferMap_[OttCallEventId::OTT_CALL_EVENT_FUNCTION_UNSUPPORTED] =
98 CallAbilityEventId::EVENT_OTT_FUNCTION_UNSUPPORTED;
99 mEventIdTransferMap_[RequestResultEventId::RESULT_COMBINE_SEND_FAILED] =
100 CallAbilityEventId::EVENT_COMBINE_CALL_FAILED;
101 mEventIdTransferMap_[RequestResultEventId::RESULT_SPLIT_SEND_FAILED] =
102 CallAbilityEventId::EVENT_SPLIT_CALL_FAILED;
103 }
104
UnInit()105 int32_t CallStatusManager::UnInit()
106 {
107 for (int32_t i = 0; i < SLOT_NUM; i++) {
108 callDetailsInfo_[i].callVec.clear();
109 tmpCallDetailsInfo_[i].callVec.clear();
110 }
111 mEventIdTransferMap_.clear();
112 mOttEventIdTransferMap_.clear();
113 return TELEPHONY_SUCCESS;
114 }
115
HandleCallReportInfo(const CallDetailInfo & info)116 int32_t CallStatusManager::HandleCallReportInfo(const CallDetailInfo &info)
117 {
118 int32_t ret = TELEPHONY_ERR_FAIL;
119 callReportInfo_ = info;
120 if (info.callType == CallType::TYPE_VOIP) {
121 return HandleVoipCallReportInfo(info);
122 }
123 if (info.callType == CallType::TYPE_BLUETOOTH) {
124 HandleBluetoothCallReportInfo(info);
125 }
126 switch (info.state) {
127 case TelCallState::CALL_STATUS_ACTIVE:
128 ret = ActiveHandle(info);
129 break;
130 case TelCallState::CALL_STATUS_HOLDING:
131 ret = HoldingHandle(info);
132 break;
133 case TelCallState::CALL_STATUS_DIALING: {
134 ret = DialingHandle(info);
135 FinishAsyncTrace(HITRACE_TAG_OHOS, "DialCall", getpid());
136 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingDialTimeOut(
137 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
138 break;
139 }
140 case TelCallState::CALL_STATUS_ALERTING:
141 ret = AlertHandle(info);
142 break;
143 case TelCallState::CALL_STATUS_INCOMING: {
144 DelayedSingleton<CallControlManager>::GetInstance()->AcquireIncomingLock();
145 ret = IncomingHandle(info);
146 DelayedSingleton<CallControlManager>::GetInstance()->ReleaseIncomingLock();
147 FinishAsyncTrace(HITRACE_TAG_OHOS, "InComingCall", getpid());
148 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingIncomingTimeOut(
149 info.accountId, static_cast<int32_t>(info.callType), static_cast<int32_t>(info.callMode));
150 break;
151 }
152 case TelCallState::CALL_STATUS_WAITING:
153 case TelCallState::CALL_STATUS_DISCONNECTED:
154 case TelCallState::CALL_STATUS_DISCONNECTING:
155 ret = HandleCallReportInfoEx(info);
156 break;
157 default:
158 TELEPHONY_LOGE("Invalid call state!");
159 break;
160 }
161 TELEPHONY_LOGI("Entry CallStatusManager HandleCallReportInfo");
162 HandleDsdaInfo(info.accountId);
163 DelayedSingleton<BluetoothCallService>::GetInstance()->GetCallState();
164 TELEPHONY_LOGI("End CallStatusManager HandleCallReportInfo");
165 return ret;
166 }
167
HandleBluetoothCallReportInfo(const CallDetailInfo & info)168 void CallStatusManager::HandleBluetoothCallReportInfo(const CallDetailInfo &info)
169 {
170 if (info.state == TelCallState::CALL_STATUS_WAITING || info.state == TelCallState::CALL_STATUS_INCOMING) {
171 return;
172 }
173 sptr<CallBase> call = nullptr;
174 if (info.index > 0) {
175 if (info.state == TelCallState::CALL_STATUS_DIALING || info.state == TelCallState::CALL_STATUS_ALERTING) {
176 call = GetOneCallObjectByIndexSlotIdAndCallType(INIT_INDEX, info.accountId, info.callType);
177 if (call != nullptr) {
178 BtCallDialingHandleFirst(call, info);
179 return;
180 }
181 }
182 if (call == nullptr) {
183 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
184 }
185 if (call != nullptr) {
186 return;
187 }
188 } else {
189 return;
190 }
191 if (call == nullptr) {
192 call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
193 if (call == nullptr) {
194 TELEPHONY_LOGE("Call is NULL");
195 return;
196 }
197 AddOneCallObject(call);
198 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
199 }
200 return;
201 }
202
HandleDsdaInfo(int32_t slotId)203 void CallStatusManager::HandleDsdaInfo(int32_t slotId)
204 {
205 int32_t dsdsMode = DSDS_MODE_V2;
206 bool noOtherCall = true;
207 std::list<int32_t> callIdList;
208 GetCarrierCallList(callIdList);
209 int32_t currentCallNum = GetCurrentCallNum();
210 DelayedSingleton<CallRequestProcess>::GetInstance()->IsExistCallOtherSlot(callIdList, slotId, noOtherCall);
211 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
212 TELEPHONY_LOGI("dsdsMode:%{public}d", dsdsMode);
213 if ((dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
214 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) &&
215 !noOtherCall) {
216 TELEPHONY_LOGI("Handle DsdaCallInfo");
217 sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
218 if (holdCall != nullptr && currentCallNum > CALL_NUMBER) {
219 holdCall->SetCanUnHoldState(false);
220 }
221 }
222 }
223
224 // handle call state changes, incoming call, outgoing call.
HandleCallsReportInfo(const CallDetailsInfo & info)225 int32_t CallStatusManager::HandleCallsReportInfo(const CallDetailsInfo &info)
226 {
227 bool flag = false;
228 TELEPHONY_LOGI("call list size:%{public}zu,slotId:%{public}d", info.callVec.size(), info.slotId);
229 int32_t curSlotId = info.slotId;
230 if (!DelayedSingleton<CallNumberUtils>::GetInstance()->IsValidSlotId(curSlotId)) {
231 TELEPHONY_LOGE("invalid slotId!");
232 return CALL_ERR_INVALID_SLOT_ID;
233 }
234 tmpCallDetailsInfo_[curSlotId].callVec.clear();
235 tmpCallDetailsInfo_[curSlotId] = info;
236 for (auto &it : info.callVec) {
237 for (const auto &it1 : callDetailsInfo_[curSlotId].callVec) {
238 if (it.index == it1.index) {
239 // call state changes
240 if (it.state != it1.state || it.mpty != it1.mpty || it.callType != it1.callType
241 || it.callMode != it1.callMode || it.state == TelCallState::CALL_STATUS_ALERTING) {
242 TELEPHONY_LOGI("handle updated call state:%{public}d", it.state);
243 HandleCallReportInfo(it);
244 }
245 flag = true;
246 break;
247 }
248 }
249 // incoming/outgoing call handle
250 if (!flag || callDetailsInfo_[curSlotId].callVec.empty()) {
251 HandleConnectingCallReportInfo(it);
252 }
253 flag = false;
254 }
255 // disconnected calls handle
256 for (auto &it2 : callDetailsInfo_[curSlotId].callVec) {
257 for (const auto &it3 : info.callVec) {
258 if (it2.index == it3.index) {
259 TELEPHONY_LOGI("state:%{public}d", it2.state);
260 flag = true;
261 break;
262 }
263 }
264 if (!flag) {
265 it2.state = TelCallState::CALL_STATUS_DISCONNECTED;
266 HandleCallReportInfo(it2);
267 }
268 flag = false;
269 }
270 UpdateCallDetailsInfo(info);
271 return TELEPHONY_SUCCESS;
272 }
273
HandleConnectingCallReportInfo(const CallDetailInfo & info)274 void CallStatusManager::HandleConnectingCallReportInfo(const CallDetailInfo &info)
275 {
276 int32_t callId = ERR_ID;
277 bool isMeetimeActiveCallExist = CallObjectManager::IsVoipCallExist(TelCallState::CALL_STATUS_ACTIVE, callId);
278 CallDetailInfo tempInfo = info;
279 TELEPHONY_LOGI("handle new call state:%{public}d, isMeetimeActiveCallExist:%{public}d",
280 info.state, isMeetimeActiveCallExist);
281 if (isMeetimeActiveCallExist && info.state == TelCallState::CALL_STATUS_INCOMING) {
282 tempInfo.state = TelCallState::CALL_STATUS_WAITING;
283 }
284 HandleCallReportInfo(tempInfo);
285 }
286
UpdateCallDetailsInfo(const CallDetailsInfo & info)287 void CallStatusManager::UpdateCallDetailsInfo(const CallDetailsInfo &info)
288 {
289 int32_t curSlotId = info.slotId;
290 callDetailsInfo_[curSlotId].callVec.clear();
291 callDetailsInfo_[curSlotId] = info;
292 auto condition = [](CallDetailInfo i) { return i.state == TelCallState::CALL_STATUS_DISCONNECTED; };
293 auto it_end = std::remove_if(callDetailsInfo_[curSlotId].callVec.begin(),
294 callDetailsInfo_[curSlotId].callVec.end(), condition);
295 callDetailsInfo_[curSlotId].callVec.erase(it_end, callDetailsInfo_[curSlotId].callVec.end());
296 if (callDetailsInfo_[curSlotId].callVec.empty()) {
297 TELEPHONY_LOGI("clear tmpCallDetailsInfo");
298 tmpCallDetailsInfo_[curSlotId].callVec.clear();
299 }
300 TELEPHONY_LOGI("End CallStatusManager HandleCallsReportInfo slotId:%{public}d, "
301 "callDetailsInfo_ size:%{public}zu", info.slotId, callDetailsInfo_[curSlotId].callVec.size());
302 }
303
HandleVoipCallReportInfo(const CallDetailInfo & info)304 int32_t CallStatusManager::HandleVoipCallReportInfo(const CallDetailInfo &info)
305 {
306 TELEPHONY_LOGI("Entry CallStatusManager HandleVoipCallReportInfo");
307 int32_t ret = TELEPHONY_ERR_FAIL;
308 switch (info.state) {
309 case TelCallState::CALL_STATUS_ACTIVE:
310 ret = ActiveVoipCallHandle(info);
311 break;
312 case TelCallState::CALL_STATUS_INCOMING: {
313 ret = IncomingVoipCallHandle(info);
314 break;
315 }
316 case TelCallState::CALL_STATUS_DISCONNECTED:
317 ret = DisconnectedVoipCallHandle(info);
318 break;
319 case TelCallState::CALL_STATUS_DIALING:
320 ret = OutgoingVoipCallHandle(info);
321 break;
322 case TelCallState::CALL_STATUS_ANSWERED:
323 ret = AnsweredVoipCallHandle(info);
324 break;
325 case TelCallState::CALL_STATUS_DISCONNECTING:
326 ret = DisconnectingVoipCallHandle(info);
327 break;
328 default:
329 TELEPHONY_LOGE("Invalid call state!");
330 break;
331 }
332 return ret;
333 }
334
HandleDisconnectedCause(const DisconnectedDetails & details)335 int32_t CallStatusManager::HandleDisconnectedCause(const DisconnectedDetails &details)
336 {
337 bool ret = DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallDestroyed(details);
338 if (!ret) {
339 TELEPHONY_LOGI("NotifyCallDestroyed failed!");
340 return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
341 }
342 return TELEPHONY_SUCCESS;
343 }
344
HandleEventResultReportInfo(const CellularCallEventInfo & info)345 int32_t CallStatusManager::HandleEventResultReportInfo(const CellularCallEventInfo &info)
346 {
347 if (info.eventType != CellularCallEventType::EVENT_REQUEST_RESULT_TYPE) {
348 TELEPHONY_LOGE("unexpected type event occurs, eventId:%{public}d", info.eventId);
349 return CALL_ERR_PHONE_TYPE_UNEXPECTED;
350 }
351 TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.eventId);
352 sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
353 if (call != nullptr) {
354 int32_t ret = DealFailDial(call);
355 TELEPHONY_LOGI("DealFailDial ret:%{public}d", ret);
356 }
357 CallEventInfo eventInfo;
358 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
359 if (mEventIdTransferMap_.find(info.eventId) != mEventIdTransferMap_.end()) {
360 eventInfo.eventId = mEventIdTransferMap_[info.eventId];
361 DialParaInfo dialInfo;
362 if (eventInfo.eventId == CallAbilityEventId::EVENT_DIAL_NO_CARRIER) {
363 DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(dialInfo);
364 if (dialInfo.number.length() > static_cast<size_t>(kMaxNumberLen)) {
365 TELEPHONY_LOGE("Number out of limit!");
366 return CALL_ERR_NUMBER_OUT_OF_RANGE;
367 }
368 if (memcpy_s(eventInfo.phoneNum, kMaxNumberLen, dialInfo.number.c_str(), dialInfo.number.length()) != EOK) {
369 TELEPHONY_LOGE("memcpy_s failed!");
370 return TELEPHONY_ERR_MEMCPY_FAIL;
371 }
372 } else if (eventInfo.eventId == CallAbilityEventId::EVENT_COMBINE_CALL_FAILED) {
373 sptr<CallBase> activeCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
374 if (activeCall != nullptr) {
375 activeCall->HandleCombineConferenceFailEvent();
376 }
377 } else if (eventInfo.eventId == CallAbilityEventId::EVENT_HOLD_CALL_FAILED) {
378 needWaitHold_ = false;
379 }
380 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
381 } else {
382 TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.eventId);
383 }
384 return TELEPHONY_SUCCESS;
385 }
386
HandleOttEventReportInfo(const OttCallEventInfo & info)387 int32_t CallStatusManager::HandleOttEventReportInfo(const OttCallEventInfo &info)
388 {
389 TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.ottCallEventId);
390 CallEventInfo eventInfo;
391 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
392 if (mOttEventIdTransferMap_.find(info.ottCallEventId) != mOttEventIdTransferMap_.end()) {
393 eventInfo.eventId = mOttEventIdTransferMap_[info.ottCallEventId];
394 if (strlen(info.bundleName) > static_cast<size_t>(kMaxNumberLen)) {
395 TELEPHONY_LOGE("Number out of limit!");
396 return CALL_ERR_NUMBER_OUT_OF_RANGE;
397 }
398 if (memcpy_s(eventInfo.bundleName, kMaxNumberLen, info.bundleName, strlen(info.bundleName)) != EOK) {
399 TELEPHONY_LOGE("memcpy_s failed!");
400 return TELEPHONY_ERR_MEMCPY_FAIL;
401 }
402 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
403 } else {
404 TELEPHONY_LOGW("unknown type Event, eventid %{public}d", info.ottCallEventId);
405 }
406 return TELEPHONY_SUCCESS;
407 }
408
HandleVoipEventReportInfo(const VoipCallEventInfo & info)409 int32_t CallStatusManager::HandleVoipEventReportInfo(const VoipCallEventInfo &info)
410 {
411 TELEPHONY_LOGI("recv one Event, eventId:%{public}d", info.voipCallEvent);
412 sptr<CallBase> call = GetOneCallObjectByVoipCallId(info.voipCallId, info.bundleName, info.uid);
413 if (call == nullptr) {
414 TELEPHONY_LOGE("voip call is null");
415 return TELEPHONY_ERR_LOCAL_PTR_NULL;
416 }
417 if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_ACTIVE
418 && call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_DIALING) {
419 return TELEPHONY_ERR_FAIL;
420 }
421 if (info.voipCallEvent == VoipCallEvent::VOIP_CALL_EVENT_MUTED) {
422 call->SetMicPhoneState(true);
423 } else if (info.voipCallEvent == VoipCallEvent::VOIP_CALL_EVENT_UNMUTED) {
424 call->SetMicPhoneState(false);
425 }
426 DelayedSingleton<AudioDeviceManager>::GetInstance()->ReportAudioDeviceInfo(call);
427 return TELEPHONY_SUCCESS;
428 }
429
IncomingHandle(const CallDetailInfo & info)430 int32_t CallStatusManager::IncomingHandle(const CallDetailInfo &info)
431 {
432 TELEPHONY_LOGI("handle incoming state");
433 detectStartTime = std::chrono::system_clock::from_time_t(0);
434 int32_t ret = TELEPHONY_SUCCESS;
435 bool isExisted = false;
436 ret = RefreshOldCall(info, isExisted);
437 if (isExisted) {
438 return ret;
439 }
440 if (info.callType == CallType::TYPE_CS || info.callType == CallType::TYPE_IMS ||
441 info.callType == CallType::TYPE_SATELLITE) {
442 ret = IncomingFilterPolicy(info);
443 if (ret != TELEPHONY_SUCCESS) {
444 return ret;
445 }
446 }
447 sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
448 if (call == nullptr) {
449 TELEPHONY_LOGE("CreateNewCall failed!");
450 return CALL_ERR_CALL_OBJECT_IS_NULL;
451 }
452 if (IsFromTheSameNumberAtTheSameTime(call)) {
453 ModifyEsimType();
454 }
455 SetContactInfo(call, std::string(info.phoneNum));
456 bool block = false;
457 if (IsRejectCall(call, info, block)) {
458 return HandleRejectCall(call, block);
459 }
460 if (info.callType != CallType::TYPE_VOIP && info.callType != CallType::TYPE_BLUETOOTH &&
461 IsRingOnceCall(call, info)) {
462 return HandleRingOnceCall(call);
463 }
464 AddOneCallObject(call);
465 StartInComingCallMotionRecognition();
466 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
467 ret = UpdateCallState(call, info.state);
468 if (ret != TELEPHONY_SUCCESS) {
469 TELEPHONY_LOGE("UpdateCallState failed!");
470 return ret;
471 }
472 ret = FilterResultsDispose(call);
473 if (ret != TELEPHONY_SUCCESS) {
474 TELEPHONY_LOGE("FilterResultsDispose failed!");
475 }
476 return ret;
477 }
478
SetContactInfo(sptr<CallBase> & call,std::string phoneNum)479 void CallStatusManager::SetContactInfo(sptr<CallBase> &call, std::string phoneNum)
480 {
481 if (call == nullptr) {
482 TELEPHONY_LOGE("CreateVoipCall failed!");
483 return;
484 }
485 ContactInfo contactInfo = {
486 .name = "",
487 .number = phoneNum,
488 .isContacterExists = false,
489 .ringtonePath = "",
490 .isSendToVoicemail = false,
491 .isEcc = false,
492 .isVoiceMail = false,
493 .isQueryComplete = true,
494 };
495 if (call->GetCallType() == CallType::TYPE_BLUETOOTH) {
496 std::string contactName = DelayedSingleton<BluetoothCallConnection>::GetInstance()->GetHfpContactName(
497 phoneNum);
498 if (!contactName.empty()) {
499 contactInfo.name = contactName;
500 contactInfo.isContacterExists = true;
501 call->SetCallerInfo(contactInfo);
502 AAFwk::WantParams params = call->GetExtraParams();
503 params.SetParam("BtCallContactName", AAFwk::String::Box(contactName));
504 call->SetExtraParams(params);
505 TELEPHONY_LOGI("SetCallerInfo end for type bluetooth.");
506 return;
507 }
508 }
509 ffrt::submit([=, &call]() {
510 sptr<CallBase> callObjectPtr = call;
511 // allow list filtering
512 // Get the contact data from the database
513 ContactInfo contactInfoTemp = contactInfo;
514 QueryCallerInfo(contactInfoTemp, phoneNum);
515 callObjectPtr->SetCallerInfo(contactInfoTemp);
516 CallVoiceAssistantManager::GetInstance()->UpdateContactInfo(contactInfoTemp, callObjectPtr->GetCallID());
517 DelayedSingleton<DistributedCommunicationManager>::GetInstance()->ProcessCallInfo(callObjectPtr,
518 DistributedDataType::NAME);
519 });
520 }
521
HandleRejectCall(sptr<CallBase> & call,bool isBlock)522 int32_t CallStatusManager::HandleRejectCall(sptr<CallBase> &call, bool isBlock)
523 {
524 if (call == nullptr) {
525 TELEPHONY_LOGE("call is nullptr!");
526 return TELEPHONY_ERR_LOCAL_PTR_NULL;
527 }
528 int32_t ret = call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
529 if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
530 TELEPHONY_LOGE("Set CallState failed!");
531 return ret;
532 }
533 ret = call->RejectCall();
534 if (ret != TELEPHONY_SUCCESS) {
535 TELEPHONY_LOGE("RejectCall failed!");
536 return ret;
537 }
538 if (isBlock) {
539 return DelayedSingleton<CallControlManager>::GetInstance()->AddBlockLogAndNotification(call);
540 }
541 return DelayedSingleton<CallControlManager>::GetInstance()->AddCallLogAndNotification(call);
542 }
543
IncomingVoipCallHandle(const CallDetailInfo & info)544 int32_t CallStatusManager::IncomingVoipCallHandle(const CallDetailInfo &info)
545 {
546 int32_t ret = TELEPHONY_ERROR;
547 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
548 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
549 if (call != nullptr) {
550 return TELEPHONY_SUCCESS;
551 }
552 call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
553 if (call == nullptr) {
554 TELEPHONY_LOGE("CreateVoipCall failed!");
555 return CALL_ERR_CALL_OBJECT_IS_NULL;
556 }
557 AddOneCallObject(call);
558 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
559 ret = UpdateCallState(call, info.state);
560 if (ret != TELEPHONY_SUCCESS) {
561 TELEPHONY_LOGE("UpdateCallState failed!");
562 return ret;
563 }
564 return ret;
565 }
566
OutgoingVoipCallHandle(const CallDetailInfo & info)567 int32_t CallStatusManager::OutgoingVoipCallHandle(const CallDetailInfo &info)
568 {
569 int32_t ret = TELEPHONY_ERROR;
570 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
571 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
572 if (call != nullptr) {
573 VideoStateType originalType = call->GetVideoStateType();
574 if (originalType != info.callMode) {
575 TELEPHONY_LOGI("change VideoStateType from %{public}d to %{public}d",
576 static_cast<int32_t>(originalType), static_cast<int32_t>(info.callMode));
577 call->SetVideoStateType(info.callMode);
578 return UpdateCallState(call, info.state);
579 }
580 return TELEPHONY_SUCCESS;
581 }
582 call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
583 if (call == nullptr) {
584 TELEPHONY_LOGE("CreateVoipCall failed!");
585 return CALL_ERR_CALL_OBJECT_IS_NULL;
586 }
587 AddOneCallObject(call);
588 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
589 ret = UpdateCallState(call, info.state);
590 if (ret != TELEPHONY_SUCCESS) {
591 TELEPHONY_LOGE("UpdateCallState failed!");
592 return ret;
593 }
594 return ret;
595 }
596
AnsweredVoipCallHandle(const CallDetailInfo & info)597 int32_t CallStatusManager::AnsweredVoipCallHandle(const CallDetailInfo &info)
598 {
599 int32_t ret = TELEPHONY_ERROR;
600 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
601 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
602 if (call == nullptr) {
603 return ret;
604 }
605 if (DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
606 call, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED)) {
607 return TELEPHONY_SUCCESS;
608 } else {
609 return ret;
610 }
611 }
612
DisconnectingVoipCallHandle(const CallDetailInfo & info)613 int32_t CallStatusManager::DisconnectingVoipCallHandle(const CallDetailInfo &info)
614 {
615 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
616 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
617 if (call == nullptr) {
618 return TELEPHONY_ERROR;
619 }
620 return UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
621 }
622
QueryCallerInfo(ContactInfo & contactInfo,std::string phoneNum)623 void CallStatusManager::QueryCallerInfo(ContactInfo &contactInfo, std::string phoneNum)
624 {
625 TELEPHONY_LOGI("Entry CallStatusManager QueryCallerInfo");
626 std::shared_ptr<CallDataBaseHelper> callDataPtr = DelayedSingleton<CallDataBaseHelper>::GetInstance();
627 if (callDataPtr == nullptr) {
628 TELEPHONY_LOGE("callDataPtr is nullptr!");
629 return;
630 }
631 DataShare::DataSharePredicates predicates;
632 predicates.EqualTo(TYPE_ID, 5); // type 5 means query number
633 predicates.And();
634 predicates.EqualTo(IS_DELETED, 0);
635 predicates.And();
636 #ifdef TELEPHONY_CUST_SUPPORT
637 TELEPHONY_LOGI("telephony cust support.");
638 if (phoneNum.length() >= static_cast<size_t>(QUERY_CONTACT_LEN)) {
639 TELEPHONY_LOGI("phoneNum is longer than 7");
640 predicates.BeginWrap();
641 predicates.EndsWith(DETAIL_INFO, phoneNum.substr(phoneNum.length() - QUERY_CONTACT_LEN));
642 predicates.Or();
643 predicates.EndsWith(FORMAT_PHONE_NUMBER, phoneNum.substr(phoneNum.length() - QUERY_CONTACT_LEN));
644 predicates.EndWrap();
645 if (!callDataPtr->QueryContactInfoEnhanced(contactInfo, predicates)) {
646 TELEPHONY_LOGE("Query contact database enhanced fail!");
647 }
648 return;
649 }
650 #endif
651 predicates.EqualTo(DETAIL_INFO, phoneNum);
652 if (!callDataPtr->Query(contactInfo, predicates)) {
653 TELEPHONY_LOGE("Query contact database fail!");
654 }
655 }
656
IncomingFilterPolicy(const CallDetailInfo & info)657 int32_t CallStatusManager::IncomingFilterPolicy(const CallDetailInfo &info)
658 {
659 if (CallIncomingFilterManagerPtr_ == nullptr) {
660 TELEPHONY_LOGE("CallIncomingFilterManagerPtr_ is null");
661 return TELEPHONY_ERR_LOCAL_PTR_NULL;
662 }
663 return CallIncomingFilterManagerPtr_->DoIncomingFilter(info);
664 }
665
CallFilterCompleteResult(const CallDetailInfo & info)666 void CallStatusManager::CallFilterCompleteResult(const CallDetailInfo &info)
667 {
668 int32_t ret = TELEPHONY_ERR_FAIL;
669 sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_IN);
670 if (call == nullptr) {
671 TELEPHONY_LOGE("CreateNewCall failed!");
672 return;
673 }
674 AddOneCallObject(call);
675 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
676 ret = UpdateCallState(call, info.state);
677 if (ret != TELEPHONY_SUCCESS) {
678 TELEPHONY_LOGE("UpdateCallState failed!");
679 return;
680 }
681 ret = FilterResultsDispose(call);
682 if (ret != TELEPHONY_SUCCESS) {
683 TELEPHONY_LOGE("FilterResultsDispose failed!");
684 return;
685 }
686 }
687
UpdateDialingCallInfo(const CallDetailInfo & info)688 int32_t CallStatusManager::UpdateDialingCallInfo(const CallDetailInfo &info)
689 {
690 TELEPHONY_LOGI("UpdateDialingCallInfo start.");
691 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
692 if (call != nullptr) {
693 TELEPHONY_LOGI("RefreshCallIfNecessary for not null.");
694 call = RefreshCallIfNecessary(call, info);
695 return TELEPHONY_SUCCESS;
696 }
697 call = GetOneCallObjectByIndex(INIT_INDEX);
698 if (call == nullptr) {
699 TELEPHONY_LOGE("call is nullptr");
700 return TELEPHONY_ERR_LOCAL_PTR_NULL;
701 }
702
703 std::string oriNum = call->GetAccountNumber();
704 TELEPHONY_LOGI("RefreshCallIfNecessary");
705 call = RefreshCallIfNecessary(call, info);
706 call->SetCallIndex(info.index);
707 call->SetBundleName(info.bundleName);
708 call->SetSlotId(info.accountId);
709 call->SetTelCallState(info.state);
710 call->SetVideoStateType(info.callMode);
711 call->SetCallType(info.callType);
712 call->SetAccountNumber(oriNum);
713 ClearPendingState(call);
714 return TELEPHONY_SUCCESS;
715 }
716
DialingHandle(const CallDetailInfo & info)717 int32_t CallStatusManager::DialingHandle(const CallDetailInfo &info)
718 {
719 TELEPHONY_LOGI("handle dialing state, index: %{public}d", info.index);
720 bool isDistributedDeviceDialing = false;
721 if (info.index > 0) {
722 if (UpdateDialingHandle(info, isDistributedDeviceDialing)) {
723 return UpdateDialingCallInfo(info);
724 }
725 }
726 sptr<CallBase> call = CreateNewCall(info, CallDirection::CALL_DIRECTION_OUT);
727 if (call == nullptr) {
728 TELEPHONY_LOGE("CreateNewCall failed!");
729 return TELEPHONY_ERR_LOCAL_PTR_NULL;
730 }
731 SetDistributedDeviceDialing(call, isDistributedDeviceDialing);
732 if (IsDcCallConneceted()) {
733 SetContactInfo(call, std::string(info.phoneNum));
734 }
735 AddOneCallObject(call);
736 auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
737 if (info.index == INIT_INDEX) {
738 callRequestEventHandler->SetPendingMo(true, call->GetCallID());
739 call->SetPhoneOrWatchDial(static_cast<int32_t>(PhoneOrWatchDial::WATCH_DIAL));
740 SetBtCallDialByPhone(call, false);
741 StartOutGoingCallMotionRecognition();
742 }
743 callRequestEventHandler->RestoreDialingFlag(false);
744 callRequestEventHandler->RemoveEventHandlerTask();
745 int32_t ret = call->DialingProcess();
746 if (ret != TELEPHONY_SUCCESS) {
747 return ret;
748 }
749 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
750 MyLocationEngine::StartEccService(call, info);
751 ret = UpdateCallState(call, TelCallState::CALL_STATUS_DIALING);
752 if (ret != TELEPHONY_SUCCESS) {
753 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
754 }
755 return ret;
756 }
757
UpdateDialingHandle(const CallDetailInfo & info,bool & isDistributedDeviceDialing)758 bool CallStatusManager::UpdateDialingHandle(const CallDetailInfo &info, bool &isDistributedDeviceDialing)
759 {
760 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(INIT_INDEX, info.accountId, info.callType);
761 if (info.callType == CallType::TYPE_BLUETOOTH) {
762 BtCallDialingHandle(call, info);
763 } else {
764 if (call == nullptr) {
765 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
766 isDistributedDeviceDialing = IsDistributeCallSourceStatus();
767 }
768 }
769 if (call != nullptr) {
770 TELEPHONY_LOGI("need update call info");
771 return true;
772 }
773 return false;
774 }
775
ActiveHandle(const CallDetailInfo & info)776 int32_t CallStatusManager::ActiveHandle(const CallDetailInfo &info)
777 {
778 TELEPHONY_LOGI("handle active state");
779 StopCallMotionRecognition(TelCallState::CALL_STATUS_ACTIVE);
780 std::string tmpStr(info.phoneNum);
781 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
782 if (call == nullptr && IsDcCallConneceted()) {
783 TELEPHONY_LOGW("need create new call.");
784 CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_UNKNOW);
785 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
786 }
787 if (call == nullptr) {
788 TELEPHONY_LOGE("Call is NULL");
789 return TELEPHONY_ERR_LOCAL_PTR_NULL;
790 }
791 #ifdef NOT_SUPPORT_MULTICALL
792 OneCallAnswerAtPhone(call->GetCallID());
793 #endif
794 ClearPendingState(call);
795 TELEPHONY_LOGI("refresh call.");
796 call = RefreshCallIfNecessary(call, info);
797 SetOriginalCallTypeForActiveState(call);
798 // call state change active, need to judge if launching a conference
799 std::vector<sptr<CallBase>> conferenceCallList = GetConferenceCallList(call->GetSlotId());
800 if (info.mpty == 1 && conferenceCallList.size() > 1) {
801 SetConferenceCall(conferenceCallList);
802 } else if (call->ExitConference() == TELEPHONY_SUCCESS) {
803 TELEPHONY_LOGI("SubCallSeparateFromConference success!");
804 } else {
805 TELEPHONY_LOGI("SubCallSeparateFromConference fail!");
806 }
807 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
808 if (ret != TELEPHONY_SUCCESS) {
809 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
810 return ret;
811 }
812 sptr<CallBase> holdCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
813 if (holdCall != nullptr) {
814 holdCall->SetCanSwitchCallState(true);
815 TELEPHONY_LOGI("holdcall:%{public}d can swap", holdCall->GetCallID());
816 }
817 #ifdef AUDIO_SUPPORT
818 ToSpeakerPhone(call);
819 DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
820 #endif
821 TELEPHONY_LOGI("handle active state success");
822
823 bool isAntiFraudSupport = OHOS::system::GetBoolParameter(ANTIFRAUD_FEATURE, true);
824 if (isAntiFraudSupport) {
825 SetupAntiFraudService(call, info);
826 }
827 return ret;
828 }
829
GetAntiFraudSlotId()830 int32_t CallStatusManager::GetAntiFraudSlotId()
831 {
832 std::lock_guard<ffrt::mutex> lock(mutex_);
833 return antiFraudSlotId_;
834 }
835
GetAntiFraudIndex()836 int32_t CallStatusManager::GetAntiFraudIndex()
837 {
838 std::lock_guard<ffrt::mutex> lock(mutex_);
839 return antiFraudIndex_;
840 }
841
SetAntiFraudSlotId(int32_t slotId)842 void CallStatusManager::SetAntiFraudSlotId(int32_t slotId)
843 {
844 std::lock_guard<ffrt::mutex> lock(mutex_);
845 antiFraudSlotId_ = slotId;
846 }
847
SetAntiFraudIndex(int32_t index)848 void CallStatusManager::SetAntiFraudIndex(int32_t index)
849 {
850 std::lock_guard<ffrt::mutex> lock(mutex_);
851 antiFraudIndex_ = index;
852 }
853
SetupAntiFraudService(const sptr<CallBase> & call,const CallDetailInfo & info)854 void CallStatusManager::SetupAntiFraudService(const sptr<CallBase> &call, const CallDetailInfo &info)
855 {
856 auto antiFraudService = DelayedSingleton<AntiFraudService>::GetInstance();
857 NumberMarkInfo numberMarkInfo = call->GetNumberMarkInfo();
858 std::string tmpStr(info.phoneNum);
859 if (numberMarkInfo.markType != MarkType::MARK_TYPE_FRAUD &&
860 numberMarkInfo.markType != MarkType::MARK_TYPE_YELLOW_PAGE &&
861 numberMarkInfo.markType != MarkType::MARK_TYPE_ENTERPRISE &&
862 !IsContactPhoneNum(tmpStr) && antiFraudService->IsAntiFraudSwitchOn()) {
863 int32_t slotId = call->GetSlotId();
864 if (slotId == -1) {
865 return;
866 }
867 if (GetAntiFraudSlotId() != -1 || GetAntiFraudIndex() != -1) {
868 return;
869 }
870 SetAntiFraudSlotId(slotId);
871 SetAntiFraudIndex(info.index);
872 ffrt::submit([tmpStr, slotId, info, this]() {
873 int32_t ret = DelayedSingleton<AntiFraudService>::GetInstance()->
874 StartAntiFraudService(tmpStr, slotId, info.index);
875 if (ret != 0) {
876 SetAntiFraudSlotId(-1);
877 SetAntiFraudIndex(-1);
878 }
879 });
880 }
881 }
882
StopAntiFraudDetect(sptr<CallBase> & call,const CallDetailInfo & info)883 void CallStatusManager::StopAntiFraudDetect(sptr<CallBase> &call, const CallDetailInfo &info)
884 {
885 if (GetAntiFraudSlotId() != call->GetSlotId() || GetAntiFraudIndex() != info.index) {
886 return;
887 }
888 DelayedSingleton<AntiFraudService>::GetInstance()->StopAntiFraudService(call->GetSlotId(), info.index);
889 SetAntiFraudSlotId(-1);
890 SetAntiFraudIndex(-1);
891 TELEPHONY_LOGI("call ending, can begin a new antifraud");
892 UpdateAntiFraudState(call, static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_FINISHED));
893 }
894
HandleCeliaCall(sptr<CallBase> & call)895 void CallStatusManager::HandleCeliaCall(sptr<CallBase> &call)
896 {
897 int32_t slotId = call->GetSlotId();
898 int32_t index = call->GetCallIndex();
899 TELEPHONY_LOGI("handle celia call, slotId=%{public}d, index=%{public}d", slotId, index);
900 if (GetAntiFraudSlotId() != slotId || GetAntiFraudIndex() != index) {
901 return;
902 }
903 DelayedSingleton<AntiFraudService>::GetInstance()->StopAntiFraudService(slotId, index);
904 SetAntiFraudSlotId(-1);
905 SetAntiFraudIndex(-1);
906 TELEPHONY_LOGI("celia call begin, recover AntiFraud SlotId and Index");
907 UpdateAntiFraudState(call, static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_FINISHED));
908
909 if (call->GetTelCallState() == TelCallState::CALL_STATUS_ACTIVE) {
910 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
911 if (ret != TELEPHONY_SUCCESS) {
912 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
913 }
914 }
915 }
916
UpdateAntiFraudState(sptr<CallBase> & call,int32_t antiFraudState)917 void CallStatusManager::UpdateAntiFraudState(sptr<CallBase> &call, int32_t antiFraudState)
918 {
919 AAFwk::WantParams extraParams = call->GetExtraParams();
920 extraParams.SetParam("antiFraudState", AAFwk::Integer::Box(antiFraudState));
921 call->SetExtraParams(extraParams);
922 }
923
IsContactPhoneNum(const std::string & phoneNum)924 bool CallStatusManager::IsContactPhoneNum(const std::string &phoneNum)
925 {
926 ContactInfo contactInfo = {
927 .name = "",
928 .number = phoneNum,
929 .isContacterExists = false,
930 .ringtonePath = "",
931 .isSendToVoicemail = false,
932 .isEcc = false,
933 .isVoiceMail = false,
934 .isQueryComplete = true,
935 };
936 QueryCallerInfo(contactInfo, phoneNum);
937 if (contactInfo.name.length() < 1) {
938 TELEPHONY_LOGI("no corresponding contact found");
939 return false;
940 } else {
941 return true;
942 }
943 }
944
TriggerAntiFraud(int32_t antiFraudState)945 void CallStatusManager::TriggerAntiFraud(int32_t antiFraudState)
946 {
947 TELEPHONY_LOGI("TriggerAntiState, antiFraudState = %{public}d", antiFraudState);
948 sptr<CallBase> call = nullptr;
949 int32_t antiFraudSlotId = GetAntiFraudSlotId();
950 if (antiFraudSlotId >= SLOT_NUM || antiFraudSlotId < 0) {
951 return;
952 }
953 for (auto &it : callDetailsInfo_[antiFraudSlotId].callVec) {
954 if (it.index == GetAntiFraudIndex()) {
955 it.antiFraudState = antiFraudState;
956 call = GetOneCallObjectByIndexSlotIdAndCallType(it.index, it.accountId, it.callType);
957 break;
958 }
959 }
960 if (antiFraudState == static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_RISK) ||
961 antiFraudState == static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_FINISHED)) {
962 SetAntiFraudSlotId(-1);
963 SetAntiFraudIndex(-1);
964 TELEPHONY_LOGI("detect finish, can begin a new antifraud");
965 }
966
967 if (call == nullptr) {
968 return;
969 }
970 if (antiFraudState != static_cast<int32_t>(AntiFraudState::ANTIFRAUD_STATE_DEFAULT)) {
971 UpdateAntiFraudState(call, antiFraudState);
972 }
973
974 if (call->GetTelCallState() == TelCallState::CALL_STATUS_ACTIVE) {
975 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
976 if (ret != TELEPHONY_SUCCESS) {
977 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
978 }
979 }
980 }
981
SetConferenceCall(std::vector<sptr<CallBase>> conferenceCallList)982 void CallStatusManager::SetConferenceCall(std::vector<sptr<CallBase>> conferenceCallList)
983 {
984 for (auto conferenceCall : conferenceCallList) {
985 TELEPHONY_LOGI("SetConferenceCall callid : %{public}d; State : %{public}d",
986 conferenceCall->GetCallID(), conferenceCall->GetTelConferenceState());
987 if (conferenceCall->GetTelConferenceState() != TelConferenceState::TEL_CONFERENCE_ACTIVE) {
988 conferenceCall->LaunchConference();
989 UpdateCallState(conferenceCall, conferenceCall->GetTelCallState());
990 }
991 }
992 }
993
ActiveVoipCallHandle(const CallDetailInfo & info)994 int32_t CallStatusManager::ActiveVoipCallHandle(const CallDetailInfo &info)
995 {
996 TELEPHONY_LOGI("handle active state");
997 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
998 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
999 if (call == nullptr) {
1000 TELEPHONY_LOGE("voip Call is NULL");
1001 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1002 }
1003 VideoStateType originalType = call->GetVideoStateType();
1004 if (originalType != info.callMode) {
1005 TELEPHONY_LOGI("change VideoStateType from %{public}d to %{public}d",
1006 static_cast<int32_t>(originalType), static_cast<int32_t>(info.callMode));
1007 call->SetVideoStateType(info.callMode);
1008 }
1009 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ACTIVE);
1010 if (ret != TELEPHONY_SUCCESS) {
1011 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1012 return ret;
1013 }
1014 TELEPHONY_LOGI("handle active state success");
1015 return ret;
1016 }
1017
HoldingHandle(const CallDetailInfo & info)1018 int32_t CallStatusManager::HoldingHandle(const CallDetailInfo &info)
1019 {
1020 TELEPHONY_LOGI("handle holding state");
1021 std::string tmpStr(info.phoneNum);
1022 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1023 if (call == nullptr && IsDcCallConneceted()) {
1024 CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_UNKNOW);
1025 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1026 }
1027 if (call == nullptr) {
1028 TELEPHONY_LOGE("Call is NULL");
1029 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1030 }
1031 StopAntiFraudDetect(call, info);
1032 // if the call is in a conference, it will exit, otherwise just set it holding
1033 TELEPHONY_LOGI("refresh call.");
1034 call = RefreshCallIfNecessary(call, info);
1035 if (info.mpty == 1) {
1036 int32_t ret = call->HoldConference();
1037 if (ret == TELEPHONY_SUCCESS) {
1038 TELEPHONY_LOGI("HoldConference success");
1039 }
1040 }
1041 return UpdateCallStateAndHandleDsdsMode(info, call);
1042 }
1043
WaitingHandle(const CallDetailInfo & info)1044 int32_t CallStatusManager::WaitingHandle(const CallDetailInfo &info)
1045 {
1046 DelayedSingleton<CallControlManager>::GetInstance()->AcquireIncomingLock();
1047 int32_t ret = IncomingHandle(info);
1048 DelayedSingleton<CallControlManager>::GetInstance()->ReleaseIncomingLock();
1049 return ret;
1050 }
1051
AlertHandle(const CallDetailInfo & info)1052 int32_t CallStatusManager::AlertHandle(const CallDetailInfo &info)
1053 {
1054 TELEPHONY_LOGI("handle alerting state");
1055 std::string tmpStr(info.phoneNum);
1056 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1057 if (call == nullptr && IsDcCallConneceted()) {
1058 TELEPHONY_LOGI("create new call.");
1059 CreateAndSaveNewCall(info, CallDirection::CALL_DIRECTION_OUT);
1060 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1061 }
1062 if (call == nullptr) {
1063 TELEPHONY_LOGE("Call is NULL");
1064 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1065 }
1066 ClearPendingState(call);
1067 TELEPHONY_LOGI("refresh call.");
1068 call = RefreshCallIfNecessary(call, info);
1069 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_ALERTING);
1070 if (ret != TELEPHONY_SUCCESS) {
1071 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1072 return ret;
1073 }
1074 #ifdef AUDIO_SUPPORT
1075 ToSpeakerPhone(call);
1076 TurnOffMute(call);
1077 DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
1078 #endif
1079 return ret;
1080 }
1081
DisconnectingHandle(const CallDetailInfo & info)1082 int32_t CallStatusManager::DisconnectingHandle(const CallDetailInfo &info)
1083 {
1084 TELEPHONY_LOGI("handle disconnecting state");
1085 std::string tmpStr(info.phoneNum);
1086 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1087 if (call == nullptr) {
1088 TELEPHONY_LOGE("Call is NULL");
1089 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1090 }
1091 StopAntiFraudDetect(call, info);
1092 TELEPHONY_LOGI("refresh call.");
1093 call = RefreshCallIfNecessary(call, info);
1094 SetOriginalCallTypeForDisconnectState(call);
1095 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTING);
1096 if (ret != TELEPHONY_SUCCESS) {
1097 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1098 }
1099 return ret;
1100 }
1101
DisconnectedVoipCallHandle(const CallDetailInfo & info)1102 int32_t CallStatusManager::DisconnectedVoipCallHandle(const CallDetailInfo &info)
1103 {
1104 TELEPHONY_LOGI("handle disconnected voip call state");
1105 sptr<CallBase> call = GetOneCallObjectByVoipCallId(
1106 info.voipCallInfo.voipCallId, info.voipCallInfo.voipBundleName, info.voipCallInfo.uid);
1107 if (call == nullptr) {
1108 TELEPHONY_LOGE("voip Call is NULL");
1109 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1110 }
1111 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
1112 if (ret != TELEPHONY_SUCCESS) {
1113 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1114 return ret;
1115 }
1116 DeleteOneCallObject(call->GetCallID());
1117 TELEPHONY_LOGI("handle disconnected voip call state success");
1118 return ret;
1119 }
1120
DisconnectedHandle(const CallDetailInfo & info)1121 int32_t CallStatusManager::DisconnectedHandle(const CallDetailInfo &info)
1122 {
1123 TELEPHONY_LOGI("handle disconnected state");
1124 if (timeWaitHelper_ != nullptr) {
1125 TELEPHONY_LOGI("ringtone once");
1126 timeWaitHelper_->NotifyAll();
1127 timeWaitHelper_ = nullptr;
1128 }
1129 std::string tmpStr(info.phoneNum);
1130 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
1131 if (call == nullptr) {
1132 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1133 }
1134 StopAntiFraudDetect(call, info);
1135 #ifdef NOT_SUPPORT_MULTICALL
1136 bool isTwoCallBtCallAndESIM = CallObjectManager::IsTwoCallBtCallAndESIM();
1137 bool IsTwoCallESIMCall = CallObjectManager::IsTwoCallESIMCall();
1138 #endif
1139 call = RefreshCallIfNecessary(call, info);
1140 RefreshCallDisconnectReason(call, static_cast<int32_t>(info.reason));
1141 ClearPendingState(call);
1142 SetOriginalCallTypeForDisconnectState(call);
1143 std::vector<std::u16string> callIdList;
1144 call->GetSubCallIdList(callIdList);
1145 CallRunningState previousState = call->GetCallRunningState();
1146 call->ExitConference();
1147 TelCallState priorState = call->GetTelCallState();
1148 UpdateCallState(call, TelCallState::CALL_STATUS_DISCONNECTED);
1149 MyLocationEngine::StopEccService(call->GetCallID());
1150 HandleHoldCallOrAutoAnswerCall(call, callIdList, previousState, priorState);
1151 std::vector<sptr<CallBase>> conferenceCallList = GetConferenceCallList(call->GetSlotId());
1152 if (conferenceCallList.size() == 1) {
1153 sptr<CallBase> leftOneConferenceCall = conferenceCallList[0];
1154 if (leftOneConferenceCall != nullptr &&
1155 leftOneConferenceCall->GetTelConferenceState() != TelConferenceState::TEL_CONFERENCE_IDLE) {
1156 TELEPHONY_LOGI("Not enough calls to be a conference!");
1157 leftOneConferenceCall->SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_IDLE);
1158 UpdateCallState(leftOneConferenceCall, leftOneConferenceCall->GetTelCallState());
1159 }
1160 }
1161 int32_t currentCallNum = CallObjectManager::GetCurrentCallNum();
1162 if (currentCallNum <= 0) {
1163 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->RestoreSuperPrivacyMode();
1164 }
1165 #ifdef NOT_SUPPORT_MULTICALL
1166 if (isTwoCallBtCallAndESIM || IsTwoCallESIMCall) {
1167 TELEPHONY_LOGI("Auto AnswerCall");
1168 AutoAnswerSecondCall();
1169 }
1170 #endif
1171 StopCallMotionRecognition(TelCallState::CALL_STATUS_DISCONNECTED);
1172 return TELEPHONY_SUCCESS;
1173 }
1174
StopCallMotionRecognition(TelCallState nextState)1175 void CallStatusManager::StopCallMotionRecognition(TelCallState nextState)
1176 {
1177 switch (nextState) {
1178 case TelCallState::CALL_STATUS_ACTIVE:
1179 MotionRecogntion::UnsubscribePickupSensor();
1180 MotionRecogntion::UnsubscribeFlipSensor();
1181 break;
1182 case TelCallState::CALL_STATUS_DISCONNECTED:
1183 if (!CallObjectManager::HasCellularCallExist()) {
1184 MotionRecogntion::UnsubscribePickupSensor();
1185 MotionRecogntion::UnsubscribeFlipSensor();
1186 MotionRecogntion::UnsubscribeCloseToEarSensor();
1187 Rosen::UnloadMotionSensor();
1188 }
1189 break;
1190 default:
1191 break;
1192 }
1193 }
1194
GetConferenceCallList(int32_t slotId)1195 std::vector<sptr<CallBase>> CallStatusManager::GetConferenceCallList(int32_t slotId)
1196 {
1197 if (slotId >= SLOT_NUM || slotId < 0) {
1198 return std::vector<sptr<CallBase>>();
1199 }
1200 std::vector<sptr<CallBase>> conferenceCallList;
1201 for (const auto &it : tmpCallDetailsInfo_[slotId].callVec) {
1202 if (it.mpty == 1) {
1203 sptr<CallBase> conferenceCall = GetOneCallObjectByIndexAndSlotId(it.index, it.accountId);
1204 if (conferenceCall != nullptr) {
1205 conferenceCallList.emplace_back(conferenceCall);
1206 }
1207 }
1208 }
1209 TELEPHONY_LOGI("Conference call list size:%{public}zu", conferenceCallList.size());
1210 return conferenceCallList;
1211 }
1212
HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,std::vector<std::u16string> callIdList,CallRunningState previousState,TelCallState priorState)1213 void CallStatusManager::HandleHoldCallOrAutoAnswerCall(const sptr<CallBase> call,
1214 std::vector<std::u16string> callIdList, CallRunningState previousState, TelCallState priorState)
1215 {
1216 if (call == nullptr) {
1217 TELEPHONY_LOGE("call is null");
1218 return;
1219 }
1220 bool canUnHold = false;
1221 size_t size = callIdList.size();
1222 int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
1223 int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
1224 IsCanUnHold(activeCallNum, waitingCallNum, size, canUnHold);
1225 sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
1226 if (previousState != CallRunningState::CALL_RUNNING_STATE_HOLD &&
1227 previousState != CallRunningState::CALL_RUNNING_STATE_ACTIVE &&
1228 priorState == TelCallState::CALL_STATUS_DISCONNECTING) {
1229 if (holdCall != nullptr && canUnHold && holdCall->GetCanUnHoldState()) {
1230 if (holdCall->GetSlotId() == call->GetSlotId()) {
1231 TELEPHONY_LOGI("release call and recover the held call");
1232 holdCall->UnHoldCall();
1233 }
1234 }
1235 }
1236 DeleteOneCallObject(call->GetCallID());
1237 int32_t dsdsMode = DSDS_MODE_V2;
1238 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
1239 if (dsdsMode == DSDS_MODE_V3) {
1240 AutoAnswer(activeCallNum, waitingCallNum);
1241 } else if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
1242 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
1243 bool canSwitchCallState = call->GetCanSwitchCallState();
1244 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), true);
1245 }
1246 }
1247
IsCanUnHold(int32_t activeCallNum,int32_t waitingCallNum,int32_t size,bool & canUnHold)1248 void CallStatusManager::IsCanUnHold(int32_t activeCallNum, int32_t waitingCallNum, int32_t size, bool &canUnHold)
1249 {
1250 int32_t incomingCallNum = GetCallNum(TelCallState::CALL_STATUS_INCOMING);
1251 int32_t answeredCallNum = GetCallNum(TelCallState::CALL_STATUS_ANSWERED);
1252 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1253 if (answeredCallNum == 0 && incomingCallNum == 0 && (size == 0 || size == 1) && activeCallNum == 0 &&
1254 waitingCallNum == 0 && dialingCallNum == 0) {
1255 canUnHold = true;
1256 }
1257 TELEPHONY_LOGI("CanUnHold state: %{public}d", canUnHold);
1258 }
1259
AutoHandleForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId,bool continueAnswer)1260 void CallStatusManager::AutoHandleForDsda(
1261 bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId, bool continueAnswer)
1262 {
1263 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1264 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1265 std::list<int32_t> callIdList;
1266 GetCarrierCallList(callIdList);
1267 for (int32_t ringCallId : callIdList) {
1268 sptr<CallBase> ringCall = GetOneCallObject(ringCallId);
1269 if (ringCall != nullptr && ringCall->GetAutoAnswerState()) {
1270 TELEPHONY_LOGI("ringCall is not nullptr");
1271 int32_t videoState = static_cast<int32_t>(ringCall->GetVideoStateType());
1272 if (videoState == static_cast<int32_t>(VideoStateType::TYPE_VIDEO)) {
1273 TELEPHONY_LOGI("AutoAnswer VideoCall for Dsda");
1274 AutoAnswerForVideoCall(activeCallNum);
1275 AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
1276 return;
1277 }
1278 if (dialingCallNum == 0 && alertingCallNum == 0 && activeCallNum == 0 &&
1279 ringCall->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
1280 TELEPHONY_LOGI("AutoAnswer VoiceCall for Dsda");
1281 AutoAnswerForVoiceCall(ringCall, slotId, continueAnswer);
1282 AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
1283 return;
1284 }
1285 }
1286 }
1287 AutoUnHoldForDsda(canSwitchCallState, priorState, activeCallNum, slotId);
1288 }
1289
AutoUnHoldForDsda(bool canSwitchCallState,TelCallState priorState,int32_t activeCallNum,int32_t slotId)1290 void CallStatusManager::AutoUnHoldForDsda(
1291 bool canSwitchCallState, TelCallState priorState, int32_t activeCallNum, int32_t slotId)
1292 {
1293 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1294 int32_t waitingCallNum = GetCallNum(TelCallState::CALL_STATUS_WAITING);
1295 int32_t callNum = 2;
1296 std::list<int32_t> callIdList;
1297 GetCarrierCallList(callIdList);
1298 int32_t currentCallNum = GetCurrentCallNum();
1299 for (int32_t otherCallId : callIdList) {
1300 sptr<CallBase> otherCall = GetOneCallObject(otherCallId);
1301 if (otherCall == nullptr) {
1302 TELEPHONY_LOGE("otherCall is nullptr");
1303 continue;
1304 }
1305 TelCallState state = otherCall->GetTelCallState();
1306 TelConferenceState confState = otherCall->GetTelConferenceState();
1307 int32_t conferenceId = ERR_ID;
1308 otherCall->GetMainCallId(conferenceId);
1309 if (slotId != otherCall->GetSlotId() && state == TelCallState::CALL_STATUS_HOLDING &&
1310 otherCall->GetCanUnHoldState() && activeCallNum == 0 && waitingCallNum == 0 &&
1311 dialingCallNum == 0 &&
1312 ((confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == otherCallId) ||
1313 confState == TelConferenceState::TEL_CONFERENCE_IDLE)) {
1314 // Actively hang up the processing unhold state or exchange call
1315 if (priorState == TelCallState::CALL_STATUS_DISCONNECTING ||
1316 (!canSwitchCallState && currentCallNum == callNum)) {
1317 otherCall->UnHoldCall();
1318 return;
1319 }
1320 }
1321 }
1322 for (int32_t otherCallId : callIdList) {
1323 sptr<CallBase> holdCall = GetOneCallObject(otherCallId);
1324 if (holdCall != nullptr && holdCall->GetTelCallState() == TelCallState::CALL_STATUS_HOLDING) {
1325 if (currentCallNum == callNum) {
1326 holdCall->SetCanUnHoldState(true);
1327 }
1328 }
1329 }
1330 }
1331
AutoAnswerForVoiceCall(sptr<CallBase> ringCall,int32_t slotId,bool continueAnswer)1332 void CallStatusManager::AutoAnswerForVoiceCall(sptr<CallBase> ringCall, int32_t slotId, bool continueAnswer)
1333 {
1334 /* Need to check whether the autoAnswer call and the holding call are on the same slotid
1335 * To prevent repeated AT command delivery.
1336 */
1337 if (continueAnswer || slotId != ringCall->GetSlotId()) {
1338 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(
1339 ringCall, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
1340 int ret = ringCall->AnswerCall(ringCall->GetAnswerVideoState());
1341 if (ret == TELEPHONY_SUCCESS) {
1342 DelayedSingleton<CallControlManager>::GetInstance()->NotifyIncomingCallAnswered(ringCall);
1343 }
1344 TELEPHONY_LOGI("ret = %{public}d", ret);
1345 }
1346 ringCall->SetAutoAnswerState(false);
1347 }
1348
AutoAnswerForVideoCall(int32_t activeCallNum)1349 void CallStatusManager::AutoAnswerForVideoCall(int32_t activeCallNum)
1350 {
1351 int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
1352 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1353 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1354 if (activeCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 && alertingCallNum == 0) {
1355 std::list<int32_t> ringCallIdList;
1356 GetCarrierCallList(ringCallIdList);
1357 for (int32_t ringingCallId : ringCallIdList) {
1358 sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
1359 if (ringingCall == nullptr) {
1360 TELEPHONY_LOGE("ringingCall is nullptr");
1361 return;
1362 }
1363 CallRunningState ringingCallState = ringingCall->GetCallRunningState();
1364 if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
1365 (ringingCall->GetAutoAnswerState()))) {
1366 ringingCall->SetAutoAnswerState(false);
1367 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
1368 TELEPHONY_LOGI("ret = %{public}d", ret);
1369 break;
1370 }
1371 }
1372 }
1373 }
1374
AutoAnswer(int32_t activeCallNum,int32_t waitingCallNum)1375 void CallStatusManager::AutoAnswer(int32_t activeCallNum, int32_t waitingCallNum)
1376 {
1377 int32_t holdingCallNum = GetCallNum(TelCallState::CALL_STATUS_HOLDING);
1378 int32_t dialingCallNum = GetCallNum(TelCallState::CALL_STATUS_DIALING);
1379 int32_t alertingCallNum = GetCallNum(TelCallState::CALL_STATUS_ALERTING);
1380 if (activeCallNum == 0 && waitingCallNum == 0 && holdingCallNum == 0 && dialingCallNum == 0 &&
1381 alertingCallNum == 0) {
1382 std::list<int32_t> ringCallIdList;
1383 GetCarrierCallList(ringCallIdList);
1384 for (int32_t ringingCallId : ringCallIdList) {
1385 sptr<CallBase> ringingCall = GetOneCallObject(ringingCallId);
1386 if (ringingCall == nullptr) {
1387 TELEPHONY_LOGE("ringingCall is nullptr");
1388 return;
1389 }
1390 CallRunningState ringingCallState = ringingCall->GetCallRunningState();
1391 if ((ringingCallState == CallRunningState::CALL_RUNNING_STATE_RINGING &&
1392 (ringingCall->GetAutoAnswerState()))) {
1393 ringingCall->SetAutoAnswerState(false);
1394 int ret = ringingCall->AnswerCall(ringingCall->GetAnswerVideoState());
1395 TELEPHONY_LOGI("ret = %{public}d", ret);
1396 break;
1397 }
1398 }
1399 }
1400 }
1401
UpdateCallState(sptr<CallBase> & call,TelCallState nextState)1402 int32_t CallStatusManager::UpdateCallState(sptr<CallBase> &call, TelCallState nextState)
1403 {
1404 TELEPHONY_LOGW("UpdateCallState start");
1405 if (call == nullptr) {
1406 TELEPHONY_LOGE("Call is NULL");
1407 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1408 }
1409 TelCallState priorState = call->GetTelCallState();
1410 VideoStateType videoState = call->GetVideoStateType();
1411 TELEPHONY_LOGI(
1412 "callIndex:%{public}d, callId:%{public}d, priorState:%{public}d, nextState:%{public}d, videoState:%{public}d",
1413 call->GetCallIndex(), call->GetCallID(), priorState, nextState, videoState);
1414 if (call->GetCallType() == CallType::TYPE_SATELLITE) {
1415 DelayedSingleton<SatelliteCallControl>::GetInstance()->
1416 HandleSatelliteCallStateUpdate(call, priorState, nextState);
1417 }
1418 if (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE) {
1419 DelayedSingleton<CallManagerHisysevent>::GetInstance()->JudgingAnswerTimeOut(
1420 call->GetSlotId(), call->GetCallID(), static_cast<int32_t>(call->GetVideoStateType()));
1421 }
1422 int32_t ret = call->SetTelCallState(nextState);
1423 UpdateOneCallObjectByCallId(call->GetCallID(), nextState);
1424 if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
1425 TELEPHONY_LOGE("SetTelCallState failed");
1426 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1427 }
1428 if (!DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallStateUpdated(call, priorState, nextState)) {
1429 TELEPHONY_LOGE(
1430 "NotifyCallStateUpdated failed! priorState:%{public}d,nextState:%{public}d", priorState, nextState);
1431 if (nextState == TelCallState::CALL_STATUS_INCOMING) {
1432 CallManagerHisysevent::WriteIncomingCallFaultEvent(call->GetSlotId(),
1433 static_cast<int32_t>(call->GetCallType()), static_cast<int32_t>(call->GetVideoStateType()), ret,
1434 "NotifyCallStateUpdated failed");
1435 }
1436 return CALL_ERR_PHONE_CALLSTATE_NOTIFY_FAILED;
1437 }
1438 SetVideoCallState(call, nextState);
1439 return TELEPHONY_SUCCESS;
1440 }
1441
SetVideoCallState(sptr<CallBase> & call,TelCallState nextState)1442 void CallStatusManager::SetVideoCallState(sptr<CallBase> &call, TelCallState nextState)
1443 {
1444 if (call == nullptr) {
1445 TELEPHONY_LOGE("Call is NULL");
1446 return;
1447 }
1448 int slotId = call->GetSlotId();
1449 bool isSlotIdValid = false;
1450 if (slotId >= SLOT_NUM || slotId < 0) {
1451 return;
1452 }
1453 VideoStateType videoState = call->GetVideoStateType();
1454 TELEPHONY_LOGI("nextVideoState:%{public}d, priorVideoState:%{public}d", videoState, priorVideoState_[slotId]);
1455 if (priorVideoState_[slotId] != videoState) {
1456 DelayedSingleton<AudioControlManager>::GetInstance()->VideoStateUpdated(
1457 call, priorVideoState_[slotId], videoState);
1458 priorVideoState_[slotId] = videoState;
1459 }
1460 if (nextState == TelCallState::CALL_STATUS_DISCONNECTED) {
1461 priorVideoState_[slotId] = VideoStateType::TYPE_VOICE;
1462 }
1463 }
1464
RefreshCallIfNecessary(const sptr<CallBase> & call,const CallDetailInfo & info)1465 sptr<CallBase> CallStatusManager::RefreshCallIfNecessary(const sptr<CallBase> &call, const CallDetailInfo &info)
1466 {
1467 TELEPHONY_LOGI("RefreshCallIfNecessary");
1468 if (call->GetCallType() == CallType::TYPE_IMS && call->GetVideoStateType() != info.callMode) {
1469 call->SetVideoStateType(info.callMode);
1470 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
1471 imsCall->InitVideoCall();
1472 }
1473 if (call->GetCallType() == CallType::TYPE_IMS) {
1474 call->SetCrsType(info.crsType);
1475 }
1476 if (call->GetCallType() == info.callType) {
1477 TELEPHONY_LOGI("RefreshCallIfNecessary not need Refresh");
1478 return call;
1479 }
1480 TelCallState priorState = call->GetTelCallState();
1481 CallAttributeInfo attrInfo;
1482 (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1483 call->GetCallAttributeBaseInfo(attrInfo);
1484 sptr<CallBase> newCall = CreateNewCall(info, attrInfo.callDirection);
1485 if (newCall == nullptr) {
1486 TELEPHONY_LOGE("RefreshCallIfNecessary createCallFail");
1487 return call;
1488 }
1489 AddOneCallObject(newCall);
1490 newCall->SetCallRunningState(call->GetCallRunningState());
1491 newCall->SetTelConferenceState(call->GetTelConferenceState());
1492 newCall->SetStartTime(attrInfo.startTime);
1493 newCall->SetPolicyFlag(PolicyFlag(call->GetPolicyFlag()));
1494 newCall->SetSpeakerphoneOn(call->IsSpeakerphoneOn());
1495 newCall->SetCallEndedType(call->GetCallEndedType());
1496 newCall->SetCallBeginTime(attrInfo.callBeginTime);
1497 newCall->SetCallCreateTime(attrInfo.callCreateTime);
1498 newCall->SetCallEndTime(attrInfo.callEndTime);
1499 newCall->SetRingBeginTime(attrInfo.ringBeginTime);
1500 newCall->SetRingEndTime(attrInfo.ringEndTime);
1501 newCall->SetAnswerType(attrInfo.answerType);
1502 newCall->SetMicPhoneState(call->IsMuted());
1503 DeleteOneCallObject(call->GetCallID());
1504 newCall->SetCallId(call->GetCallID());
1505 newCall->SetTelCallState(priorState);
1506 if (call->GetNumberLocation() != "default") {
1507 newCall->SetNumberLocation(call->GetNumberLocation());
1508 }
1509 NumberMarkInfo numberMarkInfo = call->GetNumberMarkInfo();
1510 if (numberMarkInfo.markType > MarkType::MARK_TYPE_NONE) {
1511 newCall->SetNumberMarkInfo(numberMarkInfo);
1512 }
1513 return newCall;
1514 }
1515
SetOriginalCallTypeForActiveState(sptr<CallBase> & call)1516 void CallStatusManager::SetOriginalCallTypeForActiveState(sptr<CallBase> &call)
1517 {
1518 if (call == nullptr) {
1519 TELEPHONY_LOGE("Call is NULL");
1520 return;
1521 }
1522 TelCallState priorState = call->GetTelCallState();
1523 VideoStateType videoState = call->GetVideoStateType();
1524 int32_t videoStateHistory = call->GetOriginalCallType();
1525 if (priorState == TelCallState::CALL_STATUS_ALERTING || priorState == TelCallState::CALL_STATUS_INCOMING ||
1526 priorState == TelCallState::CALL_STATUS_WAITING) {
1527 // outgoing/incoming video call, but accepted/answered with voice call
1528 if (videoStateHistory != static_cast<int32_t>(videoState)) {
1529 TELEPHONY_LOGD("set videoState:%{public}d as original call type", static_cast<int32_t>(videoState));
1530 call->SetOriginalCallType(static_cast<int32_t>(videoState));
1531 }
1532 } else if (priorState == TelCallState::CALL_STATUS_ACTIVE || priorState == TelCallState::CALL_STATUS_HOLDING) {
1533 int32_t videoStateCurrent =
1534 static_cast<int32_t>(static_cast<uint32_t>(videoStateHistory) | static_cast<uint32_t>(videoState));
1535 TELEPHONY_LOGD("maybe upgrade/downgrade operation, keep video record always, videoStateCurrent:%{public}d",
1536 videoStateCurrent);
1537 call->SetOriginalCallType(videoStateCurrent);
1538 }
1539 }
1540
SetOriginalCallTypeForDisconnectState(sptr<CallBase> & call)1541 void CallStatusManager::SetOriginalCallTypeForDisconnectState(sptr<CallBase> &call)
1542 {
1543 if (call == nullptr) {
1544 TELEPHONY_LOGE("Call is NULL");
1545 return;
1546 }
1547 TelCallState priorState = call->GetTelCallState();
1548 CallAttributeInfo attrInfo;
1549 (void)memset_s(&attrInfo, sizeof(CallAttributeInfo), 0, sizeof(CallAttributeInfo));
1550 call->GetCallAttributeBaseInfo(attrInfo);
1551 if (priorState == TelCallState::CALL_STATUS_DIALING || priorState == TelCallState::CALL_STATUS_ALERTING ||
1552 ((priorState == TelCallState::CALL_STATUS_INCOMING || priorState == TelCallState::CALL_STATUS_WAITING) &&
1553 attrInfo.answerType != CallAnswerType::CALL_ANSWER_REJECT)) {
1554 // outgoing/incoming video call, but canceled or missed
1555 TELEPHONY_LOGD("canceled or missed call, set voice type as original call type");
1556 call->SetOriginalCallType(static_cast<int32_t>(VideoStateType::TYPE_VOICE));
1557 }
1558 }
1559
ToSpeakerPhone(sptr<CallBase> & call)1560 int32_t CallStatusManager::ToSpeakerPhone(sptr<CallBase> &call)
1561 {
1562 int32_t ret = TELEPHONY_ERR_FAIL;
1563 if (call == nullptr) {
1564 TELEPHONY_LOGE("Call is NULL");
1565 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1566 }
1567 if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_DIALING) {
1568 TELEPHONY_LOGI("Call is CALL_STATUS_DIALING");
1569 return ret;
1570 }
1571 if (call->IsSpeakerphoneOn()) {
1572 AudioDevice device = {
1573 .deviceType = AudioDeviceType::DEVICE_SPEAKER,
1574 .address = { 0 },
1575 };
1576 DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(device);
1577 ret = call->SetSpeakerphoneOn(false);
1578 }
1579 return ret;
1580 }
1581
TurnOffMute(sptr<CallBase> & call)1582 int32_t CallStatusManager::TurnOffMute(sptr<CallBase> &call)
1583 {
1584 bool enabled = true;
1585 if (HasEmergencyCall(enabled) != TELEPHONY_SUCCESS) {
1586 TELEPHONY_LOGI("CallStatusManager::TurnOffMute HasEmergencyCall failed.");
1587 }
1588 if (call->GetEmergencyState() || enabled) {
1589 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(false);
1590 } else {
1591 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1592 }
1593 return TELEPHONY_SUCCESS;
1594 }
1595
CreateNewCall(const CallDetailInfo & info,CallDirection dir)1596 sptr<CallBase> CallStatusManager::CreateNewCall(const CallDetailInfo &info, CallDirection dir)
1597 {
1598 TELEPHONY_LOGI("CreateNewCall");
1599 DialParaInfo paraInfo;
1600 AppExecFwk::PacMap extras;
1601 extras.Clear();
1602 PackParaInfo(paraInfo, info, dir, extras);
1603
1604 sptr<CallBase> callPtr = CreateNewCallByCallType(paraInfo, info, dir, extras);
1605 if (callPtr == nullptr) {
1606 TELEPHONY_LOGE("CreateNewCall failed!");
1607 return nullptr;
1608 }
1609 DialScene dialScene = (DialScene)extras.GetIntValue("dialScene");
1610 if (dialScene == DialScene::CALL_EMERGENCY) {
1611 callPtr->SetIsEccContact(true);
1612 }
1613 callPtr->SetOriginalCallType(info.originalCallType);
1614 TELEPHONY_LOGD("originalCallType:%{public}d", info.originalCallType);
1615 if (info.callType == CallType::TYPE_VOIP) {
1616 return callPtr;
1617 }
1618 if (info.state == TelCallState::CALL_STATUS_INCOMING || info.state == TelCallState::CALL_STATUS_WAITING ||
1619 (info.state == TelCallState::CALL_STATUS_DIALING && (info.index == 0 || IsDcCallConneceted()))) {
1620 TELEPHONY_LOGI("NumberLocationUpdate start");
1621 wptr<CallBase> callBaseWeakPtr = callPtr;
1622 ffrt::submit([callBaseWeakPtr, info]() {
1623 sptr<CallBase> callBasePtr = callBaseWeakPtr.promote();
1624 if (callBasePtr == nullptr) {
1625 TELEPHONY_LOGE("callBasePtr is nullptr");
1626 return;
1627 }
1628 DelayedSingleton<CallNumberUtils>::GetInstance()->NumberLocationUpdate(callBasePtr);
1629 DelayedSingleton<DistributedCommunicationManager>::GetInstance()->ProcessCallInfo(callBasePtr,
1630 DistributedDataType::LOCATION);
1631 if (info.state == TelCallState::CALL_STATUS_DIALING) {
1632 DelayedSingleton<CallNumberUtils>::GetInstance()->YellowPageAndMarkUpdate(callBasePtr);
1633 }
1634 });
1635 }
1636 time_t createTime = time(nullptr);
1637 if (createTime < 0) {
1638 createTime = 0;
1639 }
1640 callPtr->SetCallCreateTime(createTime);
1641 return callPtr;
1642 }
1643
CreateNewCallByCallType(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1644 sptr<CallBase> CallStatusManager::CreateNewCallByCallType(
1645 DialParaInfo ¶Info, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1646 {
1647 sptr<CallBase> callPtr = nullptr;
1648 switch (info.callType) {
1649 case CallType::TYPE_CS: {
1650 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1651 callPtr = (std::make_unique<CSCall>(paraInfo, extras)).release();
1652 } else {
1653 callPtr = (std::make_unique<CSCall>(paraInfo)).release();
1654 }
1655 break;
1656 }
1657 case CallType::TYPE_IMS: {
1658 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1659 callPtr = (std::make_unique<IMSCall>(paraInfo, extras)).release();
1660 } else {
1661 callPtr = (std::make_unique<IMSCall>(paraInfo)).release();
1662 }
1663 if (callPtr->GetCallType() == CallType::TYPE_IMS) {
1664 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(callPtr.GetRefPtr());
1665 imsCall->InitVideoCall();
1666 }
1667 break;
1668 }
1669 case CallType::TYPE_OTT: {
1670 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1671 callPtr = (std::make_unique<OTTCall>(paraInfo, extras)).release();
1672 } else {
1673 callPtr = (std::make_unique<OTTCall>(paraInfo)).release();
1674 }
1675 break;
1676 }
1677 case CallType::TYPE_VOIP:
1678 case CallType::TYPE_SATELLITE:
1679 case CallType::TYPE_BLUETOOTH: {
1680 callPtr = CreateNewCallByCallTypeEx(paraInfo, info, dir, extras);
1681 break;
1682 }
1683 default:
1684 return nullptr;
1685 }
1686 return callPtr;
1687 }
1688
CreateNewCallByCallTypeEx(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1689 sptr<CallBase> CallStatusManager::CreateNewCallByCallTypeEx(
1690 DialParaInfo ¶Info, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1691 {
1692 sptr<CallBase> callPtr = nullptr;
1693 switch (info.callType) {
1694 case CallType::TYPE_VOIP: {
1695 callPtr = (std::make_unique<VoIPCall>(paraInfo)).release();
1696 break;
1697 }
1698 case CallType::TYPE_SATELLITE: {
1699 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1700 callPtr = (std::make_unique<SatelliteCall>(paraInfo, extras)).release();
1701 } else {
1702 callPtr = (std::make_unique<SatelliteCall>(paraInfo)).release();
1703 }
1704 break;
1705 }
1706 case CallType::TYPE_BLUETOOTH: {
1707 std::string macAddress = DelayedSingleton<BluetoothCallConnection>::GetInstance()->GetMacAddress();
1708 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1709 callPtr = (std::make_unique<BluetoothCall>(paraInfo, extras, macAddress)).release();
1710 } else {
1711 callPtr = (std::make_unique<BluetoothCall>(paraInfo, macAddress)).release();
1712 }
1713 break;
1714 }
1715 default:
1716 return nullptr;
1717 }
1718 return callPtr;
1719 }
1720
ShouldRejectIncomingCall()1721 bool CallStatusManager::ShouldRejectIncomingCall()
1722 {
1723 bool hasEcc = false;
1724 if (HasEmergencyCall(hasEcc) == TELEPHONY_SUCCESS && hasEcc) {
1725 TELEPHONY_LOGI("HasEmergencyCall reject incoming call.");
1726 return true;
1727 }
1728
1729 auto datashareHelper = SettingsDataShareHelper::GetInstance();
1730 std::string device_provisioned {"0"};
1731 OHOS::Uri uri(
1732 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=device_provisioned");
1733 int resp = datashareHelper->Query(uri, "device_provisioned", device_provisioned);
1734 if ((resp == TELEPHONY_SUCCESS || resp == TELEPHONY_ERROR) &&
1735 (device_provisioned == "0" || device_provisioned.empty())) {
1736 TELEPHONY_LOGW("ShouldRejectIncomingCall: device_provisioned = 0");
1737 return true;
1738 }
1739
1740 std::string user_setup_complete {"1"};
1741 std::vector<int> activedOsAccountIds;
1742 OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
1743 if (activedOsAccountIds.empty()) {
1744 TELEPHONY_LOGW("ShouldRejectIncomingCall: activedOsAccountIds is empty");
1745 return false;
1746 }
1747 int userId = activedOsAccountIds[0];
1748 OHOS::Uri uri_setup(
1749 "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_"
1750 + std::to_string(userId) + "?Proxy=true&key=user_setup_complete");
1751 int resp_userSetup = datashareHelper->Query(uri_setup, "user_setup_complete", user_setup_complete);
1752 if (resp_userSetup == TELEPHONY_SUCCESS && (user_setup_complete == "0" || user_setup_complete.empty())) {
1753 TELEPHONY_LOGW("ShouldRejectIncomingCall: user_setup_complete = 0");
1754 return true;
1755 }
1756 return false;
1757 }
1758
ShouldBlockIncomingCall(const sptr<CallBase> & call,const CallDetailInfo & info)1759 bool CallStatusManager::ShouldBlockIncomingCall(const sptr<CallBase> &call, const CallDetailInfo &info)
1760 {
1761 bool isEcc = false;
1762 DelayedSingleton<CellularCallConnection>::GetInstance()->IsEmergencyPhoneNumber(
1763 info.phoneNum, info.accountId, isEcc);
1764 if (isEcc) {
1765 TELEPHONY_LOGW("incoming phoneNumber is ecc.");
1766 return false;
1767 }
1768 std::shared_ptr<SpamCallAdapter> spamCallAdapterPtr_ = std::make_shared<SpamCallAdapter>();
1769 if (spamCallAdapterPtr_ == nullptr) {
1770 TELEPHONY_LOGE("create SpamCallAdapter object failed!");
1771 return false;
1772 }
1773 bool isDetectedSpamCall = spamCallAdapterPtr_->DetectSpamCall(std::string(info.phoneNum), info.accountId);
1774 if (!isDetectedSpamCall) {
1775 TELEPHONY_LOGE("DetectSpamCall failed!");
1776 return false;
1777 }
1778 detectStartTime = std::chrono::system_clock::now();
1779 if (spamCallAdapterPtr_->WaitForDetectResult()) {
1780 TELEPHONY_LOGW("DetectSpamCall no time out");
1781 NumberMarkInfo numberMarkInfo;
1782 bool isBlock = false;
1783 int32_t blockReason;
1784 std::string detectDetails = "";
1785 spamCallAdapterPtr_->GetParseResult(isBlock, numberMarkInfo, blockReason, detectDetails);
1786 call->SetNumberMarkInfo(numberMarkInfo);
1787 call->SetBlockReason(blockReason);
1788 call->SetDetectDetails(detectDetails);
1789 if (isBlock) {
1790 return true;
1791 }
1792 }
1793 return false;
1794 }
1795
IsRingOnceCall(const sptr<CallBase> & call,const CallDetailInfo & info)1796 bool CallStatusManager::IsRingOnceCall(const sptr<CallBase> &call, const CallDetailInfo &info)
1797 {
1798 NumberMarkInfo numberMarkInfo = call->GetNumberMarkInfo();
1799 ContactInfo contactInfo = call->GetCallerInfo();
1800 if (numberMarkInfo.markType == MarkType::MARK_TYPE_YELLOW_PAGE || contactInfo.name != "") {
1801 TELEPHONY_LOGW("yellowpage or contact, no need check ring once call");
1802 return false;
1803 }
1804 auto datashareHelper = SettingsDataShareHelper::GetInstance();
1805 std::string is_check_ring_once {"0"};
1806 std::string key = "spamshield_sim" + std::to_string(info.accountId + 1) + "_phone_switch_ring_once";
1807 OHOS::Uri uri(
1808 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true&key=" + key);
1809 int32_t ret = datashareHelper->Query(uri, key, is_check_ring_once);
1810 TELEPHONY_LOGW("is_check_ring_once = %{public}s", is_check_ring_once.c_str());
1811 if (ret != TELEPHONY_SUCCESS || is_check_ring_once == "0") {
1812 return false;
1813 }
1814 auto waitTime = WAIT_TIME_THREE_SECOND;
1815 if (detectStartTime != std::chrono::system_clock::from_time_t(0)) {
1816 auto detectEndTime = std::chrono::system_clock::now();
1817 auto diff = detectEndTime - detectStartTime;
1818 std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(diff);
1819 if (diff >= WAIT_TIME_THREE_SECOND) {
1820 TELEPHONY_LOGW("cost time over 3s, non need check ring once call");
1821 }
1822 waitTime = WAIT_TIME_THREE_SECOND - ms;
1823 }
1824 if (timeWaitHelper_ == nullptr) {
1825 timeWaitHelper_ = std::make_unique<TimeWaitHelper>(waitTime);
1826 }
1827 if (!timeWaitHelper_->WaitForResult()) {
1828 TELEPHONY_LOGW("is not ring once");
1829 timeWaitHelper_ = nullptr;
1830 return false;
1831 }
1832 timeWaitHelper_ = nullptr;
1833 return true;
1834 }
1835
HandleRingOnceCall(sptr<CallBase> & call)1836 int32_t CallStatusManager::HandleRingOnceCall(sptr<CallBase> &call)
1837 {
1838 if (call == nullptr) {
1839 TELEPHONY_LOGE("call is nullptr!");
1840 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1841 }
1842 int32_t ret = call->SetTelCallState(TelCallState::CALL_STATUS_INCOMING);
1843 if (ret != TELEPHONY_SUCCESS && ret != CALL_ERR_NOT_NEW_STATE) {
1844 TELEPHONY_LOGE("Set CallState failed!");
1845 return ret;
1846 }
1847 return DelayedSingleton<CallControlManager>::GetInstance()->AddCallLogAndNotification(call);
1848 }
1849
PackParaInfo(DialParaInfo & paraInfo,const CallDetailInfo & info,CallDirection dir,AppExecFwk::PacMap & extras)1850 void CallStatusManager::PackParaInfo(
1851 DialParaInfo ¶Info, const CallDetailInfo &info, CallDirection dir, AppExecFwk::PacMap &extras)
1852 {
1853 paraInfo.isEcc = false;
1854 paraInfo.dialType = DialType::DIAL_CARRIER_TYPE;
1855 if (dir == CallDirection::CALL_DIRECTION_OUT) {
1856 DelayedSingleton<CallControlManager>::GetInstance()->GetDialParaInfo(paraInfo, extras);
1857 }
1858 TELEPHONY_LOGI("is ecc: %{public}d", paraInfo.isEcc);
1859 if (info.callType == CallType::TYPE_VOIP) {
1860 paraInfo.voipCallInfo.voipCallId = info.voipCallInfo.voipCallId;
1861 paraInfo.voipCallInfo.userName = info.voipCallInfo.userName;
1862 (paraInfo.voipCallInfo.userProfile).assign(
1863 (info.voipCallInfo.userProfile).begin(), (info.voipCallInfo.userProfile).end());
1864 paraInfo.voipCallInfo.abilityName = info.voipCallInfo.abilityName;
1865 paraInfo.voipCallInfo.extensionId = info.voipCallInfo.extensionId;
1866 paraInfo.voipCallInfo.voipBundleName = info.voipCallInfo.voipBundleName;
1867 paraInfo.voipCallInfo.showBannerForIncomingCall = info.voipCallInfo.showBannerForIncomingCall;
1868 paraInfo.voipCallInfo.isConferenceCall = info.voipCallInfo.isConferenceCall;
1869 paraInfo.voipCallInfo.isVoiceAnswerSupported = info.voipCallInfo.isVoiceAnswerSupported;
1870 paraInfo.voipCallInfo.hasMicPermission = info.voipCallInfo.hasMicPermission;
1871 paraInfo.voipCallInfo.isCapsuleSticky = info.voipCallInfo.isCapsuleSticky;
1872 paraInfo.voipCallInfo.uid = info.voipCallInfo.uid;
1873 }
1874 paraInfo.number = info.phoneNum;
1875 paraInfo.callId = GetNewCallId();
1876 paraInfo.index = info.index;
1877 paraInfo.videoState = info.callMode;
1878 paraInfo.accountId = info.accountId;
1879 paraInfo.callType = info.callType;
1880 paraInfo.callState = info.state;
1881 paraInfo.bundleName = info.bundleName;
1882 paraInfo.crsType = info.crsType;
1883 paraInfo.originalCallType = info.originalCallType;
1884 paraInfo.extraParams =
1885 AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(extras.GetStringValue("extraParams"));
1886 bool value = false;
1887 int32_t namePresentation;
1888 OperatorConfig config;
1889 CoreServiceClient::GetInstance().GetOperatorConfigs(info.accountId, config);
1890 if (config.boolValue.find("support_cnap_bool") != config.boolValue.end()) {
1891 value = config.boolValue["support_cnap_bool"];
1892 }
1893 namePresentation = value ? info.namePresentation : PRESENTATION_RESTRICTED;
1894 paraInfo.extraParams.SetParam("namePresentation", AAFwk::Integer::Box(namePresentation));
1895 paraInfo.extraParams.SetParam("name", AAFwk::String::Box(namePresentation == 0 ? info.name : ""));
1896 paraInfo.phoneOrWatch = info.phoneOrWatch;
1897 }
1898
IsFocusModeOpen()1899 bool CallStatusManager::IsFocusModeOpen()
1900 {
1901 auto datashareHelper = SettingsDataShareHelper::GetInstance();
1902 std::string focusModeEnable {"0"};
1903 std::vector<int> activedOsAccountIds;
1904 OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
1905 if (activedOsAccountIds.empty()) {
1906 TELEPHONY_LOGW("ShouldRejectIncomingCall: activedOsAccountIds is empty");
1907 return false;
1908 }
1909 int userId = activedOsAccountIds[0];
1910 OHOS::Uri uri(
1911 "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_"
1912 + std::to_string(userId) + "?Proxy=true&key=focus_mode_enable");
1913 int resp = datashareHelper->Query(uri, "focus_mode_enable", focusModeEnable);
1914 TELEPHONY_LOGI("IsFocusModeOpen: userId = %{public}d, focus_mode_enable = %{public}s",
1915 userId, focusModeEnable.c_str());
1916 if (resp == TELEPHONY_SUCCESS && focusModeEnable == "1") {
1917 return true;
1918 }
1919 return false;
1920 }
1921
IsRejectCall(sptr<CallBase> & call,const CallDetailInfo & info,bool & block)1922 bool CallStatusManager::IsRejectCall(sptr<CallBase> &call, const CallDetailInfo &info, bool &block)
1923 {
1924 int32_t state;
1925 DelayedSingleton<CallControlManager>::GetInstance()->GetVoIPCallState(state);
1926 if (ShouldRejectIncomingCall() || state == (int32_t)CallStateToApp::CALL_STATE_RINGING) {
1927 CallManagerHisysevent::HiWriteBehaviorEventPhoneUE(
1928 CALL_INCOMING_REJECT_BY_SYSTEM, PNAMEID_KEY, KEY_CALL_MANAGER, PVERSIONID_KEY, "",
1929 ACTION_TYPE, REJECT_BY_OOBE);
1930 block = false;
1931 return true;
1932 }
1933 if (info.callType != CallType::TYPE_VOIP && info.callType != CallType::TYPE_BLUETOOTH &&
1934 ShouldBlockIncomingCall(call, info)) {
1935 CallManagerHisysevent::HiWriteBehaviorEventPhoneUE(
1936 CALL_INCOMING_REJECT_BY_SYSTEM, PNAMEID_KEY, KEY_CALL_MANAGER, PVERSIONID_KEY, "",
1937 ACTION_TYPE, REJECT_BY_NUM_BLOCK);
1938 block = true;
1939 return true;
1940 }
1941 if (IsFocusModeOpen()) {
1942 int ret = Notification::NotificationHelper::IsNeedSilentInDoNotDisturbMode(info.phoneNum, 0);
1943 TELEPHONY_LOGW("IsRejectCall IsNeedSilentInDoNotDisturbMode ret:%{public}d", ret);
1944 if (ret == 0) {
1945 CallManagerHisysevent::HiWriteBehaviorEventPhoneUE(
1946 CALL_INCOMING_REJECT_BY_SYSTEM, PNAMEID_KEY, KEY_CALL_MANAGER, PVERSIONID_KEY, "",
1947 ACTION_TYPE, REJECT_IN_FOCUSMODE);
1948 AAFwk::WantParams params = call->GetExtraParams();
1949 params.SetParam("IsNeedSilentInDoNotDisturbMode", AAFwk::Integer::Box(1));
1950 call->SetExtraParams(params);
1951 }
1952 }
1953 return false;
1954 }
1955
CreateAndSaveNewCall(const CallDetailInfo & info,CallDirection direction)1956 void CallStatusManager::CreateAndSaveNewCall(const CallDetailInfo &info, CallDirection direction)
1957 {
1958 if (GetOneCallObjectByIndex(INIT_INDEX) != nullptr) {
1959 TELEPHONY_LOGI("get init_index call success");
1960 UpdateDialingCallInfo(info);
1961 return;
1962 }
1963 auto call = CreateNewCall(info, direction);
1964 if (call != nullptr) {
1965 ffrt::submit([=]() {
1966 DelayedSingleton<CallNumberUtils>::GetInstance()->YellowPageAndMarkUpdate(call);
1967 });
1968 AddOneCallObject(call);
1969 DelayedSingleton<CallControlManager>::GetInstance()->NotifyNewCallCreated(call);
1970 }
1971 }
1972
UpdateCallStateAndHandleDsdsMode(const CallDetailInfo & info,sptr<CallBase> & call)1973 int32_t CallStatusManager::UpdateCallStateAndHandleDsdsMode(const CallDetailInfo &info, sptr<CallBase> &call)
1974 {
1975 if (call == nullptr) {
1976 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1977 }
1978 TelCallState priorState = call->GetTelCallState();
1979 int32_t ret = UpdateCallState(call, TelCallState::CALL_STATUS_HOLDING);
1980 if (ret != TELEPHONY_SUCCESS) {
1981 TELEPHONY_LOGE("UpdateCallState failed, errCode:%{public}d", ret);
1982 }
1983 int32_t callId = call->GetCallID();
1984 int32_t dsdsMode = DSDS_MODE_V2;
1985 DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDsdsMode(dsdsMode);
1986 TELEPHONY_LOGE("HoldingHandle dsdsMode:%{public}d", dsdsMode);
1987 bool canSwitchCallState = call->GetCanSwitchCallState();
1988 if (dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_DSDA) ||
1989 dsdsMode == static_cast<int32_t>(DsdsMode::DSDS_MODE_V5_TDM)) {
1990 int32_t activeCallNum = GetCallNum(TelCallState::CALL_STATUS_ACTIVE);
1991 if (needWaitHold_ && activeCallNum == 0) {
1992 needWaitHold_ = false;
1993 HandleDialWhenHolding(callId, call);
1994 } else {
1995 TelConferenceState confState = call->GetTelConferenceState();
1996 int32_t conferenceId = ERR_ID;
1997 call->GetMainCallId(conferenceId);
1998 if (confState != TelConferenceState::TEL_CONFERENCE_IDLE && conferenceId == callId) {
1999 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
2000 } else if (confState == TelConferenceState::TEL_CONFERENCE_IDLE) {
2001 AutoHandleForDsda(canSwitchCallState, priorState, activeCallNum, call->GetSlotId(), false);
2002 }
2003 }
2004 }
2005 return ret;
2006 }
2007
HandleDialWhenHolding(int32_t callId,sptr<CallBase> & call)2008 void CallStatusManager::HandleDialWhenHolding(int32_t callId, sptr<CallBase> &call)
2009 {
2010 auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
2011 if (callRequestEventHandler->IsPendingHangup()) {
2012 sptr<CallBase> holdCall = CallObjectManager::GetOneCallObject(callId);
2013 if (holdCall != nullptr) {
2014 holdCall->UnHoldCall();
2015 }
2016 int32_t pendingHangupCallId = callRequestEventHandler->GetPendingHangupCallId();
2017 sptr<CallBase> pendingHangupCall = CallObjectManager::GetOneCallObject(pendingHangupCallId);
2018 if (pendingHangupCall != nullptr) {
2019 UpdateCallState(pendingHangupCall, TelCallState::CALL_STATUS_DISCONNECTED);
2020 DeleteOneCallObject(pendingHangupCallId);
2021 }
2022 callRequestEventHandler->SetPendingHangup(false, -1);
2023 } else {
2024 int32_t result = DelayedSingleton<CellularCallConnection>::GetInstance()->Dial(GetDialCallInfo());
2025 sptr<CallBase> dialCall = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
2026 if (result != TELEPHONY_SUCCESS && dialCall != nullptr) {
2027 DealFailDial(call);
2028 TELEPHONY_LOGI("Dial call fail");
2029 }
2030 }
2031 }
2032
IsDcCallConneceted()2033 bool CallStatusManager::IsDcCallConneceted()
2034 {
2035 std::string dcStatus = "";
2036 auto settingHelper = SettingsDataShareHelper::GetInstance();
2037 if (settingHelper != nullptr) {
2038 OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI);
2039 settingHelper->Query(settingUri, "distributed_modem_state", dcStatus);
2040 }
2041 if (dcStatus == "1_sink" || dcStatus == "1_source") {
2042 return true;
2043 }
2044 return false;
2045 }
2046
IsDistributeCallSourceStatus()2047 bool CallStatusManager::IsDistributeCallSourceStatus()
2048 {
2049 std::string dcStatus = "";
2050 auto settingHelper = SettingsDataShareHelper::GetInstance();
2051 if (settingHelper != nullptr) {
2052 OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI);
2053 settingHelper->Query(settingUri, "distributed_modem_state", dcStatus);
2054 }
2055 if (dcStatus == "1_source") {
2056 return true;
2057 }
2058 return false;
2059 }
2060
SetBtCallDialByPhone(const sptr<CallBase> & call,bool isBtCallDialByPhone)2061 void CallStatusManager::SetBtCallDialByPhone(const sptr<CallBase> &call, bool isBtCallDialByPhone)
2062 {
2063 if (call == nullptr) {
2064 return;
2065 }
2066 CallAttributeInfo info;
2067 call->GetCallAttributeInfo(info);
2068 AAFwk::WantParams object = AAFwk::WantParamWrapper::ParseWantParamsWithBrackets(info.extraParamsString);
2069 object.SetParam("isBtCallDialByPhone", AAFwk::Boolean::Box(isBtCallDialByPhone));
2070 call->SetExtraParams(object);
2071 call->GetCallAttributeBaseInfo(info);
2072 }
2073
BtCallDialingHandle(sptr<CallBase> & call,const CallDetailInfo & info)2074 void CallStatusManager::BtCallDialingHandle(sptr<CallBase> &call, const CallDetailInfo &info)
2075 {
2076 if (call != nullptr) {
2077 call->SetPhoneOrWatchDial(static_cast<int32_t>(PhoneOrWatchDial::WATCH_DIAL));
2078 SetBtCallDialByPhone(call, false);
2079 } else {
2080 call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
2081 if (call != nullptr) {
2082 call->SetPhoneOrWatchDial(static_cast<int32_t>(PhoneOrWatchDial::PHONE_DIAL));
2083 SetBtCallDialByPhone(call, true);
2084 }
2085 }
2086 }
2087
SetDistributedDeviceDialing(sptr<CallBase> call,bool isDistributedDeviceDialing)2088 void CallStatusManager::SetDistributedDeviceDialing(sptr<CallBase> call, bool isDistributedDeviceDialing)
2089 {
2090 if (call == nullptr) {
2091 return;
2092 }
2093 if (isDistributedDeviceDialing) {
2094 AAFwk::WantParams extraParams;
2095 extraParams.SetParam("isDistributedDeviceDialing", AAFwk::String::Box("true"));
2096 call->SetExtraParams(extraParams);
2097 }
2098 }
2099
BtCallDialingHandleFirst(sptr<CallBase> call,const CallDetailInfo & info)2100 void CallStatusManager::BtCallDialingHandleFirst(sptr<CallBase> call, const CallDetailInfo &info)
2101 {
2102 if (call == nullptr) {
2103 return;
2104 }
2105 call->SetPhoneOrWatchDial(static_cast<int32_t>(PhoneOrWatchDial::WATCH_DIAL));
2106 SetBtCallDialByPhone(call, false);
2107 if (info.state == TelCallState::CALL_STATUS_ALERTING) {
2108 UpdateDialingCallInfo(info);
2109 if (call->GetTelCallState() == TelCallState::CALL_STATUS_ALERTING) {
2110 call->SetTelCallState(TelCallState::CALL_STATUS_DIALING);
2111 }
2112 }
2113 }
2114
HandleCallReportInfoEx(const CallDetailInfo & info)2115 int32_t CallStatusManager::HandleCallReportInfoEx(const CallDetailInfo &info)
2116 {
2117 int32_t ret = TELEPHONY_ERR_FAIL;
2118 switch (info.state) {
2119 case TelCallState::CALL_STATUS_WAITING:
2120 ret = WaitingHandle(info);
2121 break;
2122 case TelCallState::CALL_STATUS_DISCONNECTED:
2123 ret = DisconnectedHandle(info);
2124 break;
2125 case TelCallState::CALL_STATUS_DISCONNECTING:
2126 ret = DisconnectingHandle(info);
2127 break;
2128 default:
2129 TELEPHONY_LOGE("Invalid call state!");
2130 break;
2131 }
2132 return ret;
2133 }
2134
ClearPendingState(sptr<CallBase> & call)2135 void CallStatusManager::ClearPendingState(sptr<CallBase> &call)
2136 {
2137 auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
2138 int32_t callId = call->GetCallID();
2139 TELEPHONY_LOGI("check clear pending state callId = %{public}d", callId);
2140 if (callRequestEventHandler->HasPendingMo(callId)) {
2141 callRequestEventHandler->SetPendingMo(false, -1);
2142 }
2143 if (callRequestEventHandler->HasPendingHangup(callId)) {
2144 if (call->GetCallRunningState() != CallRunningState::CALL_RUNNING_STATE_ENDED) {
2145 call->HangUpCall();
2146 }
2147 callRequestEventHandler->SetPendingHangup(false, -1);
2148 }
2149 }
2150
RefreshCallDisconnectReason(const sptr<CallBase> & call,int32_t reason)2151 void CallStatusManager::RefreshCallDisconnectReason(const sptr<CallBase> &call, int32_t reason)
2152 {
2153 switch (reason) {
2154 case static_cast<int32_t>(RilDisconnectedReason::DISCONNECTED_REASON_ANSWERED_ELSEWHER):
2155 call->SetAnswerType(CallAnswerType::CALL_ANSWERED_ELSEWHER);
2156 TELEPHONY_LOGI("call answered elsewhere");
2157 break;
2158 case static_cast<int32_t>(RilDisconnectedReason::DISCONNECTED_REASON_NORMAL):
2159 {
2160 AAFwk::WantParams params = call->GetExtraParams();
2161 params.SetParam("disconnectedReason",
2162 AAFwk::Integer::Box(static_cast<int32_t>(CallAnswerType::CALL_DISCONNECTED_BY_REMOTE)));
2163 call->SetExtraParams(params);
2164 }
2165 break;
2166 default:
2167 break;
2168 }
2169 }
2170 #ifdef NOT_SUPPORT_MULTICALL
AutoAnswerSecondCall()2171 void CallStatusManager::AutoAnswerSecondCall()
2172 {
2173 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
2174 for (auto call : allCallList) {
2175 if (call->GetTelCallState() != TelCallState::CALL_STATUS_INCOMING &&
2176 call->GetTelCallState() != TelCallState::CALL_STATUS_WAITING) {
2177 continue;
2178 }
2179 if (call->GetAutoAnswerState()) {
2180 TELEPHONY_LOGI("Auto AnswerCall callid=%{public}d", call->GetCallID());
2181 int ret = DelayedSingleton<CallControlManager>::GetInstance()->AnswerCall(call->GetCallID(),
2182 static_cast<int32_t>(call->GetVideoStateType()));
2183 if (ret != TELEPHONY_SUCCESS) {
2184 TELEPHONY_LOGE("Auto AnswerCall failed callid=%{public}d", call->GetCallID());
2185 }
2186 return;
2187 }
2188 }
2189 return;
2190 }
OneCallAnswerAtPhone(int32_t callId)2191 void CallStatusManager::OneCallAnswerAtPhone(int32_t callId)
2192 {
2193 TELEPHONY_LOGI("One Call AnswerCall AtPhone callid=%{public}d", callId);
2194 if (CallObjectManager::IsOneNumberDualTerminal()) {
2195 return;
2196 }
2197 if (!CallObjectManager::IsTwoCallBtCallAndESIM()) {
2198 return;
2199 }
2200 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
2201 for (auto call : allCallList) {
2202 if (call->GetCallID() == callId) {
2203 continue;
2204 }
2205 if (call->GetTelCallState() == TelCallState::CALL_STATUS_DIALING ||
2206 call->GetTelCallState() == TelCallState::CALL_STATUS_ALERTING ||
2207 call->GetTelCallState() == TelCallState::CALL_STATUS_ACTIVE) {
2208 int32_t ret = DelayedSingleton<CallControlManager>::GetInstance()->HangUpCall(call->GetCallID());
2209 if (ret != TELEPHONY_SUCCESS) {
2210 TELEPHONY_LOGE("One Call AnswerCall AtPhone HangUpCall failed callid=%{public}d", call->GetCallID());
2211 }
2212 }
2213 if (call->GetTelCallState() == TelCallState::CALL_STATUS_INCOMING ||
2214 call->GetTelCallState() == TelCallState::CALL_STATUS_WAITING) {
2215 TELEPHONY_LOGI("Need AnswerCall callid=%{public}d", call->GetCallID());
2216 int32_t ret = DelayedSingleton<CallControlManager>::GetInstance()->RejectCall(
2217 call->GetCallID(), false, u"");
2218 if (ret != TELEPHONY_SUCCESS) {
2219 TELEPHONY_LOGE("One Call AnswerCall AtPhone RejectCall failed callid=%{public}d", call->GetCallID());
2220 }
2221 }
2222 }
2223 return;
2224 }
2225 #endif
IsFromTheSameNumberAtTheSameTime(const sptr<CallBase> & newCall)2226 bool CallStatusManager::IsFromTheSameNumberAtTheSameTime(const sptr<CallBase> &newCall)
2227 {
2228 if (newCall == nullptr) {
2229 return false;
2230 }
2231 // get the old call obj with phoneNumber of new call.
2232 std::string phoneNumber = newCall->GetAccountNumber();
2233 sptr<CallBase> oldCall = GetOneCallObject(phoneNumber);
2234 if (oldCall == nullptr) {
2235 return false;
2236 }
2237 // compare old with new in scene of one-number-dual-terminal
2238 if ((abs(newCall->GetCallID() - oldCall->GetCallID()) != 1)) {
2239 return false;
2240 }
2241 CallAttributeInfo oldAttrInfo;
2242 oldCall->GetCallAttributeBaseInfo(oldAttrInfo);
2243 if (oldAttrInfo.callState != TelCallState::CALL_STATUS_INCOMING) {
2244 return false;
2245 }
2246 CallAttributeInfo newAttrInfo;
2247 newCall->GetCallAttributeBaseInfo(newAttrInfo);
2248 constexpr int32_t CALLS_COMING_MAX_INTERVAL_DURATION = 10 * 1000;
2249 if ((newAttrInfo.callCreateTime - oldAttrInfo.callCreateTime) > CALLS_COMING_MAX_INTERVAL_DURATION) {
2250 return false;
2251 }
2252 TELEPHONY_LOGI("the new call is from the same number at the same time.");
2253 return true;
2254 }
2255
ModifyEsimType()2256 void CallStatusManager::ModifyEsimType()
2257 {
2258 auto datashareHelper = SettingsDataShareHelper::GetInstance();
2259 if (datashareHelper == nullptr) {
2260 return;
2261 }
2262 OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI);
2263 std::string esimCardType = "";
2264
2265 constexpr const char* ESIM_TYPE_ONE_NUMBER_DUAL_TERMINAL = "1";
2266 int32_t retCode = datashareHelper->Query(settingUri, "key_esim_card_type", esimCardType);
2267 if ((retCode == TELEPHONY_SUCCESS) && (esimCardType == ESIM_TYPE_ONE_NUMBER_DUAL_TERMINAL ||
2268 esimCardType == "")) {
2269 TELEPHONY_LOGI("do not need to fix esim card type, current type: %{public}s", esimCardType.c_str());
2270 return;
2271 }
2272
2273 retCode = datashareHelper->Update(settingUri, "key_esim_card_type", ESIM_TYPE_ONE_NUMBER_DUAL_TERMINAL);
2274 if (retCode != TELEPHONY_SUCCESS) {
2275 TELEPHONY_LOGE("update esim card type failed, retCode: %{public}d", retCode);
2276 return;
2277 }
2278 std::string manullySetState = "";
2279 retCode = datashareHelper->Query(settingUri, "key_manually_set_net", manullySetState);
2280 if (manullySetState == "") {
2281 manullySetState = "000";
2282 }
2283 constexpr int32_t STATUS_VALUE_LEN = 3;
2284 const char *changeStatus = manullySetState.c_str();
2285 if (strlen(changeStatus) != STATUS_VALUE_LEN) {
2286 return;
2287 }
2288 constexpr char SMARTOFF_NETWORK_MODIFIED = '1';
2289 int32_t index = 0;
2290 if (changeStatus[index++] != SMARTOFF_NETWORK_MODIFIED) {
2291 retCode = datashareHelper->Update(settingUri, "key_smartoff_network_bluetooth_connection", "1");
2292 }
2293 if (changeStatus[index++] != SMARTOFF_NETWORK_MODIFIED) {
2294 retCode = datashareHelper->Update(settingUri, "key_smartoff_network_not_wear", "true");
2295 }
2296 if (changeStatus[index++] != SMARTOFF_NETWORK_MODIFIED) {
2297 retCode = datashareHelper->Update(settingUri, "key_smartoff_network_sleep_mode", "true");
2298 }
2299 }
2300
RefreshOldCall(const CallDetailInfo & info,bool & isExistedOldCall)2301 int32_t CallStatusManager::RefreshOldCall(const CallDetailInfo &info, bool &isExistedOldCall)
2302 {
2303 TELEPHONY_LOGI("RefreshOldCall enter.");
2304 sptr<CallBase> call = GetOneCallObjectByIndexSlotIdAndCallType(info.index, info.accountId, info.callType);
2305 if (call == nullptr) {
2306 isExistedOldCall = false;
2307 return TELEPHONY_SUCCESS;
2308 }
2309 isExistedOldCall = true;
2310 auto oldCallType = call->GetCallType();
2311 auto videoState = call->GetVideoStateType();
2312 if (oldCallType != info.callType || call->GetTelCallState() != info.state || videoState != info.callMode) {
2313 TELEPHONY_LOGI("refresh call.");
2314 call = RefreshCallIfNecessary(call, info);
2315 if (oldCallType != info.callType || videoState != info.callMode) {
2316 return UpdateCallState(call, info.state);
2317 }
2318 }
2319
2320 return TELEPHONY_SUCCESS;
2321 }
2322
IsCallMotionRecognitionEnable(const std::string & key)2323 bool CallStatusManager::IsCallMotionRecognitionEnable(const std::string& key)
2324 {
2325 std::vector<int> activedOsAccountIds;
2326 OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activedOsAccountIds);
2327 if (activedOsAccountIds.empty()) {
2328 TELEPHONY_LOGW("activedOsAccountIds is empty");
2329 return false;
2330 }
2331 int userId = activedOsAccountIds[0];
2332 OHOS::Uri uri(
2333 "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_"
2334 + std::to_string(userId) + "?Proxy=true");
2335 auto datashareHelper = SettingsDataShareHelper::GetInstance();
2336 std::string is_motion_switch_on {"0"};
2337 int resp = datashareHelper->Query(uri, key, is_motion_switch_on);
2338 TELEPHONY_LOGI("key = %{public}s, value = %{public}s", key.c_str(), is_motion_switch_on.c_str());
2339 if (resp == TELEPHONY_SUCCESS && is_motion_switch_on == "1") {
2340 return true;
2341 }
2342 return false;
2343 }
2344
StartInComingCallMotionRecognition()2345 void CallStatusManager::StartInComingCallMotionRecognition()
2346 {
2347 if (GetOneCarrierCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING) != nullptr ||
2348 GetOneCarrierCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE) != nullptr ||
2349 GetOneCarrierCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD) != nullptr) {
2350 TELEPHONY_LOGI("has dialing active or holding call return");
2351 return;
2352 }
2353 bool isPickupReduceVolumeSwitchOn =
2354 IsCallMotionRecognitionEnable(SettingsDataShareHelper::QUERY_MOTION_PICKUP_REDUCE_KEY);
2355 bool isFlipMuteSwitchOn = IsCallMotionRecognitionEnable(SettingsDataShareHelper::QUERY_MOTION_FLIP_MUTE_KEY);
2356 bool isCloseToEarQuickAnswerSwitchOn =
2357 IsCallMotionRecognitionEnable(SettingsDataShareHelper::QUERY_MOTION_CLOSE_TO_EAR_KEY);
2358 if (isPickupReduceVolumeSwitchOn || isFlipMuteSwitchOn || isCloseToEarQuickAnswerSwitchOn) {
2359 if (!Rosen::LoadMotionSensor()) {
2360 TELEPHONY_LOGE("LoadMotionSensor failed");
2361 return;
2362 }
2363 TELEPHONY_LOGI("LoadMotionSensor success");
2364 if (isPickupReduceVolumeSwitchOn) {
2365 MotionRecogntion::SubscribePickupSensor();
2366 }
2367 if (isFlipMuteSwitchOn) {
2368 MotionRecogntion::SubscribeFlipSensor();
2369 }
2370 if (isCloseToEarQuickAnswerSwitchOn) {
2371 MotionRecogntion::SubscribeCloseToEarSensor();
2372 }
2373 }
2374 }
2375
StartOutGoingCallMotionRecognition()2376 void CallStatusManager::StartOutGoingCallMotionRecognition()
2377 {
2378 bool isCloseToEarQuickAnswerSwitchOn =
2379 IsCallMotionRecognitionEnable(SettingsDataShareHelper::QUERY_MOTION_CLOSE_TO_EAR_KEY);
2380 if (isCloseToEarQuickAnswerSwitchOn) {
2381 if (!Rosen::LoadMotionSensor()) {
2382 TELEPHONY_LOGE("LoadMotionSensor failed");
2383 return;
2384 }
2385 TELEPHONY_LOGI("LoadMotionSensor success");
2386 MotionRecogntion::SubscribeCloseToEarSensor();
2387 }
2388 }
2389 } // namespace Telephony
2390 } // namespace OHOS
2391