1 /*
2 * Copyright (C) 2021-2025 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_control_manager.h"
17 #include "cpp/task_ext.h"
18 #include <cstdint>
19 #include <securec.h>
20 #include "csignal"
21 #include <string_ex.h>
22
23 #include "app_mgr_interface.h"
24 #include "audio_control_manager.h"
25 #include "bluetooth_call_manager.h"
26 #include "call_ability_report_proxy.h"
27 #include "call_connect_ability.h"
28 #include "call_dialog.h"
29 #include "call_manager_errors.h"
30 #include "call_manager_hisysevent.h"
31 #include "call_number_utils.h"
32 #include "call_records_manager.h"
33 #include "call_request_event_handler_helper.h"
34 #include "call_state_report_proxy.h"
35 #include "cellular_call_connection.h"
36 #include "common_type.h"
37 #include "ims_call.h"
38 #include "incoming_flash_reminder.h"
39 #include "iservice_registry.h"
40 #include "reject_call_sms.h"
41 #include "report_call_info_handler.h"
42 #include "satellite_call_control.h"
43 #include "telephony_log_wrapper.h"
44 #include "video_control_manager.h"
45 #include "audio_device_manager.h"
46 #include "distributed_call_manager.h"
47 #include "call_superprivacy_control_manager.h"
48 #include "distributed_communication_manager.h"
49 #include "call_voice_assistant_manager.h"
50 #include "interoperable_communication_manager.h"
51 #include "settings_datashare_helper.h"
52
53 #ifdef ABILITY_POWER_SUPPORT
54 #include "power_mgr_client.h"
55 #endif
56
57 namespace OHOS {
58 namespace Telephony {
59 bool CallControlManager::alarmSeted = false;
60 constexpr int32_t CRS_TYPE = 2;
61 const uint64_t DISCONNECT_DELAY_TIME = 1000000;
62 static const int32_t SATCOMM_UID = 1096;
63 using namespace OHOS::EventFwk;
CallControlManager()64 CallControlManager::CallControlManager()
65 : callStateListenerPtr_(nullptr), CallRequestHandlerPtr_(nullptr), incomingCallWakeup_(nullptr),
66 missedCallNotification_(nullptr), callSettingManagerPtr_(nullptr)
67 {
68 dialSrcInfo_.callId = ERR_ID;
69 dialSrcInfo_.number = "";
70 extras_.Clear();
71 dialSrcInfo_.isDialing = false;
72 }
73
~CallControlManager()74 CallControlManager::~CallControlManager()
75 {}
76
Init()77 bool CallControlManager::Init()
78 {
79 callStateListenerPtr_ = std::make_unique<CallStateListener>();
80 CallRequestHandlerPtr_ = std::make_unique<CallRequestHandler>();
81 CallRequestHandlerPtr_->Init();
82 incomingCallWakeup_ = std::make_shared<IncomingCallWakeup>();
83 missedCallNotification_ = std::make_shared<MissedCallNotification>();
84 callSettingManagerPtr_ = std::make_unique<CallSettingManager>();
85 if (SubscriberSaStateChange() != TELEPHONY_SUCCESS) {
86 TELEPHONY_LOGE("SubscriberSaStateChange failed!");
87 }
88 DelayedSingleton<AudioControlManager>::GetInstance()->Init();
89 CallStateObserve();
90 DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->RegisterSuperPrivacyMode();
91 DelayedSingleton<CallStateReportProxy>::GetInstance()->UpdateCallStateForVoIPOrRestart();
92 return true;
93 }
94
UnInit()95 void CallControlManager::UnInit()
96 {
97 if (statusChangeListener_ != nullptr) {
98 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
99 if (samgrProxy != nullptr) {
100 samgrProxy->UnSubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
101 statusChangeListener_ = nullptr;
102 }
103 }
104 {
105 std::lock_guard<std::mutex> lock(voipMutex_);
106 if (appMgrProxy != nullptr && appStateObserver != nullptr) {
107 appMgrProxy->UnregisterApplicationStateObserver(appStateObserver);
108 appMgrProxy = nullptr;
109 appStateObserver = nullptr;
110 }
111 }
112 UnRegisterObserver();
113 DelayedSingleton<AudioControlManager>::GetInstance()->UnInit();
114 }
115
ReportPhoneUEInSuperPrivacy(const std::string & eventName)116 void CallControlManager::ReportPhoneUEInSuperPrivacy(const std::string &eventName)
117 {
118 if (DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->GetCurrentIsSuperPrivacyMode()) {
119 CallManagerHisysevent::HiWriteBehaviorEventPhoneUE(
120 eventName, PNAMEID_KEY, KEY_CALL_MANAGER, PVERSIONID_KEY, "");
121 }
122 }
123
DialCall(std::u16string & number,AppExecFwk::PacMap & extras)124 int32_t CallControlManager::DialCall(std::u16string &number, AppExecFwk::PacMap &extras)
125 {
126 sptr<CallBase> callObjectPtr = nullptr;
127 std::string accountNumber(Str16ToStr8(number));
128 int32_t ret = NumberLegalityCheck(accountNumber);
129 if (ret != TELEPHONY_SUCCESS) {
130 TELEPHONY_LOGE("Invalid number!");
131 return ret;
132 }
133 TELEPHONY_LOGI("dialInfo slotId is[%{public}d]", extras.GetIntValue("accountId"));
134 bool isEcc = false;
135 std::string newPhoneNum =
136 DelayedSingleton<CallNumberUtils>::GetInstance()->RemoveSeparatorsPhoneNumber(accountNumber);
137 DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(
138 newPhoneNum, extras.GetIntValue("accountId"), isEcc);
139 if (isEcc) {
140 extras.PutIntValue("dialScene", (int32_t)DialScene::CALL_EMERGENCY);
141 }
142 ret = DelayedSingleton<SatelliteCallControl>::GetInstance()->IsSatelliteSwitchEnable();
143 if (ret == TELEPHONY_SUCCESS) {
144 ret = DelayedSingleton<SatelliteCallControl>::GetInstance()->IsAllowedSatelliteDialCall();
145 if (ret != TELEPHONY_SUCCESS) {
146 return ret;
147 } else {
148 extras.PutIntValue("callType", (int32_t)CallType::TYPE_SATELLITE);
149 }
150 }
151 ReportPhoneUEInSuperPrivacy(CALL_DIAL_IN_SUPER_PRIVACY);
152 int32_t dialType = extras.GetIntValue("dialType");
153 if (dialType == (int32_t)DialType::DIAL_BLUETOOTH_TYPE) {
154 extras.PutIntValue("callType", (int32_t)CallType::TYPE_BLUETOOTH);
155 }
156 std::u16string newPhoneNumU16 = Str8ToStr16(newPhoneNum);
157 ret = CanDial(newPhoneNumU16, extras, isEcc);
158 if (ret != TELEPHONY_SUCCESS) {
159 CallManagerHisysevent::WriteDialCallFaultEvent(extras.GetIntValue("accountId"), extras.GetIntValue("callType"),
160 extras.GetIntValue("videoState"), ret, "Dial policy failed");
161 return ret;
162 }
163 SetCallTypeExtras(extras);
164 // temporarily save dial information
165 PackageDialInformation(extras, newPhoneNum, isEcc);
166 if (CallRequestHandlerPtr_ == nullptr) {
167 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
168 return TELEPHONY_ERR_LOCAL_PTR_NULL;
169 }
170 ret = CallRequestHandlerPtr_->DialCall();
171 if (ret != TELEPHONY_SUCCESS) {
172 TELEPHONY_LOGE("DialCall failed!");
173 return ret;
174 }
175 return TELEPHONY_SUCCESS;
176 }
177
SetCallTypeExtras(AppExecFwk::PacMap & extras)178 void CallControlManager::SetCallTypeExtras(AppExecFwk::PacMap &extras)
179 {
180 int32_t dialType = extras.GetIntValue("dialType");
181 if (dialType == (int32_t)DialType::DIAL_CARRIER_TYPE || dialType == (int32_t)DialType::DIAL_VOICE_MAIL_TYPE) {
182 if (!IsSupportVideoCall(extras)) {
183 extras.PutIntValue("videoState", (int32_t)VideoStateType::TYPE_VOICE);
184 }
185 VideoStateType videoState = (VideoStateType)extras.GetIntValue("videoState");
186 if (videoState == VideoStateType::TYPE_VIDEO) {
187 extras.PutIntValue("callType", (int32_t)CallType::TYPE_IMS);
188 }
189 }
190 }
191
CanDial(std::u16string & number,AppExecFwk::PacMap & extras,bool isEcc)192 int32_t CallControlManager::CanDial(std::u16string &number, AppExecFwk::PacMap &extras, bool isEcc)
193 {
194 int32_t ret = DialPolicy(number, extras, isEcc);
195 if (ret != TELEPHONY_SUCCESS) {
196 TELEPHONY_LOGE("dial policy result:%{public}d", ret);
197 return ret;
198 }
199 ret = CanDialMulityCall(extras, isEcc);
200 if (ret != TELEPHONY_SUCCESS) {
201 TELEPHONY_LOGE("dial policy result:%{public}d", ret);
202 return ret;
203 }
204 return TELEPHONY_SUCCESS;
205 }
206
PackageDialInformation(AppExecFwk::PacMap & extras,std::string accountNumber,bool isEcc)207 void CallControlManager::PackageDialInformation(AppExecFwk::PacMap &extras, std::string accountNumber, bool isEcc)
208 {
209 std::lock_guard<std::mutex> lock(mutex_);
210 dialSrcInfo_.callId = ERR_ID;
211 dialSrcInfo_.number = accountNumber;
212 dialSrcInfo_.isDialing = true;
213 dialSrcInfo_.isEcc = isEcc;
214 dialSrcInfo_.callType = (CallType)extras.GetIntValue("callType");
215 dialSrcInfo_.accountId = extras.GetIntValue("accountId");
216 dialSrcInfo_.dialType = (DialType)extras.GetIntValue("dialType");
217 dialSrcInfo_.videoState = (VideoStateType)extras.GetIntValue("videoState");
218 dialSrcInfo_.originalCallType = (int32_t)extras.GetIntValue("videoState");
219 dialSrcInfo_.bundleName = extras.GetStringValue("bundleName");
220 extras_.Clear();
221 extras_ = extras;
222 }
223
AnswerCall(int32_t callId,int32_t videoState)224 int32_t CallControlManager::AnswerCall(int32_t callId, int32_t videoState)
225 {
226 StopFlashRemind();
227 #ifdef NOT_SUPPORT_MULTICALL
228 if (HangUpFirstCall(callId)) {
229 return TELEPHONY_SUCCESS;
230 }
231 #endif
232 sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
233 if (call == nullptr) {
234 TELEPHONY_LOGE("call is nullptr");
235 CallManagerHisysevent::WriteAnswerCallFaultEvent(
236 INVALID_PARAMETER, callId, videoState, TELEPHONY_ERR_LOCAL_PTR_NULL, "call is nullptr");
237 return TELEPHONY_ERR_LOCAL_PTR_NULL;
238 }
239 if (callId == INVALID_CALLID) {
240 callId = call->GetCallID();
241 }
242 call = GetOneCallObject(callId);
243 if (call == nullptr) {
244 TELEPHONY_LOGE("call is nullptr");
245 return TELEPHONY_ERR_LOCAL_PTR_NULL;
246 }
247 call->SetAnsweredCall(true);
248 if (call->GetCrsType() == CRS_TYPE && static_cast<VideoStateType>(videoState) != VideoStateType::TYPE_VIDEO) {
249 TELEPHONY_LOGI("answer call set speaker deactive");
250 DelayedSingleton<AudioProxy>::GetInstance()->SetSpeakerDevActive(false);
251 }
252 ReportPhoneUEInSuperPrivacy(CALL_ANSWER_IN_SUPER_PRIVACY);
253 if (CurrentIsSuperPrivacyMode(callId, videoState)) {
254 return TELEPHONY_SUCCESS;
255 }
256 AnswerHandlerForSatelliteOrVideoCall(call, videoState);
257 TELEPHONY_LOGI("report answered state");
258 NotifyCallStateUpdated(call, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_ANSWERED);
259 CarrierAndVoipConflictProcess(callId, TelCallState::CALL_STATUS_ANSWERED);
260 if (VoIPCallState_ != CallStateToApp::CALL_STATE_IDLE && call->GetCallType() != CallType::TYPE_VOIP) {
261 TELEPHONY_LOGW("VoIP call is active, waiting for VoIP to disconnect");
262 AnsweredCallQueue_.hasCall = true;
263 AnsweredCallQueue_.callId = callId;
264 AnsweredCallQueue_.videoState = videoState;
265 return TELEPHONY_SUCCESS;
266 }
267 int32_t ret = AnswerCallPolicy(callId, videoState);
268 if (ret != TELEPHONY_SUCCESS) {
269 TELEPHONY_LOGE("AnswerCallPolicy failed!");
270 if (IsVoipCallExist()) {
271 sendEventToVoip(CallAbilityEventId::EVENT_ANSWER_VOIP_CALL);
272 return TELEPHONY_SUCCESS;
273 }
274 CallManagerHisysevent::WriteAnswerCallFaultEvent(
275 INVALID_PARAMETER, callId, videoState, ret, "AnswerCallPolicy failed");
276 return ret;
277 }
278 CallManagerHisysevent::WriteVoipCallStatisticalEvent(callId, "MtBannerAnswer");
279 return HandlerAnswerCall(callId, videoState);
280 }
281
HandlerAnswerCall(int32_t callId,int32_t videoState)282 int32_t CallControlManager::HandlerAnswerCall(int32_t callId, int32_t videoState)
283 {
284 if (CallRequestHandlerPtr_ == nullptr) {
285 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
286 return TELEPHONY_ERR_LOCAL_PTR_NULL;
287 }
288 int ret = CallRequestHandlerPtr_->AnswerCall(callId, videoState);
289 if (ret != TELEPHONY_SUCCESS) {
290 TELEPHONY_LOGE("AnswerCall failed!");
291 return ret;
292 }
293 return TELEPHONY_SUCCESS;
294 }
CurrentIsSuperPrivacyMode(int32_t callId,int32_t videoState)295 bool CallControlManager::CurrentIsSuperPrivacyMode(int32_t callId, int32_t videoState)
296 {
297 bool currentIsSuperPrivacyMode = DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->
298 GetCurrentIsSuperPrivacyMode();
299 TELEPHONY_LOGI("call policy answer currentIsSuperPrivacyMode:%{public}d", currentIsSuperPrivacyMode);
300 if (currentIsSuperPrivacyMode) {
301 DelayedSingleton<AudioControlManager>::GetInstance()->MuteRinger();
302 DelayedSingleton<CallDialog>::GetInstance()->DialogConnectAnswerPrivpacyModeExtension("SUPER_PRIVACY_MODE",
303 callId, videoState, true);
304 return true;
305 }
306 return false;
307 }
308
AnswerHandlerForSatelliteOrVideoCall(sptr<CallBase> & call,int32_t videoState)309 void CallControlManager::AnswerHandlerForSatelliteOrVideoCall(sptr<CallBase> &call, int32_t videoState)
310 {
311 if (call == nullptr) {
312 TELEPHONY_LOGE("call is nullptr");
313 return;
314 }
315 if (call->GetCallType() == CallType::TYPE_IMS && videoState != static_cast<int32_t>(call->GetVideoStateType())) {
316 call->SetVideoStateType(static_cast<VideoStateType>(videoState));
317 sptr<IMSCall> imsCall = reinterpret_cast<IMSCall *>(call.GetRefPtr());
318 imsCall->InitVideoCall();
319 TELEPHONY_LOGI("videoState has changed");
320 }
321 if (call->GetCallType() == CallType::TYPE_SATELLITE) {
322 sptr<CallBase> foregroundSatelliteCall =
323 CallObjectManager::GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
324 if (foregroundSatelliteCall != nullptr) {
325 CallRequestHandlerPtr_->HangUpCall(foregroundSatelliteCall->GetCallID());
326 }
327 }
328 }
329
CarrierAndVoipConflictProcess(int32_t callId,TelCallState callState)330 int32_t CallControlManager::CarrierAndVoipConflictProcess(int32_t callId, TelCallState callState)
331 {
332 if (callState != TelCallState::CALL_STATUS_ANSWERED) {
333 TELEPHONY_LOGI("voip calls should be handled with only when a carrier call is answered");
334 return TELEPHONY_SUCCESS;
335 }
336 sptr<CallBase> call = GetOneCallObject(callId);
337 if (call == nullptr) {
338 TELEPHONY_LOGE("CarrierAndVoipConflictProcess, call is nullptr!");
339 return TELEPHONY_ERR_LOCAL_PTR_NULL;
340 }
341 if (call->GetCallType() == CallType::TYPE_CS ||
342 call->GetCallType() == CallType::TYPE_IMS ||
343 call->GetCallType() == CallType::TYPE_SATELLITE) {
344 std::list<int32_t> voipCallIdList;
345 int32_t ret = GetVoipCallList(voipCallIdList);
346 if (ret != TELEPHONY_SUCCESS) {
347 TELEPHONY_LOGE("GetVoipCallList failed!");
348 return ret;
349 }
350 for (auto voipCallId : voipCallIdList) {
351 sptr<CallBase> voipCall = GetOneCallObject(voipCallId);
352 TelCallState voipCallState = voipCall->GetTelCallState();
353 if (voipCallState == TelCallState::CALL_STATUS_INCOMING) {
354 TELEPHONY_LOGI("the system is rejecting a voip call, callId = %{public}d", voipCall->GetCallID());
355 ret = RejectCall(voipCallId, true, u"CarrierAndVoipConflictProcess");
356 } else if (voipCallState == TelCallState::CALL_STATUS_DIALING) {
357 TELEPHONY_LOGI("the system is hanging up a voip call, callId = %{public}d", voipCall->GetCallID());
358 ret = HangUpCall(voipCallId);
359 }
360 if (ret != TELEPHONY_SUCCESS) {
361 TELEPHONY_LOGE("CarrierAndVoipConflictProcess failed!");
362 return ret;
363 }
364 }
365 return TELEPHONY_SUCCESS;
366 }
367 return TELEPHONY_SUCCESS;
368 }
369
RejectCall(int32_t callId,bool rejectWithMessage,std::u16string textMessage)370 int32_t CallControlManager::RejectCall(int32_t callId, bool rejectWithMessage, std::u16string textMessage)
371 {
372 if (CallRequestHandlerPtr_ == nullptr) {
373 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
374 return TELEPHONY_ERR_LOCAL_PTR_NULL;
375 }
376
377 if (callId == INVALID_CALLID) {
378 sptr<CallBase> call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
379 if (call == nullptr) {
380 TELEPHONY_LOGE("call is nullptr");
381 CallManagerHisysevent::WriteHangUpFaultEvent(
382 INVALID_PARAMETER, callId, TELEPHONY_ERR_LOCAL_PTR_NULL, "Reject call is nullptr");
383 return TELEPHONY_ERR_LOCAL_PTR_NULL;
384 }
385 callId = call->GetCallID();
386 }
387
388 int32_t ret = RejectCallPolicy(callId);
389 if (ret != TELEPHONY_SUCCESS) {
390 TELEPHONY_LOGE("RejectCallPolicy failed!");
391 if (callId >= VOIP_CALL_MINIMUM && IsVoipCallExist()) {
392 sendEventToVoip(CallAbilityEventId::EVENT_REJECT_VOIP_CALL);
393 return TELEPHONY_SUCCESS;
394 }
395 CallManagerHisysevent::WriteHangUpFaultEvent(INVALID_PARAMETER, callId, ret, "Reject RejectCallPolicy failed");
396 return ret;
397 }
398 std::string messageStr(Str16ToStr8(textMessage));
399 StopFlashRemind();
400 ret = CallRequestHandlerPtr_->RejectCall(callId, rejectWithMessage, messageStr);
401 if (ret != TELEPHONY_SUCCESS) {
402 TELEPHONY_LOGE("RejectCall failed!");
403 return ret;
404 }
405 CallManagerHisysevent::WriteVoipCallStatisticalEvent(callId, "MtBannerReject");
406 ReportPhoneUEInSuperPrivacy(CALL_REJECT_IN_SUPER_PRIVACY);
407 return TELEPHONY_SUCCESS;
408 }
409
HangUpCall(int32_t callId)410 int32_t CallControlManager::HangUpCall(int32_t callId)
411 {
412 if (callId == INVALID_CALLID) {
413 std::vector<CallRunningState> callRunningStateVec;
414 callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
415 callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_DIALING);
416 callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_CONNECTING);
417 callRunningStateVec.push_back(CallRunningState::CALL_RUNNING_STATE_HOLD);
418
419 for (auto &state : callRunningStateVec) {
420 sptr<CallBase> call = GetOneCallObject(state);
421 if (call != nullptr) {
422 callId = call->GetCallID();
423 break;
424 }
425 }
426
427 if (callId == INVALID_CALLID) {
428 TELEPHONY_LOGE("callId is INVALID_CALLID!");
429 CallManagerHisysevent::WriteHangUpFaultEvent(
430 INVALID_PARAMETER, callId, TELEPHONY_ERR_LOCAL_PTR_NULL, "HangUp callId is INVALID_CALLID");
431 return TELEPHONY_ERR_ARGUMENT_INVALID;
432 }
433 }
434
435 if (CallRequestHandlerPtr_ == nullptr) {
436 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
437 return TELEPHONY_ERR_LOCAL_PTR_NULL;
438 }
439 int32_t ret = HangUpPolicy(callId);
440 if (ret != TELEPHONY_SUCCESS) {
441 TELEPHONY_LOGE("HangUpPolicy failed!");
442 if (callId >= VOIP_CALL_MINIMUM && IsVoipCallExist()) {
443 sendEventToVoip(CallAbilityEventId::EVENT_HANGUP_VOIP_CALL);
444 return TELEPHONY_SUCCESS;
445 }
446 CallManagerHisysevent::WriteHangUpFaultEvent(INVALID_PARAMETER, callId, ret, "HangUp HangUpPolicy failed");
447 return ret;
448 }
449 auto callRequestEventHandler = DelayedSingleton<CallRequestEventHandlerHelper>::GetInstance();
450 if (callRequestEventHandler->HasPendingMo(callId)) {
451 callRequestEventHandler->SetPendingMo(false, -1);
452 callRequestEventHandler->SetPendingHangup(true, callId);
453 TELEPHONY_LOGI("HangUpCall before dialingHandle,hangup after CLCC");
454 return TELEPHONY_SUCCESS;
455 }
456 ret = CallRequestHandlerPtr_->HangUpCall(callId);
457 if (ret != TELEPHONY_SUCCESS) {
458 TELEPHONY_LOGE("HangUpCall failed!");
459 return ret;
460 }
461 CallManagerHisysevent::WriteVoipCallStatisticalEvent(callId, "HungupByBanner");
462 return TELEPHONY_SUCCESS;
463 }
464
sendEventToVoip(CallAbilityEventId eventId)465 void CallControlManager::sendEventToVoip(CallAbilityEventId eventId)
466 {
467 CallEventInfo eventInfo;
468 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
469 eventInfo.eventId = eventId;
470 NotifyCallEventUpdated(eventInfo);
471 }
472
GetCallState()473 int32_t CallControlManager::GetCallState()
474 {
475 CallStateToApp callState = CallStateToApp::CALL_STATE_UNKNOWN;
476 if (!HasCellularCallExist() && (VoIPCallState_ == CallStateToApp::CALL_STATE_IDLE ||
477 VoIPCallState_ == CallStateToApp::CALL_STATE_UNKNOWN)) {
478 callState = CallStateToApp::CALL_STATE_IDLE;
479 } else {
480 callState = CallStateToApp::CALL_STATE_OFFHOOK;
481 bool hasRingingCall = false;
482 if ((HasRingingCall(hasRingingCall) == TELEPHONY_SUCCESS && hasRingingCall) ||
483 VoIPCallState_ == CallStateToApp::CALL_STATE_RINGING) {
484 callState = CallStateToApp::CALL_STATE_RINGING;
485 }
486 }
487 return static_cast<int32_t>(callState);
488 }
489
HoldCall(int32_t callId)490 int32_t CallControlManager::HoldCall(int32_t callId)
491 {
492 int32_t ret = HoldCallPolicy(callId);
493 if (ret != TELEPHONY_SUCCESS) {
494 TELEPHONY_LOGE("HoldCall failed!");
495 return ret;
496 }
497 if (CallRequestHandlerPtr_ == nullptr) {
498 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
499 return TELEPHONY_ERR_LOCAL_PTR_NULL;
500 }
501 ret = CallRequestHandlerPtr_->HoldCall(callId);
502 if (ret != TELEPHONY_SUCCESS) {
503 TELEPHONY_LOGE("HoldCall failed!");
504 return ret;
505 }
506 return TELEPHONY_SUCCESS;
507 }
508
UnHoldCall(const int32_t callId)509 int32_t CallControlManager::UnHoldCall(const int32_t callId)
510 {
511 int32_t ret = UnHoldCallPolicy(callId);
512 if (ret != TELEPHONY_SUCCESS) {
513 TELEPHONY_LOGE("UnHoldCall failed!");
514 return ret;
515 }
516 if (CallRequestHandlerPtr_ == nullptr) {
517 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
518 return TELEPHONY_ERR_LOCAL_PTR_NULL;
519 }
520 ret = CallRequestHandlerPtr_->UnHoldCall(callId);
521 if (ret != TELEPHONY_SUCCESS) {
522 TELEPHONY_LOGE("UnHoldCall failed!");
523 return ret;
524 }
525 return TELEPHONY_SUCCESS;
526 }
527
528 // swap two calls state, turn active call into holding, and turn holding call into active
SwitchCall(int32_t callId)529 int32_t CallControlManager::SwitchCall(int32_t callId)
530 {
531 int32_t ret = SwitchCallPolicy(callId);
532 if (ret != TELEPHONY_SUCCESS) {
533 TELEPHONY_LOGE("SwitchCall failed!");
534 return ret;
535 }
536 if (CallRequestHandlerPtr_ == nullptr) {
537 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
538 return TELEPHONY_ERR_LOCAL_PTR_NULL;
539 }
540 ret = CallRequestHandlerPtr_->SwitchCall(callId);
541 if (ret != TELEPHONY_SUCCESS) {
542 TELEPHONY_LOGE("SwitchCall failed!");
543 return ret;
544 }
545 return TELEPHONY_SUCCESS;
546 }
547
HasCall()548 bool CallControlManager::HasCall()
549 {
550 if (VoIPCallState_ == CallStateToApp::CALL_STATE_ANSWERED ||
551 VoIPCallState_ == CallStateToApp::CALL_STATE_OFFHOOK ||
552 VoIPCallState_ == CallStateToApp::CALL_STATE_RINGING ||
553 HasCellularCallExist()) {
554 return true;
555 }
556 return false;
557 }
558
HasVoipCall()559 bool CallControlManager::HasVoipCall()
560 {
561 return HasVoipCallExist();
562 }
563
IsNewCallAllowed(bool & enabled)564 int32_t CallControlManager::IsNewCallAllowed(bool &enabled)
565 {
566 return IsNewCallAllowedCreate(enabled);
567 }
568
IsRinging(bool & enabled)569 int32_t CallControlManager::IsRinging(bool &enabled)
570 {
571 return HasRingingCall(enabled);
572 }
573
HasEmergency(bool & enabled)574 int32_t CallControlManager::HasEmergency(bool &enabled)
575 {
576 return HasEmergencyCall(enabled);
577 }
578
NotifyNewCallCreated(sptr<CallBase> & callObjectPtr)579 bool CallControlManager::NotifyNewCallCreated(sptr<CallBase> &callObjectPtr)
580 {
581 if (callObjectPtr == nullptr) {
582 TELEPHONY_LOGE("callObjectPtr is null!");
583 return false;
584 }
585 if (callStateListenerPtr_ != nullptr) {
586 callStateListenerPtr_->NewCallCreated(callObjectPtr);
587 }
588 return true;
589 }
590
NotifyCallDestroyed(const DisconnectedDetails & details)591 bool CallControlManager::NotifyCallDestroyed(const DisconnectedDetails &details)
592 {
593 if (callStateListenerPtr_ != nullptr) {
594 callStateListenerPtr_->CallDestroyed(details);
595 return true;
596 }
597 return false;
598 }
599
NotifyCallStateUpdated(sptr<CallBase> & callObjectPtr,TelCallState priorState,TelCallState nextState)600 bool CallControlManager::NotifyCallStateUpdated(
601 sptr<CallBase> &callObjectPtr, TelCallState priorState, TelCallState nextState)
602 {
603 if (callObjectPtr == nullptr) {
604 TELEPHONY_LOGE("callObjectPtr is null!");
605 return false;
606 }
607 if (callStateListenerPtr_ != nullptr) {
608 TELEPHONY_LOGI("NotifyCallStateUpdated priorState:%{public}d,nextState:%{public}d", priorState, nextState);
609 callStateListenerPtr_->CallStateUpdated(callObjectPtr, priorState, nextState);
610 if (callObjectPtr->GetCallType() == CallType::TYPE_VOIP) {
611 return true;
612 }
613 if (IsCallActivated(priorState, nextState)) {
614 TELEPHONY_LOGI("call is actived, now check and switch call to distributed audio device");
615 DelayedSingleton<AudioDeviceManager>::GetInstance()->CheckAndSwitchDistributedAudioDevice();
616 } else if ((priorState == TelCallState::CALL_STATUS_ACTIVE &&
617 nextState == TelCallState::CALL_STATUS_DISCONNECTED) ||
618 (priorState == TelCallState::CALL_STATUS_DISCONNECTING &&
619 nextState == TelCallState::CALL_STATUS_DISCONNECTED)) {
620 bool hasHoldCall = false;
621 if ((HasHoldCall(hasHoldCall) == TELEPHONY_SUCCESS) && !hasHoldCall) {
622 TELEPHONY_LOGI("call is disconnected, clear distributed call state");
623 DelayedSingleton<AudioDeviceManager>::GetInstance()->OnActivedCallDisconnected();
624 }
625 } else if (priorState == TelCallState::CALL_STATUS_WAITING &&
626 nextState == TelCallState::CALL_STATUS_ACTIVE) {
627 if (DelayedSingleton<DistributedCallManager>::GetInstance()->IsDCallDeviceSwitchedOn()) {
628 TELEPHONY_LOGI("answer multi-line call, need switch again.");
629 DelayedSingleton<AudioDeviceManager>::GetInstance()->CheckAndSwitchDistributedAudioDevice();
630 }
631 }
632 return true;
633 }
634 return false;
635 }
636
IsCallActivated(const TelCallState & priorState,const TelCallState & nextState)637 bool CallControlManager::IsCallActivated(const TelCallState& priorState, const TelCallState& nextState)
638 {
639 return (priorState == TelCallState::CALL_STATUS_DIALING && nextState == TelCallState::CALL_STATUS_ALERTING) ||
640 (priorState == TelCallState::CALL_STATUS_DIALING && nextState == TelCallState::CALL_STATUS_ACTIVE) ||
641 (priorState == TelCallState::CALL_STATUS_INCOMING && nextState == TelCallState::CALL_STATUS_ACTIVE) ||
642 (priorState == TelCallState::CALL_STATUS_ALERTING && nextState == TelCallState::CALL_STATUS_ACTIVE);
643 }
644
NotifyVoipCallStateUpdated(CallAttributeInfo info,TelCallState priorState,TelCallState nextState)645 bool CallControlManager::NotifyVoipCallStateUpdated(
646 CallAttributeInfo info, TelCallState priorState, TelCallState nextState)
647 {
648 if (callStateListenerPtr_ != nullptr) {
649 TELEPHONY_LOGI("NotifyVoipStateUpdated priorState:%{public}d,nextState:%{public}d", priorState, nextState);
650 callStateListenerPtr_->MeeTimeStateUpdated(info, priorState, nextState);
651 return true;
652 }
653 return false;
654 }
655
NotifyIncomingCallAnswered(sptr<CallBase> & callObjectPtr)656 bool CallControlManager::NotifyIncomingCallAnswered(sptr<CallBase> &callObjectPtr)
657 {
658 if (callObjectPtr == nullptr) {
659 TELEPHONY_LOGE("callObjectPtr is null!");
660 return false;
661 }
662 if (callStateListenerPtr_ != nullptr) {
663 callStateListenerPtr_->IncomingCallActivated(callObjectPtr);
664 return true;
665 }
666 return false;
667 }
668
NotifyIncomingCallRejected(sptr<CallBase> & callObjectPtr,bool isSendSms,std::string content)669 bool CallControlManager::NotifyIncomingCallRejected(
670 sptr<CallBase> &callObjectPtr, bool isSendSms, std::string content)
671 {
672 if (callObjectPtr == nullptr) {
673 TELEPHONY_LOGE("callObjectPtr is null!");
674 return false;
675 }
676 if (callStateListenerPtr_ != nullptr) {
677 callStateListenerPtr_->IncomingCallHungUp(callObjectPtr, isSendSms, content);
678 return true;
679 }
680 return false;
681 }
682
NotifyCallEventUpdated(CallEventInfo & info)683 bool CallControlManager::NotifyCallEventUpdated(CallEventInfo &info)
684 {
685 if (callStateListenerPtr_ != nullptr) {
686 callStateListenerPtr_->CallEventUpdated(info);
687 return true;
688 }
689 return false;
690 }
691
StartDtmf(int32_t callId,char str)692 int32_t CallControlManager::StartDtmf(int32_t callId, char str)
693 {
694 sptr<CallBase> call = GetOneCallObject(callId);
695 if (call == nullptr) {
696 return TELEPHONY_ERR_ARGUMENT_INVALID;
697 }
698 if (!call->IsAliveState()) {
699 return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
700 }
701
702 int32_t ret = call->StartDtmf(str);
703 if (ret != TELEPHONY_SUCCESS) {
704 TELEPHONY_LOGE("StartDtmf failed, return:%{public}d", ret);
705 }
706 ffrt::submit([str]() {
707 DelayedSingleton<AudioControlManager>::GetInstance()->PlayDtmfTone(str);
708 });
709 return ret;
710 }
711
StopDtmf(int32_t callId)712 int32_t CallControlManager::StopDtmf(int32_t callId)
713 {
714 sptr<CallBase> call = GetOneCallObject(callId);
715 if (call == nullptr) {
716 return TELEPHONY_ERR_ARGUMENT_INVALID;
717 }
718 if (!call->IsAliveState()) {
719 return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
720 }
721
722 int32_t ret = call->StopDtmf();
723 if (ret != TELEPHONY_SUCCESS) {
724 TELEPHONY_LOGE("StopDtmf failed, return:%{public}d", ret);
725 }
726 DelayedSingleton<AudioControlManager>::GetInstance()->StopDtmfTone();
727 return ret;
728 }
729
PostDialProceed(int32_t callId,bool proceed)730 int32_t CallControlManager::PostDialProceed(int32_t callId, bool proceed)
731 {
732 sptr<CallBase> call = GetOneCallObject(callId);
733 if (call == nullptr) {
734 return TELEPHONY_ERR_ARGUMENT_INVALID;
735 }
736 if (!call->IsAliveState()) {
737 return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
738 }
739
740 int32_t ret = call->PostDialProceed(proceed);
741 if (ret != TELEPHONY_SUCCESS) {
742 TELEPHONY_LOGE("PostDialProceed failed, return:%{public}d", ret);
743 }
744 return ret;
745 }
746
GetCallWaiting(int32_t slotId)747 int32_t CallControlManager::GetCallWaiting(int32_t slotId)
748 {
749 int32_t ret = CallPolicy::GetCallWaitingPolicy(slotId);
750 if (ret != TELEPHONY_SUCCESS) {
751 TELEPHONY_LOGE("GetCallWaiting failed!");
752 return ret;
753 }
754 if (callSettingManagerPtr_ != nullptr) {
755 return callSettingManagerPtr_->GetCallWaiting(slotId);
756 } else {
757 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
758 return TELEPHONY_ERR_LOCAL_PTR_NULL;
759 }
760 }
761
SetCallWaiting(int32_t slotId,bool activate)762 int32_t CallControlManager::SetCallWaiting(int32_t slotId, bool activate)
763 {
764 int32_t ret = CallPolicy::SetCallWaitingPolicy(slotId);
765 if (ret != TELEPHONY_SUCCESS) {
766 TELEPHONY_LOGE("SetCallWaiting failed!");
767 return ret;
768 }
769 if (callSettingManagerPtr_ != nullptr) {
770 return callSettingManagerPtr_->SetCallWaiting(slotId, activate);
771 } else {
772 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
773 return TELEPHONY_ERR_LOCAL_PTR_NULL;
774 }
775 }
776
GetCallRestriction(int32_t slotId,CallRestrictionType type)777 int32_t CallControlManager::GetCallRestriction(int32_t slotId, CallRestrictionType type)
778 {
779 int32_t ret = CallPolicy::GetCallRestrictionPolicy(slotId);
780 if (ret != TELEPHONY_SUCCESS) {
781 TELEPHONY_LOGE("GetCallRestriction failed!");
782 return ret;
783 }
784 if (callSettingManagerPtr_ != nullptr) {
785 return callSettingManagerPtr_->GetCallRestriction(slotId, type);
786 } else {
787 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
788 return TELEPHONY_ERR_LOCAL_PTR_NULL;
789 }
790 }
791
SetCallRestriction(int32_t slotId,CallRestrictionInfo & info)792 int32_t CallControlManager::SetCallRestriction(int32_t slotId, CallRestrictionInfo &info)
793 {
794 int32_t ret = CallPolicy::SetCallRestrictionPolicy(slotId);
795 if (ret != TELEPHONY_SUCCESS) {
796 TELEPHONY_LOGE("SetCallRestriction failed!");
797 return ret;
798 }
799 if (callSettingManagerPtr_ != nullptr) {
800 return callSettingManagerPtr_->SetCallRestriction(slotId, info);
801 } else {
802 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
803 return TELEPHONY_ERR_LOCAL_PTR_NULL;
804 }
805 }
806
SetCallRestrictionPassword(int32_t slotId,CallRestrictionType fac,const char * oldPassword,const char * newPassword)807 int32_t CallControlManager::SetCallRestrictionPassword(
808 int32_t slotId, CallRestrictionType fac, const char *oldPassword, const char *newPassword)
809 {
810 int32_t ret = CallPolicy::SetCallRestrictionPolicy(slotId);
811 if (ret != TELEPHONY_SUCCESS) {
812 TELEPHONY_LOGE("policy check failed!");
813 return ret;
814 }
815 if (callSettingManagerPtr_ != nullptr) {
816 return callSettingManagerPtr_->SetCallRestrictionPassword(slotId, fac, oldPassword, newPassword);
817 } else {
818 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
819 return TELEPHONY_ERR_LOCAL_PTR_NULL;
820 }
821 }
822
GetCallTransferInfo(int32_t slotId,CallTransferType type)823 int32_t CallControlManager::GetCallTransferInfo(int32_t slotId, CallTransferType type)
824 {
825 int32_t ret = CallPolicy::GetCallTransferInfoPolicy(slotId);
826 if (ret != TELEPHONY_SUCCESS) {
827 TELEPHONY_LOGE("GetCallTransferInfo failed!");
828 return ret;
829 }
830 if (callSettingManagerPtr_ != nullptr) {
831 return callSettingManagerPtr_->GetCallTransferInfo(slotId, type);
832 } else {
833 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
834 return TELEPHONY_ERR_LOCAL_PTR_NULL;
835 }
836 }
837
SetCallTransferInfo(int32_t slotId,CallTransferInfo & info)838 int32_t CallControlManager::SetCallTransferInfo(int32_t slotId, CallTransferInfo &info)
839 {
840 int32_t ret = CallPolicy::SetCallTransferInfoPolicy(slotId);
841 if (ret != TELEPHONY_SUCCESS) {
842 TELEPHONY_LOGE("SetCallTransferInfo failed!");
843 return ret;
844 }
845 if (callSettingManagerPtr_ != nullptr) {
846 return callSettingManagerPtr_->SetCallTransferInfo(slotId, info);
847 } else {
848 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
849 return TELEPHONY_ERR_LOCAL_PTR_NULL;
850 }
851 }
852
CanSetCallTransferTime(int32_t slotId,bool & result)853 int32_t CallControlManager::CanSetCallTransferTime(int32_t slotId, bool &result)
854 {
855 int32_t ret = CallPolicy::SetCallTransferInfoPolicy(slotId);
856 if (ret != TELEPHONY_SUCCESS) {
857 TELEPHONY_LOGE("[slot%{public}d] failed!", slotId);
858 return ret;
859 }
860 if (callSettingManagerPtr_ != nullptr) {
861 return callSettingManagerPtr_->CanSetCallTransferTime(slotId, result);
862 } else {
863 TELEPHONY_LOGE("[slot%{public}d] callSettingManagerPtr_ is nullptr!", slotId);
864 return TELEPHONY_ERR_LOCAL_PTR_NULL;
865 }
866 }
867
SetCallPreferenceMode(int32_t slotId,int32_t mode)868 int32_t CallControlManager::SetCallPreferenceMode(int32_t slotId, int32_t mode)
869 {
870 int32_t ret = CallPolicy::SetCallPreferenceModePolicy(slotId);
871 if (ret != TELEPHONY_SUCCESS) {
872 TELEPHONY_LOGE("SetCallPreferenceMode failed!");
873 return ret;
874 }
875 if (callSettingManagerPtr_ != nullptr) {
876 return callSettingManagerPtr_->SetCallPreferenceMode(slotId, mode);
877 } else {
878 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
879 return TELEPHONY_ERR_LOCAL_PTR_NULL;
880 }
881 }
882
883 /**
884 * start a telephone conference by merging three-way calls,steps as follows:
885 * 1.A call B: A<---->B,set holding
886 * 2.A call C: A<---->C, active
887 * 3.A initial merge request by CombineConference
888 * @param mainCallId:active call id
889 */
CombineConference(int32_t mainCallId)890 int32_t CallControlManager::CombineConference(int32_t mainCallId)
891 {
892 sptr<CallBase> mainCall = GetOneCallObject(mainCallId);
893 if (mainCall == nullptr) {
894 TELEPHONY_LOGE("GetOneCallObject failed, mainCallId:%{public}d", mainCallId);
895 return TELEPHONY_ERR_ARGUMENT_INVALID;
896 }
897 if (mainCall->GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
898 TELEPHONY_LOGE("mainCall state should be active ");
899 return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
900 }
901 if (!CallObjectManager::IsCallExist(mainCall->GetCallType(), TelCallState::CALL_STATUS_HOLDING)) {
902 TELEPHONY_LOGE("callType:%{public}d,callState:CALL_STATUS_HOLDING is not exist!", mainCall->GetCallType());
903 return CALL_ERR_CALL_STATE_MISMATCH_OPERATION;
904 }
905 int32_t ret = mainCall->CanCombineConference();
906 if (ret != TELEPHONY_SUCCESS) {
907 TELEPHONY_LOGE("CanCombineConference failed");
908 return ret;
909 }
910 if (CallRequestHandlerPtr_ == nullptr) {
911 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
912 return TELEPHONY_ERR_LOCAL_PTR_NULL;
913 }
914 ret = CallRequestHandlerPtr_->CombineConference(mainCallId);
915 if (ret != TELEPHONY_SUCCESS) {
916 TELEPHONY_LOGE("CombineConference failed!");
917 }
918 return ret;
919 }
920
SeparateConference(int32_t callId)921 int32_t CallControlManager::SeparateConference(int32_t callId)
922 {
923 sptr<CallBase> call = GetOneCallObject(callId);
924 if (call == nullptr) {
925 TELEPHONY_LOGE("GetOneCallObject failed, callId:%{public}d", callId);
926 return TELEPHONY_ERR_ARGUMENT_INVALID;
927 }
928 int32_t ret = call->CanSeparateConference();
929 if (ret != TELEPHONY_SUCCESS) {
930 TELEPHONY_LOGE("CanSeparateConference failed");
931 return ret;
932 }
933 if (CallRequestHandlerPtr_ == nullptr) {
934 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
935 return TELEPHONY_ERR_LOCAL_PTR_NULL;
936 }
937 ret = CallRequestHandlerPtr_->SeparateConference(callId);
938 if (ret != TELEPHONY_SUCCESS) {
939 TELEPHONY_LOGE("SeparateConference failed!");
940 return ret;
941 }
942 return TELEPHONY_SUCCESS;
943 }
944
KickOutFromConference(int32_t callId)945 int32_t CallControlManager::KickOutFromConference(int32_t callId)
946 {
947 sptr<CallBase> call = GetOneCallObject(callId);
948 if (call == nullptr) {
949 TELEPHONY_LOGE("GetOneCallObject failed, callId:%{public}d", callId);
950 return TELEPHONY_ERR_ARGUMENT_INVALID;
951 }
952 int32_t ret = call->CanKickOutFromConference();
953 if (ret != TELEPHONY_SUCCESS) {
954 TELEPHONY_LOGE("CanKickOutFromConference failed");
955 return ret;
956 }
957 if (CallRequestHandlerPtr_ == nullptr) {
958 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
959 return TELEPHONY_ERR_LOCAL_PTR_NULL;
960 }
961 ret = CallRequestHandlerPtr_->KickOutFromConference(callId);
962 if (ret != TELEPHONY_SUCCESS) {
963 TELEPHONY_LOGE("KickOutFromConference failed!");
964 return ret;
965 }
966 return TELEPHONY_SUCCESS;
967 }
968
GetMainCallId(int32_t callId,int32_t & mainCallId)969 int32_t CallControlManager::GetMainCallId(int32_t callId, int32_t &mainCallId)
970 {
971 sptr<CallBase> call = GetOneCallObject(callId);
972 if (call == nullptr) {
973 TELEPHONY_LOGE("GetMainCallId failed! callId:%{public}d", callId);
974 return TELEPHONY_ERR_ARGUMENT_INVALID;
975 }
976 return call->GetMainCallId(mainCallId);
977 }
978
GetSubCallIdList(int32_t callId,std::vector<std::u16string> & callIdList)979 int32_t CallControlManager::GetSubCallIdList(int32_t callId, std::vector<std::u16string> &callIdList)
980 {
981 sptr<CallBase> call = GetOneCallObject(callId);
982 if (call == nullptr) {
983 TELEPHONY_LOGE("GetSubCallIdList failed! callId:%{public}d", callId);
984 return TELEPHONY_ERR_ARGUMENT_INVALID;
985 }
986 return call->GetSubCallIdList(callIdList);
987 }
988
GetCallIdListForConference(int32_t callId,std::vector<std::u16string> & callIdList)989 int32_t CallControlManager::GetCallIdListForConference(int32_t callId, std::vector<std::u16string> &callIdList)
990 {
991 sptr<CallBase> call = GetOneCallObject(callId);
992 if (call == nullptr) {
993 TELEPHONY_LOGE("GetCallIdListForConference failed! callId:%{public}d", callId);
994 return TELEPHONY_ERR_ARGUMENT_INVALID;
995 }
996 return call->GetCallIdListForConference(callIdList);
997 }
998
GetImsConfig(int32_t slotId,ImsConfigItem item)999 int32_t CallControlManager::GetImsConfig(int32_t slotId, ImsConfigItem item)
1000 {
1001 int32_t ret = CallPolicy::GetImsConfigPolicy(slotId);
1002 if (ret != TELEPHONY_SUCCESS) {
1003 TELEPHONY_LOGE("GetImsConfig failed!");
1004 return ret;
1005 }
1006 if (callSettingManagerPtr_ != nullptr) {
1007 return callSettingManagerPtr_->GetImsConfig(slotId, item);
1008 } else {
1009 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1010 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1011 }
1012 }
1013
SetImsConfig(int32_t slotId,ImsConfigItem item,std::u16string & value)1014 int32_t CallControlManager::SetImsConfig(int32_t slotId, ImsConfigItem item, std::u16string &value)
1015 {
1016 int32_t ret = CallPolicy::SetImsConfigPolicy(slotId);
1017 if (ret != TELEPHONY_SUCCESS) {
1018 TELEPHONY_LOGE("SetImsConfig failed!");
1019 return ret;
1020 }
1021 if (callSettingManagerPtr_ != nullptr) {
1022 return callSettingManagerPtr_->SetImsConfig(slotId, item, value);
1023 } else {
1024 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1025 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1026 }
1027 }
1028
GetImsFeatureValue(int32_t slotId,FeatureType type)1029 int32_t CallControlManager::GetImsFeatureValue(int32_t slotId, FeatureType type)
1030 {
1031 int32_t ret = CallPolicy::GetImsFeatureValuePolicy(slotId);
1032 if (ret != TELEPHONY_SUCCESS) {
1033 TELEPHONY_LOGE("GetImsFeatureValue failed!");
1034 return ret;
1035 }
1036 if (callSettingManagerPtr_ != nullptr) {
1037 return callSettingManagerPtr_->GetImsFeatureValue(slotId, type);
1038 } else {
1039 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1040 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1041 }
1042 }
1043
SetImsFeatureValue(int32_t slotId,FeatureType type,int32_t value)1044 int32_t CallControlManager::SetImsFeatureValue(int32_t slotId, FeatureType type, int32_t value)
1045 {
1046 int32_t ret = CallPolicy::SetImsFeatureValuePolicy(slotId);
1047 if (ret != TELEPHONY_SUCCESS) {
1048 TELEPHONY_LOGE("SetImsFeatureValue failed!");
1049 return ret;
1050 }
1051 if (callSettingManagerPtr_ != nullptr) {
1052 return callSettingManagerPtr_->SetImsFeatureValue(slotId, type, value);
1053 } else {
1054 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1055 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1056 }
1057 }
1058
EnableImsSwitch(int32_t slotId)1059 int32_t CallControlManager::EnableImsSwitch(int32_t slotId)
1060 {
1061 int32_t ret = CallPolicy::EnableVoLtePolicy(slotId);
1062 if (ret != TELEPHONY_SUCCESS) {
1063 TELEPHONY_LOGE("EnableImsSwitch failed!");
1064 return ret;
1065 }
1066 if (callSettingManagerPtr_ != nullptr) {
1067 return callSettingManagerPtr_->EnableImsSwitch(slotId);
1068 } else {
1069 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1070 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1071 }
1072 }
1073
DisableImsSwitch(int32_t slotId)1074 int32_t CallControlManager::DisableImsSwitch(int32_t slotId)
1075 {
1076 int32_t ret = CallPolicy::DisableVoLtePolicy(slotId);
1077 if (ret != TELEPHONY_SUCCESS) {
1078 TELEPHONY_LOGE("DisableImsSwitch failed!");
1079 return ret;
1080 }
1081 if (callSettingManagerPtr_ != nullptr) {
1082 return callSettingManagerPtr_->DisableImsSwitch(slotId);
1083 } else {
1084 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1085 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1086 }
1087 }
1088
IsImsSwitchEnabled(int32_t slotId,bool & enabled)1089 int32_t CallControlManager::IsImsSwitchEnabled(int32_t slotId, bool &enabled)
1090 {
1091 int32_t ret = CallPolicy::IsVoLteEnabledPolicy(slotId);
1092 if (ret != TELEPHONY_SUCCESS) {
1093 TELEPHONY_LOGE("IsImsSwitchEnabled failed!");
1094 return ret;
1095 }
1096 if (callSettingManagerPtr_ != nullptr) {
1097 return callSettingManagerPtr_->IsImsSwitchEnabled(slotId, enabled);
1098 } else {
1099 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1100 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1101 }
1102 }
1103
SetVoNRState(int32_t slotId,int32_t state)1104 int32_t CallControlManager::SetVoNRState(int32_t slotId, int32_t state)
1105 {
1106 int32_t ret = CallPolicy::VoNRStatePolicy(slotId, state);
1107 if (ret != TELEPHONY_SUCCESS) {
1108 TELEPHONY_LOGE("SetVoNRState failed!");
1109 return ret;
1110 }
1111 if (callSettingManagerPtr_ != nullptr) {
1112 return callSettingManagerPtr_->SetVoNRState(slotId, state);
1113 } else {
1114 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1115 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1116 }
1117 }
1118
GetVoNRState(int32_t slotId,int32_t & state)1119 int32_t CallControlManager::GetVoNRState(int32_t slotId, int32_t &state)
1120 {
1121 int32_t ret = CallPolicy::IsValidSlotId(slotId);
1122 if (ret != TELEPHONY_SUCCESS) {
1123 TELEPHONY_LOGE("SetVoNRState failed!");
1124 return ret;
1125 }
1126 if (callSettingManagerPtr_ != nullptr) {
1127 ret = callSettingManagerPtr_->GetVoNRState(slotId, state);
1128 if (ret == TELEPHONY_SUCCESS) {
1129 ret = CallPolicy::VoNRStatePolicy(slotId, state);
1130 }
1131 return ret;
1132 } else {
1133 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1134 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1135 }
1136 }
1137
UpdateImsCallMode(int32_t callId,ImsCallMode mode)1138 int32_t CallControlManager::UpdateImsCallMode(int32_t callId, ImsCallMode mode)
1139 {
1140 return TELEPHONY_SUCCESS;
1141 }
1142
StartRtt(int32_t callId,std::u16string & msg)1143 int32_t CallControlManager::StartRtt(int32_t callId, std::u16string &msg)
1144 {
1145 int32_t ret = CallPolicy::StartRttPolicy(callId);
1146 if (ret != TELEPHONY_SUCCESS) {
1147 TELEPHONY_LOGE("NO IMS call,can not StartRtt!");
1148 return ret;
1149 }
1150 if (CallRequestHandlerPtr_ == nullptr) {
1151 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1152 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1153 }
1154 ret = CallRequestHandlerPtr_->StartRtt(callId, msg);
1155 if (ret != TELEPHONY_SUCCESS) {
1156 TELEPHONY_LOGE("StartRtt failed!");
1157 return ret;
1158 }
1159 return TELEPHONY_SUCCESS;
1160 }
1161
StopRtt(int32_t callId)1162 int32_t CallControlManager::StopRtt(int32_t callId)
1163 {
1164 int32_t ret = CallPolicy::StopRttPolicy(callId);
1165 if (ret != TELEPHONY_SUCCESS) {
1166 TELEPHONY_LOGE("NO IMS call,no need StopRtt!");
1167 return ret;
1168 }
1169 if (CallRequestHandlerPtr_ == nullptr) {
1170 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1171 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1172 }
1173 ret = CallRequestHandlerPtr_->StopRtt(callId);
1174 if (ret != TELEPHONY_SUCCESS) {
1175 TELEPHONY_LOGE("StopRtt failed!");
1176 return ret;
1177 }
1178 return TELEPHONY_SUCCESS;
1179 }
1180
JoinConference(int32_t callId,std::vector<std::u16string> & numberList)1181 int32_t CallControlManager::JoinConference(int32_t callId, std::vector<std::u16string> &numberList)
1182 {
1183 if (CallRequestHandlerPtr_ == nullptr) {
1184 TELEPHONY_LOGE("CallRequestHandlerPtr_ is nullptr!");
1185 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1186 }
1187 std::vector<std::string> phoneNumberList(numberList.size());
1188 for (size_t index = 0; index < numberList.size(); ++index) {
1189 phoneNumberList[index] = Str16ToStr8(numberList[index]);
1190 }
1191 int32_t ret = CallPolicy::InviteToConferencePolicy(callId, phoneNumberList);
1192 if (ret != TELEPHONY_SUCCESS) {
1193 TELEPHONY_LOGE("check InviteToConference Policy failed!");
1194 return ret;
1195 }
1196 ret = CallRequestHandlerPtr_->JoinConference(callId, phoneNumberList);
1197 if (ret != TELEPHONY_SUCCESS) {
1198 TELEPHONY_LOGE("JoinConference failed!");
1199 return ret;
1200 }
1201 return TELEPHONY_SUCCESS;
1202 }
1203
SetMuted(bool isMute)1204 int32_t CallControlManager::SetMuted(bool isMute)
1205 {
1206 sptr<CallBase> call = CallObjectManager::GetAudioLiveCall();
1207 if (call == nullptr) {
1208 return CALL_ERR_AUDIO_SETTING_MUTE_FAILED;
1209 }
1210
1211 if (call->GetCallType() == CallType::TYPE_VOIP) {
1212 TELEPHONY_LOGI("SetMute by voip");
1213 return call->SetMute(isMute, call->GetSlotId());
1214 }
1215 if (call->GetCallType() == CallType::TYPE_IMS
1216 || call->GetCallType() == CallType::TYPE_CS) {
1217 TELEPHONY_LOGI("SetMute by ims or cs,isMute = %{public}d", isMute);
1218 call->SetMute(isMute, call->GetSlotId());
1219 }
1220
1221 return DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(isMute);
1222 }
1223
MuteRinger()1224 int32_t CallControlManager::MuteRinger()
1225 {
1226 CallVoiceAssistantManager::GetInstance()->MuteRinger();
1227 return DelayedSingleton<AudioControlManager>::GetInstance()->MuteRinger();
1228 }
1229
SetAudioDevice(const AudioDevice & audioDevice)1230 int32_t CallControlManager::SetAudioDevice(const AudioDevice &audioDevice)
1231 {
1232 return DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(audioDevice, true);
1233 }
1234
ControlCamera(std::u16string cameraId,int32_t callingUid,int32_t callingPid)1235 int32_t CallControlManager::ControlCamera(std::u16string cameraId, int32_t callingUid, int32_t callingPid)
1236 {
1237 return TELEPHONY_SUCCESS;
1238 }
1239
SetPreviewWindow(VideoWindow & window)1240 int32_t CallControlManager::SetPreviewWindow(VideoWindow &window)
1241 {
1242 return TELEPHONY_SUCCESS;
1243 }
1244
SetDisplayWindow(VideoWindow & window)1245 int32_t CallControlManager::SetDisplayWindow(VideoWindow &window)
1246 {
1247 return TELEPHONY_SUCCESS;
1248 }
1249
SetCameraZoom(float zoomRatio)1250 int32_t CallControlManager::SetCameraZoom(float zoomRatio)
1251 {
1252 return TELEPHONY_SUCCESS;
1253 }
1254
SetPausePicture(std::u16string path)1255 int32_t CallControlManager::SetPausePicture(std::u16string path)
1256 {
1257 return TELEPHONY_SUCCESS;
1258 }
1259
SetDeviceDirection(int32_t rotation)1260 int32_t CallControlManager::SetDeviceDirection(int32_t rotation)
1261 {
1262 return TELEPHONY_SUCCESS;
1263 }
1264
IsEmergencyPhoneNumber(std::u16string & number,int32_t slotId,bool & enabled)1265 int32_t CallControlManager::IsEmergencyPhoneNumber(std::u16string &number, int32_t slotId, bool &enabled)
1266 {
1267 if (IsValidSlotId(slotId)) {
1268 return CALL_ERR_INVALID_SLOT_ID;
1269 }
1270 std::string newPhoneNum =
1271 DelayedSingleton<CallNumberUtils>::GetInstance()->RemoveSeparatorsPhoneNumber(Str16ToStr8(number));
1272 return DelayedSingleton<CallNumberUtils>::GetInstance()->CheckNumberIsEmergency(
1273 newPhoneNum, slotId, enabled);
1274 }
1275
FormatPhoneNumber(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1276 int32_t CallControlManager::FormatPhoneNumber(
1277 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1278 {
1279 std::string tmpStr("");
1280 int32_t ret = DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumber(
1281 Str16ToStr8(number), Str16ToStr8(countryCode), tmpStr);
1282 formatNumber = Str8ToStr16(tmpStr);
1283 return ret;
1284 }
1285
FormatPhoneNumberToE164(std::u16string & number,std::u16string & countryCode,std::u16string & formatNumber)1286 int32_t CallControlManager::FormatPhoneNumberToE164(
1287 std::u16string &number, std::u16string &countryCode, std::u16string &formatNumber)
1288 {
1289 std::string tmpStr("");
1290 int32_t ret = DelayedSingleton<CallNumberUtils>::GetInstance()->FormatPhoneNumberToE164(
1291 Str16ToStr8(number), Str16ToStr8(countryCode), tmpStr);
1292 formatNumber = Str8ToStr16(tmpStr);
1293 return ret;
1294 }
1295
CloseUnFinishedUssd(int32_t slotId)1296 int32_t CallControlManager::CloseUnFinishedUssd(int32_t slotId)
1297 {
1298 int32_t ret = CallPolicy::CloseUnFinishedUssdPolicy(slotId);
1299 if (ret != TELEPHONY_SUCCESS) {
1300 TELEPHONY_LOGE("CloseUnFinishedUssd failed!");
1301 return ret;
1302 }
1303 if (callSettingManagerPtr_ != nullptr) {
1304 return callSettingManagerPtr_->CloseUnFinishedUssd(slotId);
1305 } else {
1306 TELEPHONY_LOGE("callSettingManagerPtr_ is nullptr!");
1307 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1308 }
1309 }
1310
GetDialParaInfo(DialParaInfo & info)1311 void CallControlManager::GetDialParaInfo(DialParaInfo &info)
1312 {
1313 std::lock_guard<std::mutex> lock(mutex_);
1314 info = dialSrcInfo_;
1315 }
1316
GetDialParaInfo(DialParaInfo & info,AppExecFwk::PacMap & extras)1317 void CallControlManager::GetDialParaInfo(DialParaInfo &info, AppExecFwk::PacMap &extras)
1318 {
1319 std::lock_guard<std::mutex> lock(mutex_);
1320 info = dialSrcInfo_;
1321 extras = extras_;
1322 }
1323
handler()1324 void CallControlManager::handler()
1325 {
1326 alarmSeted = false;
1327 TELEPHONY_LOGE("handle DisconnectAbility");
1328 if (!CallObjectManager::HasCallExist()) {
1329 DelayedSingleton<CallConnectAbility>::GetInstance()->DisconnectAbility();
1330 }
1331 }
1332
cancel(ffrt::task_handle & handle)1333 bool CallControlManager::cancel(ffrt::task_handle &handle)
1334 {
1335 if (handle != nullptr) {
1336 TELEPHONY_LOGI("skip disconnect ability task");
1337 int ret = ffrt::skip(handle);
1338 if (ret != TELEPHONY_SUCCESS) {
1339 TELEPHONY_LOGE("skip task failed, ret = %{public}d", ret);
1340 return false;
1341 }
1342 }
1343 return true;
1344 }
1345
ConnectCallUiService(bool shouldConnect)1346 void CallControlManager::ConnectCallUiService(bool shouldConnect)
1347 {
1348 if (shouldConnect) {
1349 if (alarmSeted) {
1350 if (!cancel(disconnectHandle)) {
1351 return;
1352 }
1353 alarmSeted = false;
1354 }
1355 DelayedSingleton<CallConnectAbility>::GetInstance()->ConnectAbility();
1356 shouldDisconnect = false;
1357 } else {
1358 shouldDisconnect = true;
1359 if (!alarmSeted) {
1360 TELEPHONY_LOGI("submit delay disconnect ability");
1361 disconnectHandle = ffrt::submit_h([&]() {
1362 handler();
1363 }, {}, {}, ffrt::task_attr().delay(DISCONNECT_DELAY_TIME));
1364 alarmSeted = true;
1365 } else {
1366 if (!cancel(disconnectHandle)) {
1367 return;
1368 }
1369 TELEPHONY_LOGI("submit delay disconnect ability");
1370 disconnectHandle = ffrt::submit_h([&]() {
1371 handler();
1372 }, {}, {}, ffrt::task_attr().delay(DISCONNECT_DELAY_TIME));
1373 }
1374 }
1375 }
1376
ShouldDisconnectService()1377 bool CallControlManager::ShouldDisconnectService()
1378 {
1379 return shouldDisconnect;
1380 }
1381
RemoveMissedIncomingCallNotification()1382 int32_t CallControlManager::RemoveMissedIncomingCallNotification()
1383 {
1384 int32_t ret = DelayedSingleton<CallRecordsManager>::GetInstance()->RemoveMissedIncomingCallNotification();
1385 if (ret != TELEPHONY_SUCCESS) {
1386 TELEPHONY_LOGE("RemoveMissedIncomingCallNotification failed!");
1387 return ret;
1388 }
1389 return TELEPHONY_SUCCESS;
1390 }
1391
SetVoIPCallState(int32_t state)1392 int32_t CallControlManager::SetVoIPCallState(int32_t state)
1393 {
1394 TELEPHONY_LOGI("VoIP state is %{public}d", state);
1395 VoIPCallState_ = (CallStateToApp)state;
1396 std::string identity = IPCSkeleton::ResetCallingIdentity();
1397 DelayedSingleton<CallStateReportProxy>::GetInstance()->UpdateCallStateForVoIPOrRestart();
1398 CallVoiceAssistantManager::GetInstance()->UpdateVoipCallState(state);
1399 if (VoIPCallState_ == CallStateToApp::CALL_STATE_IDLE ||
1400 VoIPCallState_ == CallStateToApp::CALL_STATE_UNKNOWN) {
1401 std::lock_guard<std::mutex> lock(voipMutex_);
1402 if (appMgrProxy != nullptr && appStateObserver != nullptr) {
1403 appMgrProxy->UnregisterApplicationStateObserver(appStateObserver);
1404 appMgrProxy = nullptr;
1405 appStateObserver = nullptr;
1406 }
1407 } else {
1408 AppStateObserver();
1409 }
1410 IPCSkeleton::SetCallingIdentity(identity);
1411 if (VoIPCallState_ == CallStateToApp::CALL_STATE_ANSWERED) {
1412 TELEPHONY_LOGI("VoIP answered the call, should hangup all calls");
1413 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
1414 for (auto call : allCallList) {
1415 int32_t ret = HangUpCall(call->GetCallID());
1416 if (ret != TELEPHONY_SUCCESS) {
1417 return ret;
1418 }
1419 }
1420 }
1421 if (VoIPCallState_ == CallStateToApp::CALL_STATE_OFFHOOK) {
1422 HangUpVoipCall();
1423 }
1424 if (VoIPCallState_ == CallStateToApp::CALL_STATE_IDLE) {
1425 TELEPHONY_LOGI("VoIP call state is not active");
1426 if (AnsweredCallQueue_.hasCall) {
1427 AnsweredCallQueue_.hasCall = false;
1428 return AnswerCall(AnsweredCallQueue_.callId, AnsweredCallQueue_.videoState);
1429 }
1430 }
1431 return TELEPHONY_SUCCESS;
1432 }
1433
SetVoIPCallInfo(int32_t callId,int32_t state,std::string phoneNumber)1434 int32_t CallControlManager::SetVoIPCallInfo(int32_t callId, int32_t state, std::string phoneNumber)
1435 {
1436 if (!IsSupportSetVoipInfo()) {
1437 TELEPHONY_LOGE("SetVoIPCallState is not support");
1438 return TELEPHONY_ERROR;
1439 }
1440 if (callId == ILLEGAL_CALLID) {
1441 TELEPHONY_LOGE("The calling is dead and need the call list cleared");
1442 ClearVoipList();
1443 return TELEPHONY_ERROR;
1444 }
1445 int32_t numActive = GetCallNum(TelCallState::CALL_STATUS_ACTIVE, false);
1446 int32_t numHeld = GetCallNum(TelCallState::CALL_STATUS_HOLDING, false);
1447 switch (state) {
1448 case (int32_t)TelCallState::CALL_STATUS_IDLE: {
1449 HandleVoipConnected(numActive, callId);
1450 break;
1451 }
1452 case (int32_t)TelCallState::CALL_STATUS_INCOMING: {
1453 HandleVoipIncoming(numActive, callId, phoneNumber);
1454 break;
1455 }
1456 case (int32_t)TelCallState::CALL_STATUS_DISCONNECTED: {
1457 return HandleVoipDisconnected(numActive, numHeld, callId,
1458 state, phoneNumber);
1459 }
1460 case (int32_t)TelCallState::CALL_STATUS_ALERTING: {
1461 HandleVoipAlerting(callId, phoneNumber);
1462 break;
1463 }
1464 default:
1465 break;
1466 }
1467 SetVoipCallInfoInner(callId, state, phoneNumber);
1468 TELEPHONY_LOGI("SetVoIPCallInfo,numActive:%{public}d,numHeld:%{public}d,callState:%{public}d", numActive, numHeld,
1469 state);
1470 return DelayedSingleton<BluetoothCallManager>::GetInstance()->
1471 SendBtCallState(numActive, numHeld, state, phoneNumber);
1472 }
1473
IsSupportSetVoipInfo()1474 bool CallControlManager::IsSupportSetVoipInfo()
1475 {
1476 std::string readSetVoipCallInfo = system::GetParameter(KEY_CONST_TELEPHONY_READ_SET_VOIP_CALL_INFO, "");
1477 if (readSetVoipCallInfo.compare("false") == 0) {
1478 return false;
1479 }
1480 return true;
1481 }
1482
HandleVoipConnected(int32_t & numActive,int32_t callId)1483 void CallControlManager::HandleVoipConnected(int32_t &numActive, int32_t callId)
1484 {
1485 if (numActive == 0) {
1486 numActive = 1;
1487 }
1488 NotifyVoipCallStateUpdated(GetVoipCallInfo(), TelCallState::CALL_STATUS_INCOMING,
1489 TelCallState::CALL_STATUS_ACTIVE);
1490 UpdateOneVoipCallObjectByCallId(callId, TelCallState::CALL_STATUS_ACTIVE);
1491 }
1492
HandleVoipIncoming(int32_t & numActive,int32_t callId,const std::string phoneNumber)1493 void CallControlManager::HandleVoipIncoming(int32_t &numActive, int32_t callId, const std::string phoneNumber)
1494 {
1495 CallAttributeInfo info;
1496 size_t copiedChars = phoneNumber.copy(info.accountNumber, sizeof(info.accountNumber) - 1);
1497 info.accountNumber[copiedChars] = '\0';
1498 info.callType = CallType::TYPE_VOIP;
1499 info.callId = callId;
1500 if (HasCallExist() || IsVoipCallExist()) {
1501 info.callState = TelCallState::CALL_STATUS_WAITING;
1502 } else {
1503 info.callState = TelCallState::CALL_STATUS_INCOMING;
1504 }
1505 info.callDirection = CallDirection::CALL_DIRECTION_IN;
1506 if (IsVoipCallExist() && (GetVoipCallInfo().callState == TelCallState::CALL_STATUS_ACTIVE)) {
1507 if (numActive == 0) {
1508 numActive = 1;
1509 }
1510 }
1511 NotifyVoipCallStateUpdated(info, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_INCOMING);
1512 AddOneVoipCallObject(info);
1513 bool res = DelayedSingleton<AudioDeviceManager>::GetInstance()->SetVirtualCall(false);
1514 TELEPHONY_LOGI("SetVirtualCall res: %{public}d.", res);
1515 }
1516
HandleVoipDisconnected(int32_t & numActive,int32_t numHeld,int32_t callId,int32_t state,const std::string phoneNumber)1517 int32_t CallControlManager::HandleVoipDisconnected(int32_t &numActive, int32_t numHeld, int32_t callId,
1518 int32_t state, const std::string phoneNumber)
1519 {
1520 CallAttributeInfo info;
1521 size_t copiedChars = phoneNumber.copy(info.accountNumber, sizeof(info.accountNumber) - 1);
1522 info.accountNumber[copiedChars] = '\0';
1523 info.callType = CallType::TYPE_VOIP;
1524 info.callId = callId;
1525 info.callState = (TelCallState)state;
1526 NotifyVoipCallStateUpdated(info, TelCallState::CALL_STATUS_ACTIVE, TelCallState::CALL_STATUS_DISCONNECTED);
1527 DeleteOneVoipCallObject(callId);
1528 DelayedSingleton<BluetoothCallManager>::GetInstance()->
1529 SendBtCallState(numActive, numHeld, state, phoneNumber);
1530 int32_t carrierCallId = ERR_ID;
1531 IsCallExist(TelCallState::CALL_STATUS_WAITING, carrierCallId);
1532 bool res = DelayedSingleton<AudioDeviceManager>::GetInstance()->SetVirtualCall(true);
1533 TELEPHONY_LOGI("SetVirtualCall res: %{public}d.", res);
1534 if (carrierCallId != ERR_ID) {
1535 TELEPHONY_LOGI("SetVoIPCallInfo handle cs call sucessed");
1536 sptr<CallBase> call = GetOneCallObject(carrierCallId);
1537 if (call != nullptr) {
1538 return DelayedSingleton<BluetoothCallManager>::GetInstance()->
1539 SendBtCallState(0, 0, (int32_t)TelCallState::CALL_STATUS_INCOMING, call->GetAccountNumber());
1540 }
1541 }
1542 return DelayedSingleton<BluetoothCallManager>::GetInstance()->
1543 SendBtCallState(numActive, numHeld, (int32_t)TelCallState::CALL_STATUS_IDLE, "");
1544 }
1545
1546
HandleVoipAlerting(int32_t callId,const std::string phoneNumber)1547 void CallControlManager::HandleVoipAlerting(int32_t callId, const std::string phoneNumber)
1548 {
1549 CallAttributeInfo info;
1550 size_t copiedChars = phoneNumber.copy(info.accountNumber, sizeof(info.accountNumber) - 1);
1551 info.accountNumber[copiedChars] = '\0';
1552 info.callType = CallType::TYPE_VOIP;
1553 info.callId = callId;
1554 info.callState = TelCallState::CALL_STATUS_ALERTING;
1555 info.callDirection = CallDirection::CALL_DIRECTION_OUT;
1556 AddOneVoipCallObject(info);
1557 NotifyVoipCallStateUpdated(info, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_DIALING);
1558 bool res = DelayedSingleton<AudioDeviceManager>::GetInstance()->SetVirtualCall(false);
1559 TELEPHONY_LOGI("SetVirtualCall res = %{public}d.", res);
1560 }
1561
GetMeetimeCallState()1562 int32_t CallControlManager::GetMeetimeCallState()
1563 {
1564 return VoipCallInfo_.state;
1565 }
1566
SetVoipCallInfoInner(const int32_t callId,const int32_t state,const std::string phoneNumber)1567 void CallControlManager::SetVoipCallInfoInner(const int32_t callId, const int32_t state,
1568 const std::string phoneNumber)
1569 {
1570 VoipCallInfo_.callId = callId;
1571 VoipCallInfo_.state = state;
1572 VoipCallInfo_.phoneNumber = phoneNumber;
1573 }
1574
GetVoIPCallInfo(int32_t & callId,int32_t & state,std::string & phoneNumber)1575 int32_t CallControlManager::GetVoIPCallInfo(int32_t &callId, int32_t &state, std::string &phoneNumber)
1576 {
1577 if (!IsSupportSetVoipInfo()) {
1578 TELEPHONY_LOGE("GetVoIPCallInfo is not support");
1579 return TELEPHONY_ERROR;
1580 }
1581 callId = VoipCallInfo_.callId;
1582 state = VoipCallInfo_.state;
1583 phoneNumber = VoipCallInfo_.phoneNumber;
1584 return TELEPHONY_SUCCESS;
1585 }
1586
AppStateObserver()1587 void CallControlManager::AppStateObserver()
1588 {
1589 std::lock_guard<std::mutex> lock(voipMutex_);
1590 if (appStateObserver == nullptr) {
1591 appStateObserver = new (std::nothrow) ApplicationStateObserver();
1592 if (appStateObserver == nullptr) {
1593 TELEPHONY_LOGE("Failed to Create AppStateObserver Instance");
1594 return;
1595 }
1596 sptr<ISystemAbilityManager> samgrClient = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1597 if (samgrClient == nullptr) {
1598 TELEPHONY_LOGE("Failed to get samgrClient");
1599 appStateObserver = nullptr;
1600 return;
1601 }
1602 appMgrProxy = iface_cast<AppExecFwk::IAppMgr>(samgrClient->GetSystemAbility(APP_MGR_SERVICE_ID));
1603 if (appMgrProxy == nullptr) {
1604 TELEPHONY_LOGE("Failed to get appMgrProxy");
1605 appStateObserver = nullptr;
1606 samgrClient = nullptr;
1607 return;
1608 }
1609 appMgrProxy->RegisterApplicationStateObserver(appStateObserver);
1610 }
1611 }
1612
HangUpVoipCall()1613 int32_t CallControlManager::HangUpVoipCall()
1614 {
1615 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
1616 for (auto call : allCallList) {
1617 if (call == nullptr || call->GetCallType() != CallType::TYPE_VOIP) {
1618 continue;
1619 }
1620 TelCallState voipCallState = call->GetTelCallState();
1621 if (voipCallState == TelCallState::CALL_STATUS_ACTIVE) {
1622 TELEPHONY_LOGI("the voip call with callId %{public}d is active, no need to hangup", call->GetCallID());
1623 } else if (voipCallState == TelCallState::CALL_STATUS_INCOMING) {
1624 TELEPHONY_LOGI("Reject VoipCall callId %{public}d", call->GetCallID());
1625 int32_t ret = RejectCall(call->GetCallID(), true, u"CarrierAndVoipConflictProcess");
1626 if (ret != TELEPHONY_SUCCESS) {
1627 TELEPHONY_LOGE("reject voip call %{public}d failed!", call->GetCallID());
1628 return ret;
1629 }
1630 } else {
1631 TELEPHONY_LOGI("HangUp VoipCall callId %{public}d", call->GetCallID());
1632 int32_t ret = HangUpCall(call->GetCallID());
1633 if (ret != TELEPHONY_SUCCESS) {
1634 TELEPHONY_LOGE("hangup voip call %{public}d failed!", call->GetCallID());
1635 return ret;
1636 }
1637 }
1638 }
1639 return TELEPHONY_SUCCESS;
1640 }
1641
GetVoIPCallState(int32_t & state)1642 int32_t CallControlManager::GetVoIPCallState(int32_t &state)
1643 {
1644 state = (int32_t)VoIPCallState_;
1645 return TELEPHONY_SUCCESS;
1646 }
1647
CallStateObserve()1648 void CallControlManager::CallStateObserve()
1649 {
1650 if (callStateListenerPtr_ == nullptr) {
1651 TELEPHONY_LOGE("callStateListenerPtr_ is null");
1652 return;
1653 }
1654 std::shared_ptr<RejectCallSms> hangUpSmsPtr = std::make_shared<RejectCallSms>();
1655 callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallAbilityReportProxy>::GetInstance());
1656 callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallStateReportProxy>::GetInstance());
1657 callStateListenerPtr_->AddOneObserver(DelayedSingleton<AudioControlManager>::GetInstance());
1658 callStateListenerPtr_->AddOneObserver(hangUpSmsPtr);
1659 callStateListenerPtr_->AddOneObserver(missedCallNotification_);
1660 callStateListenerPtr_->AddOneObserver(incomingCallWakeup_);
1661 callStateListenerPtr_->AddOneObserver(DelayedSingleton<CallRecordsManager>::GetInstance());
1662 callStateListenerPtr_->AddOneObserver(DelayedSingleton<DistributedCommunicationManager>::GetInstance());
1663 callStateListenerPtr_->AddOneObserver(DelayedSingleton<InteroperableCommunicationManager>::GetInstance());
1664 callStateListenerPtr_->AddOneObserver(CallVoiceAssistantManager::GetInstance());
1665 }
1666
AddCallLogAndNotification(sptr<CallBase> & callObjectPtr)1667 int32_t CallControlManager::AddCallLogAndNotification(sptr<CallBase> &callObjectPtr)
1668 {
1669 if (callObjectPtr == nullptr) {
1670 TELEPHONY_LOGE("callObjectPtr is null");
1671 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1672 }
1673 callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_MISSED);
1674 DelayedSingleton<CallRecordsManager>::GetInstance()
1675 ->CallStateUpdated(callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_DISCONNECTED);
1676 if (missedCallNotification_ == nullptr) {
1677 TELEPHONY_LOGE("missedCallNotification is null");
1678 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1679 }
1680 missedCallNotification_->PublishMissedCallEvent(callObjectPtr);
1681 return TELEPHONY_SUCCESS;
1682 }
1683
AddBlockLogAndNotification(sptr<CallBase> & callObjectPtr)1684 int32_t CallControlManager::AddBlockLogAndNotification(sptr<CallBase> &callObjectPtr)
1685 {
1686 if (callObjectPtr == nullptr) {
1687 TELEPHONY_LOGE("callObjectPtr is null");
1688 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1689 }
1690 callObjectPtr->SetAnswerType(CallAnswerType::CALL_ANSWER_BLOCKED);
1691 DelayedSingleton<CallRecordsManager>::GetInstance()
1692 ->CallStateUpdated(callObjectPtr, TelCallState::CALL_STATUS_INCOMING, TelCallState::CALL_STATUS_DISCONNECTED);
1693 if (missedCallNotification_ == nullptr) {
1694 TELEPHONY_LOGE("missedCallNotification is null");
1695 return TELEPHONY_ERR_LOCAL_PTR_NULL;
1696 }
1697 missedCallNotification_->PublishBlockedCallEvent(callObjectPtr);
1698 return TELEPHONY_SUCCESS;
1699 }
1700
NumberLegalityCheck(std::string & number)1701 int32_t CallControlManager::NumberLegalityCheck(std::string &number)
1702 {
1703 if (number.empty()) {
1704 TELEPHONY_LOGE("phone number is NULL!");
1705 return CALL_ERR_PHONE_NUMBER_EMPTY;
1706 }
1707 if (number.length() > kMaxNumberLen) {
1708 TELEPHONY_LOGE(
1709 "the number length exceeds limit,len:%{public}zu,maxLen:%{public}d", number.length(), kMaxNumberLen);
1710 return CALL_ERR_NUMBER_OUT_OF_RANGE;
1711 }
1712 return TELEPHONY_SUCCESS;
1713 }
1714
AcquireIncomingLock()1715 void CallControlManager::AcquireIncomingLock()
1716 {
1717 if (incomingCallWakeup_ == nullptr) {
1718 return;
1719 }
1720 incomingCallWakeup_->AcquireIncomingLock();
1721 }
1722
ReleaseIncomingLock()1723 void CallControlManager::ReleaseIncomingLock()
1724 {
1725 if (incomingCallWakeup_ == nullptr) {
1726 return;
1727 }
1728 incomingCallWakeup_->ReleaseIncomingLock();
1729 }
1730
AcquireDisconnectedLock()1731 void CallControlManager::AcquireDisconnectedLock()
1732 {
1733 #ifdef ABILITY_POWER_SUPPORT
1734 if (disconnectedRunningLock_ == nullptr) {
1735 disconnectedRunningLock_ = PowerMgr::PowerMgrClient::GetInstance().
1736 CreateRunningLock("disconnectedrunninglock", PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE);
1737 }
1738 if (disconnectedRunningLock_ != nullptr) {
1739 disconnectedRunningLock_->Lock(DISCONNECTED_LOCK_TIMEOUT);
1740 TELEPHONY_LOGI("disconnectedRunningLock_ locked");
1741 }
1742 #endif
1743 }
1744
ReleaseDisconnectedLock()1745 void CallControlManager::ReleaseDisconnectedLock()
1746 {
1747 #ifdef ABILITY_POWER_SUPPORT
1748 if (disconnectedRunningLock_ == nullptr || !disconnectedRunningLock_->IsUsed()) {
1749 return;
1750 }
1751 disconnectedRunningLock_->UnLock();
1752 TELEPHONY_LOGI("disconnectedRunningLock_ unlocked");
1753 #endif
1754 }
1755
DisconnectAllCalls()1756 void CallControlManager::DisconnectAllCalls()
1757 {
1758 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
1759 int32_t ret = -1;
1760 for (auto call : allCallList) {
1761 if (call == nullptr) {
1762 continue;
1763 }
1764 if (call->GetCallType() == CallType::TYPE_BLUETOOTH) {
1765 continue;
1766 }
1767 if (call->GetCallRunningState() == CallRunningState::CALL_RUNNING_STATE_RINGING) {
1768 ret = RejectCall(call->GetCallID(), false, Str8ToStr16(""));
1769 } else {
1770 ret = HangUpCall(call->GetCallID());
1771 }
1772 if (ret == TELEPHONY_SUCCESS) {
1773 TELEPHONY_LOGI("one call is disconnected. call state: %{public}d, callId: %{public}d",
1774 call->GetCallRunningState(), call->GetCallID());
1775 }
1776 }
1777 }
1778
SystemAbilityListener()1779 CallControlManager::SystemAbilityListener::SystemAbilityListener() {}
1780
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1781 void CallControlManager::SystemAbilityListener::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
1782 {
1783 if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1784 TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1785 return;
1786 }
1787 std::string identity = IPCSkeleton::ResetCallingIdentity();
1788 CommonBroadcastSubscriber();
1789 ContactsBroadcastSubscriber();
1790 SatcommBroadcastSubscriber();
1791 SuperPrivacyModeBroadcastSubscriber();
1792 HSDRBroadcastSubscriber();
1793 HfpBroadcastSubscriber();
1794 MuteKeyBroadcastSubscriber();
1795 IPCSkeleton::SetCallingIdentity(identity);
1796 TELEPHONY_LOGI("CallControlManager add BroadcastSubscriber");
1797 }
1798
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)1799 void CallControlManager::SystemAbilityListener::OnRemoveSystemAbility(
1800 int32_t systemAbilityId, const std::string &deviceId)
1801 {
1802 if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
1803 TELEPHONY_LOGE("systemAbilityId is not COMMON_EVENT_SERVICE_ID");
1804 return;
1805 }
1806 std::string identity = IPCSkeleton::ResetCallingIdentity();
1807 for (const auto& subscriberPtr : subscriberPtrList_) {
1808 bool subscribeResult = EventFwk::CommonEventManager::UnSubscribeCommonEvent(subscriberPtr);
1809 TELEPHONY_LOGI("CallControlManager UnSubscribeCommonEvent = %{public}d", subscribeResult);
1810 }
1811 subscriberPtrList_.clear();
1812 IPCSkeleton::SetCallingIdentity(identity);
1813 TELEPHONY_LOGI("CallControlManager remove BroadcastSubscriber");
1814 }
1815
CommonBroadcastSubscriber()1816 void CallControlManager::SystemAbilityListener::CommonBroadcastSubscriber()
1817 {
1818 EventFwk::MatchingSkills matchingSkills;
1819 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SIM_STATE_CHANGED);
1820 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_UNLOCKED);
1821 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_BLUETOOTH_REMOTEDEVICE_NAME_UPDATE);
1822 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
1823 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_SHUTDOWN);
1824 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1825 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1826 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
1827 subscriberPtrList_.emplace_back(subscriberPtr);
1828 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr);
1829 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1830 }
1831
ContactsBroadcastSubscriber()1832 void CallControlManager::SystemAbilityListener::ContactsBroadcastSubscriber()
1833 {
1834 EventFwk::MatchingSkills matchingSkills;
1835 matchingSkills.AddEvent("event.custom.contacts.PAGE_STATE_CHANGE");
1836 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1837 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1838 subscriberInfo.SetPermission("ohos.permission.SET_TELEPHONY_STATE");
1839 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
1840 subscriberPtrList_.emplace_back(subscriberPtr);
1841 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr);
1842 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1843 }
1844
SatcommBroadcastSubscriber()1845 void CallControlManager::SystemAbilityListener::SatcommBroadcastSubscriber()
1846 {
1847 EventFwk::MatchingSkills matchingSkills;
1848 matchingSkills.AddEvent("usual.event.thermal.satcomm.HIGH_TEMP_LEVEL");
1849 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1850 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1851 subscriberInfo.SetPublisherUid(SATCOMM_UID);
1852 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
1853 subscriberPtrList_.emplace_back(subscriberPtr);
1854 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr);
1855 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1856 }
1857
SuperPrivacyModeBroadcastSubscriber()1858 void CallControlManager::SystemAbilityListener::SuperPrivacyModeBroadcastSubscriber()
1859 {
1860 EventFwk::MatchingSkills matchingSkills;
1861 matchingSkills.AddEvent("usual.event.SUPER_PRIVACY_MODE");
1862 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1863 subscriberInfo.SetPublisherBundleName("com.settings");
1864 subscriberInfo.SetPermission("ohos.permission.SET_TELEPHONY_STATE");
1865 subscriberInfo.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1866 std::shared_ptr<CallBroadcastSubscriber> subscriberPtr = std::make_shared<CallBroadcastSubscriber>(subscriberInfo);
1867 subscriberPtrList_.emplace_back(subscriberPtr);
1868 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriberPtr);
1869 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1870 }
1871
HSDRBroadcastSubscriber()1872 void CallControlManager::SystemAbilityListener::HSDRBroadcastSubscriber()
1873 {
1874 EventFwk::MatchingSkills matchingSkillsHsdr;
1875 matchingSkillsHsdr.AddEvent("usual.event.HSDR_EVENT");
1876 EventFwk::CommonEventSubscribeInfo subscriberInfos(matchingSkillsHsdr);
1877 subscriberInfos.SetPublisherBundleName("com.hsdr");
1878 subscriberInfos.SetPermission("ohos.permission.securityguard.REPORT_SECURITY_INFO");
1879 subscriberInfos.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1880 std::shared_ptr<CallBroadcastSubscriber> subscriber = std::make_shared<CallBroadcastSubscriber>(subscriberInfos);
1881 subscriberPtrList_.emplace_back(subscriber);
1882 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber);
1883 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1884 }
1885
HfpBroadcastSubscriber()1886 void CallControlManager::SystemAbilityListener::HfpBroadcastSubscriber()
1887 {
1888 #ifdef HFP_ASYNC_ENABLE
1889 EventFwk::MatchingSkills matchingSkillsHfp;
1890 matchingSkillsHfp.AddEvent("usual.event.bluetooth.CONNECT_HFP_HF");
1891 EventFwk::CommonEventSubscribeInfo subscriberInfos(matchingSkillsHfp);
1892 subscriberInfos.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1893 subscriberInfos.SetPermission("ohos.permission.MANAGE_SETTINGS");
1894 std::shared_ptr<CallBroadcastSubscriber> subscriber = std::make_shared<CallBroadcastSubscriber>(subscriberInfos);
1895 subscriberPtrList_.emplace_back(subscriber);
1896 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber);
1897 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1898 #endif
1899 }
1900
MuteKeyBroadcastSubscriber()1901 void CallControlManager::SystemAbilityListener::MuteKeyBroadcastSubscriber()
1902 {
1903 EventFwk::MatchingSkills matchingSkills;
1904 matchingSkills.AddEvent("multimodal.event.MUTE_KEY_PRESS");
1905 EventFwk::CommonEventSubscribeInfo subscriberInfos(matchingSkills);
1906 subscriberInfos.SetPermission("ohos.permission.SET_TELEPHONY_STATE");
1907 subscriberInfos.SetThreadMode(EventFwk::CommonEventSubscribeInfo::COMMON);
1908 std::shared_ptr<CallBroadcastSubscriber> subscriber = std::make_shared<CallBroadcastSubscriber>(subscriberInfos);
1909 subscriberPtrList_.emplace_back(subscriber);
1910 bool subscribeResult = EventFwk::CommonEventManager::SubscribeCommonEvent(subscriber);
1911 TELEPHONY_LOGI("CallControlManager SubscribeCommonEvent subscribeResult = %{public}d", subscribeResult);
1912 }
1913
SubscriberSaStateChange()1914 int32_t CallControlManager::SubscriberSaStateChange()
1915 {
1916 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1917 if (samgrProxy == nullptr) {
1918 TELEPHONY_LOGE("samgrProxy is nullptr");
1919 return TELEPHONY_ERROR;
1920 }
1921 statusChangeListener_ = new (std::nothrow) SystemAbilityListener();
1922 if (statusChangeListener_ == nullptr) {
1923 TELEPHONY_LOGE("statusChangeListener_ is nullptr");
1924 return TELEPHONY_ERROR;
1925 }
1926 int32_t ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
1927 TELEPHONY_LOGI("CallControlManager::SubscriberSaStateChange ret: %{public}d", ret);
1928 return TELEPHONY_SUCCESS;
1929 }
1930
1931 #ifdef ABILITY_MEDIA_SUPPORT
onButtonDealing(HeadsetButtonService::ButtonEvent type)1932 bool CallControlManager::onButtonDealing(HeadsetButtonService::ButtonEvent type)
1933 {
1934 bool isRingState = false;
1935 sptr<CallBase> call = nullptr;
1936
1937 if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING) != nullptr) {
1938 call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
1939 isRingState = true;
1940 } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING) != nullptr) {
1941 call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_DIALING);
1942 } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE) != nullptr) {
1943 call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_ACTIVE);
1944 } else if (GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD) != nullptr) {
1945 call = GetOneCallObject(CallRunningState::CALL_RUNNING_STATE_HOLD);
1946 } else {
1947 return false;
1948 }
1949
1950 switch (type) {
1951 case HeadsetButtonService::SHORT_PRESS_EVENT:
1952 if (isRingState) {
1953 call->HangUpCall();
1954 } else {
1955 call->AnswerCall(0);
1956 }
1957 break;
1958 case HeadsetButtonService::LONG_PRESS_EVENT:
1959 if (isRingState) {
1960 std::string str = "";
1961 call->RejectCall(false, str);
1962 } else {
1963 DelayedSingleton<AudioControlManager>::GetInstance()->SetMute(true);
1964 }
1965 break;
1966 default:
1967 return false;
1968 }
1969 return true;
1970 }
1971 #endif
1972 #ifdef NOT_SUPPORT_MULTICALL
HangUpFirstCallBtAndESIM(int32_t secondCallId)1973 bool CallControlManager::HangUpFirstCallBtAndESIM(int32_t secondCallId)
1974 {
1975 if (!CallObjectManager::IsTwoCallBtCallAndESIM()) {
1976 return false;
1977 }
1978 HangUpFirstCallBySecondCallID(secondCallId, true);
1979 return true;
1980 }
1981
HangUpFirstCallBtCall(int32_t secondCallId)1982 bool CallControlManager::HangUpFirstCallBtCall(int32_t secondCallId)
1983 {
1984 if (!CallObjectManager::IsTwoCallBtCall()) {
1985 return false;
1986 }
1987 HangUpFirstCallBySecondCallID(secondCallId);
1988 return true;
1989 }
1990
HangUpFirstCallESIMCall(int32_t secondCallId)1991 bool CallControlManager::HangUpFirstCallESIMCall(int32_t secondCallId)
1992 {
1993 if (!CallObjectManager::IsTwoCallESIMCall()) {
1994 return false;
1995 }
1996 HangUpFirstCallBySecondCallID(secondCallId, true);
1997 return true;
1998 }
1999
HangUpFirstCall(int32_t secondCallId)2000 bool CallControlManager::HangUpFirstCall(int32_t secondCallId)
2001 {
2002 if (CallObjectManager::IsTwoCallBtCallAndESIM()) {
2003 return HangUpFirstCallBtAndESIM(secondCallId);
2004 } else if (CallObjectManager::IsTwoCallBtCall()) {
2005 HangUpFirstCallBtCall(secondCallId);
2006 } else if (CallObjectManager::IsTwoCallESIMCall()) {
2007 return HangUpFirstCallESIMCall(secondCallId);
2008 }
2009 return false;
2010 }
2011
HangUpFirstCallBySecondCallID(int32_t secondCallId,bool secondAutoAnswer)2012 void CallControlManager::HangUpFirstCallBySecondCallID(int32_t secondCallId, bool secondAutoAnswer)
2013 {
2014 sptr<CallBase> answerCall = CallObjectManager::GetOneCallObject(secondCallId);
2015 if (answerCall != nullptr &&
2016 (answerCall->GetTelCallState() == TelCallState::CALL_STATUS_INCOMING ||
2017 answerCall->GetTelCallState() == TelCallState::CALL_STATUS_WAITING)) {
2018 TELEPHONY_LOGI("AutoAnswerCall second callid=%{public}d", secondCallId);
2019 answerCall->SetAutoAnswerState(secondAutoAnswer);
2020 }
2021 std::list<sptr<CallBase>> allCallList = CallObjectManager::GetAllCallList();
2022 for (auto call : allCallList) {
2023 if (call->GetCallID() == secondCallId) {
2024 continue;
2025 }
2026 TelCallState telCallState = call->GetTelCallState();
2027 if (telCallState == TelCallState::CALL_STATUS_ACTIVE ||
2028 telCallState == TelCallState::CALL_STATUS_DIALING ||
2029 telCallState == TelCallState::CALL_STATUS_ALERTING) {
2030 TELEPHONY_LOGI("first call HangUpCall callid=%{public}d", call->GetCallID());
2031 int32_t ret = HangUpCall(call->GetCallID());
2032 if (ret != TELEPHONY_SUCCESS) {
2033 TELEPHONY_LOGE("first call HangUpCall fail callid=%{public}d", call->GetCallID());
2034 }
2035 } else if (telCallState == TelCallState::CALL_STATUS_INCOMING ||
2036 telCallState == TelCallState::CALL_STATUS_WAITING) {
2037 TELEPHONY_LOGI("first call RejectCall callid=%{public}d", call->GetCallID());
2038 if (answerCall != nullptr && answerCall->GetAccountNumber() == call->GetAccountNumber()) {
2039 break;
2040 }
2041 int32_t ret = RejectCall(call->GetCallID(), false, Str8ToStr16(""));
2042 if (ret != TELEPHONY_SUCCESS) {
2043 TELEPHONY_LOGE("first call RejectCall fail callid=%{public}d", call->GetCallID());
2044 }
2045 }
2046 break;
2047 }
2048 }
2049 #endif
OnChange()2050 void WearStatusObserver::OnChange()
2051 {
2052 std::string wearStatus = "";
2053 auto settingHelper = SettingsDataShareHelper::GetInstance();
2054 auto callControlMgr = DelayedSingleton<CallControlManager>().GetInstance();
2055 if (settingHelper != nullptr) {
2056 OHOS::Uri settingUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI);
2057 settingHelper->Query(settingUri, "wear_status", wearStatus);
2058 }
2059 TELEPHONY_LOGI("OnChange wear status: %{public}s", wearStatus.c_str());
2060 if (wearStatus == "1") {
2061 callControlMgr->SetWearState(WEAR_STATUS_OFF);
2062 } else if (wearStatus == "2") {
2063 callControlMgr->SetWearState(WEAR_STATUS_ON);
2064 } else {
2065 callControlMgr->SetWearState(WEAR_STATUS_INVALID);
2066 }
2067 }
RegisterObserver()2068 void CallControlManager::RegisterObserver()
2069 {
2070 if (wearStatusObserver_ != nullptr) {
2071 return;
2072 }
2073 wearStatusObserver_ = new (std::nothrow) WearStatusObserver();
2074 if (wearStatusObserver_ == nullptr) {
2075 TELEPHONY_LOGE("wearStatusObserver_ is null");
2076 return;
2077 }
2078
2079 OHOS::Uri wearStatusUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI + "&key=wear_status");
2080 auto helper = DelayedSingleton<SettingsDataShareHelper>().GetInstance();
2081 if (!helper->RegisterToDataShare(wearStatusUri, wearStatusObserver_)) {
2082 TELEPHONY_LOGE("RegisterObserver failed");
2083 }
2084 }
2085
UnRegisterObserver()2086 void CallControlManager::UnRegisterObserver()
2087 {
2088 if (wearStatusObserver_ == nullptr) {
2089 return;
2090 }
2091
2092 OHOS::Uri wearStatusUri(SettingsDataShareHelper::SETTINGS_DATASHARE_URI + "&key=wear_status");
2093 auto helper = DelayedSingleton<SettingsDataShareHelper>().GetInstance();
2094 if (!helper->UnRegisterToDataShare(wearStatusUri, wearStatusObserver_)) {
2095 TELEPHONY_LOGE("RegisterObserver failed");
2096 }
2097 }
2098
SetWearState(int32_t state)2099 void CallControlManager::SetWearState(int32_t state)
2100 {
2101 std::lock_guard<std::mutex> lock(wearStatusMutex_);
2102 wearStatus_ = state;
2103 }
2104
IsNotWearOnWrist()2105 bool CallControlManager::IsNotWearOnWrist()
2106 {
2107 std::lock_guard<std::mutex> lock(wearStatusMutex_);
2108 if (wearStatus_ == WEAR_STATUS_OFF) {
2109 return true;
2110 }
2111 return false;
2112 }
2113
HandleVideoRingPlayFail()2114 void CallControlManager::HandleVideoRingPlayFail()
2115 {
2116 sptr<CallBase> incomingCall =
2117 CallObjectManager::GetOneCarrierCallObject(CallRunningState::CALL_RUNNING_STATE_RINGING);
2118 if (incomingCall == nullptr) {
2119 TELEPHONY_LOGE("incomingCall is nullptr");
2120 return;
2121 }
2122 ContactInfo contactInfo = incomingCall->GetCallerInfo();
2123 if (memset_s(&contactInfo.ringtonePath, FILE_PATH_MAX_LEN, 0, FILE_PATH_MAX_LEN) != EOK) {
2124 TELEPHONY_LOGE("memset_s fail.");
2125 }
2126 incomingCall->SetCallerInfo(contactInfo);
2127 if (CallObjectManager::IsNeedSilentInDoNotDisturbMode()) {
2128 TELEPHONY_LOGI("no need play system ring.");
2129 return;
2130 }
2131 DelayedSingleton<AudioControlManager>::GetInstance()->PlayRingtone();
2132 }
2133
StartFlashRemind()2134 void CallControlManager::StartFlashRemind()
2135 {
2136 std::lock_guard<ffrt::mutex> lock(reminderMutex_);
2137 if (incomingFlashReminder_ == nullptr) {
2138 auto runner = AppExecFwk::EventRunner::Create("handler_incoming_flash_reminder");
2139 incomingFlashReminder_ = std::make_shared<IncomingFlashReminder>(runner,
2140 []() {
2141 TELEPHONY_LOGI("clear flash reminder");
2142 DelayedSingleton<CallControlManager>::GetInstance()->ClearFlashReminder();
2143 }
2144 );
2145 }
2146 if (!incomingFlashReminder_->IsFlashRemindNecessary()) {
2147 incomingFlashReminder_ = nullptr;
2148 return;
2149 }
2150 incomingFlashReminder_->StartFlashRemind();
2151 }
2152
StopFlashRemind()2153 void CallControlManager::StopFlashRemind()
2154 {
2155 std::lock_guard<ffrt::mutex> lock(reminderMutex_);
2156 if (incomingFlashReminder_ == nullptr) {
2157 return;
2158 }
2159 incomingFlashReminder_->StopFlashRemind();
2160 }
2161
ClearFlashReminder()2162 void CallControlManager::ClearFlashReminder()
2163 {
2164 std::lock_guard<ffrt::mutex> lock(reminderMutex_);
2165 incomingFlashReminder_ = nullptr;
2166 }
2167
SetVirtualCall(bool isVirtual)2168 bool CallControlManager::SetVirtualCall(bool isVirtual)
2169 {
2170 TELEPHONY_LOGI("Virtualcall SetVirtualCall: %{public}d.", isVirtual);
2171 return DelayedSingleton<AudioDeviceManager>::GetInstance()->SetVirtualCall(isVirtual);
2172 }
2173 } // namespace Telephony
2174 } // namespace OHOS
2175