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
28namespace OHOS {
29namespace Telephony {
30const uint64_t DELAY_STOP_PLAY_TIME = 3000000;
31BluetoothCallService::BluetoothCallService()
32    : callControlManagerPtr_(DelayedSingleton<CallControlManager>::GetInstance()),
33    sendDtmfState_(false), sendDtmfCallId_(ERR_ID)
34{}
35
36BluetoothCallService::~BluetoothCallService()
37{}
38
39int32_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
76int32_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
98int32_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
118int32_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
170int32_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
190int32_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
210int32_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
230int32_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
255int32_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
276int32_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
296int32_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
311int32_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
326std::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