1 /*
2  * Copyright (c) 2024 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 "hdf_ril_callback_common.h"
17 
18 OHOS::sptr<OHOS::HDI::Ril::V1_3::IRil> g_rilInterface = nullptr;
19 RilCallback g_callback;
20 
21 std::map<int32_t, int32_t> g_simState;
22 int32_t g_currentChannelld = 1;
23 int32_t g_currentSerialId = 0;
24 bool g_hangupResponseFlag = false;
25 bool g_rejectResponseFlag = false;
26 bool g_answerResponseFlag = false;
27 bool g_holdCallResponseFlag = false;
28 bool g_unHoldCallResponseFlag = false;
29 bool g_switchCallResponseFlag = false;
30 bool g_getClipResponseFlag = false;
31 bool g_setClipResponseFlag = false;
32 bool g_simStkSendTerminalResponseResponseFlag = false;
33 bool g_simStkSendEnvelopeResponseFlag = false;
34 bool g_simStkSendCallSetupRequestResultResponseFlag = false;
35 bool g_simStkIsReadyResponseFlag = false;
36 bool g_getRadioProtocolResponseFlag = false;
37 bool g_setRadioProtocolResponseFlag = false;
38 bool g_simOpenLogicalChannelResponseFlag = false;
39 bool g_simCloseLogicalChannelResponseFlag = false;
40 bool g_simTransmitApduLogicalChannelResponseFlag = false;
41 bool g_simTransmitApduBasicChannelResponseFlag = false;
42 bool g_simAuthenticationResponseFlag = false;
43 bool g_unlockSimLockResponseFlag = false;
44 bool g_getSignalStrengthResponseFlag = false;
45 bool g_getCsRegStatusResponseFlag = false;
46 bool g_getPsRegStatusResponseFlag = false;
47 bool g_getOperatorInfoResponseFlag = false;
48 bool g_getNetworkSearchInformationResponseFlag = false;
49 bool g_getNetworkSelectionModeResponseFlag = false;
50 bool g_getNeighboringCellInfoListResponseFlag = false;
51 bool g_getCurrentCellInfoResponseFlag = false;
52 bool g_getCurrentCellInfoResponse11Flag = false;
53 bool g_setNetworkSelectionModeResponseFlag = false;
54 bool g_setLocateUpdatesResponseFlag = false;
55 bool g_setNotificationFilterResponseFlag = false;
56 bool g_setDeviceStateResponseFlag = false;
57 bool g_sendGsmSmsResponseFlag = false;
58 bool g_sendCdmaSmsResponseFlag = false;
59 bool g_addSimMessageResponseFlag = false;
60 bool g_delSimMessageResponseFlag = false;
61 bool g_updateSimMessageResponseFlag = false;
62 bool g_addCdmaSimMessageResponseFlag = false;
63 bool g_delCdmaSimMessageResponseFlag = false;
64 bool g_setPreferredNetworkResponseFlag = false;
65 bool g_getPreferredNetworkResponseFlag = false;
66 bool g_getPhysicalChannelConfigResponseFlag = false;
67 bool g_separateConferenceResponseFlag = false;
68 bool g_callSupplementResponseFlag = false;
69 bool g_getCallWaitingResponseFlag = false;
70 bool g_setCallWaitingResponseFlag = false;
71 bool g_getUssdResponseFlag = false;
72 bool g_setMuteResponseFlag = false;
73 bool g_getMuteResponseFlag = false;
74 bool g_setDataPermittedResponseFlag = false;
75 bool g_shutDownResponseFlag = false;
76 bool g_setRadioStateResponseFlag = false;
77 bool g_getRadioStateResponseFlag = false;
78 bool g_getImeiResponseFlag = false;
79 bool g_getImeiSvResponseFlag = false;
80 bool g_getMeidResponseFlag = false;
81 bool g_getBasebandVersionResponseFlag = false;
82 bool g_getImsiResponseFlag = false;
83 bool g_setActiveSimResponseFlag = false;
84 bool g_setNrOptionModeResponseFlag = false;
85 bool g_getNrOptionModeResponseFlag = false;
86 bool g_dialResponseFlag = false;
87 bool g_setCdmaCBConfigResponseFlag = false;
88 bool g_getCdmaCBConfigResponseFlag = false;
89 bool g_sendSmsMoreModeResponseFlag = false;
90 bool g_sendSmsAckResponseFlag = false;
91 bool g_updateCdmaSimMessageResponseFlag = false;
92 bool g_setSmscAddrResponseFlag = false;
93 bool g_getSmscAddrResponseFlag = false;
94 bool g_setCBConfigResponseFlag = false;
95 bool g_getCBConfigResponseFlag = false;
96 bool g_signalStrengthUpdatedFlag = false;
97 bool g_networkPhyChnlCfgUpdatedFlag = false;
98 bool g_networkCurrentCellUpdatedFlag = false;
99 bool g_setCallTransferInfoResponseFlag = false;
100 bool g_getCallRestrictionResponseFlag = false;
101 bool g_setCallRestrictionResponseFlag = false;
102 bool g_getClirResponseFlag = false;
103 bool g_setClirResponseFlag = false;
104 bool g_startDtmfResponseFlag = false;
105 bool g_sendDtmfResponseFlag = false;
106 bool g_stopDtmfResponseFlag = false;
107 bool g_getCallPreferenceModeResponseFlag = false;
108 bool g_setCallPreferenceModeResponseFlag = false;
109 bool g_setUssdResponseFlag = false;
110 bool g_closeUnFinishedUssdResponseFlag = false;
111 bool g_getCallFailReasonResponseFlag = false;
112 bool g_setBarringPasswordResponseFlag = false;
113 bool g_deactivatePdpContextResponseFlag = false;
114 bool g_getPdpContextListResponseFlag = false;
115 bool g_setInitApnInfoResponseFlag = false;
116 bool g_getLinkBandwidthInfoResponseFlag = false;
117 bool g_getLinkCapabilityResponseFlag = false;
118 bool g_getVoiceRadioTechnologyResponseFlag = false;
119 bool g_getSimIOResponseFlag = false;
120 bool g_getSimStatusResponseFlag = false;
121 bool g_getSimCardStatusResponseFlag = false;
122 bool g_setSimLockResponseFlag = false;
123 bool g_changeSimPasswordResponseFlag = false;
124 bool g_unlockPinResponseFlag = false;
125 bool g_unlockPukResponseFlag = false;
126 bool g_unlockPin2ResponseFlag = false;
127 bool g_unlockPuk2ResponseFlag = false;
128 bool g_setVonrSwitchResponseFlag = false;
129 bool g_getSimLockStatusResponseFlag = false;
130 bool g_getCallTransferInfoResponseFlag = false;
131 bool g_combineConferenceResponseFlag = false;
132 bool g_getCallListResponseFlag = false;
133 bool g_getEmergencyCallListResponseFlag = false;
134 bool g_setEmergencyCallListResponse = false;
135 /**
136 ** RilCallback implement
137 **/
NotifyAll()138 void RilCallback::NotifyAll()
139 {
140     std::unique_lock<std::mutex> callbackLock(callbackMutex_);
141     if (resultInfo_.serial != g_currentSerialId) {
142         hdiId_ = HdiId::HREQ_NONE;
143         HDF_LOGI("NotifyAll g_currentSerialId : %{public}d, serial: %{public}d not equal", g_currentSerialId,
144                  resultInfo_.serial);
145         return;
146     }
147     cv_.notify_all();
148 }
149 
WaitFor(int32_t timeoutSecond)150 void RilCallback::WaitFor(int32_t timeoutSecond)
151 {
152     Clean();
153     std::unique_lock<std::mutex> callbackLock(callbackMutex_);
154     cv_.wait_for(callbackLock, std::chrono::seconds(timeoutSecond));
155 }
156 
Clean()157 void RilCallback::Clean() { hdiId_ = HdiId::HREQ_NONE; }
158 
GetBoolResult(HdiId hdiId)159 bool RilCallback::GetBoolResult(HdiId hdiId)
160 {
161     HDF_LOGI("GetBoolResult hdiId: %{public}d, error: %{public}d", hdiId, static_cast<int32_t>(resultInfo_.error));
162     bool ret = false;
163     if (hdiId_ == HdiId::HREQ_NONE) {
164         HDF_LOGE("response timeout, not implemented."
165                  "hdiId: %d, current hdiId_: %{public}d",
166                  static_cast<int32_t>(hdiId), hdiId_);
167         ret = true;
168         Clean();
169         return ret;
170     }
171     if (hdiId_ != hdiId) {
172         ret = false;
173         HDF_LOGE("GetBoolResult hdiId does not match. hdiId: %{public}d, current hdiId: %{public}d",
174                  static_cast<int32_t>(hdiId), hdiId_);
175         Clean();
176         return ret;
177     }
178     ret = true;
179     Clean();
180     return ret;
181 }
182 
SimStateUpdated(const RilRadioResponseInfo &responseInfo)183 int32_t RilCallback::SimStateUpdated(const RilRadioResponseInfo &responseInfo)
184 {
185     HDF_LOGI("SimStateUpdated notice : slotId = %{public}d", responseInfo.slotId);
186     g_rilInterface->GetSimStatus(GetSerialId(), responseInfo.slotId);
187     return 0;
188 }
189 
SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo)190 int32_t RilCallback::SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo)
191 {
192     HDF_LOGI("SimStkSessionEndNotify notice : slotId = %{public}d", responseInfo.slotId);
193     return 0;
194 }
195 
SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)196 int32_t RilCallback::SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
197 {
198     HDF_LOGI("SimStkProactiveNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId,
199              response.c_str());
200     return 0;
201 }
202 
SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)203 int32_t RilCallback::SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
204 {
205     HDF_LOGI("SimStkAlphaNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId,
206              response.c_str());
207     return 0;
208 }
209 
SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)210 int32_t RilCallback::SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
211 {
212     HDF_LOGI("SimStkEventNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId,
213              response.c_str());
214     return 0;
215 }
216 
SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo)217 int32_t RilCallback::SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo)
218 {
219     HDF_LOGI("SimStkCallSetupNotify notice : slotId = %{public}d", responseInfo.slotId);
220     return 0;
221 }
222 
SimRefreshNotify(const RilRadioResponseInfo &responseInfo)223 int32_t RilCallback::SimRefreshNotify(const RilRadioResponseInfo &responseInfo)
224 {
225     HDF_LOGI("SimRefreshNotify notice : slotId = %{public}d", responseInfo.slotId);
226     return 0;
227 }
228 
GetSimStatusResponse(const RilRadioResponseInfo &responseInfo, const CardStatusInfo &result)229 int32_t RilCallback::GetSimStatusResponse(const RilRadioResponseInfo &responseInfo, const CardStatusInfo &result)
230 {
231     g_getSimStatusResponseFlag = true;
232     HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, g_simState = %{public}d",
233              responseInfo.slotId, result.simType, result.simState);
234     g_simState[responseInfo.slotId] = result.simState;
235     HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, g_simState[responseInfo.slotId]);
236     hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
237     resultInfo_ = responseInfo;
238     NotifyAll();
239     return 0;
240 }
241 
GetSimCardStatusResponse(const RilRadioResponseInfo &responseInfo, const SimCardStatusInfo &result)242 int32_t RilCallback::GetSimCardStatusResponse(const RilRadioResponseInfo &responseInfo, const SimCardStatusInfo &result)
243 {
244     g_getSimCardStatusResponseFlag = true;
245     HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, g_simState = %{public}d",
246              responseInfo.slotId, result.simType, result.simState);
247     g_simState[responseInfo.slotId] = result.simState;
248     HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, g_simState[responseInfo.slotId]);
249     hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
250     resultInfo_ = responseInfo;
251     NotifyAll();
252     return 0;
253 }
254 
GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)255 int32_t RilCallback::GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
256 {
257     g_getSimIOResponseFlag = true;
258     HDF_LOGI("GetBoolResult GetSimIO result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s", result.sw1,
259              result.sw2, result.response.c_str());
260     hdiId_ = HdiId::HREQ_SIM_GET_SIM_IO;
261     resultInfo_ = responseInfo;
262     NotifyAll();
263     return 0;
264 }
265 
GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response)266 int32_t RilCallback::GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response)
267 {
268     g_getImsiResponseFlag = true;
269     HDF_LOGI("GetBoolResult GetImsi result : response = %{public}s", response.c_str());
270     hdiId_ = HdiId::HREQ_SIM_GET_IMSI;
271     resultInfo_ = responseInfo;
272     NotifyAll();
273     return 0;
274 }
GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus)275 int32_t RilCallback::GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus)
276 {
277     g_getSimLockStatusResponseFlag = true;
278     HDF_LOGI("GetBoolResult GetSimLockStatus result : simLockStatus = %{public}d", simLockStatus);
279     hdiId_ = HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS;
280     resultInfo_ = responseInfo;
281     NotifyAll();
282     return 0;
283 }
SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)284 int32_t RilCallback::SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
285 {
286     g_setSimLockResponseFlag = true;
287     HDF_LOGI("GetBoolResult SetSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
288              lockStatus.remain);
289     hdiId_ = HdiId::HREQ_SIM_SET_SIM_LOCK;
290     resultInfo_ = responseInfo;
291     NotifyAll();
292     return 0;
293 }
ChangeSimPasswordResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)294 int32_t RilCallback::ChangeSimPasswordResponse(const RilRadioResponseInfo &responseInfo,
295                                                const LockStatusResp &lockStatus)
296 {
297     g_changeSimPasswordResponseFlag = true;
298     HDF_LOGI("GetBoolResult ChangeSimPassword result : result = %{public}d, remain = %{public}d", lockStatus.result,
299              lockStatus.remain);
300     hdiId_ = HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD;
301     resultInfo_ = responseInfo;
302     NotifyAll();
303     return 0;
304 }
UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)305 int32_t RilCallback::UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
306 {
307     g_unlockPinResponseFlag = true;
308     HDF_LOGI("GetBoolResult UnlockPin result : result = %{public}d, remain = %{public}d", lockStatus.result,
309              lockStatus.remain);
310     hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN;
311     resultInfo_ = responseInfo;
312     NotifyAll();
313     return 0;
314 }
UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)315 int32_t RilCallback::UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
316 {
317     g_unlockPukResponseFlag = true;
318     HDF_LOGI("GetBoolResult UnlockPuk result : result = %{public}d, remain = %{public}d", lockStatus.result,
319              lockStatus.remain);
320     hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK;
321     resultInfo_ = responseInfo;
322     NotifyAll();
323     return 0;
324 }
UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)325 int32_t RilCallback::UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
326 {
327     g_unlockPin2ResponseFlag = true;
328     HDF_LOGI("GetBoolResult UnlockPin2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
329              lockStatus.remain);
330     hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN2;
331     resultInfo_ = responseInfo;
332     NotifyAll();
333     return 0;
334 }
UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)335 int32_t RilCallback::UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
336 {
337     g_unlockPuk2ResponseFlag = true;
338     HDF_LOGI("GetBoolResult UnlockPuk2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
339              lockStatus.remain);
340     hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK2;
341     resultInfo_ = responseInfo;
342     NotifyAll();
343     return 0;
344 }
345 
SetActiveSimResponse(const RilRadioResponseInfo &responseInfo)346 int32_t RilCallback::SetActiveSimResponse(const RilRadioResponseInfo &responseInfo)
347 {
348     g_setActiveSimResponseFlag = true;
349     HDF_LOGI("GetBoolResult SetActiveSim result");
350     hdiId_ = HdiId::HREQ_SIM_SET_ACTIVE_SIM;
351     resultInfo_ = responseInfo;
352     NotifyAll();
353     return 0;
354 }
355 
SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo)356 int32_t RilCallback::SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo)
357 {
358     g_simStkSendTerminalResponseResponseFlag = true;
359     HDF_LOGI("GetBoolResult SimStkSendTerminalResponse result");
360     hdiId_ = HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE;
361     resultInfo_ = responseInfo;
362     NotifyAll();
363     return 0;
364 }
365 
SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo)366 int32_t RilCallback::SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo)
367 {
368     g_simStkSendEnvelopeResponseFlag = true;
369     HDF_LOGI("GetBoolResult SimStkSendEnvelope result");
370     hdiId_ = HdiId::HREQ_SIM_STK_SEND_ENVELOPE;
371     resultInfo_ = responseInfo;
372     NotifyAll();
373     return 0;
374 }
375 
SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo)376 int32_t RilCallback::SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo)
377 {
378     g_simStkSendCallSetupRequestResultResponseFlag = true;
379     HDF_LOGI("GetBoolResult SimStkSendCallSetupRequestResult result");
380     hdiId_ = HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT;
381     resultInfo_ = responseInfo;
382     NotifyAll();
383     return 0;
384 }
385 
SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo)386 int32_t RilCallback::SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo)
387 {
388     g_simStkIsReadyResponseFlag = true;
389     HDF_LOGI("GetBoolResult SimStkIsReady result");
390     hdiId_ = HdiId::HREQ_SIM_STK_IS_READY;
391     resultInfo_ = responseInfo;
392     NotifyAll();
393     return 0;
394 }
395 
SetRadioProtocolResponse(const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol)396 int32_t RilCallback::SetRadioProtocolResponse(const RilRadioResponseInfo &responseInfo,
397                                               const RadioProtocol &radioProtocol)
398 {
399     g_setRadioProtocolResponseFlag = true;
400     HDF_LOGI("GetBoolResult SetRadioProtocol result : phase = %{public}d, slotId = %{public}d", radioProtocol.phase,
401              radioProtocol.slotId);
402     hdiId_ = HdiId::HREQ_SIM_RADIO_PROTOCOL;
403     resultInfo_ = responseInfo;
404     NotifyAll();
405     return 0;
406 }
407 
GetRadioProtocolResponse(const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol)408 int32_t RilCallback::GetRadioProtocolResponse(const RilRadioResponseInfo &responseInfo,
409                                               const RadioProtocol &radioProtocol)
410 {
411     g_getRadioProtocolResponseFlag = true;
412     return 0;
413 }
414 
SimOpenLogicalChannelResponse(const RilRadioResponseInfo &responseInfo, const OpenLogicalChannelResponse &pOpenLogicalChannelResponse)415 int32_t RilCallback::SimOpenLogicalChannelResponse(const RilRadioResponseInfo &responseInfo,
416                                                    const OpenLogicalChannelResponse &pOpenLogicalChannelResponse)
417 {
418     g_simOpenLogicalChannelResponseFlag = true;
419     HDF_LOGI("GetBoolResult SimOpenLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, channelId = %{public}d, "
420              "response = %{public}s",
421              pOpenLogicalChannelResponse.sw1, pOpenLogicalChannelResponse.sw2, pOpenLogicalChannelResponse.channelId,
422              pOpenLogicalChannelResponse.response.c_str());
423     g_currentChannelld = pOpenLogicalChannelResponse.channelId;
424     hdiId_ = HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL;
425     resultInfo_ = responseInfo;
426     NotifyAll();
427     return 0;
428 }
429 
SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo)430 int32_t RilCallback::SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo)
431 {
432     g_simCloseLogicalChannelResponseFlag = true;
433     HDF_LOGI("GetBoolResult SimCloseLogicalChannel result");
434     hdiId_ = HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL;
435     resultInfo_ = responseInfo;
436     NotifyAll();
437     return 0;
438 }
439 
SimTransmitApduLogicalChannelResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)440 int32_t RilCallback::SimTransmitApduLogicalChannelResponse(const RilRadioResponseInfo &responseInfo,
441                                                            const IccIoResultInfo &result)
442 {
443     g_simTransmitApduLogicalChannelResponseFlag = true;
444     HDF_LOGI("GetBoolResult SimTransmitApduLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, response = "
445              "%{public}s",
446              result.sw1, result.sw2, result.response.c_str());
447     hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL;
448     resultInfo_ = responseInfo;
449     NotifyAll();
450     return 0;
451 }
452 
SimTransmitApduBasicChannelResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)453 int32_t RilCallback::SimTransmitApduBasicChannelResponse(const RilRadioResponseInfo &responseInfo,
454                                                          const IccIoResultInfo &result)
455 {
456     g_simTransmitApduBasicChannelResponseFlag = true;
457     HDF_LOGI(
458         "GetBoolResult SimTransmitApduBasicChannel result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
459         result.sw1, result.sw2, result.response.c_str());
460     hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL;
461     resultInfo_ = responseInfo;
462     NotifyAll();
463     return 0;
464 }
SimAuthenticationResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)465 int32_t RilCallback::SimAuthenticationResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
466 {
467     g_simAuthenticationResponseFlag = true;
468     HDF_LOGI("GetBoolResult SimAuthentication result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
469              result.sw1, result.sw2, result.response.c_str());
470     hdiId_ = HdiId::HREQ_SIM_AUTHENTICATION;
471     resultInfo_ = responseInfo;
472     NotifyAll();
473     return 0;
474 }
475 
UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)476 int32_t RilCallback::UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
477 {
478     g_unlockSimLockResponseFlag = true;
479     HDF_LOGI("GetBoolResult UnlockSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
480              lockStatus.remain);
481     hdiId_ = HdiId::HREQ_SIM_UNLOCK_SIM_LOCK;
482     resultInfo_ = responseInfo;
483     NotifyAll();
484     return 0;
485 }
486 
SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo)487 int32_t RilCallback::SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo)
488 {
489     HDF_LOGI("GetBoolResult SendSimMatchedOperatorInfo result");
490     hdiId_ = HdiId::HREQ_SIM_SEND_NCFG_OPER_INFO;
491     resultInfo_ = responseInfo;
492     NotifyAll();
493     return 0;
494 }
495 
NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo)496 int32_t RilCallback::NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
497                                                const CsRegStatusInfo &csRegStatusInfo)
498 {
499     HDF_LOGI("RilCallback::NetworkCsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, "
500              "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
501              csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
502              csRegStatusInfo.radioTechnology);
503     return 0;
504 }
505 
NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo)506 int32_t RilCallback::NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
507                                                const PsRegStatusInfo &psRegStatusInfo)
508 {
509     HDF_LOGI(
510         "RilCallback::NetworkPsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
511         "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
512         psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
513         psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
514         psRegStatusInfo.isEnDcAvailable);
515     return 0;
516 }
517 
SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)518 int32_t RilCallback::SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
519 {
520     g_signalStrengthUpdatedFlag = true;
521     HDF_LOGI("RilCallback::SignalStrengthUpdated rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
522     return 0;
523 }
524 
NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr)525 int32_t RilCallback::NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr)
526 {
527     HDF_LOGI("RilCallback::NetworkTimeZoneUpdated timeZone:%{public}s", timeZoneStr.c_str());
528     return 0;
529 }
530 
NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr)531 int32_t RilCallback::NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr)
532 {
533     HDF_LOGI("RilCallback::NetworkTimeZoneUpdated time:%{public}s", timeStr.c_str());
534     return 0;
535 }
536 
NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList)537 int32_t RilCallback::NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo,
538                                               const ChannelConfigInfoList &channelConfigInfoList)
539 {
540     g_networkPhyChnlCfgUpdatedFlag = true;
541     HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated itemNum:%{public}d", channelConfigInfoList.itemNum);
542     for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
543         HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated cellConnStatus:%{public}d, "
544                  "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
545                  "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
546                  "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
547                  phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
548                  phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
549                  phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
550         for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
551             HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
552         }
553     }
554     return 0;
555 }
556 
NetworkCurrentCellUpdated(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellListCurrentInfo)557 int32_t RilCallback::NetworkCurrentCellUpdated(const RilRadioResponseInfo &responseInfo,
558                                                const CellListCurrentInfo &cellListCurrentInfo)
559 {
560     g_networkCurrentCellUpdatedFlag = true;
561     HDF_LOGI("RilCallback::NetworkCurrentCellUpdated itemNum:%{public}d", cellListCurrentInfo.itemNum);
562     for (auto info : cellListCurrentInfo.cellCurrentInfo) {
563         HDF_LOGI("RilCallback::NetworkCurrentCellUpdated ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
564                  info.ratType, info.mcc, info.mnc);
565         switch (static_cast<RatType>(info.ratType)) {
566             case RatType::NETWORK_TYPE_LTE:
567                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
568                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
569                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
570                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
571                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
572                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
573                 break;
574             case RatType::NETWORK_TYPE_GSM:
575                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
576                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
577                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
578                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
579                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
580                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
581                 break;
582             case RatType::NETWORK_TYPE_WCDMA:
583                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
584                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
585                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
586                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
587                 break;
588             case RatType::NETWORK_TYPE_NR:
589                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
590                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
591                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
592                 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
593                 break;
594             default:
595                 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated invalid ratType");
596         }
597     }
598     return 0;
599 }
600 
NetworkCurrentCellUpdated_1_1(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)601 int32_t RilCallback::NetworkCurrentCellUpdated_1_1(const RilRadioResponseInfo &responseInfo,
602                                                    const CellListCurrentInfo_1_1 &cellListCurrentInfo)
603 {
604     HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
605     for (auto info : cellListCurrentInfo.cellCurrentInfo) {
606         HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
607                  info.ratType, info.mcc, info.mnc);
608         switch (static_cast<RatType>(info.ratType)) {
609             case RatType::NETWORK_TYPE_LTE:
610                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
611                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
612                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
613                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
614                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
615                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
616                 break;
617             case RatType::NETWORK_TYPE_GSM:
618                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
619                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
620                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
621                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
622                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
623                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
624                 break;
625             case RatType::NETWORK_TYPE_WCDMA:
626                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
627                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
628                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
629                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
630                 break;
631             case RatType::NETWORK_TYPE_NR:
632                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
633                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
634                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
635                 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
636                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
637                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
638                 break;
639             default:
640                 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated_1_1 invalid ratType");
641         }
642     }
643     return 0;
644 }
645 
NetworkCurrentCellUpdated_1_2(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)646 int32_t RilCallback::NetworkCurrentCellUpdated_1_2(const RilRadioResponseInfo &responseInfo,
647                                                    const CellListCurrentInfo_1_2 &cellListCurrentInfo)
648 {
649     HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
650     for (auto info : cellListCurrentInfo.cellCurrentInfo) {
651         HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
652         switch (static_cast<RatType>(info.ratType)) {
653             case RatType::NETWORK_TYPE_LTE:
654                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
655                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
656                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
657                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
658                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
659                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
660                 break;
661             case RatType::NETWORK_TYPE_GSM:
662                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
663                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
664                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
665                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
666                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
667                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
668                 break;
669             case RatType::NETWORK_TYPE_WCDMA:
670                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
671                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
672                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
673                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
674                 break;
675             case RatType::NETWORK_TYPE_NR:
676                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
677                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
678                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
679                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
680                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
681                 break;
682             default:
683                 HDF_LOGE("invalid ratType");
684                 break;
685         }
686     }
687     return 0;
688 }
689 
ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn)690 int32_t RilCallback::ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn)
691 {
692     HDF_LOGI("RilCallback::ResidentNetworkUpdated plmn:%{public}s", plmn.c_str());
693     return 0;
694 }
695 
GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)696 int32_t RilCallback::GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
697 {
698     g_getSignalStrengthResponseFlag = true;
699     HDF_LOGI("RilCallback::GetSignalStrengthResponse rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
700     hdiId_ = HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH;
701     resultInfo_ = responseInfo;
702     NotifyAll();
703     return 0;
704 }
705 
GetCsRegStatusResponse(const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo)706 int32_t RilCallback::GetCsRegStatusResponse(const RilRadioResponseInfo &responseInfo,
707                                             const CsRegStatusInfo &csRegStatusInfo)
708 {
709     g_getCsRegStatusResponseFlag = true;
710     HDF_LOGI("RilCallback::GetCsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, "
711              "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
712              csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
713              csRegStatusInfo.radioTechnology);
714     hdiId_ = HdiId::HREQ_NETWORK_GET_CS_REG_STATUS;
715     resultInfo_ = responseInfo;
716     NotifyAll();
717     return 0;
718 }
719 
GetPsRegStatusResponse(const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo)720 int32_t RilCallback::GetPsRegStatusResponse(const RilRadioResponseInfo &responseInfo,
721                                             const PsRegStatusInfo &psRegStatusInfo)
722 {
723     g_getPsRegStatusResponseFlag = true;
724     HDF_LOGI(
725         "RilCallback::GetPsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
726         "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
727         psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
728         psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
729         psRegStatusInfo.isEnDcAvailable);
730     hdiId_ = HdiId::HREQ_NETWORK_GET_PS_REG_STATUS;
731     resultInfo_ = responseInfo;
732     NotifyAll();
733     return 0;
734 }
735 
GetOperatorInfoResponse(const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo)736 int32_t RilCallback::GetOperatorInfoResponse(const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo)
737 {
738     g_getOperatorInfoResponseFlag = true;
739     HDF_LOGI("RilCallback::GetOperatorInfoResponse longName:%{public}s, shortName:%{public}s, numeric:%{public}s",
740              operatorInfo.longName.c_str(), operatorInfo.shortName.c_str(), operatorInfo.numeric.c_str());
741     hdiId_ = HdiId::HREQ_NETWORK_GET_OPERATOR_INFO;
742     resultInfo_ = responseInfo;
743     NotifyAll();
744     return 0;
745 }
746 
GetNetworkSearchInformationResponse(const RilRadioResponseInfo &responseInfo, const AvailableNetworkList &availableNetworkList)747 int32_t RilCallback::GetNetworkSearchInformationResponse(const RilRadioResponseInfo &responseInfo,
748                                                          const AvailableNetworkList &availableNetworkList)
749 {
750     g_getNetworkSearchInformationResponseFlag = true;
751     HDF_LOGI("RilCallback::GetNetworkSearchInformationResponse itemNum:%{public}d", availableNetworkList.itemNum);
752     for (auto availableInfo : availableNetworkList.availableNetworkInfo) {
753         HDF_LOGI("status:%{public}d", availableInfo.status);
754         HDF_LOGI("numeric:%{public}s", availableInfo.numeric.c_str());
755         HDF_LOGI("shortName:%{public}s", availableInfo.shortName.c_str());
756         HDF_LOGI("longName:%{public}s", availableInfo.longName.c_str());
757         HDF_LOGI("rat:%{public}d", availableInfo.rat);
758     }
759     hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION;
760     resultInfo_ = responseInfo;
761     NotifyAll();
762     return 0;
763 }
764 
GetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo, const SetNetworkModeInfo &setNetworkModeInfo)765 int32_t RilCallback::GetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo,
766                                                      const SetNetworkModeInfo &setNetworkModeInfo)
767 {
768     g_getNetworkSelectionModeResponseFlag = true;
769     HDF_LOGI("RilCallback::GetNetworkSelectionModeResponse selectMode:%{public}d", setNetworkModeInfo.selectMode);
770     hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE;
771     resultInfo_ = responseInfo;
772     NotifyAll();
773     return 0;
774 }
775 
SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo)776 int32_t RilCallback::SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo)
777 {
778     g_setNetworkSelectionModeResponseFlag = true;
779     HDF_LOGI("RilCallback::SetNetworkSelectionModeResponse error:%{public}d", responseInfo.error);
780     hdiId_ = HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE;
781     resultInfo_ = responseInfo;
782     NotifyAll();
783     return 0;
784 }
785 
GetNeighboringCellInfoListResponse(const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo &cellInfoList)786 int32_t RilCallback::GetNeighboringCellInfoListResponse(const RilRadioResponseInfo &responseInfo,
787                                                         const CellListNearbyInfo &cellInfoList)
788 {
789     g_getNeighboringCellInfoListResponseFlag = true;
790     HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse itemNum:%{public}d", cellInfoList.itemNum);
791     for (auto info : cellInfoList.cellNearbyInfo) {
792         HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse ratType:%{public}d", info.ratType);
793         switch (static_cast<RatType>(info.ratType)) {
794             case RatType::NETWORK_TYPE_LTE:
795                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
796                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
797                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
798                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
799                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
800                 break;
801             case RatType::NETWORK_TYPE_GSM:
802                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
803                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
804                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
805                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
806                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
807                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
808                 break;
809             case RatType::NETWORK_TYPE_WCDMA:
810                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
811                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
812                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
813                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
814                 break;
815             case RatType::NETWORK_TYPE_NR:
816                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
817                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
818                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
819                 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
820                 break;
821             default:
822                 HDF_LOGE("RilCallback::GetNeighboringCellInfoListResponse invalid ratType");
823         }
824     }
825     hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
826     resultInfo_ = responseInfo;
827     NotifyAll();
828     return 0;
829 }
830 
GetNeighboringCellInfoListResponse_1_2(const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo_1_2 &cellInfoList)831 int32_t RilCallback::GetNeighboringCellInfoListResponse_1_2(const RilRadioResponseInfo &responseInfo,
832                                                             const CellListNearbyInfo_1_2 &cellInfoList)
833 {
834     HDF_LOGI("itemNum:%{public}d", cellInfoList.itemNum);
835     for (auto info : cellInfoList.cellNearbyInfo) {
836         HDF_LOGI("ratType:%{public}d", info.ratType);
837         switch (static_cast<RatType>(info.ratType)) {
838             case RatType::NETWORK_TYPE_LTE:
839                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
840                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
841                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
842                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
843                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
844                 break;
845             case RatType::NETWORK_TYPE_GSM:
846                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
847                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
848                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
849                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
850                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
851                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
852                 break;
853             case RatType::NETWORK_TYPE_WCDMA:
854                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
855                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
856                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
857                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
858                 break;
859             case RatType::NETWORK_TYPE_NR:
860                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
861                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
862                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
863                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
864                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
865                 break;
866             default:
867                 HDF_LOGE("invalid ratType");
868                 break;
869         }
870     }
871     hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
872     resultInfo_ = responseInfo;
873     NotifyAll();
874     return 0;
875 }
876 
GetCurrentCellInfoResponse(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellInfoList)877 int32_t RilCallback::GetCurrentCellInfoResponse(const RilRadioResponseInfo &responseInfo,
878                                                 const CellListCurrentInfo &cellInfoList)
879 {
880     g_getCurrentCellInfoResponseFlag = true;
881     HDF_LOGI("RilCallback::GetCurrentCellInfoResponse itemNum:%{public}d", cellInfoList.itemNum);
882     for (auto info : cellInfoList.cellCurrentInfo) {
883         HDF_LOGI("RilCallback::GetCurrentCellInfoResponse ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
884                  info.ratType, info.mcc, info.mnc);
885         switch (static_cast<RatType>(info.ratType)) {
886             case RatType::NETWORK_TYPE_LTE:
887                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
888                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
889                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
890                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
891                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
892                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
893                 break;
894             case RatType::NETWORK_TYPE_GSM:
895                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
896                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
897                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
898                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
899                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
900                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
901                 break;
902             case RatType::NETWORK_TYPE_WCDMA:
903                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
904                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
905                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
906                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
907                 break;
908             case RatType::NETWORK_TYPE_NR:
909                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
910                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
911                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
912                 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
913                 break;
914             default:
915                 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse invalid ratType");
916         }
917     }
918     hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
919     resultInfo_ = responseInfo;
920     NotifyAll();
921     return 0;
922 }
923 
GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)924 int32_t RilCallback::GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo &responseInfo,
925                                                     const CellListCurrentInfo_1_1 &cellListCurrentInfo)
926 {
927     g_getCurrentCellInfoResponse11Flag = true;
928     HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
929     for (auto info : cellListCurrentInfo.cellCurrentInfo) {
930         HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
931                  info.ratType, info.mcc, info.mnc);
932         switch (static_cast<RatType>(info.ratType)) {
933             case RatType::NETWORK_TYPE_LTE:
934                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
935                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
936                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
937                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
938                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
939                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
940                 break;
941             case RatType::NETWORK_TYPE_GSM:
942                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
943                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
944                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
945                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
946                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
947                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
948                 break;
949             case RatType::NETWORK_TYPE_WCDMA:
950                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
951                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
952                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
953                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
954                 break;
955             case RatType::NETWORK_TYPE_NR:
956                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
957                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
958                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
959                 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
960                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
961                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
962                 break;
963             default:
964                 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse_1_1 invalid ratType");
965         }
966     }
967     hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
968     resultInfo_ = responseInfo;
969     NotifyAll();
970     return 0;
971 }
972 
GetCurrentCellInfoResponse_1_2(const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)973 int32_t RilCallback::GetCurrentCellInfoResponse_1_2(const RilRadioResponseInfo &responseInfo,
974                                                     const CellListCurrentInfo_1_2 &cellListCurrentInfo)
975 {
976     HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
977     for (auto info : cellListCurrentInfo.cellCurrentInfo) {
978         HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
979         switch (static_cast<RatType>(info.ratType)) {
980             case RatType::NETWORK_TYPE_LTE:
981                 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
982                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
983                 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
984                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
985                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
986                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
987                 break;
988             case RatType::NETWORK_TYPE_GSM:
989                 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
990                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
991                 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
992                 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
993                 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
994                 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
995                 break;
996             case RatType::NETWORK_TYPE_WCDMA:
997                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
998                 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
999                 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1000                 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1001                 break;
1002             case RatType::NETWORK_TYPE_NR:
1003                 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1004                 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1005                 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1006                 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1007                 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1008                 break;
1009             default:
1010                 HDF_LOGE("invalid ratType");
1011                 break;
1012         }
1013     }
1014     hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1015     resultInfo_ = responseInfo;
1016     NotifyAll();
1017     return 0;
1018 }
1019 
SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo)1020 int32_t RilCallback::SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo)
1021 {
1022     g_setPreferredNetworkResponseFlag = true;
1023     HDF_LOGI("RilCallback::SetPreferredNetworkResponse error:%{public}d", responseInfo.error);
1024     hdiId_ = HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK;
1025     resultInfo_ = responseInfo;
1026     NotifyAll();
1027     return 0;
1028 }
1029 
GetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo, const PreferredNetworkTypeInfo &preferredNetworkTypeInfo)1030 int32_t RilCallback::GetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo,
1031                                                  const PreferredNetworkTypeInfo &preferredNetworkTypeInfo)
1032 {
1033     g_getPreferredNetworkResponseFlag = true;
1034     HDF_LOGI("RilCallback::GetPreferredNetworkResponse type:%{public}d", preferredNetworkTypeInfo.preferredNetworkType);
1035     hdiId_ = HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK;
1036     resultInfo_ = responseInfo;
1037     NotifyAll();
1038     return 0;
1039 }
1040 
GetPhysicalChannelConfigResponse(const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList)1041 int32_t RilCallback::GetPhysicalChannelConfigResponse(const RilRadioResponseInfo &responseInfo,
1042                                                       const ChannelConfigInfoList &channelConfigInfoList)
1043 {
1044     g_getPhysicalChannelConfigResponseFlag = true;
1045     HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse itemNum:%{public}d", channelConfigInfoList.itemNum);
1046     for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
1047         HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse cellConnStatus:%{public}d, "
1048                  "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
1049                  "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
1050                  "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
1051                  phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
1052                  phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
1053                  phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
1054         for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
1055             HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
1056         }
1057     }
1058     hdiId_ = HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG;
1059     resultInfo_ = responseInfo;
1060     NotifyAll();
1061     return 0;
1062 }
1063 
SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo)1064 int32_t RilCallback::SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo)
1065 {
1066     g_setLocateUpdatesResponseFlag = true;
1067     HDF_LOGI("RilCallback::SetLocateUpdatesResponse error:%{public}d", responseInfo.error);
1068     hdiId_ = HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES;
1069     resultInfo_ = responseInfo;
1070     NotifyAll();
1071     return 0;
1072 }
1073 
SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo)1074 int32_t RilCallback::SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo)
1075 {
1076     g_setNotificationFilterResponseFlag = true;
1077     HDF_LOGI("RilCallback::SetNotificationFilterResponse error:%{public}d", responseInfo.error);
1078     hdiId_ = HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER;
1079     resultInfo_ = responseInfo;
1080     NotifyAll();
1081     return 0;
1082 }
1083 
SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo)1084 int32_t RilCallback::SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo)
1085 {
1086     g_setDeviceStateResponseFlag = true;
1087     HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1088     hdiId_ = HdiId::HREQ_NETWORK_SET_DEVICE_STATE;
1089     resultInfo_ = responseInfo;
1090     NotifyAll();
1091     return 0;
1092 }
1093 
GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)1094 int32_t RilCallback::GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1095 {
1096     HDF_LOGI("RilCallback::GetRrcConnectionStateResponse state:%{public}d", state);
1097     hdiId_ = HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE;
1098     resultInfo_ = responseInfo;
1099     NotifyAll();
1100     return 0;
1101 }
1102 
SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo)1103 int32_t RilCallback::SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo)
1104 {
1105     g_setNrOptionModeResponseFlag = true;
1106     HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1107     hdiId_ = HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE;
1108     resultInfo_ = responseInfo;
1109     NotifyAll();
1110     return 0;
1111 }
1112 
GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t state)1113 int32_t RilCallback::GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1114 {
1115     g_getNrOptionModeResponseFlag = true;
1116     HDF_LOGI("RilCallback::GetNrOptionModeResponse state:%{public}d", state);
1117     hdiId_ = HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE;
1118     resultInfo_ = responseInfo;
1119     NotifyAll();
1120     return 0;
1121 }
1122 
GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)1123 int32_t RilCallback::GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1124 {
1125     HDF_LOGI("RilCallback::GetRrcConnectionStateUpdated state:%{public}d", state);
1126     return 0;
1127 }
1128 
GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds)1129 int32_t RilCallback::GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds)
1130 {
1131     int32_t ssbListNum = 0;
1132     int32_t nbCellNum = 0;
1133     HDF_LOGE("rsrp:%{public}d", nrCellSsbIds.rsrp);
1134     HDF_LOGE("sinr:%{public}d", nrCellSsbIds.sinr);
1135     for (auto info : nrCellSsbIds.sCellSsbList) {
1136         ssbListNum = ssbListNum + 1;
1137         HDF_LOGE("sCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, info.rsrp);
1138     }
1139     HDF_LOGE("nbCellCount:%{public}d", nrCellSsbIds.nbCellCount);
1140     for (auto info : nrCellSsbIds.nbCellSsbList) {
1141         nbCellNum = nbCellNum + 1;
1142         HDF_LOGE("nbCellNum:%{public}d, rsrp:%{public}d, sinr:%{public}d", nbCellNum, info.rsrp, info.sinr);
1143         ssbListNum = 0;
1144         for (auto infoNbCell : info.ssbIdList) {
1145             ssbListNum = ssbListNum + 1;
1146             HDF_LOGE("nbCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, infoNbCell.rsrp);
1147         }
1148     }
1149     hdiId_ = HdiId::HREQ_NETWORK_GET_NR_SSBID_INFO;
1150     resultInfo_ = responseInfo;
1151     NotifyAll();
1152     return 0;
1153 }
1154 
CallEmergencyNotice(const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)1155 int32_t RilCallback::CallEmergencyNotice(const RilRadioResponseInfo &responseInfo,
1156                                          const EmergencyInfoList &emergencyInfoList)
1157 {
1158     HDF_LOGI("GetBoolResult CallEmergencyNotice callSize : %{public}d", emergencyInfoList.callSize);
1159     return 0;
1160 }
1161 
CallStateUpdated(const RilRadioResponseInfo &responseInfo)1162 int32_t RilCallback::CallStateUpdated(const RilRadioResponseInfo &responseInfo)
1163 {
1164     HDF_LOGI("GetBoolResult CallStateUpdated slotId : %{public}d, type: %{public}d", responseInfo.slotId,
1165              responseInfo.type);
1166     return 0;
1167 }
1168 
CallRingbackVoiceNotice(const RilRadioResponseInfo &responseInfo, const RingbackVoice &ringbackVoice)1169 int32_t RilCallback::CallRingbackVoiceNotice(const RilRadioResponseInfo &responseInfo,
1170                                              const RingbackVoice &ringbackVoice)
1171 {
1172     HDF_LOGI("GetBoolResult CallRingbackVoiceNotice slotId : %{public}d, ringbackVoice: %{public}d",
1173              responseInfo.slotId, ringbackVoice.status);
1174     return 0;
1175 }
1176 
CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus)1177 int32_t RilCallback::CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus)
1178 {
1179     HDF_LOGI("GetBoolResult CallSrvccStatusNotice slotId : %{public}d, srvccStatus: %{public}d", responseInfo.slotId,
1180              srvccStatus.status);
1181     return 0;
1182 }
1183 
CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo)1184 int32_t RilCallback::CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo)
1185 {
1186     HDF_LOGI("GetBoolResult CallUssdNotice slotId : %{public}d, ussdNoticeInfo m: %{public}d, str: %{public}s",
1187              responseInfo.slotId, ussdNoticeInfo.type, ussdNoticeInfo.message.c_str());
1188     return 0;
1189 }
1190 
CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo)1191 int32_t RilCallback::CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo)
1192 {
1193     HDF_LOGI("GetBoolResult CallSsNotice slotId : %{public}d, result: %{public}d, serviceType: %{public}d,"
1194              "requestType: %{public}d, serviceClass: %{public}d",
1195              responseInfo.slotId, ssNoticeInfo.result, ssNoticeInfo.serviceType, ssNoticeInfo.requestType,
1196              ssNoticeInfo.serviceClass);
1197     return 0;
1198 }
1199 
CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo)1200 int32_t RilCallback::CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo)
1201 {
1202     HDF_LOGI("GetBoolResult CallRsrvccStatusNotify slotId : %{public}d", responseInfo.slotId);
1203     return 0;
1204 }
1205 
GetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)1206 int32_t RilCallback::GetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo,
1207                                                   const EmergencyInfoList &emergencyInfoList)
1208 {
1209     g_getEmergencyCallListResponseFlag = true;
1210     HDF_LOGI("GetBoolResult emergencyInfoList callSize : %{public}d", emergencyInfoList.callSize);
1211     hdiId_ = HdiId::HREQ_CALL_GET_EMERGENCY_LIST;
1212     resultInfo_ = responseInfo;
1213     NotifyAll();
1214     return 0;
1215 }
1216 
SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo)1217 int32_t RilCallback::SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo)
1218 {
1219     g_setEmergencyCallListResponse = true;
1220     HDF_LOGI("GetBoolResult SetEmergencyCallListResponse");
1221     hdiId_ = HdiId::HREQ_CALL_SET_EMERGENCY_LIST;
1222     resultInfo_ = responseInfo;
1223     NotifyAll();
1224     return 0;
1225 }
1226 
GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList)1227 int32_t RilCallback::GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList)
1228 {
1229     g_getCallListResponseFlag = true;
1230     HDF_LOGI("GetBoolResult CallInfoList callSize : %{public}d", callList.callSize);
1231     hdiId_ = HdiId::HREQ_CALL_GET_CALL_LIST;
1232     resultInfo_ = responseInfo;
1233     NotifyAll();
1234     return 0;
1235 }
1236 
DialResponse(const RilRadioResponseInfo &responseInfo)1237 int32_t RilCallback::DialResponse(const RilRadioResponseInfo &responseInfo)
1238 {
1239     g_dialResponseFlag = true;
1240     HDF_LOGI("GetBoolResult DialResponse");
1241     hdiId_ = HdiId::HREQ_CALL_DIAL;
1242     resultInfo_ = responseInfo;
1243     NotifyAll();
1244     return 0;
1245 }
1246 
HangupResponse(const RilRadioResponseInfo &responseInfo)1247 int32_t RilCallback::HangupResponse(const RilRadioResponseInfo &responseInfo)
1248 {
1249     g_hangupResponseFlag = true;
1250     HDF_LOGI("GetBoolResult HangupResponse");
1251     hdiId_ = HdiId::HREQ_CALL_HANGUP;
1252     resultInfo_ = responseInfo;
1253     NotifyAll();
1254     return 0;
1255 }
1256 
RejectResponse(const RilRadioResponseInfo &responseInfo)1257 int32_t RilCallback::RejectResponse(const RilRadioResponseInfo &responseInfo)
1258 {
1259     g_rejectResponseFlag = true;
1260     HDF_LOGI("GetBoolResult RejectResponse");
1261     hdiId_ = HdiId::HREQ_CALL_REJECT;
1262     resultInfo_ = responseInfo;
1263     NotifyAll();
1264     return 0;
1265 }
1266 
AnswerResponse(const RilRadioResponseInfo &responseInfo)1267 int32_t RilCallback::AnswerResponse(const RilRadioResponseInfo &responseInfo)
1268 {
1269     g_answerResponseFlag = true;
1270     HDF_LOGI("GetBoolResult AnswerResponse");
1271     hdiId_ = HdiId::HREQ_CALL_ANSWER;
1272     resultInfo_ = responseInfo;
1273     NotifyAll();
1274     return 0;
1275 }
1276 
HoldCallResponse(const RilRadioResponseInfo &responseInfo)1277 int32_t RilCallback::HoldCallResponse(const RilRadioResponseInfo &responseInfo)
1278 {
1279     g_holdCallResponseFlag = true;
1280     HDF_LOGI("GetBoolResult HoldCallResponse");
1281     hdiId_ = HdiId::HREQ_CALL_HOLD_CALL;
1282     resultInfo_ = responseInfo;
1283     NotifyAll();
1284     return 0;
1285 }
1286 
UnHoldCallResponse(const RilRadioResponseInfo &responseInfo)1287 int32_t RilCallback::UnHoldCallResponse(const RilRadioResponseInfo &responseInfo)
1288 {
1289     g_unHoldCallResponseFlag = true;
1290     HDF_LOGI("GetBoolResult UnHoldCallResponse");
1291     hdiId_ = HdiId::HREQ_CALL_UNHOLD_CALL;
1292     resultInfo_ = responseInfo;
1293     NotifyAll();
1294     return 0;
1295 }
1296 
SwitchCallResponse(const RilRadioResponseInfo &responseInfo)1297 int32_t RilCallback::SwitchCallResponse(const RilRadioResponseInfo &responseInfo)
1298 {
1299     g_switchCallResponseFlag = true;
1300     HDF_LOGI("GetBoolResult SwitchCallResponse");
1301     hdiId_ = HdiId::HREQ_CALL_SWITCH_CALL;
1302     resultInfo_ = responseInfo;
1303     NotifyAll();
1304     return 0;
1305 }
1306 
GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult)1307 int32_t RilCallback::GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult)
1308 {
1309     g_getClipResponseFlag = true;
1310     HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clipStat: %{public}d", getClipResult.result,
1311              getClipResult.action, getClipResult.clipStat);
1312     hdiId_ = HdiId::HREQ_CALL_GET_CLIP;
1313     resultInfo_ = responseInfo;
1314     NotifyAll();
1315     return 0;
1316 }
1317 
SetClipResponse(const RilRadioResponseInfo &responseInfo)1318 int32_t RilCallback::SetClipResponse(const RilRadioResponseInfo &responseInfo)
1319 {
1320     g_setClipResponseFlag = true;
1321     HDF_LOGI("GetBoolResult SetClipResponse");
1322     hdiId_ = HdiId::HREQ_CALL_SET_CLIP;
1323     resultInfo_ = responseInfo;
1324     NotifyAll();
1325     return 0;
1326 }
1327 
CombineConferenceResponse(const RilRadioResponseInfo &responseInfo)1328 int32_t RilCallback::CombineConferenceResponse(const RilRadioResponseInfo &responseInfo)
1329 {
1330     g_combineConferenceResponseFlag = true;
1331     HDF_LOGI("GetBoolResult CombineConferenceResponse");
1332     hdiId_ = HdiId::HREQ_CALL_COMBINE_CONFERENCE;
1333     resultInfo_ = responseInfo;
1334     NotifyAll();
1335     return 0;
1336 }
1337 
SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo)1338 int32_t RilCallback::SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo)
1339 {
1340     g_separateConferenceResponseFlag = true;
1341     HDF_LOGI("GetBoolResult SeparateConferenceResponse");
1342     hdiId_ = HdiId::HREQ_CALL_SEPARATE_CONFERENCE;
1343     resultInfo_ = responseInfo;
1344     NotifyAll();
1345     return 0;
1346 }
1347 
CallSupplementResponse(const RilRadioResponseInfo &responseInfo)1348 int32_t RilCallback::CallSupplementResponse(const RilRadioResponseInfo &responseInfo)
1349 {
1350     g_callSupplementResponseFlag = true;
1351     HDF_LOGI("GetBoolResult CallSupplementResponse");
1352     hdiId_ = HdiId::HREQ_CALL_CALL_SUPPLEMENT;
1353     resultInfo_ = responseInfo;
1354     NotifyAll();
1355     return 0;
1356 }
1357 
GetCallWaitingResponse(const RilRadioResponseInfo &responseInfo, const CallWaitResult &callWaitResult)1358 int32_t RilCallback::GetCallWaitingResponse(const RilRadioResponseInfo &responseInfo,
1359                                             const CallWaitResult &callWaitResult)
1360 {
1361     g_getCallWaitingResponseFlag = true;
1362     HDF_LOGI("GetBoolResult GetCallWaitingResponse result: %{public}d, status: %{public}d, classCw: %{public}d",
1363              callWaitResult.result, callWaitResult.status, callWaitResult.classCw);
1364     hdiId_ = HdiId::HREQ_CALL_GET_CALL_WAITING;
1365     resultInfo_ = responseInfo;
1366     NotifyAll();
1367     return 0;
1368 }
1369 
SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo)1370 int32_t RilCallback::SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo)
1371 {
1372     g_setCallWaitingResponseFlag = true;
1373     HDF_LOGI("GetBoolResult SetCallWaitingResponse");
1374     hdiId_ = HdiId::HREQ_CALL_SET_CALL_WAITING;
1375     resultInfo_ = responseInfo;
1376     NotifyAll();
1377     return 0;
1378 }
1379 
GetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo, const CallForwardQueryInfoList &cFQueryList)1380 int32_t RilCallback::GetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo,
1381                                                  const CallForwardQueryInfoList &cFQueryList)
1382 {
1383     g_getCallTransferInfoResponseFlag = true;
1384     HDF_LOGI("GetBoolResult GetCallTransferInfoResponse cFQueryList: %{public}d", cFQueryList.callSize);
1385     hdiId_ = HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO;
1386     resultInfo_ = responseInfo;
1387     NotifyAll();
1388     return 0;
1389 }
1390 
SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo)1391 int32_t RilCallback::SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo)
1392 {
1393     g_setCallTransferInfoResponseFlag = true;
1394     HDF_LOGI("GetBoolResult SetCallTransferInfoResponse");
1395     hdiId_ = HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO;
1396     resultInfo_ = responseInfo;
1397     NotifyAll();
1398     return 0;
1399 }
1400 
GetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo, const CallRestrictionResult &result)1401 int32_t RilCallback::GetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo,
1402                                                 const CallRestrictionResult &result)
1403 {
1404     g_getCallRestrictionResponseFlag = true;
1405     HDF_LOGI("GetBoolResult result: %{public}d, status: %{public}d, classCw: %{public}d", result.result, result.status,
1406              result.classCw);
1407     hdiId_ = HdiId::HREQ_CALL_GET_CALL_RESTRICTION;
1408     resultInfo_ = responseInfo;
1409     NotifyAll();
1410     return 0;
1411 }
SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo)1412 int32_t RilCallback::SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo)
1413 {
1414     g_setCallRestrictionResponseFlag = true;
1415     HDF_LOGI("GetBoolResult SetCallRestrictionResponse");
1416     hdiId_ = HdiId::HREQ_CALL_SET_CALL_RESTRICTION;
1417     resultInfo_ = responseInfo;
1418     NotifyAll();
1419     return 0;
1420 }
GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult)1421 int32_t RilCallback::GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult)
1422 {
1423     g_getClirResponseFlag = true;
1424     HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clirStat: %{public}d", getClirResult.result,
1425              getClirResult.action, getClirResult.clirStat);
1426     hdiId_ = HdiId::HREQ_CALL_GET_CLIR;
1427     resultInfo_ = responseInfo;
1428     NotifyAll();
1429     return 0;
1430 }
1431 
SetClirResponse(const RilRadioResponseInfo &responseInfo)1432 int32_t RilCallback::SetClirResponse(const RilRadioResponseInfo &responseInfo)
1433 {
1434     g_setClirResponseFlag = true;
1435     HDF_LOGI("GetBoolResult SetClirResponse");
1436     hdiId_ = HdiId::HREQ_CALL_SET_CLIR;
1437     resultInfo_ = responseInfo;
1438     NotifyAll();
1439     return 0;
1440 }
1441 
StartDtmfResponse(const RilRadioResponseInfo &responseInfo)1442 int32_t RilCallback::StartDtmfResponse(const RilRadioResponseInfo &responseInfo)
1443 {
1444     g_startDtmfResponseFlag = true;
1445     HDF_LOGI("GetBoolResult StartDtmfResponse");
1446     hdiId_ = HdiId::HREQ_CALL_START_DTMF;
1447     resultInfo_ = responseInfo;
1448     NotifyAll();
1449     return 0;
1450 }
1451 
SendDtmfResponse(const RilRadioResponseInfo &responseInfo)1452 int32_t RilCallback::SendDtmfResponse(const RilRadioResponseInfo &responseInfo)
1453 {
1454     g_sendDtmfResponseFlag = true;
1455     HDF_LOGI("GetBoolResult SendDtmfResponse");
1456     hdiId_ = HdiId::HREQ_CALL_SEND_DTMF;
1457     resultInfo_ = responseInfo;
1458     NotifyAll();
1459     return 0;
1460 }
1461 
StopDtmfResponse(const RilRadioResponseInfo &responseInfo)1462 int32_t RilCallback::StopDtmfResponse(const RilRadioResponseInfo &responseInfo)
1463 {
1464     g_stopDtmfResponseFlag = true;
1465     HDF_LOGI("GetBoolResult StopDtmfResponse");
1466     hdiId_ = HdiId::HREQ_CALL_STOP_DTMF;
1467     resultInfo_ = responseInfo;
1468     NotifyAll();
1469     return 0;
1470 }
1471 
GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode)1472 int32_t RilCallback::GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode)
1473 {
1474     g_getCallPreferenceModeResponseFlag = true;
1475     HDF_LOGI("GetBoolResult GetCallPreferenceModeResponse mode: %{public}d", mode);
1476     hdiId_ = HdiId::HREQ_CALL_GET_CALL_PREFERENCE;
1477     resultInfo_ = responseInfo;
1478     NotifyAll();
1479     return 0;
1480 }
1481 
SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo)1482 int32_t RilCallback::SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo)
1483 {
1484     g_setCallPreferenceModeResponseFlag = true;
1485     HDF_LOGI("GetBoolResult SetCallPreferenceModeResponse");
1486     hdiId_ = HdiId::HREQ_CALL_SET_CALL_PREFERENCE;
1487     resultInfo_ = responseInfo;
1488     NotifyAll();
1489     return 0;
1490 }
1491 
SetUssdResponse(const RilRadioResponseInfo &responseInfo)1492 int32_t RilCallback::SetUssdResponse(const RilRadioResponseInfo &responseInfo)
1493 {
1494     g_setUssdResponseFlag = true;
1495     HDF_LOGI("GetBoolResult SetUssdResponse");
1496     hdiId_ = HdiId::HREQ_CALL_SET_USSD;
1497     resultInfo_ = responseInfo;
1498     NotifyAll();
1499     return 0;
1500 }
1501 
GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd)1502 int32_t RilCallback::GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd)
1503 {
1504     g_getUssdResponseFlag = true;
1505     HDF_LOGI("GetBoolResult GetUssdResponse cusd: %{public}d", cusd);
1506     hdiId_ = HdiId::HREQ_CALL_GET_USSD;
1507     resultInfo_ = responseInfo;
1508     NotifyAll();
1509     return 0;
1510 }
1511 
SetMuteResponse(const RilRadioResponseInfo &responseInfo)1512 int32_t RilCallback::SetMuteResponse(const RilRadioResponseInfo &responseInfo)
1513 {
1514     g_setMuteResponseFlag = true;
1515     HDF_LOGI("GetBoolResult SetMuteResponse");
1516     hdiId_ = HdiId::HREQ_CALL_SET_MUTE;
1517     resultInfo_ = responseInfo;
1518     NotifyAll();
1519     return 0;
1520 }
1521 
GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute)1522 int32_t RilCallback::GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute)
1523 {
1524     g_getMuteResponseFlag = true;
1525     HDF_LOGI("GetBoolResult GetMuteResponse mute: %{public}d", mute);
1526     hdiId_ = HdiId::HREQ_CALL_GET_MUTE;
1527     resultInfo_ = responseInfo;
1528     NotifyAll();
1529     return 0;
1530 }
1531 
GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail)1532 int32_t RilCallback::GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail)
1533 {
1534     g_getCallFailReasonResponseFlag = true;
1535     HDF_LOGI("GetBoolResult GetCallFailReasonResponse callFail: %{public}d", callFail);
1536     hdiId_ = HdiId::HREQ_CALL_GET_FAIL_REASON;
1537     resultInfo_ = responseInfo;
1538     NotifyAll();
1539     return 0;
1540 }
1541 
SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo)1542 int32_t RilCallback::SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo)
1543 {
1544     g_setBarringPasswordResponseFlag = true;
1545     HDF_LOGI("GetBoolResult SetBarringPasswordResponse");
1546     hdiId_ = HdiId::HREQ_CALL_SET_BARRING_PASSWORD;
1547     resultInfo_ = responseInfo;
1548     NotifyAll();
1549     return 0;
1550 }
1551 
CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo)1552 int32_t RilCallback::CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo)
1553 {
1554     g_closeUnFinishedUssdResponseFlag = true;
1555     HDF_LOGI("GetBoolResult CloseUnFinishedUssdResponse");
1556     hdiId_ = HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD;
1557     resultInfo_ = responseInfo;
1558     NotifyAll();
1559     return 0;
1560 }
1561 
SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo)1562 int32_t RilCallback::SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo)
1563 {
1564     g_setVonrSwitchResponseFlag = true;
1565     HDF_LOGI("GetBoolResult SetVonrSwitchResponse");
1566     hdiId_ = HdiId::HREQ_SET_VONR_SWITCH;
1567     resultInfo_ = responseInfo;
1568     NotifyAll();
1569     return 0;
1570 }
1571 
1572 /**
1573  * modem
1574  **/
RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)1575 int32_t RilCallback::RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1576 {
1577     HDF_LOGI("RadioStateUpdated state : %{public}d", state);
1578     return 0;
1579 }
1580 
VoiceRadioTechUpdated(const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)1581 int32_t RilCallback::VoiceRadioTechUpdated(const RilRadioResponseInfo &responseInfo,
1582                                            const VoiceRadioTechnology &voiceRadioTechnology)
1583 {
1584     HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
1585              "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
1586              "%{public}s actName : %{public}s",
1587              voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
1588              voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
1589              voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(),
1590              voiceRadioTechnology.actName.c_str());
1591     return 0;
1592 }
1593 
DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode)1594 int32_t RilCallback::DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode)
1595 {
1596     HDF_LOGI("DsdsModeUpdated mode : %{public}d", mode);
1597     return 0;
1598 }
1599 
NcfgFinishedResult(const RilRadioResponseInfo &responseInfo, int32_t state)1600 int32_t RilCallback::NcfgFinishedResult(const RilRadioResponseInfo &responseInfo, int32_t state)
1601 {
1602     HDF_LOGI("NcfgFinishedResult state : %{public}d", state);
1603     return 0;
1604 }
1605 
RestartRildNvMatch(const RilRadioResponseInfo &responseInfo, int32_t state)1606 int32_t RilCallback::RestartRildNvMatch(const RilRadioResponseInfo &responseInfo, int32_t state)
1607 {
1608     HDF_LOGI("RestartRildNvMatch state : %{public}d", state);
1609     return 0;
1610 }
1611 
ShutDownResponse(const RilRadioResponseInfo &responseInfo)1612 int32_t RilCallback::ShutDownResponse(const RilRadioResponseInfo &responseInfo)
1613 {
1614     g_shutDownResponseFlag = true;
1615     HDF_LOGI("ShutDownResponse");
1616     hdiId_ = HdiId::HREQ_MODEM_SHUT_DOWN;
1617     resultInfo_ = responseInfo;
1618     NotifyAll();
1619     return 0;
1620 }
1621 
SetRadioStateResponse(const RilRadioResponseInfo &responseInfo)1622 int32_t RilCallback::SetRadioStateResponse(const RilRadioResponseInfo &responseInfo)
1623 {
1624     g_setRadioStateResponseFlag = true;
1625     HDF_LOGI("SetRadioStateResponse");
1626     hdiId_ = HdiId::HREQ_MODEM_SET_RADIO_STATUS;
1627     resultInfo_ = responseInfo;
1628     NotifyAll();
1629     return 0;
1630 }
1631 
GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)1632 int32_t RilCallback::GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1633 {
1634     g_getRadioStateResponseFlag = true;
1635     HDF_LOGI("GetRadioStateResponse state : %{public}d", state);
1636     hdiId_ = HdiId::HREQ_MODEM_GET_RADIO_STATUS;
1637     resultInfo_ = responseInfo;
1638     NotifyAll();
1639     return 0;
1640 }
1641 
GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei)1642 int32_t RilCallback::GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei)
1643 {
1644     g_getImeiResponseFlag = true;
1645     HDF_LOGI("GetImeiResponse imei : %{public}s", imei.c_str());
1646     hdiId_ = HdiId::HREQ_MODEM_GET_IMEI;
1647     resultInfo_ = responseInfo;
1648     NotifyAll();
1649     return 0;
1650 }
1651 
GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv)1652 int32_t RilCallback::GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv)
1653 {
1654     g_getImeiSvResponseFlag = true;
1655     hdiId_ = HdiId::HREQ_MODEM_GET_IMEISV;
1656     resultInfo_ = responseInfo;
1657     NotifyAll();
1658     return 0;
1659 }
1660 
GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid)1661 int32_t RilCallback::GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid)
1662 {
1663     g_getMeidResponseFlag = true;
1664     HDF_LOGI("GetMeidResponse meid : %{public}s", meid.c_str());
1665     hdiId_ = HdiId::HREQ_MODEM_GET_MEID;
1666     resultInfo_ = responseInfo;
1667     NotifyAll();
1668     return 0;
1669 }
1670 
GetVoiceRadioTechnologyResponse(const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)1671 int32_t RilCallback::GetVoiceRadioTechnologyResponse(const RilRadioResponseInfo &responseInfo,
1672                                                      const VoiceRadioTechnology &voiceRadioTechnology)
1673 {
1674     g_getVoiceRadioTechnologyResponseFlag = true;
1675     HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
1676              "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
1677              "%{public}s actName : %{public}s",
1678              voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
1679              voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
1680              voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(),
1681              voiceRadioTechnology.actName.c_str());
1682     hdiId_ = HdiId::HREQ_MODEM_GET_VOICE_RADIO;
1683     resultInfo_ = responseInfo;
1684     NotifyAll();
1685     return 0;
1686 }
1687 
GetBasebandVersionResponse(const RilRadioResponseInfo &responseInfo, const std::string &basebandVersion)1688 int32_t RilCallback::GetBasebandVersionResponse(const RilRadioResponseInfo &responseInfo,
1689                                                 const std::string &basebandVersion)
1690 {
1691     g_getBasebandVersionResponseFlag = true;
1692     HDF_LOGI("GetBasebandVersionResponse basebandVersion : %{public}s", basebandVersion.c_str());
1693     hdiId_ = HdiId::HREQ_MODEM_GET_BASEBAND_VERSION;
1694     resultInfo_ = responseInfo;
1695     NotifyAll();
1696     return 0;
1697 }
1698 
PdpContextListUpdated(const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)1699 int32_t RilCallback::PdpContextListUpdated(const RilRadioResponseInfo &responseInfo,
1700                                            const DataCallResultList &dataCallResultList)
1701 {
1702     HDF_LOGI("RilCallback::PdpContextListUpdated size:%{public}d", dataCallResultList.size);
1703     for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
1704         HDF_LOGI(
1705             "RilCallback::PdpContextListUpdated flag:%{public}d reason:%{public}d retryTime:%{public}d "
1706             "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
1707             "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
1708             "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
1709             setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
1710             setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
1711             setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
1712             setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
1713             setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
1714             setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
1715             setupDataCallResultInfo.pduSessionId);
1716     }
1717     return 0;
1718 }
1719 
DataLinkCapabilityUpdated(const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)1720 int32_t RilCallback::DataLinkCapabilityUpdated(const RilRadioResponseInfo &responseInfo,
1721                                                const DataLinkCapability &dataLinkCapability)
1722 {
1723     HDF_LOGI("RilCallback::DataLinkCapabilityUpdated primaryDownlinkKbps:%{public}d primaryUplinkKbps:%{public}d "
1724              "secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
1725              dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
1726              dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
1727     return 0;
1728 }
1729 
ActivatePdpContextResponse(const RilRadioResponseInfo &responseInfo, const SetupDataCallResultInfo &setupDataCallResultInfo)1730 int32_t RilCallback::ActivatePdpContextResponse(const RilRadioResponseInfo &responseInfo,
1731                                                 const SetupDataCallResultInfo &setupDataCallResultInfo)
1732 {
1733     HDF_LOGI("RilCallback::ActivatePdpContextResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
1734              "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
1735              "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
1736              "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
1737              setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
1738              setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
1739              setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
1740              setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
1741              setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
1742              setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
1743              setupDataCallResultInfo.pduSessionId);
1744     hdiId_ = HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT;
1745     resultInfo_ = responseInfo;
1746     NotifyAll();
1747     return 0;
1748 }
1749 
DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo)1750 int32_t RilCallback::DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo)
1751 {
1752     g_deactivatePdpContextResponseFlag = true;
1753     HDF_LOGI("RilCallback::DeactivatePdpContextResponse error:%{public}d", responseInfo.error);
1754     hdiId_ = HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT;
1755     resultInfo_ = responseInfo;
1756     NotifyAll();
1757     return 0;
1758 }
1759 
GetPdpContextListResponse(const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)1760 int32_t RilCallback::GetPdpContextListResponse(const RilRadioResponseInfo &responseInfo,
1761                                                const DataCallResultList &dataCallResultList)
1762 {
1763     g_getPdpContextListResponseFlag = true;
1764     HDF_LOGI("RilCallback::GetPdpContextListResponse size:%{public}d", dataCallResultList.size);
1765     for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
1766         HDF_LOGI(
1767             "RilCallback::GetPdpContextListResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
1768             "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
1769             "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
1770             "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
1771             setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
1772             setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
1773             setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
1774             setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
1775             setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
1776             setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
1777             setupDataCallResultInfo.pduSessionId);
1778     }
1779     hdiId_ = HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST;
1780     resultInfo_ = responseInfo;
1781     NotifyAll();
1782     return 0;
1783 }
1784 
SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo)1785 int32_t RilCallback::SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo)
1786 {
1787     g_setInitApnInfoResponseFlag = true;
1788     HDF_LOGI("RilCallback::SetInitApnInfoResponse error:%{public}d", responseInfo.error);
1789     hdiId_ = HdiId::HREQ_DATA_SET_INIT_APN_INFO;
1790     resultInfo_ = responseInfo;
1791     NotifyAll();
1792     return 0;
1793 }
1794 
SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo)1795 int32_t RilCallback::SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo)
1796 {
1797     HDF_LOGI("RilCallback::SetLinkBandwidthReportingRuleResponse error:%{public}d", responseInfo.error);
1798     hdiId_ = HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE;
1799     resultInfo_ = responseInfo;
1800     NotifyAll();
1801     return 0;
1802 }
1803 
GetLinkBandwidthInfoResponse(const RilRadioResponseInfo &responseInfo, const DataLinkBandwidthInfo &dataLinkBandwidthInfo)1804 int32_t RilCallback::GetLinkBandwidthInfoResponse(const RilRadioResponseInfo &responseInfo,
1805                                                   const DataLinkBandwidthInfo &dataLinkBandwidthInfo)
1806 {
1807     g_getLinkBandwidthInfoResponseFlag = true;
1808     HDF_LOGI(
1809         "RilCallback::GetLinkBandwidthInfoResponse serial:%{public}d cid:%{public}d qi:%{public}d dlGfbr:%{public}d "
1810         "ulGfbr:%{public}d dlMfbr:%{public}d ulMfbr:%{public}d ulSambr:%{public}d dlSambr:%{public}d "
1811         "averagingWindow:%{public}d",
1812         dataLinkBandwidthInfo.serial, dataLinkBandwidthInfo.cid, dataLinkBandwidthInfo.qi, dataLinkBandwidthInfo.dlGfbr,
1813         dataLinkBandwidthInfo.ulGfbr, dataLinkBandwidthInfo.dlMfbr, dataLinkBandwidthInfo.ulMfbr,
1814         dataLinkBandwidthInfo.ulSambr, dataLinkBandwidthInfo.dlSambr, dataLinkBandwidthInfo.averagingWindow);
1815     hdiId_ = HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO;
1816     resultInfo_ = responseInfo;
1817     NotifyAll();
1818     return 0;
1819 }
1820 
SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo)1821 int32_t RilCallback::SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo)
1822 {
1823     g_setDataPermittedResponseFlag = true;
1824     HDF_LOGI("RilCallback::SetDataPermittedResponse error:%{public}d", responseInfo.error);
1825     hdiId_ = HdiId::HREQ_DATA_SET_DATA_PERMITTED;
1826     resultInfo_ = responseInfo;
1827     NotifyAll();
1828     return 0;
1829 }
1830 
SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo)1831 int32_t RilCallback::SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo)
1832 {
1833     HDF_LOGI("RilCallback::SetDataProfileInfoResponse error:%{public}d", responseInfo.error);
1834     hdiId_ = HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO;
1835     resultInfo_ = responseInfo;
1836     NotifyAll();
1837     return 0;
1838 }
1839 
GetLinkCapabilityResponse(const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)1840 int32_t RilCallback::GetLinkCapabilityResponse(const RilRadioResponseInfo &responseInfo,
1841                                                const DataLinkCapability &dataLinkCapability)
1842 {
1843     g_getLinkCapabilityResponseFlag = true;
1844     HDF_LOGI("RilCallbackTest::GetLinkCapabilityResponse primaryDownlinkKbps:%{public}d "
1845              "primaryUplinkKbps:%{public}d secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
1846              dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
1847              dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
1848     hdiId_ = HdiId::HREQ_DATA_GET_LINK_CAPABILITY;
1849     resultInfo_ = responseInfo;
1850     NotifyAll();
1851     return 0;
1852 }
1853 
CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo)1854 int32_t RilCallback::CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo)
1855 {
1856     HDF_LOGI("RilCallback::CleanAllConnectionsResponse error:%{public}d", responseInfo.error);
1857     hdiId_ = HdiId::HREQ_DATA_CLEAN_ALL_CONNECTIONS;
1858     resultInfo_ = responseInfo;
1859     NotifyAll();
1860     return 0;
1861 }
1862 
NewSmsNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)1863 int32_t RilCallback::NewSmsNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
1864                                   const SmsMessageInfo &smsMessageInfo)
1865 {
1866     HDF_LOGI("RilCallback::NewSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
1867     return 0;
1868 }
1869 
NewCdmaSmsNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)1870 int32_t RilCallback::NewCdmaSmsNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
1871                                       const SmsMessageInfo &smsMessageInfo)
1872 {
1873     HDF_LOGI("RilCallback::NewCdmaSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
1874     return 0;
1875 }
1876 
SmsStatusReportNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)1877 int32_t RilCallback::SmsStatusReportNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
1878                                            const SmsMessageInfo &smsMessageInfo)
1879 {
1880     HDF_LOGI("RilCallback::SmsStatusReportNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
1881     return 0;
1882 }
1883 
NewSmsStoredOnSimNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t recordNumber, int32_t indicationType)1884 int32_t RilCallback::NewSmsStoredOnSimNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
1885                                              int32_t recordNumber, int32_t indicationType)
1886 {
1887     HDF_LOGI("RilCallback::NewSmsStoredOnSimNotify recordNumber : %{public}d, indicationType : %{public}d",
1888              recordNumber, indicationType);
1889     return 0;
1890 }
1891 
CBConfigNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const CBConfigReportInfo &cellBroadConfigReportInfo)1892 int32_t RilCallback::CBConfigNotify(const OHOS::HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
1893                                     const CBConfigReportInfo &cellBroadConfigReportInfo)
1894 {
1895     HDF_LOGI("RilCallback::CBConfigNotify cellBroadConfigReportInfo dcs : %{public}s",
1896              cellBroadConfigReportInfo.dcs.c_str());
1897     return 0;
1898 }
1899 
SendGsmSmsResponse(const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)1900 int32_t RilCallback::SendGsmSmsResponse(const RilRadioResponseInfo &responseInfo,
1901                                         const SendSmsResultInfo &sendSmsResultInfo)
1902 {
1903     g_sendGsmSmsResponseFlag = true;
1904     HDF_LOGI("RilCallback::SendGsmSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
1905              sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
1906     hdiId_ = HdiId::HREQ_SMS_SEND_GSM_SMS;
1907     resultInfo_ = responseInfo;
1908     NotifyAll();
1909     return 0;
1910 }
1911 
SendCdmaSmsResponse(const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)1912 int32_t RilCallback::SendCdmaSmsResponse(const RilRadioResponseInfo &responseInfo,
1913                                          const SendSmsResultInfo &sendSmsResultInfo)
1914 {
1915     g_sendCdmaSmsResponseFlag = true;
1916     HDF_LOGI("RilCallback::SendCdmaSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
1917              sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
1918     hdiId_ = HdiId::HREQ_SMS_SEND_CDMA_SMS;
1919     resultInfo_ = responseInfo;
1920     NotifyAll();
1921     return 0;
1922 }
1923 
AddSimMessageResponse(const RilRadioResponseInfo &responseInfo)1924 int32_t RilCallback::AddSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1925 {
1926     g_addSimMessageResponseFlag = true;
1927     HDF_LOGI("RilCallback::AddSimMessageResponse error : %{public}d", responseInfo.error);
1928     hdiId_ = HdiId::HREQ_SMS_ADD_SIM_MESSAGE;
1929     resultInfo_ = responseInfo;
1930     NotifyAll();
1931     return 0;
1932 }
1933 
DelSimMessageResponse(const RilRadioResponseInfo &responseInfo)1934 int32_t RilCallback::DelSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1935 {
1936     g_delSimMessageResponseFlag = true;
1937     HDF_LOGI("RilCallback::DelSimMessageResponse error : %{public}d", responseInfo.error);
1938     hdiId_ = HdiId::HREQ_SMS_DEL_SIM_MESSAGE;
1939     resultInfo_ = responseInfo;
1940     NotifyAll();
1941     return 0;
1942 }
UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo)1943 int32_t RilCallback::UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1944 {
1945     g_updateSimMessageResponseFlag = true;
1946     HDF_LOGI("RilCallback::UpdateSimMessageResponse error : %{public}d", responseInfo.error);
1947     hdiId_ = HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE;
1948     resultInfo_ = responseInfo;
1949     NotifyAll();
1950     return 0;
1951 }
1952 
AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)1953 int32_t RilCallback::AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1954 {
1955     g_addCdmaSimMessageResponseFlag = true;
1956     HDF_LOGI("RilCallback::AddCdmaSimMessageResponse error : %{public}d", responseInfo.error);
1957     hdiId_ = HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE;
1958     resultInfo_ = responseInfo;
1959     NotifyAll();
1960     return 0;
1961 }
1962 
DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)1963 int32_t RilCallback::DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1964 {
1965     g_delCdmaSimMessageResponseFlag = true;
1966     HDF_LOGI("RilCallback::DelCdmaSimMessageResponse error : %{public}d", responseInfo.error);
1967     hdiId_ = HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE;
1968     resultInfo_ = responseInfo;
1969     NotifyAll();
1970     return 0;
1971 }
1972 
UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)1973 int32_t RilCallback::UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
1974 {
1975     g_updateCdmaSimMessageResponseFlag = true;
1976     HDF_LOGI("RilCallback::UpdateCdmaSimMessageResponse error : %{public}d", responseInfo.error);
1977     hdiId_ = HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE;
1978     resultInfo_ = responseInfo;
1979     NotifyAll();
1980     return 0;
1981 }
1982 
SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo)1983 int32_t RilCallback::SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo)
1984 {
1985     g_setSmscAddrResponseFlag = true;
1986     HDF_LOGI("RilCallback::SetSmscAddrResponse error : %{public}d", responseInfo.error);
1987     hdiId_ = HdiId::HREQ_SMS_SET_SMSC_ADDR;
1988     resultInfo_ = responseInfo;
1989     NotifyAll();
1990     return 0;
1991 }
1992 
GetSmscAddrResponse(const RilRadioResponseInfo &responseInfo, const ServiceCenterAddress &serviceCenterAddress)1993 int32_t RilCallback::GetSmscAddrResponse(const RilRadioResponseInfo &responseInfo,
1994                                          const ServiceCenterAddress &serviceCenterAddress)
1995 {
1996     g_getSmscAddrResponseFlag = true;
1997     HDF_LOGI("RilCallback::GetSmscAddrResponse serviceCenterAddress tosca : %{public}d, address : %{public}s",
1998              serviceCenterAddress.tosca, serviceCenterAddress.address.c_str());
1999     hdiId_ = HdiId::HREQ_SMS_GET_SMSC_ADDR;
2000     resultInfo_ = responseInfo;
2001     NotifyAll();
2002     return 0;
2003 }
2004 
SetCBConfigResponse(const RilRadioResponseInfo &responseInfo)2005 int32_t RilCallback::SetCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2006 {
2007     g_setCBConfigResponseFlag = true;
2008     HDF_LOGI("RilCallback::SetCBConfigResponse error : %{public}d", responseInfo.error);
2009     hdiId_ = HdiId::HREQ_SMS_SET_CB_CONFIG;
2010     resultInfo_ = responseInfo;
2011     NotifyAll();
2012     return 0;
2013 }
2014 
GetCBConfigResponse(const RilRadioResponseInfo &responseInfo, const CBConfigInfo &cellBroadcastInfo)2015 int32_t RilCallback::GetCBConfigResponse(const RilRadioResponseInfo &responseInfo,
2016                                          const CBConfigInfo &cellBroadcastInfo)
2017 {
2018     g_getCBConfigResponseFlag = true;
2019     HDF_LOGI("RilCallback::GetCBConfigResponse cellBroadcastInfo mids : %{public}s, dcss: %{public}s",
2020              cellBroadcastInfo.mids.c_str(), cellBroadcastInfo.dcss.c_str());
2021     hdiId_ = HdiId::HREQ_SMS_GET_CB_CONFIG;
2022     resultInfo_ = responseInfo;
2023     NotifyAll();
2024     return 0;
2025 }
2026 
SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo)2027 int32_t RilCallback::SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2028 {
2029     g_setCdmaCBConfigResponseFlag = true;
2030     HDF_LOGI("RilCallback::SetCdmaCBConfigResponse error : %{public}d", responseInfo.error);
2031     hdiId_ = HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG;
2032     resultInfo_ = responseInfo;
2033     NotifyAll();
2034     return 0;
2035 }
2036 
GetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo, const CdmaCBConfigInfo &cdmaCBConfigInfo)2037 int32_t RilCallback::GetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo,
2038                                              const CdmaCBConfigInfo &cdmaCBConfigInfo)
2039 {
2040     g_getCdmaCBConfigResponseFlag = true;
2041     HDF_LOGI("RilCallback::GetCdmaCBConfigResponse cdmaCBConfigInfo service : %{public}d, language : %{public}d, "
2042              "checked: %{public}d",
2043              cdmaCBConfigInfo.service, cdmaCBConfigInfo.language, cdmaCBConfigInfo.checked);
2044     hdiId_ = HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG;
2045     resultInfo_ = responseInfo;
2046     NotifyAll();
2047     return 0;
2048 }
2049 
SendSmsMoreModeResponse(const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)2050 int32_t RilCallback::SendSmsMoreModeResponse(const RilRadioResponseInfo &responseInfo,
2051                                              const SendSmsResultInfo &sendSmsResultInfo)
2052 {
2053     g_sendSmsMoreModeResponseFlag = true;
2054     HDF_LOGI("RilCallback::SendSmsMoreModeResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2055              sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2056     hdiId_ = HdiId::HREQ_SMS_SEND_SMS_MORE_MODE;
2057     resultInfo_ = responseInfo;
2058     NotifyAll();
2059     return 0;
2060 }
2061 
SendSmsAckResponse(const RilRadioResponseInfo &responseInfo)2062 int32_t RilCallback::SendSmsAckResponse(const RilRadioResponseInfo &responseInfo)
2063 {
2064     g_sendSmsAckResponseFlag = true;
2065     HDF_LOGI("RilCallback::SendSmsAckResponse error:%{public}d", responseInfo.error);
2066     hdiId_ = HdiId::HREQ_SMS_SEND_SMS_ACK;
2067     resultInfo_ = responseInfo;
2068     NotifyAll();
2069     return 0;
2070 }
2071 
CommonErrorResponse(const RilRadioResponseInfo &responseInfo)2072 int32_t RilCallback::CommonErrorResponse(const RilRadioResponseInfo &responseInfo)
2073 {
2074     HDF_LOGI("RilCallback::CommonErrorResponse type:%{public}d error:%{public}d", responseInfo.type,
2075              responseInfo.error);
2076     return 0;
2077 }
2078 
2079 /**
2080 ** common fun
2081 **/
WaitFor(int32_t timeoutSecond)2082 void WaitFor(int32_t timeoutSecond) { g_callback.WaitFor(WAIT_TIME_SECOND); }
2083 
GetBoolResult(HdiId hdiId)2084 bool GetBoolResult(HdiId hdiId) { return g_callback.GetBoolResult(hdiId); }
2085 
GetSerialId()2086 int32_t GetSerialId()
2087 {
2088     std::uniform_int_distribution< long long > u(0, RAND_MAXVALUE);
2089     std::default_random_engine e(time(nullptr));
2090 
2091     return u(e);
2092 }
2093 
IsReady(int32_t slotId)2094 bool IsReady(int32_t slotId)
2095 {
2096     if (g_rilInterface == nullptr) {
2097         return false;
2098     }
2099     return g_simState[slotId] != 0 && g_simState[slotId] != -1;
2100 }