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 "call_base.h"
17
18 #include <securec.h>
19
20 #include "call_manager_errors.h"
21 #include "telephony_log_wrapper.h"
22
23 #include "common_type.h"
24 #include "cellular_call_connection.h"
25 #include "audio_control_manager.h"
26
27 namespace OHOS {
28 namespace Telephony {
CallBase(DialParaInfo & info)29 CallBase::CallBase(DialParaInfo &info)
30 : callId_(info.callId), callType_(info.callType), videoState_(info.videoState), accountNumber_(info.number),
31 bundleName_(info.bundleName), callRunningState_(CallRunningState::CALL_RUNNING_STATE_CREATE),
32 conferenceState_(TelConferenceState::TEL_CONFERENCE_IDLE), startTime_(0),
33 direction_(CallDirection::CALL_DIRECTION_IN), policyFlag_(0), callState_(info.callState),
34 isSpeakerphoneOn_(false), callEndedType_(CallEndedType::UNKNOWN), callBeginTime_(0), callEndTime_(0),
35 ringBeginTime_(0), ringEndTime_(0), answerType_(CallAnswerType::CALL_ANSWER_MISSED)
36 {
37 (void)memset_s(&contactInfo_, sizeof(ContactInfo), 0, sizeof(ContactInfo));
38 }
39
CallBase(DialParaInfo & info,AppExecFwk::PacMap & extras)40 CallBase::CallBase(DialParaInfo &info, AppExecFwk::PacMap &extras)
41 : callId_(info.callId), callType_(info.callType), videoState_(info.videoState), accountNumber_(info.number),
42 bundleName_(info.bundleName), callRunningState_(CallRunningState::CALL_RUNNING_STATE_CREATE),
43 conferenceState_(TelConferenceState::TEL_CONFERENCE_IDLE), startTime_(0),
44 direction_(CallDirection::CALL_DIRECTION_OUT), policyFlag_(0), callState_(info.callState),
45 isSpeakerphoneOn_(false), callEndedType_(CallEndedType::UNKNOWN), callBeginTime_(0), callEndTime_(0),
46 ringBeginTime_(0), ringEndTime_(0), answerType_(CallAnswerType::CALL_ANSWER_MISSED)
47 {
48 (void)memset_s(&contactInfo_, sizeof(ContactInfo), 0, sizeof(ContactInfo));
49 }
50
~CallBase()51 CallBase::~CallBase() {}
52
DialCallBase()53 int32_t CallBase::DialCallBase()
54 {
55 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_CONNECTING;
56 TELEPHONY_LOGI("start to set audio");
57 // Set audio, set hands-free
58 SetAudio();
59 return TELEPHONY_SUCCESS;
60 }
61
IncomingCallBase()62 int32_t CallBase::IncomingCallBase()
63 {
64 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
65 return TELEPHONY_SUCCESS;
66 }
67
AnswerCallBase()68 int32_t CallBase::AnswerCallBase()
69 {
70 if (!IsCurrentRinging()) {
71 TELEPHONY_LOGW("the device is currently not ringing");
72 return CALL_ERR_PHONE_ANSWER_IS_BUSY;
73 }
74 DelayedSingleton<AudioControlManager>::GetInstance()->SetVolumeAudible();
75 return TELEPHONY_SUCCESS;
76 }
77
RejectCallBase()78 int32_t CallBase::RejectCallBase()
79 {
80 answerType_ = CallAnswerType::CALL_ANSWER_REJECT;
81 return TELEPHONY_SUCCESS;
82 }
83
GetCallAttributeBaseInfo(CallAttributeInfo & info)84 void CallBase::GetCallAttributeBaseInfo(CallAttributeInfo &info)
85 {
86 std::lock_guard<std::mutex> lock(mutex_);
87 (void)memset_s(info.accountNumber, kMaxNumberLen, 0, kMaxNumberLen);
88 if (memcpy_s(info.accountNumber, kMaxNumberLen, accountNumber_.c_str(), accountNumber_.length()) == 0) {
89 info.speakerphoneOn = isSpeakerphoneOn_;
90 info.videoState = videoState_;
91 info.startTime = startTime_;
92 info.callType = callType_;
93 info.callId = callId_;
94 info.callState = callState_;
95 info.conferenceState = conferenceState_;
96 info.callBeginTime = callBeginTime_;
97 info.callEndTime = callEndTime_;
98 info.ringBeginTime = ringBeginTime_;
99 info.ringEndTime = ringEndTime_;
100 info.callDirection = direction_;
101 info.answerType = answerType_;
102 if (memcpy_s(info.bundleName, kMaxBundleNameLen, bundleName_.c_str(), bundleName_.length()) != 0) {
103 TELEPHONY_LOGE("memcpy_s failed!");
104 }
105 }
106 }
107
GetCallID()108 int32_t CallBase::GetCallID()
109 {
110 std::lock_guard<std::mutex> lock(mutex_);
111 return callId_;
112 }
113
GetCallType()114 CallType CallBase::GetCallType()
115 {
116 return callType_;
117 }
118
GetCallRunningState()119 CallRunningState CallBase::GetCallRunningState()
120 {
121 std::lock_guard<std::mutex> lock(mutex_);
122 return callRunningState_;
123 }
124
125 // transfer from external call state to callmanager local state
SetTelCallState(TelCallState nextState)126 int32_t CallBase::SetTelCallState(TelCallState nextState)
127 {
128 std::lock_guard<std::mutex> lock(mutex_);
129 if (callState_ == nextState) {
130 TELEPHONY_LOGI("Call state duplication %{public}d", nextState);
131 return CALL_ERR_NOT_NEW_STATE;
132 }
133 callState_ = nextState;
134 switch (nextState) {
135 case TelCallState::CALL_STATUS_DIALING:
136 StateChangesToDialing();
137 break;
138 case TelCallState::CALL_STATUS_INCOMING:
139 StateChangesToIncoming();
140 break;
141 case TelCallState::CALL_STATUS_WAITING:
142 StateChangesToWaiting();
143 break;
144 case TelCallState::CALL_STATUS_ACTIVE:
145 StateChangesToActive();
146 break;
147 case TelCallState::CALL_STATUS_HOLDING:
148 StateChangesToHolding();
149 break;
150 case TelCallState::CALL_STATUS_DISCONNECTED:
151 StateChangesToDisconnected();
152 break;
153 case TelCallState::CALL_STATUS_DISCONNECTING:
154 StateChangesToDisconnecting();
155 break;
156 case TelCallState::CALL_STATUS_ALERTING:
157 StateChangesToAlerting();
158 break;
159 default:
160 break;
161 }
162 return TELEPHONY_SUCCESS;
163 }
164
StateChangesToDialing()165 void CallBase::StateChangesToDialing()
166 {
167 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_DIALING;
168 }
169
StateChangesToIncoming()170 void CallBase::StateChangesToIncoming()
171 {
172 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
173 ringBeginTime_ = time(nullptr);
174 }
175
StateChangesToWaiting()176 void CallBase::StateChangesToWaiting()
177 {
178 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_RINGING;
179 ringBeginTime_ = time(nullptr);
180 }
181
StateChangesToActive()182 void CallBase::StateChangesToActive()
183 {
184 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_ACTIVE;
185 if (callBeginTime_ == 0) {
186 callBeginTime_ = ringEndTime_ = time(nullptr);
187 startTime_ = callBeginTime_;
188 answerType_ = CallAnswerType::CALL_ANSWER_ACTIVED;
189 }
190 }
191
StateChangesToHolding()192 void CallBase::StateChangesToHolding()
193 {
194 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_HOLD;
195 if (conferenceState_ == TelConferenceState::TEL_CONFERENCE_ACTIVE) {
196 conferenceState_ = TelConferenceState::TEL_CONFERENCE_DISCONNECTED;
197 }
198 }
199
StateChangesToDisconnected()200 void CallBase::StateChangesToDisconnected()
201 {
202 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_ENDED;
203 if (conferenceState_ == TelConferenceState::TEL_CONFERENCE_DISCONNECTING ||
204 conferenceState_ == TelConferenceState::TEL_CONFERENCE_ACTIVE) {
205 conferenceState_ = TelConferenceState::TEL_CONFERENCE_DISCONNECTED;
206 }
207 callEndTime_ = time(nullptr);
208 if (ringEndTime_ == 0) {
209 ringEndTime_ = time(nullptr);
210 }
211 }
212
StateChangesToDisconnecting()213 void CallBase::StateChangesToDisconnecting()
214 {
215 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_ENDING;
216 if (conferenceState_ == TelConferenceState::TEL_CONFERENCE_ACTIVE) {
217 conferenceState_ = TelConferenceState::TEL_CONFERENCE_DISCONNECTING;
218 }
219 if (ringEndTime_ == 0) {
220 ringEndTime_ = time(nullptr);
221 }
222 }
223
StateChangesToAlerting()224 void CallBase::StateChangesToAlerting()
225 {
226 callRunningState_ = CallRunningState::CALL_RUNNING_STATE_DIALING;
227 ringBeginTime_ = time(nullptr);
228 }
229
GetTelCallState()230 TelCallState CallBase::GetTelCallState()
231 {
232 std::lock_guard<std::mutex> lock(mutex_);
233 return callState_;
234 }
235
SetTelConferenceState(TelConferenceState state)236 void CallBase::SetTelConferenceState(TelConferenceState state)
237 {
238 std::lock_guard<std::mutex> lock(mutex_);
239 conferenceState_ = state;
240 TELEPHONY_LOGI("SetTelConferenceState, state:%{public}d", state);
241 }
242
GetTelConferenceState()243 TelConferenceState CallBase::GetTelConferenceState()
244 {
245 std::lock_guard<std::mutex> lock(mutex_);
246 return conferenceState_;
247 }
248
GetVideoStateType()249 VideoStateType CallBase::GetVideoStateType()
250 {
251 std::lock_guard<std::mutex> lock(mutex_);
252 return videoState_;
253 }
254
SetVideoStateType(VideoStateType mediaType)255 void CallBase::SetVideoStateType(VideoStateType mediaType)
256 {
257 std::lock_guard<std::mutex> lock(mutex_);
258 videoState_ = mediaType;
259 }
260
SetPolicyFlag(PolicyFlag flag)261 void CallBase::SetPolicyFlag(PolicyFlag flag)
262 {
263 std::lock_guard<std::mutex> lock(mutex_);
264 policyFlag_ |= flag;
265 }
266
GetPolicyFlag()267 uint64_t CallBase::GetPolicyFlag()
268 {
269 std::lock_guard<std::mutex> lock(mutex_);
270 return policyFlag_;
271 }
272
GetCallerInfo(ContactInfo & info)273 bool CallBase::GetCallerInfo(ContactInfo &info)
274 {
275 std::lock_guard<std::mutex> lock(mutex_);
276 info = contactInfo_;
277 return true;
278 }
279
SetCallerInfo(const ContactInfo & info)280 void CallBase::SetCallerInfo(const ContactInfo &info)
281 {
282 std::lock_guard<std::mutex> lock(mutex_);
283 contactInfo_ = info;
284 }
285
GetCallEndedType()286 CallEndedType CallBase::GetCallEndedType()
287 {
288 std::lock_guard<std::mutex> lock(mutex_);
289 return callEndedType_;
290 }
291
SetCallEndedType(CallEndedType callEndedType)292 int32_t CallBase::SetCallEndedType(CallEndedType callEndedType)
293 {
294 std::lock_guard<std::mutex> lock(mutex_);
295 callEndedType_ = callEndedType;
296 return TELEPHONY_SUCCESS;
297 }
298
CheckVoicemailNumber(std::string phoneNumber)299 bool CallBase::CheckVoicemailNumber(std::string phoneNumber)
300 {
301 return false;
302 }
303
SetAudio()304 void CallBase::SetAudio()
305 {
306 // Get from the configuration file
307 bool useSpeakerWhenDocked = true;
308 /**
309 * Determine if hands-free should be enabled during docking.
310 * When the device is docked and the Bluetooth or wired headset is not in use,
311 * please turn on the hands-free
312 */
313 bool useSpeakerForDock = IsSpeakerphoneEnabled();
314 SetSpeakerphoneOn(useSpeakerWhenDocked || useSpeakerForDock);
315 // Confirm whether the speaker is turned on
316 if (isSpeakerphoneOn_) {
317 DelayedSingleton<AudioControlManager>::GetInstance()->SetAudioDevice(AudioDevice::DEVICE_SPEAKER);
318 }
319 }
320
IsSpeakerphoneEnabled()321 bool CallBase::IsSpeakerphoneEnabled()
322 {
323 // Gets whether the device can be started from the configuration
324 return true;
325 }
326
IsCurrentRinging()327 bool CallBase::IsCurrentRinging()
328 {
329 return (callRunningState_ == CallRunningState::CALL_RUNNING_STATE_RINGING) ? true : false;
330 }
331
GetAccountNumber()332 std::string CallBase::GetAccountNumber()
333 {
334 return accountNumber_;
335 }
336
SetSpeakerphoneOn(bool speakerphoneOn)337 int32_t CallBase::SetSpeakerphoneOn(bool speakerphoneOn)
338 {
339 isSpeakerphoneOn_ = speakerphoneOn;
340 return TELEPHONY_SUCCESS;
341 }
342
IsSpeakerphoneOn()343 bool CallBase::IsSpeakerphoneOn()
344 {
345 return isSpeakerphoneOn_;
346 }
347
IsAliveState()348 bool CallBase::IsAliveState()
349 {
350 return !(callState_ == TelCallState::CALL_STATUS_IDLE || callState_ == TelCallState::CALL_STATUS_DISCONNECTED ||
351 callState_ == TelCallState::CALL_STATUS_DISCONNECTING);
352 }
353 } // namespace Telephony
354 } // namespace OHOS
355