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 "ims_call.h"
17
18 #include "call_control_manager.h"
19 #include "call_object_manager.h"
20 #include "call_manager_errors.h"
21 #include "telephony_log_wrapper.h"
22 #include "ims_conference.h"
23
24 #include "cellular_call_connection.h"
25
26 namespace OHOS {
27 namespace Telephony {
IMSCall(DialParaInfo & info)28 IMSCall::IMSCall(DialParaInfo &info) : CarrierCall(info), videoCallState_(nullptr), isInitialized_(false) {}
29
IMSCall(DialParaInfo & info,AppExecFwk::PacMap & extras)30 IMSCall::IMSCall(DialParaInfo &info, AppExecFwk::PacMap &extras)
31 : CarrierCall(info, extras), videoCallState_(nullptr), isInitialized_(false)
32 {}
33
~IMSCall()34 IMSCall::~IMSCall() {}
35
InitVideoCall()36 int32_t IMSCall::InitVideoCall()
37 {
38 if (isInitialized_) {
39 TELEPHONY_LOGI("video call initialize ok!");
40 return TELEPHONY_SUCCESS;
41 }
42 sptr<VideoCallState> state = (std::make_unique<AudioOnlyState>(this)).release();
43 if (state == nullptr) {
44 TELEPHONY_LOGE("null pointer");
45 return TELEPHONY_ERR_LOCAL_PTR_NULL;
46 }
47 videoStateMap_[ImsCallMode::CALL_MODE_AUDIO_ONLY] = state;
48 videoCallState_ = state;
49 state = (std::make_unique<VideoSendState>(this)).release();
50 if (state == nullptr) {
51 TELEPHONY_LOGE("null pointer");
52 return TELEPHONY_ERR_LOCAL_PTR_NULL;
53 }
54 videoStateMap_[ImsCallMode::CALL_MODE_SEND_ONLY] = state;
55 state = (std::make_unique<VideoReceiveState>(this)).release();
56 if (state == nullptr) {
57 TELEPHONY_LOGE("null pointer");
58 return TELEPHONY_ERR_LOCAL_PTR_NULL;
59 }
60 videoStateMap_[ImsCallMode::CALL_MODE_RECEIVE_ONLY] = state;
61 state = (std::make_unique<VideoSendReceiveState>(this)).release();
62 if (state == nullptr) {
63 TELEPHONY_LOGE("null pointer");
64 return TELEPHONY_ERR_LOCAL_PTR_NULL;
65 }
66 videoStateMap_[ImsCallMode::CALL_MODE_SEND_RECEIVE] = state;
67 state = (std::make_unique<VideoPauseState>(this)).release();
68 if (state == nullptr) {
69 TELEPHONY_LOGE("null pointer");
70 return TELEPHONY_ERR_LOCAL_PTR_NULL;
71 }
72 videoStateMap_[ImsCallMode::CALL_MODE_VIDEO_PAUSED] = state;
73 isInitialized_ = true;
74 return TELEPHONY_SUCCESS;
75 }
76
DialingProcess()77 int32_t IMSCall::DialingProcess()
78 {
79 return CarrierDialingProcess();
80 }
81
AnswerCall(int32_t videoState)82 int32_t IMSCall::AnswerCall(int32_t videoState)
83 {
84 return CarrierAnswerCall(videoState);
85 }
86
RejectCall()87 int32_t IMSCall::RejectCall()
88 {
89 return CarrierRejectCall();
90 }
91
HangUpCall()92 int32_t IMSCall::HangUpCall()
93 {
94 return CarrierHangUpCall();
95 }
96
HoldCall()97 int32_t IMSCall::HoldCall()
98 {
99 return CarrierHoldCall();
100 }
101
UnHoldCall()102 int32_t IMSCall::UnHoldCall()
103 {
104 return CarrierUnHoldCall();
105 }
106
SwitchCall()107 int32_t IMSCall::SwitchCall()
108 {
109 return CarrierSwitchCall();
110 }
111
StartRtt(std::u16string & msg)112 int32_t IMSCall::StartRtt(std::u16string &msg)
113 {
114 CellularCallInfo callInfo;
115 int32_t ret = PackCellularCallInfo(callInfo);
116 if (ret != TELEPHONY_SUCCESS) {
117 TELEPHONY_LOGW("PackCellularCallInfo failed!");
118 return ret;
119 }
120 ret = DelayedSingleton<CellularCallConnection>::GetInstance()->StartRtt(callInfo, msg);
121 if (ret != TELEPHONY_SUCCESS) {
122 TELEPHONY_LOGE("StartRtt failed!");
123 return CALL_ERR_STARTRTT_FAILED;
124 }
125 return TELEPHONY_SUCCESS;
126 }
127
StopRtt()128 int32_t IMSCall::StopRtt()
129 {
130 CellularCallInfo callInfo;
131 int32_t ret = PackCellularCallInfo(callInfo);
132 if (ret != TELEPHONY_SUCCESS) {
133 TELEPHONY_LOGW("PackCellularCallInfo failed!");
134 return ret;
135 }
136 ret = DelayedSingleton<CellularCallConnection>::GetInstance()->StopRtt(callInfo);
137 if (ret != TELEPHONY_SUCCESS) {
138 TELEPHONY_LOGE("StopRtt failed!");
139 return CALL_ERR_STOPRTT_FAILED;
140 }
141 return TELEPHONY_SUCCESS;
142 }
143
SetMute(int32_t mute,int32_t slotId)144 int32_t IMSCall::SetMute(int32_t mute, int32_t slotId)
145 {
146 return DelayedSingleton<CellularCallConnection>::GetInstance()->SetMute(mute, slotId);
147 }
148
GetCallAttributeInfo(CallAttributeInfo & info)149 void IMSCall::GetCallAttributeInfo(CallAttributeInfo &info)
150 {
151 GetCallAttributeCarrierInfo(info);
152 }
153
CombineConference()154 int32_t IMSCall::CombineConference()
155 {
156 int32_t ret = DelayedSingleton<ImsConference>::GetInstance()->SetMainCall(GetCallID());
157 if (ret != TELEPHONY_SUCCESS) {
158 TELEPHONY_LOGE("SetMainCall failed, error%{public}d", ret);
159 return ret;
160 }
161 return CarrierCombineConference();
162 }
163
SeparateConference()164 int32_t IMSCall::SeparateConference()
165 {
166 return CarrierSeparateConference();
167 }
168
CanCombineConference()169 int32_t IMSCall::CanCombineConference()
170 {
171 int32_t ret = IsSupportConferenceable();
172 if (ret != TELEPHONY_SUCCESS) {
173 TELEPHONY_LOGE("call unsupport conference, error%{public}d", ret);
174 return ret;
175 }
176 return DelayedSingleton<ImsConference>::GetInstance()->CanCombineConference();
177 }
178
CanSeparateConference()179 int32_t IMSCall::CanSeparateConference()
180 {
181 return DelayedSingleton<ImsConference>::GetInstance()->CanSeparateConference();
182 }
183
GetMainCallId()184 int32_t IMSCall::GetMainCallId()
185 {
186 return DelayedSingleton<ImsConference>::GetInstance()->GetMainCall();
187 }
188
LaunchConference()189 int32_t IMSCall::LaunchConference()
190 {
191 int32_t ret = DelayedSingleton<ImsConference>::GetInstance()->JoinToConference(GetCallID());
192 if (ret == TELEPHONY_SUCCESS) {
193 SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_ACTIVE);
194 }
195 return ret;
196 }
197
ExitConference()198 int32_t IMSCall::ExitConference()
199 {
200 return DelayedSingleton<ImsConference>::GetInstance()->LeaveFromConference(GetCallID());
201 }
202
HoldConference()203 int32_t IMSCall::HoldConference()
204 {
205 int32_t ret = DelayedSingleton<ImsConference>::GetInstance()->HoldConference(GetCallID());
206 if (ret == TELEPHONY_SUCCESS) {
207 SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_HOLDING);
208 }
209 return ret;
210 }
211
GetSubCallIdList()212 std::vector<std::u16string> IMSCall::GetSubCallIdList()
213 {
214 return DelayedSingleton<ImsConference>::GetInstance()->GetSubCallIdList(GetCallID());
215 }
216
GetCallIdListForConference()217 std::vector<std::u16string> IMSCall::GetCallIdListForConference()
218 {
219 return DelayedSingleton<ImsConference>::GetInstance()->GetCallIdListForConference(GetCallID());
220 }
221
IsSupportConferenceable()222 int32_t IMSCall::IsSupportConferenceable()
223 {
224 #ifdef ABILIT_CONFIG_SUPPORT
225 bool carrierSupport = GetCarrierConfig(IMS_SUPPORT_CONFERENCE);
226 if (!carrierSupport) {
227 return TELEPHONY_CONFERENCE_CARRIER_NOT_SUPPORT;
228 }
229 if (isVideoCall()) {
230 carrierSupport = GetCarrierConfig(IMS_VIDEO_SUPPORT_CONFERENCE)
231 }
232 if (!carrierSupport) {
233 return TELEPHONY_CONFERENCE_VIDEO_CALL_NOT_SUPPORT;
234 }
235 #endif
236 return CarrierCall::IsSupportConferenceable();
237 }
238
AcceptVideoCall()239 int32_t IMSCall::AcceptVideoCall()
240 {
241 TELEPHONY_LOGI("always accept video call request.");
242 return SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
243 }
244
RefuseVideoCall()245 int32_t IMSCall::RefuseVideoCall()
246 {
247 TELEPHONY_LOGI("always refuse video call request.");
248 return SendUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
249 }
250
SendUpdateCallMediaModeRequest(ImsCallMode mode)251 int32_t IMSCall::SendUpdateCallMediaModeRequest(ImsCallMode mode)
252 {
253 std::lock_guard<std::mutex> lock(videoUpdateMutex_);
254 int32_t ret = InitVideoCall();
255 if (ret != TELEPHONY_SUCCESS) {
256 TELEPHONY_LOGE("video call initialize failed");
257 return ret;
258 }
259 if (GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
260 TELEPHONY_LOGE("call state is not active");
261 return CALL_ERR_CALL_STATE;
262 }
263 if (videoCallState_ == nullptr) {
264 TELEPHONY_LOGE("unexpect null pointer");
265 return TELEPHONY_ERR_LOCAL_PTR_NULL;
266 }
267 return videoCallState_->SendUpdateCallMediaModeRequest(mode);
268 }
269
SendUpdateCallMediaModeResponse(ImsCallMode mode)270 int32_t IMSCall::SendUpdateCallMediaModeResponse(ImsCallMode mode)
271 {
272 std::lock_guard<std::mutex> lock(videoUpdateMutex_);
273 int32_t ret = InitVideoCall();
274 if (ret != TELEPHONY_SUCCESS) {
275 TELEPHONY_LOGE("video call initialize failed");
276 return ret;
277 }
278
279 if (GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
280 TELEPHONY_LOGE("call state is not active");
281 return CALL_ERR_CALL_STATE;
282 }
283 return videoCallState_->SendUpdateCallMediaModeResponse(mode);
284 }
285
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)286 int32_t IMSCall::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
287 {
288 std::lock_guard<std::mutex> lock(videoUpdateMutex_);
289 int32_t ret = InitVideoCall();
290 if (ret != TELEPHONY_SUCCESS) {
291 TELEPHONY_LOGE("video call initialize failed");
292 return ret;
293 }
294 if (GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
295 TELEPHONY_LOGE("call state is not active");
296 return CALL_ERR_CALL_STATE;
297 }
298 return videoCallState_->RecieveUpdateCallMediaModeRequest(mode);
299 }
300
ReceiveUpdateCallMediaModeResponse(CallMediaModeResponse & response)301 int32_t IMSCall::ReceiveUpdateCallMediaModeResponse(CallMediaModeResponse &response)
302 {
303 std::lock_guard<std::mutex> lock(videoUpdateMutex_);
304 int32_t ret = InitVideoCall();
305 if (ret != TELEPHONY_SUCCESS) {
306 TELEPHONY_LOGE("video call initialize failed");
307 return ret;
308 }
309 if (GetTelCallState() != TelCallState::CALL_STATUS_ACTIVE) {
310 TELEPHONY_LOGE("call state is not active");
311 return CALL_ERR_CALL_STATE;
312 }
313 if (response.result == TELEPHONY_SUCCESS) {
314 return videoCallState_->ReceiveUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_SEND_RECEIVE);
315 }
316 return videoCallState_->ReceiveUpdateCallMediaModeResponse(ImsCallMode::CALL_MODE_AUDIO_ONLY);
317 }
318
SwitchVideoState(ImsCallMode mode)319 void IMSCall::SwitchVideoState(ImsCallMode mode)
320 {
321 // save old state.
322 TELEPHONY_LOGI("SwitchVideoState call %{public}d switch to state %{public}d", GetCallID(), mode);
323 if (videoStateMap_.find(mode) != videoStateMap_.end()) {
324 videoCallState_ = videoStateMap_[mode];
325 } else {
326 videoCallState_ = videoStateMap_[ImsCallMode::CALL_MODE_AUDIO_ONLY];
327 }
328 return;
329 }
330
IsSupportVideoCall()331 bool IMSCall::IsSupportVideoCall()
332 {
333 bool isSupportVideoCall = true;
334 #ifdef ABILITY_CONFIG_SUPPORT
335 isSupportVideoCall = GetCarrierConfig(ITEM_VIDEO_CALL);
336 #endif
337 if (GetTelCallState() == TelCallState::CALL_STATUS_INCOMING) {
338 TELEPHONY_LOGW("incoming call not support video upgrade");
339 isSupportVideoCall = false;
340 }
341 if (GetEmergencyState()) {
342 TELEPHONY_LOGW("emergency call not support video upgrade");
343 isSupportVideoCall = false;
344 }
345 return isSupportVideoCall;
346 }
347
DispatchUpdateVideoRequest(ImsCallMode mode)348 int32_t IMSCall::DispatchUpdateVideoRequest(ImsCallMode mode)
349 {
350 CellularCallInfo callInfo;
351 int32_t ret = PackCellularCallInfo(callInfo);
352 if (ret != TELEPHONY_SUCCESS) {
353 TELEPHONY_LOGW("PackCellularCallInfo failed!");
354 return ret;
355 }
356 ret = DelayedSingleton<CellularCallConnection>::GetInstance()->SendUpdateCallMediaModeRequest(callInfo, mode);
357 if (ret != TELEPHONY_SUCCESS) {
358 TELEPHONY_LOGE("send update media failed, errno:%{public}d!", ret);
359 return ret;
360 }
361 return TELEPHONY_SUCCESS;
362 }
363
DispatchUpdateVideoResponse(ImsCallMode mode)364 int32_t IMSCall::DispatchUpdateVideoResponse(ImsCallMode mode)
365 {
366 return TELEPHONY_SUCCESS;
367 }
368
GetCallVideoState(ImsCallMode mode)369 sptr<VideoCallState> IMSCall::GetCallVideoState(ImsCallMode mode)
370 {
371 TELEPHONY_LOGI("get call video state %{public}d", mode);
372 if (videoStateMap_.find(mode) != videoStateMap_.end()) {
373 return videoStateMap_[mode];
374 } else {
375 return nullptr;
376 }
377 }
378 } // namespace Telephony
379 } // namespace OHOS
380