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 "carrier_call.h"
17
18 #include <securec.h>
19
20 #include "call_manager_errors.h"
21 #include "telephony_log_wrapper.h"
22
23 #include "call_number_utils.h"
24
25 namespace OHOS {
26 namespace Telephony {
CarrierCall(DialParaInfo & info)27 CarrierCall::CarrierCall(DialParaInfo &info)
28 : CallBase(info), dialScene_(DialScene::CALL_NORMAL), slotId_(info.accountId), index_(info.index),
29 isEcc_(info.isEcc), cellularCallConnectionPtr_(DelayedSingleton<CellularCallConnection>::GetInstance())
30 {}
31
CarrierCall(DialParaInfo & info,AppExecFwk::PacMap & extras)32 CarrierCall::CarrierCall(DialParaInfo &info, AppExecFwk::PacMap &extras)
33 : CallBase(info, extras), dialScene_((DialScene)extras.GetIntValue("dialScene")), slotId_(info.accountId),
34 index_(info.index), isEcc_(info.isEcc),
35 cellularCallConnectionPtr_(DelayedSingleton<CellularCallConnection>::GetInstance())
36 {}
37
~CarrierCall()38 CarrierCall::~CarrierCall() {}
39
CarrierDialingProcess()40 int32_t CarrierCall::CarrierDialingProcess()
41 {
42 TELEPHONY_LOGI("CarrierDialingProcess start");
43 int32_t ret = DialCallBase();
44 if (ret != TELEPHONY_SUCCESS) {
45 CarrierHangUpCall();
46 }
47 return ret;
48 }
49
CarrierAnswerCall(int32_t videoState)50 int32_t CarrierCall::CarrierAnswerCall(int32_t videoState)
51 {
52 CellularCallInfo callInfo;
53 int32_t ret = AnswerCallBase();
54 if (ret != TELEPHONY_SUCCESS) {
55 TELEPHONY_LOGE("answer call failed!");
56 return CALL_ERR_ANSWER_FAILED;
57 }
58 ret = PackCellularCallInfo(callInfo);
59 if (ret != TELEPHONY_SUCCESS) {
60 TELEPHONY_LOGW("PackCellularCallInfo failed!");
61 }
62 if (cellularCallConnectionPtr_ == nullptr) {
63 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
64 return TELEPHONY_ERR_LOCAL_PTR_NULL;
65 }
66 ret = cellularCallConnectionPtr_->Answer(callInfo);
67 if (ret != TELEPHONY_SUCCESS) {
68 TELEPHONY_LOGE("answer call failed!");
69 return CALL_ERR_ANSWER_FAILED;
70 }
71 return TELEPHONY_SUCCESS;
72 }
73
CarrierRejectCall()74 int32_t CarrierCall::CarrierRejectCall()
75 {
76 CellularCallInfo callInfo;
77 int32_t ret = RejectCallBase();
78 if (ret != TELEPHONY_SUCCESS) {
79 return ret;
80 }
81 ret = PackCellularCallInfo(callInfo);
82 if (ret != TELEPHONY_SUCCESS) {
83 TELEPHONY_LOGW("PackCellularCallInfo failed!");
84 }
85 TelCallState state = GetTelCallState();
86 if (cellularCallConnectionPtr_ == nullptr) {
87 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
88 return TELEPHONY_ERR_LOCAL_PTR_NULL;
89 }
90 if (state == TelCallState::CALL_STATUS_INCOMING) {
91 ret = cellularCallConnectionPtr_->Reject(callInfo);
92 } else {
93 ret = cellularCallConnectionPtr_->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
94 }
95 if (ret != TELEPHONY_SUCCESS) {
96 TELEPHONY_LOGE("Reject failed!");
97 return CALL_ERR_REJECT_FAILED;
98 }
99 return TELEPHONY_SUCCESS;
100 }
101
CarrierHangUpCall()102 int32_t CarrierCall::CarrierHangUpCall()
103 {
104 int32_t ret = CALL_ERR_HANGUP_FAILED;
105 CellularCallInfo callInfo;
106 ret = PackCellularCallInfo(callInfo);
107 if (ret != TELEPHONY_SUCCESS) {
108 TELEPHONY_LOGW("PackCellularCallInfo failed!");
109 }
110 uint64_t policyFlag = GetPolicyFlag();
111 if (cellularCallConnectionPtr_ == nullptr) {
112 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
113 return TELEPHONY_ERR_LOCAL_PTR_NULL;
114 }
115 if (policyFlag & POLICY_FLAG_HANG_UP_ACTIVE) {
116 ret = cellularCallConnectionPtr_->HangUp(callInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
117 } else {
118 ret = cellularCallConnectionPtr_->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT);
119 }
120 if (ret != TELEPHONY_SUCCESS) {
121 TELEPHONY_LOGE("End failed!");
122 return CALL_ERR_HANGUP_FAILED;
123 }
124 return TELEPHONY_SUCCESS;
125 }
126
CarrierHoldCall()127 int32_t CarrierCall::CarrierHoldCall()
128 {
129 CellularCallInfo callInfo;
130 int32_t ret = PackCellularCallInfo(callInfo);
131 if (ret != TELEPHONY_SUCCESS) {
132 TELEPHONY_LOGW("PackCellularCallInfo failed!");
133 }
134 if (cellularCallConnectionPtr_ == nullptr) {
135 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
136 return TELEPHONY_ERR_LOCAL_PTR_NULL;
137 }
138 ret = cellularCallConnectionPtr_->HoldCall(callInfo);
139 if (ret != TELEPHONY_SUCCESS) {
140 TELEPHONY_LOGE("Hold failed!");
141 return CALL_ERR_HOLD_FAILED;
142 }
143 return TELEPHONY_SUCCESS;
144 }
145
CarrierUnHoldCall()146 int32_t CarrierCall::CarrierUnHoldCall()
147 {
148 CellularCallInfo callInfo;
149 int32_t ret = PackCellularCallInfo(callInfo);
150 if (ret != TELEPHONY_SUCCESS) {
151 TELEPHONY_LOGW("PackCellularCallInfo failed!");
152 }
153 if (cellularCallConnectionPtr_ == nullptr) {
154 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
155 return TELEPHONY_ERR_LOCAL_PTR_NULL;
156 }
157 ret = cellularCallConnectionPtr_->UnHoldCall(callInfo);
158 if (ret != TELEPHONY_SUCCESS) {
159 TELEPHONY_LOGE("UnHold failed!");
160 return CALL_ERR_UNHOLD_FAILED;
161 }
162 return TELEPHONY_SUCCESS;
163 }
164
GetCallAttributeCarrierInfo(CallAttributeInfo & info)165 void CarrierCall::GetCallAttributeCarrierInfo(CallAttributeInfo &info)
166 {
167 std::lock_guard<std::mutex> lock(mutex_);
168 info.isEcc = isEcc_;
169 info.accountId = slotId_;
170 GetCallAttributeBaseInfo(info);
171 }
172
GetEmergencyState()173 bool CarrierCall::GetEmergencyState()
174 {
175 std::lock_guard<std::mutex> lock(mutex_);
176 return isEcc_;
177 }
178
CarrierSwitchCall()179 int32_t CarrierCall::CarrierSwitchCall()
180 {
181 CellularCallInfo callInfo;
182 int32_t ret = PackCellularCallInfo(callInfo);
183 if (ret != TELEPHONY_SUCCESS) {
184 TELEPHONY_LOGW("PackCellularCallInfo failed!");
185 }
186 if (cellularCallConnectionPtr_ == nullptr) {
187 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
188 return TELEPHONY_ERR_LOCAL_PTR_NULL;
189 }
190 ret = cellularCallConnectionPtr_->SwitchCall(callInfo);
191 if (ret != TELEPHONY_SUCCESS) {
192 TELEPHONY_LOGE("SwitchCall failed!");
193 return CALL_ERR_UNHOLD_FAILED;
194 }
195 return TELEPHONY_SUCCESS;
196 }
197
GetSlotId()198 int32_t CarrierCall::GetSlotId()
199 {
200 return slotId_;
201 }
202
CarrierCombineConference()203 int32_t CarrierCall::CarrierCombineConference()
204 {
205 CellularCallInfo callInfo;
206 int32_t ret = PackCellularCallInfo(callInfo);
207 if (ret != TELEPHONY_SUCCESS) {
208 TELEPHONY_LOGW("PackCellularCallInfo failed!");
209 }
210 if (cellularCallConnectionPtr_ == nullptr) {
211 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
212 return TELEPHONY_ERR_LOCAL_PTR_NULL;
213 }
214 return cellularCallConnectionPtr_->CombineConference(callInfo);
215 }
216
CarrierSeparateConference()217 int32_t CarrierCall::CarrierSeparateConference()
218 {
219 CellularCallInfo callInfo;
220 int32_t ret = PackCellularCallInfo(callInfo);
221 if (ret != TELEPHONY_SUCCESS) {
222 TELEPHONY_LOGW("PackCellularCallInfo failed!");
223 }
224 if (cellularCallConnectionPtr_ == nullptr) {
225 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
226 return TELEPHONY_ERR_LOCAL_PTR_NULL;
227 }
228 return cellularCallConnectionPtr_->SeparateConference(callInfo);
229 }
230
IsSupportConferenceable()231 int32_t CarrierCall::IsSupportConferenceable()
232 {
233 // emergency call not allowed to join conference
234 return GetEmergencyState() != true ? TELEPHONY_SUCCESS : CALL_ERR_EMERGENCY_UNSUPPORT_CONFERENCEABLE;
235 }
236
PackCellularCallInfo(CellularCallInfo & callInfo)237 int32_t CarrierCall::PackCellularCallInfo(CellularCallInfo &callInfo)
238 {
239 callInfo.callId = callId_;
240 callInfo.callType = callType_;
241 callInfo.videoState = static_cast<int32_t>(videoState_);
242 callInfo.index = index_;
243 callInfo.slotId = slotId_;
244 callInfo.accountId = slotId_;
245 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
246 TELEPHONY_LOGW("memset_s failed!");
247 return TELEPHONY_ERR_MEMSET_FAIL;
248 }
249 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, accountNumber_.c_str(), accountNumber_.length()) != EOK) {
250 TELEPHONY_LOGW("memcpy_s failed!");
251 return TELEPHONY_ERR_MEMCPY_FAIL;
252 }
253 return TELEPHONY_SUCCESS;
254 }
255
StartDtmf(char str)256 int32_t CarrierCall::StartDtmf(char str)
257 {
258 CellularCallInfo callInfo;
259 int32_t ret = PackCellularCallInfo(callInfo);
260 if (ret != TELEPHONY_SUCCESS) {
261 TELEPHONY_LOGW("PackCellularCallInfo failed!");
262 }
263 if (cellularCallConnectionPtr_ == nullptr) {
264 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
265 return TELEPHONY_ERR_LOCAL_PTR_NULL;
266 }
267 return cellularCallConnectionPtr_->StartDtmf(str, callInfo);
268 }
269
StopDtmf()270 int32_t CarrierCall::StopDtmf()
271 {
272 CellularCallInfo callInfo;
273 int32_t ret = PackCellularCallInfo(callInfo);
274 if (ret != TELEPHONY_SUCCESS) {
275 TELEPHONY_LOGW("PackCellularCallInfo failed!");
276 }
277 if (cellularCallConnectionPtr_ == nullptr) {
278 TELEPHONY_LOGE("cellularCallConnectionPtr_ is nullptr!");
279 return TELEPHONY_ERR_LOCAL_PTR_NULL;
280 }
281 return cellularCallConnectionPtr_->StopDtmf(callInfo);
282 }
283 } // namespace Telephony
284 } // namespace OHOS
285