1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "bluetooth_call_service.h"
17
18 #include "bluetooth_call_manager.h"
19 #include "call_manager_errors.h"
20 #include "telephony_errors.h"
21 #include "telephony_log_wrapper.h"
22 #include "telephony_permission.h"
23 #include "audio_control_manager.h"
24 #include "ffrt.h"
25 #include "call_superprivacy_control_manager.h"
26
27
28 namespace OHOS {
29 namespace Telephony {
30 const uint64_t DELAY_STOP_PLAY_TIME = 3000000;
BluetoothCallService()31 BluetoothCallService::BluetoothCallService()
32 : callControlManagerPtr_(DelayedSingleton<CallControlManager>::GetInstance()),
33 sendDtmfState_(false), sendDtmfCallId_(ERR_ID)
34 {}
35
~BluetoothCallService()36 BluetoothCallService::~BluetoothCallService()
37 {}
38
AnswerCall()39 int32_t BluetoothCallService::AnswerCall()
40 {
41 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
42 TELEPHONY_LOGE("Permission denied!");
43 return TELEPHONY_ERR_PERMISSION_ERR;
44 }
45 int32_t callId = ERR_ID;
46 int32_t ret = AnswerCallPolicy(callId);
47 if (ret != TELEPHONY_SUCCESS) {
48 TELEPHONY_LOGE("AnswerCallPolicy failed!");
49 if (IsVoipCallExist()) {
50 sendEventToVoip(CallAbilityEventId::EVENT_ANSWER_VOIP_CALL);
51 }
52 return ret;
53 }
54 sptr<CallBase> call = GetOneCallObject(callId);
55 if (call == nullptr) {
56 TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
57 return TELEPHONY_ERR_LOCAL_PTR_NULL;
58 }
59 VideoStateType videoState = call->GetVideoStateType();
60 if (videoState != VideoStateType::TYPE_VOICE && videoState != VideoStateType::TYPE_VIDEO) {
61 TELEPHONY_LOGE("get original call type!");
62 videoState = static_cast<VideoStateType>(call->GetOriginalCallType());
63 }
64 if (callControlManagerPtr_ != nullptr) {
65 if (DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->
66 GetCurrentIsSuperPrivacyMode()) {
67 DelayedSingleton<AudioControlManager>::GetInstance()->PlayWaitingTone();
68 ffrt::submit_h([]() {
69 DelayedSingleton<AudioControlManager>::GetInstance()->StopWaitingTone();
70 }, {}, {}, ffrt::task_attr().delay(DELAY_STOP_PLAY_TIME));
71 }
72 return callControlManagerPtr_->AnswerCall(callId, static_cast<int32_t>(videoState));
73 } else {
74 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
75 return TELEPHONY_ERR_LOCAL_PTR_NULL;
76 }
77 }
78
RejectCall()79 int32_t BluetoothCallService::RejectCall()
80 {
81 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
82 TELEPHONY_LOGE("Permission denied!");
83 return TELEPHONY_ERR_PERMISSION_ERR;
84 }
85 int32_t callId = ERR_ID;
86 bool rejectWithMessage = false;
87 std::u16string textMessage = Str8ToStr16("");
88 int32_t ret = RejectCallPolicy(callId);
89 if (ret != TELEPHONY_SUCCESS) {
90 TELEPHONY_LOGE("RejectCallPolicy failed!");
91 if (IsVoipCallExist()) {
92 sendEventToVoip(CallAbilityEventId::EVENT_REJECT_VOIP_CALL);
93 }
94 return ret;
95 }
96 if (callControlManagerPtr_ != nullptr) {
97 return callControlManagerPtr_->RejectCall(callId, rejectWithMessage, textMessage);
98 } else {
99 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
100 return TELEPHONY_ERR_LOCAL_PTR_NULL;
101 }
102 }
103
HangUpCall()104 int32_t BluetoothCallService::HangUpCall()
105 {
106 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
107 TELEPHONY_LOGE("Permission denied!");
108 return TELEPHONY_ERR_PERMISSION_ERR;
109 }
110 int32_t callId = ERR_ID;
111 int32_t ret = HangUpPolicy(callId);
112 if (ret != TELEPHONY_SUCCESS) {
113 TELEPHONY_LOGE("HangUpPolicy Voip Call!");
114 if (IsVoipCallExist()) {
115 sendEventToVoip(CallAbilityEventId::EVENT_HANGUP_VOIP_CALL);
116 }
117 DeleteOneVoipCallObject(callId);
118 return ret;
119 }
120 if (callId >= VOIP_CALL_MINIMUM && IsVoipCallExist()) {
121 sendEventToVoip(CallAbilityEventId::EVENT_HANGUP_VOIP_CALL);
122 DeleteOneVoipCallObject(callId);
123 return CALL_ERR_ILLEGAL_CALL_OPERATION;
124 }
125 if (callControlManagerPtr_ != nullptr) {
126 return callControlManagerPtr_->HangUpCall(callId);
127 } else {
128 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
129 return TELEPHONY_ERR_LOCAL_PTR_NULL;
130 }
131 }
132
sendEventToVoip(CallAbilityEventId eventId)133 void BluetoothCallService::sendEventToVoip(CallAbilityEventId eventId)
134 {
135 CallEventInfo eventInfo;
136 (void)memset_s(&eventInfo, sizeof(CallEventInfo), 0, sizeof(CallEventInfo));
137 eventInfo.eventId = eventId;
138 DelayedSingleton<CallControlManager>::GetInstance()->NotifyCallEventUpdated(eventInfo);
139 }
140
GetCallState()141 int32_t BluetoothCallService::GetCallState()
142 {
143 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
144 return TELEPHONY_ERR_PERMISSION_ERR;
145 }
146 TELEPHONY_LOGI("Entry BluetoothCallService GetCallState");
147 int32_t numActive = 0;
148 int32_t numHeld = 0;
149 int32_t callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
150 std::string number = "";
151 std::vector<int32_t> carrierCallInfo = getCarrierCallInfoNum(callState, number);
152 if (!carrierCallInfo.empty()) {
153 numActive = carrierCallInfo[0];
154 numHeld = carrierCallInfo[1];
155 }
156 if (IsVoipCallExist() && numActive == 0) {
157 GetVoipCallState(numActive, callState, number);
158 }
159 return DelayedSingleton<BluetoothCallManager>::GetInstance()->
160 SendBtCallState(numActive, numHeld, callState, number);
161 }
162
getCarrierCallInfoNum(int32_t & callState,std::string & number)163 std::vector<int32_t> BluetoothCallService::getCarrierCallInfoNum(int32_t &callState, std::string &number)
164 {
165 int32_t numActive = GetCallNum(TelCallState::CALL_STATUS_ACTIVE, false);
166 int32_t numHeld = GetCallNum(TelCallState::CALL_STATUS_HOLDING, false);
167 int32_t numDial = GetCallNum(TelCallState::CALL_STATUS_DIALING, false);
168 int32_t numAlert = GetCallNum(TelCallState::CALL_STATUS_ALERTING, false);
169 int32_t numIncoming = GetCallNum(TelCallState::CALL_STATUS_INCOMING, false);
170 int32_t numWait = GetCallNum(TelCallState::CALL_STATUS_WAITING, false);
171 int32_t numDisconnected = GetCallNum(TelCallState::CALL_STATUS_DISCONNECTED, false);
172 int32_t numDisconnecting = GetCallNum(TelCallState::CALL_STATUS_DISCONNECTING, false);
173 if (numHeld > 0) {
174 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
175 number = GetCallNumber(TelCallState::CALL_STATUS_HOLDING, false);
176 }
177 if (numActive > 0) {
178 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
179 number = GetCallNumber(TelCallState::CALL_STATUS_ACTIVE, false);
180 }
181 if (numDial > 0) {
182 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_DIALING);
183 number = GetCallNumber(TelCallState::CALL_STATUS_DIALING, false);
184 }
185 if (numAlert > 0) {
186 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING);
187 number = GetCallNumber(TelCallState::CALL_STATUS_ALERTING, false);
188 }
189 if (numIncoming > 0) {
190 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
191 number = GetCallNumber(TelCallState::CALL_STATUS_INCOMING, false);
192 }
193 if (numWait > 0) {
194 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
195 number = GetCallNumber(TelCallState::CALL_STATUS_WAITING, false);
196 }
197 if (numDisconnected > 0) {
198 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
199 number = GetCallNumber(TelCallState::CALL_STATUS_DISCONNECTED, false);
200 }
201 if (numDisconnecting > 0) {
202 callState = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
203 number = GetCallNumber(TelCallState::CALL_STATUS_DISCONNECTING, false);
204 }
205 return {numActive, numHeld};
206 }
207
GetVoipCallState(int32_t & numActive,int32_t & callState,std::string & number)208 void BluetoothCallService::GetVoipCallState(int32_t &numActive, int32_t &callState, std::string &number)
209 {
210 TELEPHONY_LOGI("GetVoipCallState start,callState:%{public}d", callState);
211 CallAttributeInfo callAttributeInfo = GetVoipCallInfo();
212 if (callState == (int32_t)TelCallState::CALL_STATUS_IDLE && number == "") {
213 switch (callAttributeInfo.callState) {
214 case TelCallState::CALL_STATUS_IDLE:
215 numActive = 1;
216 break;
217 case TelCallState::CALL_STATUS_WAITING:
218 callState = (int32_t)TelCallState::CALL_STATUS_INCOMING;
219 break;
220 case TelCallState::CALL_STATUS_INCOMING:
221 callState = (int32_t)TelCallState::CALL_STATUS_INCOMING;
222 break;
223 case TelCallState::CALL_STATUS_ALERTING:
224 callState = (int32_t)TelCallState::CALL_STATUS_ALERTING;
225 break;
226 default:
227 TELEPHONY_LOGI("voip call state need not handle");
228 break;
229 }
230 number = callAttributeInfo.accountNumber;
231 }
232
233 if (numActive == 0 && callAttributeInfo.callState == TelCallState::CALL_STATUS_ACTIVE) {
234 numActive = 1;
235 }
236 TELEPHONY_LOGI("GetVoipCallState finish,callState:%{public}d, numActive:%{public}d", callState, numActive);
237 }
238
HoldCall()239 int32_t BluetoothCallService::HoldCall()
240 {
241 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
242 TELEPHONY_LOGE("Permission denied!");
243 return TELEPHONY_ERR_PERMISSION_ERR;
244 }
245 int32_t callId = ERR_ID;
246 int32_t ret = HoldCallPolicy(callId);
247 if (ret != TELEPHONY_SUCCESS) {
248 TELEPHONY_LOGE("HoldCallPolicy failed!");
249 return ret;
250 }
251 if (callControlManagerPtr_ != nullptr) {
252 return callControlManagerPtr_->HoldCall(callId);
253 } else {
254 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
255 return TELEPHONY_ERR_LOCAL_PTR_NULL;
256 }
257 }
258
UnHoldCall()259 int32_t BluetoothCallService::UnHoldCall()
260 {
261 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
262 TELEPHONY_LOGE("Permission denied!");
263 return TELEPHONY_ERR_PERMISSION_ERR;
264 }
265 int32_t callId = ERR_ID;
266 int32_t ret = UnHoldCallPolicy(callId);
267 if (ret != TELEPHONY_SUCCESS) {
268 TELEPHONY_LOGE("UnHoldCallPolicy failed!");
269 return ret;
270 }
271 if (callControlManagerPtr_ != nullptr) {
272 return callControlManagerPtr_->UnHoldCall(callId);
273 } else {
274 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
275 return TELEPHONY_ERR_LOCAL_PTR_NULL;
276 }
277 }
278
SwitchCall()279 int32_t BluetoothCallService::SwitchCall()
280 {
281 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
282 TELEPHONY_LOGE("Permission denied!");
283 return TELEPHONY_ERR_PERMISSION_ERR;
284 }
285 int32_t callId = ERR_ID;
286 int32_t ret = SwitchCallPolicy(callId);
287 if (ret != TELEPHONY_SUCCESS) {
288 TELEPHONY_LOGE("SwitchCallPolicy failed!");
289 return ret;
290 }
291 if (callControlManagerPtr_ != nullptr) {
292 return callControlManagerPtr_->SwitchCall(callId);
293 } else {
294 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
295 return TELEPHONY_ERR_LOCAL_PTR_NULL;
296 }
297 }
298
StartDtmf(char str)299 int32_t BluetoothCallService::StartDtmf(char str)
300 {
301 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
302 TELEPHONY_LOGE("Permission denied!");
303 return TELEPHONY_ERR_PERMISSION_ERR;
304 }
305 int32_t callId = ERR_ID;
306 int32_t ret = StartDtmfPolicy(callId);
307 if (ret != TELEPHONY_SUCCESS) {
308 TELEPHONY_LOGE("StartDtmfPolicy failed!");
309 return ret;
310 }
311 if (callControlManagerPtr_ != nullptr) {
312 {
313 std::lock_guard<std::mutex> guard(lock_);
314 sendDtmfState_ = true;
315 sendDtmfCallId_ = callId;
316 }
317 return callControlManagerPtr_->StartDtmf(callId, str);
318 } else {
319 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
320 return TELEPHONY_ERR_LOCAL_PTR_NULL;
321 }
322 }
323
StopDtmf()324 int32_t BluetoothCallService::StopDtmf()
325 {
326 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
327 TELEPHONY_LOGE("Permission denied!");
328 return TELEPHONY_ERR_PERMISSION_ERR;
329 }
330 int32_t callId = ERR_ID;
331 if (callControlManagerPtr_ != nullptr) {
332 {
333 std::lock_guard<std::mutex> guard(lock_);
334 callId = sendDtmfCallId_;
335 sendDtmfState_ = false;
336 sendDtmfCallId_ = ERR_ID;
337 }
338 return callControlManagerPtr_->StopDtmf(callId);
339 } else {
340 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
341 return TELEPHONY_ERR_LOCAL_PTR_NULL;
342 }
343 }
344
CombineConference()345 int32_t BluetoothCallService::CombineConference()
346 {
347 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
348 TELEPHONY_LOGE("Permission denied!");
349 return TELEPHONY_ERR_PERMISSION_ERR;
350 }
351 int32_t callId = ERR_ID;
352 int32_t ret = CombineConferencePolicy(callId);
353 if (ret != TELEPHONY_SUCCESS) {
354 TELEPHONY_LOGE("CombineConferencePolicy failed!");
355 return ret;
356 }
357 if (callControlManagerPtr_ != nullptr) {
358 return callControlManagerPtr_->CombineConference(callId);
359 } else {
360 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
361 return TELEPHONY_ERR_LOCAL_PTR_NULL;
362 }
363 }
364
SeparateConference()365 int32_t BluetoothCallService::SeparateConference()
366 {
367 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
368 TELEPHONY_LOGE("Permission denied!");
369 return TELEPHONY_ERR_PERMISSION_ERR;
370 }
371 int32_t callId = ERR_ID;
372 if (callControlManagerPtr_ != nullptr) {
373 return callControlManagerPtr_->SeparateConference(callId);
374 } else {
375 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
376 return TELEPHONY_ERR_LOCAL_PTR_NULL;
377 }
378 }
379
KickOutFromConference()380 int32_t BluetoothCallService::KickOutFromConference()
381 {
382 if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
383 TELEPHONY_LOGE("Permission denied!");
384 return TELEPHONY_ERR_PERMISSION_ERR;
385 }
386 int32_t callId = ERR_ID;
387 if (callControlManagerPtr_ != nullptr) {
388 return callControlManagerPtr_->KickOutFromConference(callId);
389 } else {
390 TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
391 return TELEPHONY_ERR_LOCAL_PTR_NULL;
392 }
393 }
394
GetCurrentCallList(int32_t slotId)395 std::vector<CallAttributeInfo> BluetoothCallService::GetCurrentCallList(int32_t slotId)
396 {
397 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
398 TELEPHONY_LOGE("BluetoothCallService::GetCurrentCallList, Permission denied!");
399 std::vector<CallAttributeInfo> vec;
400 vec.clear();
401 return vec;
402 }
403 if (slotId < 0) {
404 return GetAllCallInfoList();
405 }
406 return GetCallInfoList(slotId);
407 }
408 } // namespace Telephony
409 } // namespace OHOS
410