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 "ott_call.h"
17
18 #include "call_manager_errors.h"
19 #include "call_manager_hisysevent.h"
20 #include "telephony_log_wrapper.h"
21
22 #include "ott_call_connection.h"
23 #include "ott_conference.h"
24
25 namespace OHOS {
26 namespace Telephony {
OTTCall(DialParaInfo & info)27 OTTCall::OTTCall(DialParaInfo &info) : CallBase(info), ottCallConnectionPtr_(std::make_unique<OTTCallConnection>())
28 {}
29
OTTCall(DialParaInfo & info,AppExecFwk::PacMap & extras)30 OTTCall::OTTCall(DialParaInfo &info, AppExecFwk::PacMap &extras)
31 : CallBase(info, extras), ottCallConnectionPtr_(std::make_unique<OTTCallConnection>())
32 {}
33
~OTTCall()34 OTTCall::~OTTCall() {}
35
DialingProcess()36 int32_t OTTCall::DialingProcess()
37 {
38 int32_t ret = DialCallBase();
39 if (ret != TELEPHONY_SUCCESS) {
40 HangUpCall();
41 }
42 return ret;
43 }
44
AnswerCall(int32_t videoState)45 int32_t OTTCall::AnswerCall(int32_t videoState)
46 {
47 int32_t ret = AnswerCallBase();
48 if (ret != TELEPHONY_SUCCESS) {
49 TELEPHONY_LOGE("answer call failed!");
50 CallManagerHisysevent::WriteAnswerCallFaultEvent(
51 INVALID_PARAMETER, INVALID_PARAMETER, videoState, ret, "the device is currently not ringing");
52 return CALL_ERR_ANSWER_FAILED;
53 }
54 OttCallRequestInfo requestInfo;
55 ret = PackOttCallRequestInfo(requestInfo);
56 if (ret != TELEPHONY_SUCCESS) {
57 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
58 CallManagerHisysevent::WriteAnswerCallFaultEvent(
59 INVALID_PARAMETER, INVALID_PARAMETER, videoState, ret, "PackOttCallRequestInfo failed");
60 return CALL_ERR_ANSWER_FAILED;
61 }
62 if (ottCallConnectionPtr_ == nullptr) {
63 TELEPHONY_LOGE("ottCallConnectionPtr_ is nullptr!");
64 return TELEPHONY_ERR_LOCAL_PTR_NULL;
65 }
66 ret = ottCallConnectionPtr_->Answer(requestInfo);
67 if (ret != TELEPHONY_SUCCESS) {
68 TELEPHONY_LOGE("answer call failed!");
69 return CALL_ERR_ANSWER_FAILED;
70 }
71 return TELEPHONY_SUCCESS;
72 }
73
RejectCall()74 int32_t OTTCall::RejectCall()
75 {
76 int32_t ret = RejectCallBase();
77 if (ret != TELEPHONY_SUCCESS) {
78 return ret;
79 }
80 OttCallRequestInfo requestInfo;
81 ret = PackOttCallRequestInfo(requestInfo);
82 if (ret != TELEPHONY_SUCCESS) {
83 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
84 CallManagerHisysevent::WriteHangUpFaultEvent(
85 INVALID_PARAMETER, INVALID_PARAMETER, ret, "Reject PackOttCallRequestInfo failed");
86 return CALL_ERR_REJECT_FAILED;
87 }
88 ret = ottCallConnectionPtr_->Reject(requestInfo);
89 if (ret != TELEPHONY_SUCCESS) {
90 TELEPHONY_LOGE("reject call failed!");
91 return CALL_ERR_REJECT_FAILED;
92 }
93 return TELEPHONY_SUCCESS;
94 }
95
HangUpCall()96 int32_t OTTCall::HangUpCall()
97 {
98 OttCallRequestInfo requestInfo;
99 int32_t ret = PackOttCallRequestInfo(requestInfo);
100 if (ret != TELEPHONY_SUCCESS) {
101 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
102 CallManagerHisysevent::WriteHangUpFaultEvent(
103 INVALID_PARAMETER, INVALID_PARAMETER, ret, "HangUp PackOttCallRequestInfo failed");
104 return CALL_ERR_HANGUP_FAILED;
105 }
106 ret = ottCallConnectionPtr_->HangUp(requestInfo);
107 if (ret != TELEPHONY_SUCCESS) {
108 TELEPHONY_LOGE("hangUp call failed!");
109 return CALL_ERR_HANGUP_FAILED;
110 }
111 return TELEPHONY_SUCCESS;
112 }
113
HoldCall()114 int32_t OTTCall::HoldCall()
115 {
116 OttCallRequestInfo requestInfo;
117 int32_t ret = PackOttCallRequestInfo(requestInfo);
118 if (ret != TELEPHONY_SUCCESS) {
119 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
120 return CALL_ERR_HOLD_FAILED;
121 }
122 ret = ottCallConnectionPtr_->HoldCall(requestInfo);
123 if (ret != TELEPHONY_SUCCESS) {
124 TELEPHONY_LOGE("holdCall call failed!");
125 return CALL_ERR_HOLD_FAILED;
126 }
127 return TELEPHONY_SUCCESS;
128 }
129
UnHoldCall()130 int32_t OTTCall::UnHoldCall()
131 {
132 OttCallRequestInfo requestInfo;
133 int32_t ret = PackOttCallRequestInfo(requestInfo);
134 if (ret != TELEPHONY_SUCCESS) {
135 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
136 return CALL_ERR_UNHOLD_FAILED;
137 }
138 ret = ottCallConnectionPtr_->UnHoldCall(requestInfo);
139 if (ret != TELEPHONY_SUCCESS) {
140 TELEPHONY_LOGE("unHoldCall call failed!");
141 return CALL_ERR_UNHOLD_FAILED;
142 }
143 return TELEPHONY_SUCCESS;
144 }
145
SwitchCall()146 int32_t OTTCall::SwitchCall()
147 {
148 OttCallRequestInfo requestInfo;
149 int32_t ret = PackOttCallRequestInfo(requestInfo);
150 if (ret != TELEPHONY_SUCCESS) {
151 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
152 return CALL_ERR_UNHOLD_FAILED;
153 }
154 ret = ottCallConnectionPtr_->SwitchCall(requestInfo);
155 if (ret != TELEPHONY_SUCCESS) {
156 TELEPHONY_LOGE("switchCall call failed!");
157 return CALL_ERR_UNHOLD_FAILED;
158 }
159 return TELEPHONY_SUCCESS;
160 }
161
GetCallAttributeInfo(CallAttributeInfo & info)162 void OTTCall::GetCallAttributeInfo(CallAttributeInfo &info)
163 {
164 GetCallAttributeBaseInfo(info);
165 }
166
GetEmergencyState()167 bool OTTCall::GetEmergencyState()
168 {
169 return false;
170 }
171
StartDtmf(char str)172 int32_t OTTCall::StartDtmf(char str)
173 {
174 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
175 }
176
StopDtmf()177 int32_t OTTCall::StopDtmf()
178 {
179 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
180 }
181
GetSlotId()182 int32_t OTTCall::GetSlotId()
183 {
184 return CALL_ERR_ILLEGAL_CALL_OPERATION;
185 }
186
CombineConference()187 int32_t OTTCall::CombineConference()
188 {
189 int32_t ret = DelayedSingleton<OttConference>::GetInstance()->SetMainCall(GetCallID());
190 if (ret != TELEPHONY_SUCCESS) {
191 TELEPHONY_LOGE("SetMainCall failed, error%{public}d", ret);
192 return ret;
193 }
194 OttCallRequestInfo requestInfo;
195 ret = PackOttCallRequestInfo(requestInfo);
196 if (ret != TELEPHONY_SUCCESS) {
197 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
198 return ret;
199 }
200 if (ottCallConnectionPtr_ == nullptr) {
201 TELEPHONY_LOGE("ottCallConnectionPtr_ is nullptr!");
202 return TELEPHONY_ERR_LOCAL_PTR_NULL;
203 }
204 return ottCallConnectionPtr_->CombineConference(requestInfo);
205 }
206
CanCombineConference()207 int32_t OTTCall::CanCombineConference()
208 {
209 int32_t ret = IsSupportConferenceable();
210 if (ret != TELEPHONY_SUCCESS) {
211 TELEPHONY_LOGE("call unsupported conference, error%{public}d", ret);
212 return ret;
213 }
214 return DelayedSingleton<OttConference>::GetInstance()->CanCombineConference();
215 }
216
SeparateConference()217 int32_t OTTCall::SeparateConference()
218 {
219 OttCallRequestInfo requestInfo;
220 int32_t ret = PackOttCallRequestInfo(requestInfo);
221 if (ret != TELEPHONY_SUCCESS) {
222 TELEPHONY_LOGE("PackOttCallRequestInfo failed, error%{public}d", ret);
223 return ret;
224 }
225 if (ottCallConnectionPtr_ == nullptr) {
226 TELEPHONY_LOGE("ottCallConnectionPtr_ is nullptr!");
227 return TELEPHONY_ERR_LOCAL_PTR_NULL;
228 }
229 return ottCallConnectionPtr_->SeparateConference(requestInfo);
230 }
231
CanSeparateConference()232 int32_t OTTCall::CanSeparateConference()
233 {
234 return DelayedSingleton<OttConference>::GetInstance()->CanSeparateConference();
235 }
236
LaunchConference()237 int32_t OTTCall::LaunchConference()
238 {
239 int32_t ret = DelayedSingleton<OttConference>::GetInstance()->JoinToConference(GetCallID());
240 if (ret == TELEPHONY_SUCCESS) {
241 SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_ACTIVE);
242 }
243 return ret;
244 }
245
ExitConference()246 int32_t OTTCall::ExitConference()
247 {
248 return DelayedSingleton<OttConference>::GetInstance()->LeaveFromConference(GetCallID());
249 }
250
HoldConference()251 int32_t OTTCall::HoldConference()
252 {
253 int32_t ret = DelayedSingleton<OttConference>::GetInstance()->HoldConference(GetCallID());
254 if (ret == TELEPHONY_SUCCESS) {
255 SetTelConferenceState(TelConferenceState::TEL_CONFERENCE_HOLDING);
256 }
257 return ret;
258 }
259
GetMainCallId(int32_t & mainCallId)260 int32_t OTTCall::GetMainCallId(int32_t &mainCallId)
261 {
262 mainCallId = DelayedSingleton<OttConference>::GetInstance()->GetMainCall();
263 return TELEPHONY_SUCCESS;
264 }
265
GetSubCallIdList(std::vector<std::u16string> & callIdList)266 int32_t OTTCall::GetSubCallIdList(std::vector<std::u16string> &callIdList)
267 {
268 return DelayedSingleton<OttConference>::GetInstance()->GetSubCallIdList(GetCallID(), callIdList);
269 }
270
GetCallIdListForConference(std::vector<std::u16string> & callIdList)271 int32_t OTTCall::GetCallIdListForConference(std::vector<std::u16string> &callIdList)
272 {
273 return DelayedSingleton<OttConference>::GetInstance()->GetCallIdListForConference(GetCallID(), callIdList);
274 }
275
IsSupportConferenceable()276 int32_t OTTCall::IsSupportConferenceable()
277 {
278 #ifdef ABILIT_CONFIG_SUPPORT
279 bool ottSupport = GetOttConfig(OTT_SUPPORT_CONFERENCE);
280 if (!ottSupport) {
281 return TELEPHONY_CONFERENCE_OTT_NOT_SUPPORT;
282 }
283 if (isVideoCall()) {
284 ottSupport = GetOTTConfig(OTT_VIDEO_SUPPORT_CONFERENCE)
285 }
286 if (!ottSupport) {
287 return TELEPHONY_CONFERENCE_VIDEO_CALL_NOT_SUPPORT;
288 }
289 #endif
290 return TELEPHONY_SUCCESS;
291 }
292
SendUpdateCallMediaModeRequest(ImsCallMode mode)293 int32_t OTTCall::SendUpdateCallMediaModeRequest(ImsCallMode mode)
294 {
295 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
296 }
297
RecieveUpdateCallMediaModeRequest(ImsCallMode mode)298 int32_t OTTCall::RecieveUpdateCallMediaModeRequest(ImsCallMode mode)
299 {
300 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
301 }
302
SendUpdateCallMediaModeResponse(ImsCallMode mode)303 int32_t OTTCall::SendUpdateCallMediaModeResponse(ImsCallMode mode)
304 {
305 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
306 }
307
ReceiveUpdateCallMediaModeResponse(CallMediaModeResponse & response)308 int32_t OTTCall::ReceiveUpdateCallMediaModeResponse(CallMediaModeResponse &response)
309 {
310 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
311 }
312
DispatchUpdateVideoRequest(ImsCallMode mode)313 int32_t OTTCall::DispatchUpdateVideoRequest(ImsCallMode mode)
314 {
315 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
316 }
317
DispatchUpdateVideoResponse(ImsCallMode mode)318 int32_t OTTCall::DispatchUpdateVideoResponse(ImsCallMode mode)
319 {
320 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
321 }
322
SetMute(int32_t mute,int32_t slotId)323 int32_t OTTCall::SetMute(int32_t mute, int32_t slotId)
324 {
325 return CALL_ERR_FUNCTION_NOT_SUPPORTED;
326 }
327
PackOttCallRequestInfo(OttCallRequestInfo & requestInfo)328 int32_t OTTCall::PackOttCallRequestInfo(OttCallRequestInfo &requestInfo)
329 {
330 if (accountNumber_.length() > static_cast<size_t>(kMaxNumberLen)) {
331 TELEPHONY_LOGE("Number out of limit!");
332 return CALL_ERR_NUMBER_OUT_OF_RANGE;
333 }
334 if (memcpy_s(requestInfo.phoneNum, kMaxNumberLen, accountNumber_.c_str(), accountNumber_.length()) != EOK) {
335 TELEPHONY_LOGW("memset_s failed!");
336 return TELEPHONY_ERR_MEMSET_FAIL;
337 }
338 if (bundleName_.length() > static_cast<size_t>(kMaxBundleNameLen)) {
339 TELEPHONY_LOGE("Number out of limit!");
340 return CALL_ERR_NUMBER_OUT_OF_RANGE;
341 }
342 if (memcpy_s(requestInfo.bundleName, kMaxBundleNameLen, bundleName_.c_str(), bundleName_.length()) != EOK) {
343 TELEPHONY_LOGW("memset_s failed!");
344 return TELEPHONY_ERR_MEMSET_FAIL;
345 }
346 requestInfo.videoState = videoState_;
347 return TELEPHONY_SUCCESS;
348 }
349 } // namespace Telephony
350 } // namespace OHOS
351