1 /*
2 * Copyright (C) 2021-2022 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 "hril_call.h"
17
18 #include "hril_notification.h"
19 #include "hril_request.h"
20
21 namespace OHOS {
22 namespace Telephony {
HRilCall(int32_t slotId)23 HRilCall::HRilCall(int32_t slotId) : HRilBase(slotId)
24 {
25 AddCallNotificationToMap();
26 AddCallBasicResponseToMap();
27 AddCallSupplementResponseToMap();
28 AddCallAdditionalResponseToMap();
29 }
30
~HRilCall()31 HRilCall::~HRilCall()
32 {
33 callFuncs_ = nullptr;
34 }
35
IsCallResponse(uint32_t code)36 bool HRilCall::IsCallResponse(uint32_t code)
37 {
38 return ((code >= HREQ_CALL_BASE) && (code < HREQ_SMS_BASE));
39 }
40
IsCallNotification(uint32_t code)41 bool HRilCall::IsCallNotification(uint32_t code)
42 {
43 return ((code >= HNOTI_CALL_BASE) && (code < HNOTI_SMS_BASE));
44 }
45
IsCallRespOrNotify(uint32_t code)46 bool HRilCall::IsCallRespOrNotify(uint32_t code)
47 {
48 return IsCallResponse(code) || IsCallNotification(code);
49 }
50
AddCallNotificationToMap()51 void HRilCall::AddCallNotificationToMap()
52 {
53 // Notification
54 notiMemberFuncMap_[HNOTI_CALL_STATE_UPDATED] =
55 [this](int32_t notifyType, HRilErrNumber error, const void *response,
56 size_t responseLen) { return CallStateUpdated(notifyType, error, response, responseLen); };
57 notiMemberFuncMap_[HNOTI_CALL_USSD_REPORT] =
58 [this](int32_t notifyType, HRilErrNumber error, const void *response,
59 size_t responseLen) { return CallUssdNotice(notifyType, error, response, responseLen); };
60 notiMemberFuncMap_[HNOTI_CALL_SRVCC_STATUS_REPORT] =
61 [this](int32_t notifyType, HRilErrNumber error, const void *response,
62 size_t responseLen) { return CallSrvccStatusNotice(notifyType, error, response, responseLen); };
63 notiMemberFuncMap_[HNOTI_CALL_RINGBACK_VOICE_REPORT] =
64 [this](int32_t notifyType, HRilErrNumber error, const void *response,
65 size_t responseLen) { return CallRingbackVoiceNotice(notifyType, error, response, responseLen); };
66 notiMemberFuncMap_[HNOTI_CALL_EMERGENCY_NUMBER_REPORT] =
67 [this](int32_t notifyType, HRilErrNumber error, const void *response,
68 size_t responseLen) { return CallEmergencyNotice(notifyType, error, response, responseLen); };
69 notiMemberFuncMap_[HNOTI_CALL_SS_REPORT] =
70 [this](int32_t notifyType, HRilErrNumber error, const void *response,
71 size_t responseLen) { return CallSsNotice(notifyType, error, response, responseLen); };
72 notiMemberFuncMap_[HNOTI_CALL_RSRVCC_STATUS_REPORT] =
73 [this](int32_t notifyType, HRilErrNumber error, const void *response,
74 size_t responseLen) { return CallRsrvccStatusNotify(notifyType, error, response, responseLen); };
75 }
76
AddCallBasicResponseToMap()77 void HRilCall::AddCallBasicResponseToMap()
78 {
79 // Response
80 respMemberFuncMap_[HREQ_CALL_GET_CALL_LIST] =
81 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
82 size_t responseLen) { return GetCallListResponse(requestNum, responseInfo, response, responseLen); };
83 respMemberFuncMap_[HREQ_CALL_DIAL] =
84 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
85 size_t responseLen) { return DialResponse(requestNum, responseInfo, response, responseLen); };
86 respMemberFuncMap_[HREQ_CALL_HANGUP] =
87 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
88 size_t responseLen) { return HangupResponse(requestNum, responseInfo, response, responseLen); };
89 respMemberFuncMap_[HREQ_CALL_REJECT] =
90 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
91 size_t responseLen) { return RejectResponse(requestNum, responseInfo, response, responseLen); };
92 respMemberFuncMap_[HREQ_CALL_ANSWER] =
93 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
94 size_t responseLen) { return AnswerResponse(requestNum, responseInfo, response, responseLen); };
95 respMemberFuncMap_[HREQ_CALL_HOLD_CALL] =
96 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
97 size_t responseLen) { return HoldCallResponse(requestNum, responseInfo, response, responseLen); };
98 respMemberFuncMap_[HREQ_CALL_UNHOLD_CALL] =
99 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
100 size_t responseLen) { return UnHoldCallResponse(requestNum, responseInfo, response, responseLen); };
101 respMemberFuncMap_[HREQ_CALL_SWITCH_CALL] =
102 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
103 size_t responseLen) { return SwitchCallResponse(requestNum, responseInfo, response, responseLen); };
104 respMemberFuncMap_[HREQ_CALL_COMBINE_CONFERENCE] =
105 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
106 size_t responseLen) { return CombineConferenceResponse(requestNum, responseInfo, response, responseLen); };
107 respMemberFuncMap_[HREQ_CALL_SEPARATE_CONFERENCE] =
108 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
109 size_t responseLen) { return SeparateConferenceResponse(requestNum, responseInfo, response, responseLen); };
110 respMemberFuncMap_[HREQ_CALL_GET_EMERGENCY_LIST] =
111 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
112 size_t responseLen) { return GetEmergencyCallListResponse(requestNum, responseInfo, response, responseLen); };
113 respMemberFuncMap_[HREQ_CALL_SET_EMERGENCY_LIST] =
114 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
115 size_t responseLen) { return SetEmergencyCallListResponse(requestNum, responseInfo, response, responseLen); };
116 respMemberFuncMap_[HREQ_CALL_GET_FAIL_REASON] =
117 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
118 size_t responseLen) { return GetCallFailReasonResponse(requestNum, responseInfo, response, responseLen); };
119 respMemberFuncMap_[HREQ_CALL_SET_BARRING_PASSWORD] =
120 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
121 size_t responseLen) { return SetBarringPasswordResponse(requestNum, responseInfo, response, responseLen); };
122 respMemberFuncMap_[HREQ_CALL_CLOSE_UNFINISHED_USSD] =
123 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
124 size_t responseLen) { return CloseUnFinishedUssdResponse(requestNum, responseInfo, response, responseLen); };
125 }
126
AddCallSupplementResponseToMap()127 void HRilCall::AddCallSupplementResponseToMap()
128 {
129 respMemberFuncMap_[HREQ_CALL_GET_CLIP] =
130 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
131 size_t responseLen) { return GetClipResponse(requestNum, responseInfo, response, responseLen); };
132 respMemberFuncMap_[HREQ_CALL_SET_CLIP] =
133 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
134 size_t responseLen) { return SetClipResponse(requestNum, responseInfo, response, responseLen); };
135 respMemberFuncMap_[HREQ_CALL_CALL_SUPPLEMENT] =
136 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
137 size_t responseLen) { return CallSupplementResponse(requestNum, responseInfo, response, responseLen); };
138 respMemberFuncMap_[HREQ_CALL_GET_CALL_WAITING] =
139 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
140 size_t responseLen) { return GetCallWaitingResponse(requestNum, responseInfo, response, responseLen); };
141 respMemberFuncMap_[HREQ_CALL_SET_CALL_WAITING] =
142 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
143 size_t responseLen) { return SetCallWaitingResponse(requestNum, responseInfo, response, responseLen); };
144 respMemberFuncMap_[HREQ_CALL_GET_CALL_TRANSFER_INFO] =
145 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
146 size_t responseLen) { return GetCallTransferInfoResponse(requestNum, responseInfo, response, responseLen); };
147 respMemberFuncMap_[HREQ_CALL_SET_CALL_TRANSFER_INFO] =
148 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
149 size_t responseLen) { return SetCallTransferInfoResponse(requestNum, responseInfo, response, responseLen); };
150 respMemberFuncMap_[HREQ_CALL_GET_CALL_RESTRICTION] =
151 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
152 size_t responseLen) { return GetCallRestrictionResponse(requestNum, responseInfo, response, responseLen); };
153 respMemberFuncMap_[HREQ_CALL_SET_CALL_RESTRICTION] =
154 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
155 size_t responseLen) { return SetCallRestrictionResponse(requestNum, responseInfo, response, responseLen); };
156 respMemberFuncMap_[HREQ_CALL_GET_CLIR] =
157 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
158 size_t responseLen) { return GetClirResponse(requestNum, responseInfo, response, responseLen); };
159 respMemberFuncMap_[HREQ_CALL_SET_CLIR] =
160 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
161 size_t responseLen) { return SetClirResponse(requestNum, responseInfo, response, responseLen); };
162 respMemberFuncMap_[HREQ_CALL_GET_CALL_PREFERENCE] =
163 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
164 size_t responseLen) { return GetCallPreferenceModeResponse(requestNum, responseInfo, response, responseLen); };
165 respMemberFuncMap_[HREQ_CALL_SET_CALL_PREFERENCE] =
166 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
167 size_t responseLen) { return SetCallPreferenceModeResponse(requestNum, responseInfo, response, responseLen); };
168 respMemberFuncMap_[HREQ_CALL_SET_USSD] =
169 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
170 size_t responseLen) { return SetUssdResponse(requestNum, responseInfo, response, responseLen); };
171 respMemberFuncMap_[HREQ_CALL_GET_USSD] =
172 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
173 size_t responseLen) { return GetUssdResponse(requestNum, responseInfo, response, responseLen); };
174 }
175
AddCallAdditionalResponseToMap()176 void HRilCall::AddCallAdditionalResponseToMap()
177 {
178 respMemberFuncMap_[HREQ_CALL_START_DTMF] =
179 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
180 size_t responseLen) { return StartDtmfResponse(requestNum, responseInfo, response, responseLen); };
181 respMemberFuncMap_[HREQ_CALL_SEND_DTMF] =
182 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
183 size_t responseLen) { return SendDtmfResponse(requestNum, responseInfo, response, responseLen); };
184 respMemberFuncMap_[HREQ_CALL_STOP_DTMF] =
185 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
186 size_t responseLen) { return StopDtmfResponse(requestNum, responseInfo, response, responseLen); };
187 respMemberFuncMap_[HREQ_CALL_SET_MUTE] =
188 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
189 size_t responseLen) { return SetMuteResponse(requestNum, responseInfo, response, responseLen); };
190 respMemberFuncMap_[HREQ_CALL_GET_MUTE] =
191 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
192 size_t responseLen) { return GetMuteResponse(requestNum, responseInfo, response, responseLen); };
193 respMemberFuncMap_[HREQ_SET_VONR_SWITCH] =
194 [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
195 size_t responseLen) { return SetVonrSwitchResponse(requestNum, responseInfo, response, responseLen); };
196 }
197
GetCallList(int32_t serialId)198 int32_t HRilCall::GetCallList(int32_t serialId)
199 {
200 return RequestVendor(serialId, HREQ_CALL_GET_CALL_LIST, callFuncs_, &HRilCallReq::GetCallList);
201 }
202
Dial(int32_t serialId,const OHOS::HDI::Ril::V1_1::DialInfo & dialInfo)203 int32_t HRilCall::Dial(int32_t serialId, const OHOS::HDI::Ril::V1_1::DialInfo &dialInfo)
204 {
205 HRilDial dial = {};
206 dial.address = StringToCString(dialInfo.address);
207 dial.clir = dialInfo.clir;
208 return RequestVendor(serialId, HREQ_CALL_DIAL, callFuncs_, &HRilCallReq::Dial, &dial, sizeof(HRilDial));
209 }
210
Hangup(int32_t serialId,int32_t gsmIndex)211 int32_t HRilCall::Hangup(int32_t serialId, int32_t gsmIndex)
212 {
213 uint32_t data = gsmIndex;
214 return RequestVendor(serialId, HREQ_CALL_HANGUP, callFuncs_, &HRilCallReq::Hangup, &data, sizeof(uint32_t));
215 }
216
Reject(int32_t serialId)217 int32_t HRilCall::Reject(int32_t serialId)
218 {
219 return RequestVendor(serialId, HREQ_CALL_REJECT, callFuncs_, &HRilCallReq::Reject);
220 }
221
Answer(int32_t serialId)222 int32_t HRilCall::Answer(int32_t serialId)
223 {
224 return RequestVendor(serialId, HREQ_CALL_ANSWER, callFuncs_, &HRilCallReq::Answer);
225 }
226
HoldCall(int32_t serialId)227 int32_t HRilCall::HoldCall(int32_t serialId)
228 {
229 return RequestVendor(serialId, HREQ_CALL_HOLD_CALL, callFuncs_, &HRilCallReq::HoldCall);
230 }
231
UnHoldCall(int32_t serialId)232 int32_t HRilCall::UnHoldCall(int32_t serialId)
233 {
234 return RequestVendor(serialId, HREQ_CALL_UNHOLD_CALL, callFuncs_, &HRilCallReq::UnHoldCall);
235 }
236
SwitchCall(int32_t serialId)237 int32_t HRilCall::SwitchCall(int32_t serialId)
238 {
239 return RequestVendor(serialId, HREQ_CALL_SWITCH_CALL, callFuncs_, &HRilCallReq::SwitchCall);
240 }
241
CombineConference(int32_t serialId,int32_t callType)242 int32_t HRilCall::CombineConference(int32_t serialId, int32_t callType)
243 {
244 return RequestVendor(
245 serialId, HREQ_CALL_COMBINE_CONFERENCE, callFuncs_, &HRilCallReq::CombineConference, callType);
246 }
247
SeparateConference(int32_t serialId,int32_t callIndex,int32_t callType)248 int32_t HRilCall::SeparateConference(int32_t serialId, int32_t callIndex, int32_t callType)
249 {
250 return RequestVendor(
251 serialId, HREQ_CALL_SEPARATE_CONFERENCE, callFuncs_, &HRilCallReq::SeparateConference, callIndex, callType);
252 }
253
CallSupplement(int32_t serialId,int32_t type)254 int32_t HRilCall::CallSupplement(int32_t serialId, int32_t type)
255 {
256 return RequestVendor(serialId, HREQ_CALL_CALL_SUPPLEMENT, callFuncs_, &HRilCallReq::CallSupplement, type);
257 }
258
GetClip(int32_t serialId)259 int32_t HRilCall::GetClip(int32_t serialId)
260 {
261 return RequestVendor(serialId, HREQ_CALL_GET_CLIP, callFuncs_, &HRilCallReq::GetClip);
262 }
263
SetClip(int32_t serialId,int32_t action)264 int32_t HRilCall::SetClip(int32_t serialId, int32_t action)
265 {
266 return RequestVendor(serialId, HREQ_CALL_SET_CLIP, callFuncs_, &HRilCallReq::SetClip, action);
267 }
268
GetClir(int32_t serialId)269 int32_t HRilCall::GetClir(int32_t serialId)
270 {
271 return RequestVendor(serialId, HREQ_CALL_GET_CLIR, callFuncs_, &HRilCallReq::GetClir);
272 }
273
SetClir(int32_t serialId,int32_t action)274 int32_t HRilCall::SetClir(int32_t serialId, int32_t action)
275 {
276 return RequestVendor(serialId, HREQ_CALL_SET_CLIR, callFuncs_, &HRilCallReq::SetClir, action);
277 }
278
GetCallRestriction(int32_t serialId,const std::string & fac)279 int32_t HRilCall::GetCallRestriction(int32_t serialId, const std::string &fac)
280 {
281 return RequestVendor(
282 serialId, HREQ_CALL_GET_CALL_RESTRICTION, callFuncs_, &HRilCallReq::GetCallRestriction, StringToCString(fac));
283 }
284
SetCallRestriction(int32_t serialId,const OHOS::HDI::Ril::V1_1::CallRestrictionInfo & callRestrictionInfo)285 int32_t HRilCall::SetCallRestriction(
286 int32_t serialId, const OHOS::HDI::Ril::V1_1::CallRestrictionInfo &callRestrictionInfo)
287 {
288 CallRestrictionInfo info = {};
289 info.fac = StringToCString(callRestrictionInfo.fac);
290 info.mode = callRestrictionInfo.mode;
291 info.password = StringToCString(callRestrictionInfo.password);
292 return RequestVendor(serialId, HREQ_CALL_SET_CALL_RESTRICTION, callFuncs_, &HRilCallReq::SetCallRestriction, info);
293 }
294
GetCallWaiting(int32_t serialId)295 int32_t HRilCall::GetCallWaiting(int32_t serialId)
296 {
297 return RequestVendor(serialId, HREQ_CALL_GET_CALL_WAITING, callFuncs_, &HRilCallReq::GetCallWaiting);
298 }
299
SetCallWaiting(int32_t serialId,int32_t activate)300 int32_t HRilCall::SetCallWaiting(int32_t serialId, int32_t activate)
301 {
302 return RequestVendor(serialId, HREQ_CALL_SET_CALL_WAITING, callFuncs_, &HRilCallReq::SetCallWaiting, activate);
303 }
304
GetCallTransferInfo(int32_t serialId,int32_t reason)305 int32_t HRilCall::GetCallTransferInfo(int32_t serialId, int32_t reason)
306 {
307 return RequestVendor(
308 serialId, HREQ_CALL_GET_CALL_TRANSFER_INFO, callFuncs_, &HRilCallReq::GetCallTransferInfo, reason);
309 }
310
SetCallTransferInfo(int32_t serialId,const OHOS::HDI::Ril::V1_1::CallForwardSetInfo & callForwardSetInfo)311 int32_t HRilCall::SetCallTransferInfo(
312 int32_t serialId, const OHOS::HDI::Ril::V1_1::CallForwardSetInfo &callForwardSetInfo)
313 {
314 HRilCFInfo cFInfo = {};
315 cFInfo.number = StringToCString(callForwardSetInfo.number);
316 cFInfo.reason = callForwardSetInfo.reason;
317 cFInfo.mode = callForwardSetInfo.mode;
318 cFInfo.classx = callForwardSetInfo.classx;
319 return RequestVendor(
320 serialId, HREQ_CALL_SET_CALL_TRANSFER_INFO, callFuncs_, &HRilCallReq::SetCallTransferInfo, cFInfo);
321 }
322
GetCallPreferenceMode(int32_t serialId)323 int32_t HRilCall::GetCallPreferenceMode(int32_t serialId)
324 {
325 return RequestVendor(
326 serialId, HREQ_CALL_GET_CALL_PREFERENCE, callFuncs_, &HRilCallReq::GetCallPreferenceMode);
327 }
328
SetCallPreferenceMode(int32_t serialId,int32_t mode)329 int32_t HRilCall::SetCallPreferenceMode(int32_t serialId, int32_t mode)
330 {
331 return RequestVendor(
332 serialId, HREQ_CALL_SET_CALL_PREFERENCE, callFuncs_, &HRilCallReq::SetCallPreferenceMode, mode);
333 }
334
SetUssd(int32_t serialId,const std::string & str)335 int32_t HRilCall::SetUssd(int32_t serialId, const std::string &str)
336 {
337 return RequestVendor(
338 serialId, HREQ_CALL_SET_USSD, callFuncs_, &HRilCallReq::SetUssd, StringToCString(str));
339 }
340
GetUssd(int32_t serialId)341 int32_t HRilCall::GetUssd(int32_t serialId)
342 {
343 return RequestVendor(serialId, HREQ_CALL_GET_USSD, callFuncs_, &HRilCallReq::GetUssd);
344 }
345
SetMute(int32_t serialId,int32_t mute)346 int32_t HRilCall::SetMute(int32_t serialId, int32_t mute)
347 {
348 return RequestVendor(serialId, HREQ_CALL_SET_MUTE, callFuncs_, &HRilCallReq::SetMute, mute);
349 }
350
GetMute(int32_t serialId)351 int32_t HRilCall::GetMute(int32_t serialId)
352 {
353 return RequestVendor(serialId, HREQ_CALL_GET_MUTE, callFuncs_, &HRilCallReq::GetMute);
354 }
355
GetCallFailReason(int32_t serialId)356 int32_t HRilCall::GetCallFailReason(int32_t serialId)
357 {
358 return RequestVendor(serialId, HREQ_CALL_GET_FAIL_REASON, callFuncs_, &HRilCallReq::GetCallFailReason);
359 }
360
GetEmergencyCallList(int32_t serialId)361 int32_t HRilCall::GetEmergencyCallList(int32_t serialId)
362 {
363 return RequestVendor(serialId, HREQ_CALL_GET_EMERGENCY_LIST, callFuncs_, &HRilCallReq::GetEmergencyCallList);
364 }
365
SetBarringPassword(int32_t serialId,const OHOS::HDI::Ril::V1_1::SetBarringInfo & setBarringInfo)366 int32_t HRilCall::SetBarringPassword(int32_t serialId, const OHOS::HDI::Ril::V1_1::SetBarringInfo &setBarringInfo)
367 {
368 HRilSetBarringInfo info = {};
369 info.fac = StringToCString(setBarringInfo.fac);
370 info.oldPassword = StringToCString(setBarringInfo.oldPassword);
371 info.newPassword = StringToCString(setBarringInfo.newPassword);
372 return RequestVendor(
373 serialId, HREQ_CALL_SET_BARRING_PASSWORD, callFuncs_, &HRilCallReq::SetBarringPassword, info);
374 }
375
StartDtmf(int32_t serialId,const OHOS::HDI::Ril::V1_1::DtmfInfo & dtmfInfo)376 int32_t HRilCall::StartDtmf(int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
377 {
378 CallDtmfInfo info = {};
379 info.callId = dtmfInfo.callId;
380 info.dtmfKey = StringToCString(dtmfInfo.dtmfKey);
381 return RequestVendor(serialId, HREQ_CALL_START_DTMF, callFuncs_, &HRilCallReq::StartDtmf, info);
382 }
383
SendDtmf(int32_t serialId,const OHOS::HDI::Ril::V1_1::DtmfInfo & dtmfInfo)384 int32_t HRilCall::SendDtmf(int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
385 {
386 CallDtmfInfo info = {};
387 info.callId = dtmfInfo.callId;
388 info.dtmfKey = StringToCString(dtmfInfo.dtmfKey);
389 info.onLength = dtmfInfo.onLength;
390 info.offLength = dtmfInfo.offLength;
391 info.stringLength = dtmfInfo.stringLength;
392 return RequestVendor(serialId, HREQ_CALL_SEND_DTMF, callFuncs_, &HRilCallReq::SendDtmf, info);
393 }
394
StopDtmf(int32_t serialId,const OHOS::HDI::Ril::V1_1::DtmfInfo & dtmfInfo)395 int32_t HRilCall::StopDtmf(int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
396 {
397 CallDtmfInfo info = {};
398 info.callId = dtmfInfo.callId;
399 info.dtmfKey = StringToCString(dtmfInfo.dtmfKey);
400 return RequestVendor(serialId, HREQ_CALL_STOP_DTMF, callFuncs_, &HRilCallReq::StopDtmf, info);
401 }
402
CloseUnFinishedUssd(int32_t serialId)403 int32_t HRilCall::CloseUnFinishedUssd(int32_t serialId)
404 {
405 return RequestVendor(serialId, HREQ_CALL_CLOSE_UNFINISHED_USSD, callFuncs_, &HRilCallReq::CloseUnFinishedUssd);
406 }
407
SetVonrSwitch(int32_t serialId,int32_t status)408 int32_t HRilCall::SetVonrSwitch(int32_t serialId, int32_t status)
409 {
410 return RequestVendor(serialId, HREQ_SET_VONR_SWITCH, callFuncs_, &HRilCallReq::SetVonrSwitch, status);
411 }
412
BuildICallList(HDI::Ril::V1_1::CallInfoList & callInfoList,const void * response,size_t responseLen)413 void HRilCall::BuildICallList(
414 HDI::Ril::V1_1::CallInfoList &callInfoList, const void *response, size_t responseLen)
415 {
416 size_t num = responseLen / sizeof(HRilCallInfo);
417 HDI::Ril::V1_1::CallInfo callInfo;
418 callInfoList.callSize = num;
419 for (size_t i = 0; i < num; i++) {
420 HRilCallInfo *curPtr = ((HRilCallInfo *)response + i);
421 if (curPtr != nullptr) {
422 callInfo.index = curPtr->index;
423 callInfo.dir = curPtr->dir;
424 callInfo.state = curPtr->state;
425 callInfo.mode = curPtr->mode;
426 callInfo.mpty = curPtr->mpty;
427 callInfo.voiceDomain = curPtr->voiceDomain;
428 callInfo.callType = curPtr->callType;
429 callInfo.number = (curPtr->number == nullptr) ? "" : curPtr->number;
430 callInfo.type = curPtr->type;
431 callInfo.alpha = (curPtr->alpha == nullptr) ? "" : curPtr->alpha;
432 callInfoList.calls.push_back(callInfo);
433 } else {
434 TELEPHONY_LOGE("BuildCallList: Invalid curPtr");
435 break;
436 }
437 }
438 }
439
GetCallListResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)440 int32_t HRilCall::GetCallListResponse(
441 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
442 {
443 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilCallInfo)) != 0) {
444 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
445 return HRIL_ERR_INVALID_PARAMETER;
446 }
447 HDI::Ril::V1_1::CallInfoList callList = {};
448 if (response != nullptr) {
449 BuildICallList(callList, response, responseLen);
450 }
451 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallListResponse, callList);
452 }
453
DialResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)454 int32_t HRilCall::DialResponse(
455 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
456 {
457 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::DialResponse);
458 }
459
HangupResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)460 int32_t HRilCall::HangupResponse(
461 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
462 {
463 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::HangupResponse);
464 }
465
RejectResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)466 int32_t HRilCall::RejectResponse(
467 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
468 {
469 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::RejectResponse);
470 }
471
AnswerResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)472 int32_t HRilCall::AnswerResponse(
473 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
474 {
475 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::AnswerResponse);
476 }
477
HoldCallResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)478 int32_t HRilCall::HoldCallResponse(
479 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
480 {
481 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::HoldCallResponse);
482 }
483
GetClipResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)484 int32_t HRilCall::GetClipResponse(
485 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
486 {
487 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilGetClipResult)) != 0) {
488 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
489 return HRIL_ERR_INVALID_PARAMETER;
490 }
491 HDI::Ril::V1_1::GetClipResult getClipResult = {};
492 getClipResult.result = static_cast<int32_t>(responseInfo.error);
493 if (response != nullptr) {
494 const HRilGetClipResult *pGetClip = static_cast<const HRilGetClipResult *>(response);
495 getClipResult.action = pGetClip->action;
496 getClipResult.clipStat = pGetClip->clipStat;
497 }
498 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetClipResponse, getClipResult);
499 }
500
SetClipResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)501 int32_t HRilCall::SetClipResponse(
502 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
503 {
504 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetClipResponse);
505 }
506
UnHoldCallResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)507 int32_t HRilCall::UnHoldCallResponse(
508 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
509 {
510 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnHoldCallResponse);
511 }
512
SwitchCallResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)513 int32_t HRilCall::SwitchCallResponse(
514 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
515 {
516 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SwitchCallResponse);
517 }
518
CombineConferenceResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)519 int32_t HRilCall::CombineConferenceResponse(
520 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
521 {
522 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::CombineConferenceResponse);
523 }
524
SeparateConferenceResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)525 int32_t HRilCall::SeparateConferenceResponse(
526 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
527 {
528 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SeparateConferenceResponse);
529 }
530
CallSupplementResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)531 int32_t HRilCall::CallSupplementResponse(
532 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
533 {
534 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::CallSupplementResponse);
535 }
536
GetCallWaitingResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)537 int32_t HRilCall::GetCallWaitingResponse(
538 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
539 {
540 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilCallWaitResult)) != 0) {
541 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
542 return HRIL_ERR_INVALID_PARAMETER;
543 }
544 HDI::Ril::V1_1::CallWaitResult callWaitResult = {};
545 callWaitResult.result = static_cast<int32_t>(responseInfo.error);
546 if (response != nullptr) {
547 const HRilCallWaitResult *result = static_cast<const HRilCallWaitResult *>(response);
548 callWaitResult.status = result->status;
549 callWaitResult.classCw = result->classCw;
550 }
551 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallWaitingResponse, callWaitResult);
552 }
553
SetCallWaitingResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)554 int32_t HRilCall::SetCallWaitingResponse(
555 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
556 {
557 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCallWaitingResponse);
558 }
559
GetCallTransferInfoResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)560 int32_t HRilCall::GetCallTransferInfoResponse(
561 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
562 {
563 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilCFQueryInfo)) != 0) {
564 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
565 return HRIL_ERR_INVALID_PARAMETER;
566 }
567 HDI::Ril::V1_1::CallForwardQueryInfoList cFQueryList = {};
568 if (response != nullptr) {
569 BuildICallForwardQueryInfoList(cFQueryList, responseInfo, response, responseLen);
570 }
571 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallTransferInfoResponse, cFQueryList);
572 }
573
BuildICallForwardQueryInfoList(HDI::Ril::V1_1::CallForwardQueryInfoList & cFQueryList,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)574 void HRilCall::BuildICallForwardQueryInfoList(HDI::Ril::V1_1::CallForwardQueryInfoList &cFQueryList,
575 HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
576 {
577 size_t num = responseLen / sizeof(HRilCFQueryInfo);
578 HDI::Ril::V1_1::CallForwardQueryResult cFQueryResult;
579 cFQueryList.callSize = num;
580 for (size_t i = 0; i < num; i++) {
581 HRilCFQueryInfo *curPtr = ((HRilCFQueryInfo *)response + i);
582 if (curPtr != nullptr) {
583 cFQueryResult.result = static_cast<int32_t>(responseInfo.error);
584 cFQueryResult.serial = responseInfo.serial;
585 cFQueryResult.status = curPtr->status;
586 cFQueryResult.classx = curPtr->classx;
587 cFQueryResult.type = curPtr->type;
588 cFQueryResult.number = ((curPtr->number == nullptr) ? "" : curPtr->number);
589 cFQueryResult.reason = curPtr->reason;
590 cFQueryResult.time = curPtr->time;
591 cFQueryList.calls.push_back(cFQueryResult);
592 } else {
593 TELEPHONY_LOGE("BuildICallForwardQueryInfoList: Invalid curPtr");
594 break;
595 }
596 }
597 }
598
SetCallTransferInfoResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)599 int32_t HRilCall::SetCallTransferInfoResponse(
600 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
601 {
602 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCallTransferInfoResponse);
603 }
604
GetClirResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)605 int32_t HRilCall::GetClirResponse(
606 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
607 {
608 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilGetCallClirResult)) != 0) {
609 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
610 return HRIL_ERR_INVALID_PARAMETER;
611 }
612 HDI::Ril::V1_1::GetClirResult getClirResult = {};
613 getClirResult.result = static_cast<int32_t>(responseInfo.error);
614 if (response != nullptr) {
615 const HRilGetCallClirResult *pGetClir = static_cast<const HRilGetCallClirResult *>(response);
616 getClirResult.action = pGetClir->action;
617 getClirResult.clirStat = pGetClir->clirStat;
618 }
619 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetClirResponse, getClirResult);
620 }
621
SetClirResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)622 int32_t HRilCall::SetClirResponse(
623 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
624 {
625 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetClirResponse);
626 }
627
GetCallRestrictionResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)628 int32_t HRilCall::GetCallRestrictionResponse(
629 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
630 {
631 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilCallRestrictionResult)) != 0) {
632 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
633 return HRIL_ERR_INVALID_PARAMETER;
634 }
635 HDI::Ril::V1_1::CallRestrictionResult resultT = {};
636 resultT.result = static_cast<int32_t>(responseInfo.error);
637 if (response != nullptr) {
638 const HRilCallRestrictionResult *result = static_cast<const HRilCallRestrictionResult *>(response);
639 resultT.status = result->status;
640 resultT.classCw = result->classCw;
641 }
642 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallRestrictionResponse, resultT);
643 }
644
SetCallRestrictionResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)645 int32_t HRilCall::SetCallRestrictionResponse(
646 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
647 {
648 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCallRestrictionResponse);
649 }
650
SetBarringPasswordResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)651 int32_t HRilCall::SetBarringPasswordResponse(
652 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
653 {
654 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetBarringPasswordResponse);
655 }
656
StartDtmfResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)657 int32_t HRilCall::StartDtmfResponse(
658 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
659 {
660 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::StartDtmfResponse);
661 }
662
SendDtmfResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)663 int32_t HRilCall::SendDtmfResponse(
664 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
665 {
666 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SendDtmfResponse);
667 }
668
StopDtmfResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)669 int32_t HRilCall::StopDtmfResponse(
670 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
671 {
672 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::StopDtmfResponse);
673 }
674
GetCallPreferenceModeResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)675 int32_t HRilCall::GetCallPreferenceModeResponse(
676 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
677 {
678 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
679 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
680 return HRIL_ERR_INVALID_PARAMETER;
681 }
682 int32_t mode = 0;
683 if (response != nullptr) {
684 mode = *((int32_t *)response);
685 }
686 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallPreferenceModeResponse, mode);
687 }
688
SetCallPreferenceModeResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)689 int32_t HRilCall::SetCallPreferenceModeResponse(
690 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
691 {
692 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetCallPreferenceModeResponse);
693 }
694
SetUssdResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)695 int32_t HRilCall::SetUssdResponse(
696 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
697 {
698 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetUssdResponse);
699 }
700
GetMuteResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)701 int32_t HRilCall::GetMuteResponse(
702 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
703 {
704 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
705 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
706 return HRIL_ERR_INVALID_PARAMETER;
707 }
708 int32_t mute = 0;
709 if (response != nullptr) {
710 mute = *((int32_t *)response);
711 }
712 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetMuteResponse, mute);
713 }
714
SetMuteResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)715 int32_t HRilCall::SetMuteResponse(
716 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
717 {
718 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetMuteResponse);
719 }
720
GetUssdResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)721 int32_t HRilCall::GetUssdResponse(
722 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
723 {
724 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
725 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
726 return HRIL_ERR_INVALID_PARAMETER;
727 }
728 int32_t cusd = 0;
729 if (response != nullptr) {
730 cusd = *((int32_t *)response);
731 }
732 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetUssdResponse, cusd);
733 }
734
GetCallFailReasonResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)735 int32_t HRilCall::GetCallFailReasonResponse(
736 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
737 {
738 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
739 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
740 return HRIL_ERR_INVALID_PARAMETER;
741 }
742 int32_t callFail = HRIL_ERR_CALL_CAUSE;
743 if (response != nullptr) {
744 callFail = *((int32_t *)response);
745 }
746 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCallFailReasonResponse, callFail);
747 }
748
BuildIEmergencyCallList(HDI::Ril::V1_1::EmergencyInfoList & emergencyCallInfoList,const void * response,size_t responseLen)749 void HRilCall::BuildIEmergencyCallList(
750 HDI::Ril::V1_1::EmergencyInfoList &emergencyCallInfoList, const void *response, size_t responseLen)
751 {
752 size_t num = responseLen / sizeof(HRilEmergencyInfo);
753 HDI::Ril::V1_1::EmergencyCall callInfo;
754 emergencyCallInfoList.callSize = num;
755 for (size_t i = 0; i < num; i++) {
756 HRilEmergencyInfo *curPtr = ((HRilEmergencyInfo *)response + i);
757 if (curPtr != nullptr) {
758 callInfo.index = curPtr->index;
759 callInfo.total = curPtr->total;
760 callInfo.eccNum = (curPtr->eccNum == nullptr) ? "" : curPtr->eccNum;
761 callInfo.eccType = static_cast<OHOS::HDI::Ril::V1_1::EccType>(curPtr->category);
762 callInfo.simpresent = static_cast<OHOS::HDI::Ril::V1_1::SimpresentType>(curPtr->simpresent);
763 callInfo.mcc = (curPtr->mcc == nullptr) ? "" : curPtr->mcc;
764 callInfo.abnormalService = static_cast<OHOS::HDI::Ril::V1_1::AbnormalServiceType>(curPtr->abnormalService);
765 emergencyCallInfoList.calls.push_back(callInfo);
766 } else {
767 TELEPHONY_LOGE("BuildIEmergencyCallList: Invalid curPtr");
768 break;
769 }
770 }
771 }
772
GetEmergencyCallListResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)773 int32_t HRilCall::GetEmergencyCallListResponse(
774 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
775 {
776 if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilEmergencyInfo)) != 0) {
777 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
778 return HRIL_ERR_INVALID_PARAMETER;
779 }
780 HDI::Ril::V1_1::EmergencyInfoList callList = {};
781 if (response != nullptr) {
782 BuildIEmergencyCallList(callList, response, responseLen);
783 }
784 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetEmergencyCallListResponse, callList);
785 }
786
SetEmergencyCallList(int32_t serialId,const OHOS::HDI::Ril::V1_1::EmergencyInfoList & emergencyInfoList)787 int32_t HRilCall::SetEmergencyCallList(
788 int32_t serialId, const OHOS::HDI::Ril::V1_1::EmergencyInfoList &emergencyInfoList)
789 {
790 auto size = emergencyInfoList.calls.size();
791 std::unique_ptr<HRilEmergencyInfo[]> emergencyInfoCalls = std::make_unique<HRilEmergencyInfo[]>(size);
792 CopyToHRilEmergencyInfoArray(emergencyInfoCalls.get(), emergencyInfoList.calls);
793 return RequestVendor(serialId, HREQ_CALL_SET_EMERGENCY_LIST, callFuncs_, &HRilCallReq::SetEmergencyCallList,
794 emergencyInfoCalls.get(), size);
795 }
796
CopyToHRilEmergencyInfoArray(HRilEmergencyInfo * emergencyInfoCalls,std::vector<HDI::Ril::V1_1::EmergencyCall> calls)797 void HRilCall::CopyToHRilEmergencyInfoArray(
798 HRilEmergencyInfo *emergencyInfoCalls, std::vector<HDI::Ril::V1_1::EmergencyCall> calls)
799 {
800 for (unsigned int i = 0; i < calls.size(); i++) {
801 auto call = calls.at(i);
802 emergencyInfoCalls[i].index = call.index;
803 emergencyInfoCalls[i].total = call.total;
804 char *eccNum = new char[call.eccNum.size() + 1];
805 if (strcpy_s(eccNum, call.eccNum.size() + 1, call.eccNum.c_str()) == EOK) {
806 emergencyInfoCalls[i].eccNum = eccNum;
807 } else {
808 delete[] eccNum;
809 eccNum = nullptr;
810 }
811 emergencyInfoCalls[i].category = static_cast<int32_t>(call.eccType);
812 emergencyInfoCalls[i].simpresent = call.simpresent;
813 char *mcc = new char[call.mcc.size() + 1];
814 if (strcpy_s(mcc, call.mcc.size() + 1, call.mcc.c_str()) == EOK) {
815 emergencyInfoCalls[i].mcc = mcc;
816 } else {
817 delete[] mcc;
818 mcc = nullptr;
819 }
820 emergencyInfoCalls[i].abnormalService = call.abnormalService;
821 }
822 }
823
SetEmergencyCallListResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)824 int32_t HRilCall::SetEmergencyCallListResponse(
825 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
826 {
827 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetEmergencyCallListResponse);
828 }
829
CloseUnFinishedUssdResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)830 int32_t HRilCall::CloseUnFinishedUssdResponse(
831 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
832 {
833 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::CloseUnFinishedUssdResponse);
834 }
835
SetVonrSwitchResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)836 int32_t HRilCall::SetVonrSwitchResponse(
837 int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
838 {
839 return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetVonrSwitchResponse);
840 }
841
CallStateUpdated(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)842 int32_t HRilCall::CallStateUpdated(
843 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
844 {
845 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallStateUpdated);
846 }
847
CallUssdNotice(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)848 int32_t HRilCall::CallUssdNotice(
849 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
850 {
851 if ((response == nullptr) || (responseLen % sizeof(HRilUssdNoticeInfo)) != 0) {
852 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
853 return HRIL_ERR_INVALID_PARAMETER;
854 }
855 HDI::Ril::V1_1::UssdNoticeInfo ussdNoticeInfo = {};
856 const HRilUssdNoticeInfo *hUssdNoticeInfo = reinterpret_cast<const HRilUssdNoticeInfo *>(response);
857 ussdNoticeInfo.type = hUssdNoticeInfo->m;
858 ussdNoticeInfo.message = hUssdNoticeInfo->str == nullptr ? "" : hUssdNoticeInfo->str;
859 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallUssdNotice, ussdNoticeInfo);
860 }
861
CallSsNotice(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)862 int32_t HRilCall::CallSsNotice(int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
863 {
864 if ((response == nullptr) || (responseLen % sizeof(HRilSsNoticeInfo)) != 0) {
865 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
866 return HRIL_ERR_INVALID_PARAMETER;
867 }
868 HDI::Ril::V1_1::SsNoticeInfo ssNoticeInfo = {};
869 const HRilSsNoticeInfo *hSsNoticeInfo = reinterpret_cast<const HRilSsNoticeInfo *>(response);
870 ssNoticeInfo.serviceType = hSsNoticeInfo->serviceType;
871 ssNoticeInfo.requestType = hSsNoticeInfo->requestType;
872 ssNoticeInfo.serviceClass = hSsNoticeInfo->serviceClass;
873 ssNoticeInfo.result = hSsNoticeInfo->result;
874 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallSsNotice, ssNoticeInfo);
875 }
876
CallSrvccStatusNotice(int32_t notifyType,HRilErrNumber error,const void * response,size_t responseLen)877 int32_t HRilCall::CallSrvccStatusNotice(
878 int32_t notifyType, HRilErrNumber error, const void *response, size_t responseLen)
879 {
880 if ((response == nullptr) || (responseLen % sizeof(HRilCallSrvccStatus)) != 0) {
881 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
882 return HRIL_ERR_INVALID_PARAMETER;
883 }
884 HDI::Ril::V1_1::SrvccStatus srvccStatus = {};
885 const HRilCallSrvccStatus *hSrvccStatus = reinterpret_cast<const HRilCallSrvccStatus *>(response);
886 srvccStatus.status = hSrvccStatus->status;
887 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallSrvccStatusNotice, srvccStatus);
888 }
889
CallRingbackVoiceNotice(int32_t notifyType,HRilErrNumber error,const void * response,size_t responseLen)890 int32_t HRilCall::CallRingbackVoiceNotice(
891 int32_t notifyType, HRilErrNumber error, const void *response, size_t responseLen)
892 {
893 if ((response == nullptr) || (responseLen % sizeof(int32_t)) != 0) {
894 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
895 return HRIL_ERR_INVALID_PARAMETER;
896 }
897 HDI::Ril::V1_1::RingbackVoice ringbackVoice = {};
898 const int32_t *ringbackVoiceFlag = reinterpret_cast<const int32_t *>(response);
899 ringbackVoice.status = *ringbackVoiceFlag;
900 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallRingbackVoiceNotice, ringbackVoice);
901 }
902
CallEmergencyNotice(int32_t notifyType,const HRilErrNumber error,const void * response,size_t responseLen)903 int32_t HRilCall::CallEmergencyNotice(
904 int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
905 {
906 if (response == nullptr || responseLen == 0 || (responseLen % sizeof(HRilEmergencyInfo)) != 0) {
907 TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
908 return HRIL_ERR_INVALID_PARAMETER;
909 }
910 HDI::Ril::V1_1::EmergencyInfoList callList = {};
911 BuildIEmergencyCallList(callList, response, responseLen);
912 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallEmergencyNotice, callList);
913 }
914
CallRsrvccStatusNotify(int32_t notifyType,HRilErrNumber error,const void * response,size_t responseLen)915 int32_t HRilCall::CallRsrvccStatusNotify(
916 int32_t notifyType, HRilErrNumber error, const void *response, size_t responseLen)
917 {
918 return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::CallRsrvccStatusNotify);
919 }
920
RegisterCallFuncs(const HRilCallReq * callFuncs)921 void HRilCall::RegisterCallFuncs(const HRilCallReq *callFuncs)
922 {
923 callFuncs_ = callFuncs;
924 }
925 } // namespace Telephony
926 } // namespace OHOS
927