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         return ret;
50     }
51     sptr<CallBase> call = GetOneCallObject(callId);
52     if (call == nullptr) {
53         TELEPHONY_LOGE("the call object is nullptr, callId:%{public}d", callId);
54         return TELEPHONY_ERR_LOCAL_PTR_NULL;
55     }
56     VideoStateType videoState = call->GetVideoStateType();
57     if (videoState != VideoStateType::TYPE_VOICE && videoState != VideoStateType::TYPE_VIDEO) {
58         TELEPHONY_LOGE("get original call type!");
59         videoState = static_cast<VideoStateType>(call->GetOriginalCallType());
60     }
61     if (callControlManagerPtr_ != nullptr) {
62         if (DelayedSingleton<CallSuperPrivacyControlManager>::GetInstance()->
63             GetCurrentIsSuperPrivacyMode()) {
64             DelayedSingleton<AudioControlManager>::GetInstance()->PlayWaitingTone();
65             ffrt::submit_h([]() {
66                 DelayedSingleton<AudioControlManager>::GetInstance()->StopWaitingTone();
67                 }, {}, {}, ffrt::task_attr().delay(DELAY_STOP_PLAY_TIME));
68         }
69         return callControlManagerPtr_->AnswerCall(callId, static_cast<int32_t>(videoState));
70     } else {
71         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
72         return TELEPHONY_ERR_LOCAL_PTR_NULL;
73     }
74 }
75 
RejectCall()76 int32_t BluetoothCallService::RejectCall()
77 {
78     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
79         TELEPHONY_LOGE("Permission denied!");
80         return TELEPHONY_ERR_PERMISSION_ERR;
81     }
82     int32_t callId = ERR_ID;
83     bool rejectWithMessage = false;
84     std::u16string textMessage = Str8ToStr16("");
85     int32_t ret = RejectCallPolicy(callId);
86     if (ret != TELEPHONY_SUCCESS) {
87         TELEPHONY_LOGE("RejectCallPolicy failed!");
88         return ret;
89     }
90     if (callControlManagerPtr_ != nullptr) {
91         return callControlManagerPtr_->RejectCall(callId, rejectWithMessage, textMessage);
92     } else {
93         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
94         return TELEPHONY_ERR_LOCAL_PTR_NULL;
95     }
96 }
97 
HangUpCall()98 int32_t BluetoothCallService::HangUpCall()
99 {
100     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
101         TELEPHONY_LOGE("Permission denied!");
102         return TELEPHONY_ERR_PERMISSION_ERR;
103     }
104     int32_t callId = ERR_ID;
105     int32_t ret = HangUpPolicy(callId);
106     if (ret != TELEPHONY_SUCCESS) {
107         TELEPHONY_LOGE("HangUpPolicy failed!");
108         return ret;
109     }
110     if (callControlManagerPtr_ != nullptr) {
111         return callControlManagerPtr_->HangUpCall(callId);
112     } else {
113         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
114         return TELEPHONY_ERR_LOCAL_PTR_NULL;
115     }
116 }
117 
GetCallState()118 int32_t BluetoothCallService::GetCallState()
119 {
120     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
121         return TELEPHONY_ERR_PERMISSION_ERR;
122     }
123     TELEPHONY_LOGI("Entry BluetoothCallService GetCallState");
124     int32_t numActive = GetCallNum(TelCallState::CALL_STATUS_ACTIVE, false);
125     int32_t numHeld = GetCallNum(TelCallState::CALL_STATUS_HOLDING, false);
126     int32_t numDial = GetCallNum(TelCallState::CALL_STATUS_DIALING, false);
127     int32_t numAlert = GetCallNum(TelCallState::CALL_STATUS_ALERTING, false);
128     int32_t numIncoming = GetCallNum(TelCallState::CALL_STATUS_INCOMING, false);
129     int32_t numWait = GetCallNum(TelCallState::CALL_STATUS_WAITING, false);
130     int32_t numDisconnected = GetCallNum(TelCallState::CALL_STATUS_DISCONNECTED, false);
131     int32_t numDisconnecting = GetCallNum(TelCallState::CALL_STATUS_DISCONNECTING, false);
132     int32_t callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
133     std::string number = "";
134     if (numHeld > 0) {
135         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
136         number = GetCallNumber(TelCallState::CALL_STATUS_HOLDING, false);
137     }
138     if (numActive > 0) {
139         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
140         number = GetCallNumber(TelCallState::CALL_STATUS_ACTIVE, false);
141     }
142     if (numDial > 0) {
143         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_DIALING);
144         number = GetCallNumber(TelCallState::CALL_STATUS_DIALING, false);
145     }
146     if (numAlert > 0) {
147         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_ALERTING);
148         number = GetCallNumber(TelCallState::CALL_STATUS_ALERTING, false);
149     }
150     if (numIncoming > 0) {
151         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
152         number = GetCallNumber(TelCallState::CALL_STATUS_INCOMING, false);
153     }
154     if (numWait > 0) {
155         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_INCOMING);
156         number = GetCallNumber(TelCallState::CALL_STATUS_WAITING, false);
157     }
158     if (numDisconnected > 0) {
159         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_IDLE);
160         number = GetCallNumber(TelCallState::CALL_STATUS_DISCONNECTED, false);
161     }
162     if (numDisconnecting > 0) {
163         callState = static_cast<int32_t>(TelCallState::CALL_STATUS_DISCONNECTED);
164         number = GetCallNumber(TelCallState::CALL_STATUS_DISCONNECTING, false);
165     }
166     return DelayedSingleton<BluetoothCallManager>::GetInstance()->
167         SendBtCallState(numActive, numHeld, callState, number);
168 }
169 
HoldCall()170 int32_t BluetoothCallService::HoldCall()
171 {
172     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
173         TELEPHONY_LOGE("Permission denied!");
174         return TELEPHONY_ERR_PERMISSION_ERR;
175     }
176     int32_t callId = ERR_ID;
177     int32_t ret = HoldCallPolicy(callId);
178     if (ret != TELEPHONY_SUCCESS) {
179         TELEPHONY_LOGE("HoldCallPolicy failed!");
180         return ret;
181     }
182     if (callControlManagerPtr_ != nullptr) {
183         return callControlManagerPtr_->HoldCall(callId);
184     } else {
185         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
186         return TELEPHONY_ERR_LOCAL_PTR_NULL;
187     }
188 }
189 
UnHoldCall()190 int32_t BluetoothCallService::UnHoldCall()
191 {
192     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
193         TELEPHONY_LOGE("Permission denied!");
194         return TELEPHONY_ERR_PERMISSION_ERR;
195     }
196     int32_t callId = ERR_ID;
197     int32_t ret = UnHoldCallPolicy(callId);
198     if (ret != TELEPHONY_SUCCESS) {
199         TELEPHONY_LOGE("UnHoldCallPolicy failed!");
200         return ret;
201     }
202     if (callControlManagerPtr_ != nullptr) {
203         return callControlManagerPtr_->UnHoldCall(callId);
204     } else {
205         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
206         return TELEPHONY_ERR_LOCAL_PTR_NULL;
207     }
208 }
209 
SwitchCall()210 int32_t BluetoothCallService::SwitchCall()
211 {
212     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
213         TELEPHONY_LOGE("Permission denied!");
214         return TELEPHONY_ERR_PERMISSION_ERR;
215     }
216     int32_t callId = ERR_ID;
217     int32_t ret = SwitchCallPolicy(callId);
218     if (ret != TELEPHONY_SUCCESS) {
219         TELEPHONY_LOGE("SwitchCallPolicy failed!");
220         return ret;
221     }
222     if (callControlManagerPtr_ != nullptr) {
223         return callControlManagerPtr_->SwitchCall(callId);
224     } else {
225         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
226         return TELEPHONY_ERR_LOCAL_PTR_NULL;
227     }
228 }
229 
StartDtmf(char str)230 int32_t BluetoothCallService::StartDtmf(char str)
231 {
232     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
233         TELEPHONY_LOGE("Permission denied!");
234         return TELEPHONY_ERR_PERMISSION_ERR;
235     }
236     int32_t callId = ERR_ID;
237     int32_t ret = StartDtmfPolicy(callId);
238     if (ret != TELEPHONY_SUCCESS) {
239         TELEPHONY_LOGE("StartDtmfPolicy failed!");
240         return ret;
241     }
242     if (callControlManagerPtr_ != nullptr) {
243         {
244             std::lock_guard<std::mutex> guard(lock_);
245             sendDtmfState_ = true;
246             sendDtmfCallId_ = callId;
247         }
248         return callControlManagerPtr_->StartDtmf(callId, str);
249     } else {
250         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
251         return TELEPHONY_ERR_LOCAL_PTR_NULL;
252     }
253 }
254 
StopDtmf()255 int32_t BluetoothCallService::StopDtmf()
256 {
257     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
258         TELEPHONY_LOGE("Permission denied!");
259         return TELEPHONY_ERR_PERMISSION_ERR;
260     }
261     int32_t callId = ERR_ID;
262     if (callControlManagerPtr_ != nullptr) {
263         {
264             std::lock_guard<std::mutex> guard(lock_);
265             callId = sendDtmfCallId_;
266             sendDtmfState_ = false;
267             sendDtmfCallId_ = ERR_ID;
268         }
269         return callControlManagerPtr_->StopDtmf(callId);
270     } else {
271         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
272         return TELEPHONY_ERR_LOCAL_PTR_NULL;
273     }
274 }
275 
CombineConference()276 int32_t BluetoothCallService::CombineConference()
277 {
278     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
279         TELEPHONY_LOGE("Permission denied!");
280         return TELEPHONY_ERR_PERMISSION_ERR;
281     }
282     int32_t callId = ERR_ID;
283     int32_t ret = CombineConferencePolicy(callId);
284     if (ret != TELEPHONY_SUCCESS) {
285         TELEPHONY_LOGE("CombineConferencePolicy failed!");
286         return ret;
287     }
288     if (callControlManagerPtr_ != nullptr) {
289         return callControlManagerPtr_->CombineConference(callId);
290     } else {
291         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
292         return TELEPHONY_ERR_LOCAL_PTR_NULL;
293     }
294 }
295 
SeparateConference()296 int32_t BluetoothCallService::SeparateConference()
297 {
298     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
299         TELEPHONY_LOGE("Permission denied!");
300         return TELEPHONY_ERR_PERMISSION_ERR;
301     }
302     int32_t callId = ERR_ID;
303     if (callControlManagerPtr_ != nullptr) {
304         return callControlManagerPtr_->SeparateConference(callId);
305     } else {
306         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
307         return TELEPHONY_ERR_LOCAL_PTR_NULL;
308     }
309 }
310 
KickOutFromConference()311 int32_t BluetoothCallService::KickOutFromConference()
312 {
313     if (!TelephonyPermission::CheckPermission(Permission::ANSWER_CALL)) {
314         TELEPHONY_LOGE("Permission denied!");
315         return TELEPHONY_ERR_PERMISSION_ERR;
316     }
317     int32_t callId = ERR_ID;
318     if (callControlManagerPtr_ != nullptr) {
319         return callControlManagerPtr_->KickOutFromConference(callId);
320     } else {
321         TELEPHONY_LOGE("callControlManagerPtr_ is nullptr!");
322         return TELEPHONY_ERR_LOCAL_PTR_NULL;
323     }
324 }
325 
GetCurrentCallList(int32_t slotId)326 std::vector<CallAttributeInfo> BluetoothCallService::GetCurrentCallList(int32_t slotId)
327 {
328     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
329         TELEPHONY_LOGE("BluetoothCallService::GetCurrentCallList, Permission denied!");
330         std::vector<CallAttributeInfo> vec;
331         vec.clear();
332         return vec;
333     }
334     if (slotId < 0) {
335         return GetAllCallInfoList();
336     }
337     return GetCallInfoList(slotId);
338 }
339 } // namespace Telephony
340 } // namespace OHOS
341