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