1/*
2 * Copyright (C) 2023 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 "voip_call.h"
17
18#include "call_control_manager.h"
19#include "call_manager_errors.h"
20#include "call_object_manager.h"
21#include "telephony_log_wrapper.h"
22#include "voip_call_connection.h"
23
24namespace OHOS {
25namespace Telephony {
26VoIPCall::VoIPCall(DialParaInfo &info) : CarrierCall(info)
27{
28    callId_ = info.callId;
29    voipCallId_ = info.voipCallInfo.voipCallId;
30    userName_ = info.voipCallInfo.userName;
31    userProfile_.assign((info.voipCallInfo.userProfile).begin(), (info.voipCallInfo.userProfile).end());
32    abilityName_ = info.voipCallInfo.abilityName;
33    extensionId_ = info.voipCallInfo.extensionId;
34    voipBundleName_ = info.voipCallInfo.voipBundleName;
35    showBannerForIncomingCall_ = info.voipCallInfo.showBannerForIncomingCall;
36    isConferenceCall_ = info.voipCallInfo.isConferenceCall;
37    isVoiceAnswerSupported_ = info.voipCallInfo.isVoiceAnswerSupported;
38    hasMicPermission_ = info.voipCallInfo.hasMicPermission;
39    uid_ = info.voipCallInfo.uid;
40}
41
42VoIPCall::~VoIPCall() {}
43
44int32_t VoIPCall::DialingProcess()
45{
46    return TELEPHONY_SUCCESS;
47}
48
49int32_t VoIPCall::AnswerCall(int32_t videoState)
50{
51    TELEPHONY_LOGI("VoIPCall::AnswerCall");
52    VoipCallEventInfo voipcallInfo;
53    int32_t ret = TELEPHONY_ERROR;
54    ret = PackVoipCallInfo(voipcallInfo);
55    if (ret != TELEPHONY_SUCCESS) {
56        TELEPHONY_LOGW("PackVoipCallInfo failed!");
57    }
58    DelayedSingleton<VoipCallConnection>::GetInstance()->AnswerCall(voipcallInfo, videoState);
59    if (ret != TELEPHONY_SUCCESS) {
60        TELEPHONY_LOGE("answer call failed!");
61        return CALL_ERR_ANSWER_FAILED;
62    }
63    return TELEPHONY_SUCCESS;
64}
65
66int32_t VoIPCall::PackVoipCallInfo(VoipCallEventInfo &voipcallInfo)
67{
68    voipcallInfo.voipCallId = voipCallId_;
69    voipcallInfo.bundleName = voipBundleName_;
70    voipcallInfo.uid = uid_;
71    return TELEPHONY_SUCCESS;
72}
73
74int32_t VoIPCall::RejectCall()
75{
76    TELEPHONY_LOGI("VoIPCall::RejectCall enter");
77    VoipCallEventInfo voipcallInfo;
78    int32_t ret = TELEPHONY_ERROR;
79    ret = PackVoipCallInfo(voipcallInfo);
80    if (ret != TELEPHONY_SUCCESS) {
81        TELEPHONY_LOGW("PackVoipCallInfo failed!");
82    }
83    DelayedSingleton<VoipCallConnection>::GetInstance()->RejectCall(voipcallInfo);
84    if (ret != TELEPHONY_SUCCESS) {
85        TELEPHONY_LOGE("reject call failed!");
86        return CALL_ERR_ANSWER_FAILED;
87    }
88    return TELEPHONY_SUCCESS;
89}
90
91int32_t VoIPCall::HangUpCall()
92{
93    TELEPHONY_LOGI("VoIPCall::HangUpCall enter");
94    VoipCallEventInfo voipcallInfo;
95    int32_t ret = TELEPHONY_ERROR;
96    ret = PackVoipCallInfo(voipcallInfo);
97    if (ret != TELEPHONY_SUCCESS) {
98        TELEPHONY_LOGW("PackVoipCallInfo failed!");
99    }
100    voipcallInfo.errorReason = ErrorReason::USER_ANSWER_CELLULAR_FIRST;
101    DelayedSingleton<VoipCallConnection>::GetInstance()->HangUpCall(voipcallInfo);
102    if (ret != TELEPHONY_SUCCESS) {
103        TELEPHONY_LOGE("hangup call failed!");
104        return CALL_ERR_ANSWER_FAILED;
105    }
106    return TELEPHONY_SUCCESS;
107}
108
109int32_t VoIPCall::HangUpCall(const ErrorReason &status)
110{
111    TELEPHONY_LOGI("VoIPCall::dial cellularcall HangUpvoipCall enter");
112    VoipCallEventInfo voipcallInfo;
113    int32_t ret = TELEPHONY_ERROR;
114    ret = PackVoipCallInfo(voipcallInfo);
115    if (ret != TELEPHONY_SUCCESS) {
116        TELEPHONY_LOGW("PackVoipCallInfo failed!");
117    }
118    voipcallInfo.errorReason = status;
119    DelayedSingleton<VoipCallConnection>::GetInstance()->HangUpCall(voipcallInfo);
120    if (ret != TELEPHONY_SUCCESS) {
121        TELEPHONY_LOGE("hangup call failed!");
122        return CALL_ERR_ANSWER_FAILED;
123    }
124    return TELEPHONY_SUCCESS;
125}
126
127int32_t VoIPCall::HoldCall()
128{
129    return TELEPHONY_SUCCESS;
130}
131
132int32_t VoIPCall::UnHoldCall()
133{
134    return TELEPHONY_SUCCESS;
135}
136
137int32_t VoIPCall::SwitchCall()
138{
139    return TELEPHONY_SUCCESS;
140}
141
142int32_t VoIPCall::SetMute(int32_t mute, int32_t slotId)
143{
144    CallAttributeInfo info;
145    GetCallAttributeInfo(info);
146    std::string voipCallId = info.voipCallInfo.voipBundleName + ":" + std::to_string(info.voipCallInfo.uid) + ":" +
147        info.voipCallInfo.voipCallId;
148    CallAudioEvent callAudioEvent = mute == 1 ? CallAudioEvent::AUDIO_EVENT_MUTED : CallAudioEvent::AUDIO_EVENT_UNMUTED;
149    TELEPHONY_LOGI("VoIPCall::setMute voipCallId: %{public}s, callAudioEvent: %{public}d", voipCallId.c_str(),
150        callAudioEvent);
151    DelayedSingleton<VoipCallConnection>::GetInstance()->SendCallUiEvent(voipCallId, callAudioEvent);
152    return TELEPHONY_SUCCESS;
153}
154
155void VoIPCall::GetCallAttributeInfo(CallAttributeInfo &info)
156{
157    GetCallAttributeCarrierInfo(info);
158    info.callId = callId_;
159    info.voipCallInfo.voipCallId = voipCallId_;
160    info.voipCallInfo.userName = userName_;
161    (info.voipCallInfo.userProfile).assign(userProfile_.begin(), userProfile_.end());
162    info.voipCallInfo.extensionId = extensionId_;
163    info.voipCallInfo.abilityName = abilityName_;
164    info.voipCallInfo.voipBundleName = voipBundleName_;
165    info.voipCallInfo.showBannerForIncomingCall = showBannerForIncomingCall_;
166    info.voipCallInfo.isConferenceCall = isConferenceCall_;
167    info.voipCallInfo.isVoiceAnswerSupported = isVoiceAnswerSupported_;
168    info.voipCallInfo.hasMicPermission = hasMicPermission_;
169    info.voipCallInfo.uid = uid_;
170    return;
171}
172
173int32_t VoIPCall::CombineConference()
174{
175    return TELEPHONY_SUCCESS;
176}
177
178void VoIPCall::HandleCombineConferenceFailEvent()
179{
180    return;
181}
182
183int32_t VoIPCall::SeparateConference()
184{
185    return TELEPHONY_SUCCESS;
186}
187
188int32_t VoIPCall::KickOutFromConference()
189{
190    return TELEPHONY_SUCCESS;
191}
192
193int32_t VoIPCall::CanCombineConference()
194{
195    return TELEPHONY_SUCCESS;
196}
197
198int32_t VoIPCall::CanSeparateConference()
199{
200    return TELEPHONY_SUCCESS;
201}
202
203int32_t VoIPCall::CanKickOutFromConference()
204{
205    return TELEPHONY_SUCCESS;
206}
207
208int32_t VoIPCall::GetMainCallId(int32_t &mainCallId)
209{
210    return TELEPHONY_SUCCESS;
211}
212
213int32_t VoIPCall::GetSubCallIdList(std::vector<std::u16string> &callIdList)
214{
215    return TELEPHONY_SUCCESS;
216}
217
218int32_t VoIPCall::GetCallIdListForConference(std::vector<std::u16string> &callIdList)
219{
220    return TELEPHONY_SUCCESS;
221}
222
223int32_t VoIPCall::IsSupportConferenceable()
224{
225    return TELEPHONY_SUCCESS;
226}
227
228int32_t VoIPCall::LaunchConference()
229{
230    return TELEPHONY_SUCCESS;
231}
232
233int32_t VoIPCall::ExitConference()
234{
235    return TELEPHONY_SUCCESS;
236}
237
238int32_t VoIPCall::HoldConference()
239{
240    return TELEPHONY_SUCCESS;
241}
242
243std::string VoIPCall::GetVoipCallId()
244{
245    return voipCallId_;
246}
247
248std::string VoIPCall::GetVoipBundleName()
249{
250    return voipBundleName_;
251}
252
253int32_t VoIPCall::GetVoipUid()
254{
255    return uid_;
256}
257} // namespace Telephony
258} // namespace OHOS
259