1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cmath"
17 #include "condition_variable"
18 #include "cstdio"
19 #include "gtest/gtest.h"
20 #include "hdf_base.h"
21 #include "hdf_log.h"
22 #include "map"
23 #include "mutex"
24 #include "securec.h"
25 #include "stdlib.h"
26 #include "unistd.h"
27 #include "v1_3/iril.h"
28
29 using namespace OHOS::HDI::Ril::V1_3;
30 using namespace testing::ext;
31
32 enum class HdiId {
33 HREQ_NONE = -1,
34 HREQ_CALL_BASE = 0,
35 HREQ_CALL_GET_CALL_LIST,
36 HREQ_CALL_DIAL,
37 HREQ_CALL_HANGUP,
38 HREQ_CALL_REJECT,
39 HREQ_CALL_ANSWER,
40 HREQ_CALL_HOLD_CALL, // call hold value 6
41 HREQ_CALL_UNHOLD_CALL, // call active value 6
42 HREQ_CALL_SWITCH_CALL,
43 HREQ_CALL_COMBINE_CONFERENCE,
44 HREQ_CALL_SEPARATE_CONFERENCE, // Keep all other calls except the xth call
45 HREQ_CALL_CALL_SUPPLEMENT,
46 HREQ_CALL_SEND_DTMF,
47 HREQ_CALL_START_DTMF,
48 HREQ_CALL_STOP_DTMF,
49 HREQ_CALL_SET_CLIP,
50 HREQ_CALL_GET_CLIP,
51 HREQ_CALL_GET_CALL_WAITING,
52 HREQ_CALL_SET_CALL_WAITING,
53 HREQ_CALL_GET_CALL_RESTRICTION,
54 HREQ_CALL_SET_CALL_RESTRICTION,
55 HREQ_CALL_GET_CALL_TRANSFER_INFO,
56 HREQ_CALL_SET_CALL_TRANSFER_INFO,
57 HREQ_CALL_GET_CLIR,
58 HREQ_CALL_SET_CLIR,
59 HREQ_CALL_GET_CALL_PREFERENCE,
60 HREQ_CALL_SET_CALL_PREFERENCE,
61 HREQ_CALL_SET_USSD,
62 HREQ_CALL_GET_USSD,
63 HREQ_CALL_SET_MUTE,
64 HREQ_CALL_GET_MUTE,
65 HREQ_CALL_GET_EMERGENCY_LIST,
66 HREQ_CALL_SET_EMERGENCY_LIST,
67 HREQ_CALL_GET_FAIL_REASON,
68 HREQ_CALL_SET_BARRING_PASSWORD,
69 HREQ_CALL_CLOSE_UNFINISHED_USSD,
70 HREQ_SET_VONR_SWITCH,
71
72 HREQ_SMS_BASE = 100,
73 HREQ_SMS_SEND_GSM_SMS,
74 HREQ_SMS_SEND_CDMA_SMS,
75 HREQ_SMS_ADD_SIM_MESSAGE,
76 HREQ_SMS_DEL_SIM_MESSAGE,
77 HREQ_SMS_UPDATE_SIM_MESSAGE,
78 HREQ_SMS_SEND_SMS_MORE_MODE,
79 HREQ_SMS_SEND_SMS_ACK,
80 HREQ_SMS_SET_SMSC_ADDR,
81 HREQ_SMS_GET_SMSC_ADDR,
82 HREQ_SMS_SET_CB_CONFIG,
83 HREQ_SMS_GET_CB_CONFIG,
84 HREQ_SMS_GET_CDMA_CB_CONFIG,
85 HREQ_SMS_SET_CDMA_CB_CONFIG,
86 HREQ_SMS_ADD_CDMA_SIM_MESSAGE,
87 HREQ_SMS_DEL_CDMA_SIM_MESSAGE,
88 HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE,
89
90 HREQ_SIM_BASE = 200,
91 HREQ_SIM_GET_SIM_STATUS,
92 HREQ_SIM_GET_IMSI,
93 HREQ_SIM_GET_SIM_IO,
94 HREQ_SIM_GET_SIM_LOCK_STATUS,
95 HREQ_SIM_SET_SIM_LOCK,
96 HREQ_SIM_CHANGE_SIM_PASSWORD,
97 HREQ_SIM_UNLOCK_PIN,
98 HREQ_SIM_UNLOCK_PUK,
99 HREQ_SIM_GET_SIM_PIN_INPUT_TIMES,
100 HREQ_SIM_UNLOCK_PIN2,
101 HREQ_SIM_UNLOCK_PUK2,
102 HREQ_SIM_GET_SIM_PIN2_INPUT_TIMES,
103 HREQ_SIM_SET_ACTIVE_SIM,
104 HREQ_SIM_RADIO_PROTOCOL,
105 HREQ_SIM_STK_SEND_TERMINAL_RESPONSE,
106 HREQ_SIM_STK_SEND_ENVELOPE,
107 HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT,
108 HREQ_SIM_STK_IS_READY,
109 HREQ_SIM_OPEN_LOGICAL_CHANNEL,
110 HREQ_SIM_CLOSE_LOGICAL_CHANNEL,
111 HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL,
112 HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL,
113 HREQ_SIM_AUTHENTICATION,
114 HREQ_SIM_UNLOCK_SIM_LOCK,
115 HREQ_SIM_SEND_NCFG_OPER_INFO,
116
117 HREQ_DATA_BASE = 300,
118 HREQ_DATA_SET_INIT_APN_INFO,
119 HREQ_DATA_DEACTIVATE_PDP_CONTEXT,
120 HREQ_DATA_ACTIVATE_PDP_CONTEXT,
121 HREQ_DATA_GET_PDP_CONTEXT_LIST,
122 HREQ_DATA_GET_LINK_BANDWIDTH_INFO,
123 HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE,
124 HREQ_DATA_SET_DATA_PROFILE_INFO,
125 HREQ_DATA_SEND_DATA_PERFORMANCE_MODE,
126 HREQ_DATA_SEND_DATA_SLEEP_MODE,
127 HREQ_DATA_SET_DATA_PERMITTED,
128 HREQ_DATA_GET_LINK_CAPABILITY,
129 HREQ_DATA_CLEAN_ALL_CONNECTIONS,
130
131 HREQ_NETWORK_BASE = 400,
132 HREQ_NETWORK_GET_SIGNAL_STRENGTH,
133 HREQ_NETWORK_GET_CS_REG_STATUS,
134 HREQ_NETWORK_GET_PS_REG_STATUS,
135 HREQ_NETWORK_GET_OPERATOR_INFO,
136 HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION,
137 HREQ_NETWORK_GET_NETWORK_SELECTION_MODE,
138 HREQ_NETWORK_SET_NETWORK_SELECTION_MODE,
139 HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST,
140 HREQ_NETWORK_GET_CURRENT_CELL_INFO,
141 HREQ_NETWORK_SET_PREFERRED_NETWORK,
142 HREQ_NETWORK_GET_PREFERRED_NETWORK,
143 HREQ_NETWORK_GET_RADIO_CAPABILITY,
144 HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG,
145 HREQ_NETWORK_SET_LOCATE_UPDATES,
146 HREQ_NETWORK_SET_NOTIFICATION_FILTER,
147 HREQ_NETWORK_SET_DEVICE_STATE,
148 HREQ_NETWORK_GET_RRC_CONNECTION_STATE,
149 HREQ_NETWORK_SET_NR_OPTION_MODE,
150 HREQ_NETWORK_GET_NR_OPTION_MODE,
151 HREQ_NETWORK_GET_NR_SSBID_INFO,
152
153 HREQ_COMMON_BASE = 500,
154 HREQ_MODEM_SHUT_DOWN,
155 HREQ_MODEM_SET_RADIO_STATUS,
156 HREQ_MODEM_GET_RADIO_STATUS,
157 HREQ_MODEM_GET_IMEI,
158 HREQ_MODEM_GET_IMEISV,
159 HREQ_MODEM_GET_MEID,
160 HREQ_MODEM_GET_BASEBAND_VERSION,
161 HREQ_MODEM_GET_VOICE_RADIO,
162 HREQ_MODEM_EXIT = 1000
163 };
164
165 enum class DeviceStateType { POWER_SAVE_MODE, CHARGING_STATE, LOW_DATA_STATE };
166
167 enum class NrMode { NR_MODE_UNKNOWN, NR_MODE_NSA_ONLY, NR_MODE_SA_ONLY, NR_MODE_NSA_AND_SA };
168
169 enum class NotificationFilter {
170 NOTIFICATION_FILTER_ALL = -1,
171 NOTIFICATION_FILTER_NONE = 0,
172 NOTIFICATION_FILTER_SIGNAL_STRENGTH = 1,
173 NOTIFICATION_FILTER_NETWORK_STATE = 2,
174 NOTIFICATION_FILTER_DATA_CALL = 4,
175 NOTIFICATION_FILTER_LINK_CAPACITY = 8,
176 NOTIFICATION_FILTER_PHYSICAL_CHANNEL_CONFIG = 16
177 };
178
179 enum class RatType {
180 NETWORK_TYPE_UNKNOWN = 0,
181 NETWORK_TYPE_GSM,
182 NETWORK_TYPE_CDMA,
183 NETWORK_TYPE_WCDMA,
184 NETWORK_TYPE_TDSCDMA,
185 NETWORK_TYPE_LTE,
186 NETWORK_TYPE_NR
187 };
188
189 enum class SelectionMode { MODE_TYPE_UNKNOWN = -1, MODE_TYPE_AUTO = 0, MODE_TYPE_MANUAL = 1 };
190
191 enum class PreferredNetworkMode {
192 CORE_NETWORK_MODE_AUTO = 0,
193 CORE_NETWORK_MODE_GSM = 1,
194 CORE_NETWORK_MODE_WCDMA = 2,
195 CORE_NETWORK_MODE_LTE = 3,
196 CORE_NETWORK_MODE_LTE_WCDMA = 4,
197 CORE_NETWORK_MODE_LTE_WCDMA_GSM = 5,
198 CORE_NETWORK_MODE_WCDMA_GSM = 6,
199 CORE_NETWORK_MODE_CDMA = 7,
200 CORE_NETWORK_MODE_EVDO = 8,
201 CORE_NETWORK_MODE_EVDO_CDMA = 9,
202 CORE_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA = 10,
203 CORE_NETWORK_MODE_LTE_EVDO_CDMA = 11,
204 CORE_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA = 12,
205 CORE_NETWORK_MODE_TDSCDMA = 13,
206 CORE_NETWORK_MODE_TDSCDMA_GSM = 14,
207 CORE_NETWORK_MODE_TDSCDMA_WCDMA = 15,
208 CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM = 16,
209 CORE_NETWORK_MODE_LTE_TDSCDMA = 17,
210 CORE_NETWORK_MODE_LTE_TDSCDMA_GSM = 18,
211 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA = 19,
212 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM = 20,
213 CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 21,
214 CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 22,
215 CORE_NETWORK_MODE_NR = 31,
216 CORE_NETWORK_MODE_NR_LTE = 32,
217 CORE_NETWORK_MODE_NR_LTE_WCDMA = 33,
218 CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM = 34,
219 CORE_NETWORK_MODE_NR_LTE_EVDO_CDMA = 35,
220 CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA = 36,
221 CORE_NETWORK_MODE_NR_LTE_TDSCDMA = 37,
222 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_GSM = 38,
223 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA = 39,
224 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM = 40,
225 CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA = 41,
226 CORE_NETWORK_MODE_MAX_VALUE = 99,
227 };
228
229 enum class SimMessageStatus {
230 SIM_MESSAGE_STATUS_UNREAD = 0,
231 SIM_MESSAGE_STATUS_READ = 1,
232 SIM_MESSAGE_STATUS_UNSENT = 2,
233 SIM_MESSAGE_STATUS_SENT = 3,
234 };
235
236 class RilCallback : public OHOS::HDI::Ril::V1_3::IRilCallback {
237 public:
238 void NotifyAll();
239 void WaitFor(int32_t timeoutSecond);
240 bool GetBoolResult(HdiId hdiId_);
241 void Clean();
242
243 // Call
244 int32_t CallStateUpdated(const RilRadioResponseInfo &responseInfo) override;
245 int32_t CallRingbackVoiceNotice(
246 const RilRadioResponseInfo &responseInfo, const RingbackVoice &ringbackVoice) override;
247 int32_t CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus) override;
248 int32_t CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo) override;
249 int32_t CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo) override;
250 int32_t CallEmergencyNotice(
251 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList) override;
252 int32_t CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo) override;
253 int32_t SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo) override;
254 int32_t GetEmergencyCallListResponse(
255 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList) override;
256 int32_t GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList) override;
257 int32_t DialResponse(const RilRadioResponseInfo &responseInfo) override;
258 int32_t HangupResponse(const RilRadioResponseInfo &responseInfo) override;
259 int32_t RejectResponse(const RilRadioResponseInfo &responseInfo) override;
260 int32_t AnswerResponse(const RilRadioResponseInfo &responseInfo) override;
261 int32_t HoldCallResponse(const RilRadioResponseInfo &responseInfo) override;
262 int32_t UnHoldCallResponse(const RilRadioResponseInfo &responseInfo) override;
263 int32_t SwitchCallResponse(const RilRadioResponseInfo &responseInfo) override;
264 int32_t GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult) override;
265 int32_t SetClipResponse(const RilRadioResponseInfo &responseInfo) override;
266 int32_t CombineConferenceResponse(const RilRadioResponseInfo &responseInfo) override;
267 int32_t SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo) override;
268 int32_t CallSupplementResponse(const RilRadioResponseInfo &responseInfo) override;
269 int32_t GetCallWaitingResponse(
270 const RilRadioResponseInfo &responseInfo, const CallWaitResult &callWaitResult) override;
271 int32_t SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo) override;
272 int32_t GetCallTransferInfoResponse(
273 const RilRadioResponseInfo &responseInfo, const CallForwardQueryInfoList &cFQueryList) override;
274 int32_t SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo) override;
275 int32_t GetCallRestrictionResponse(
276 const RilRadioResponseInfo &responseInfo, const CallRestrictionResult &result) override;
277 int32_t SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo) override;
278 int32_t GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult) override;
279 int32_t SetClirResponse(const RilRadioResponseInfo &responseInfo) override;
280 int32_t StartDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
281 int32_t SendDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
282 int32_t StopDtmfResponse(const RilRadioResponseInfo &responseInfo) override;
283 int32_t GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
284 int32_t SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo) override;
285 int32_t SetUssdResponse(const RilRadioResponseInfo &responseInfo) override;
286 int32_t GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd) override;
287 int32_t SetMuteResponse(const RilRadioResponseInfo &responseInfo) override;
288 int32_t GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute) override;
289 int32_t GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail) override;
290 int32_t SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo) override;
291 int32_t CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo) override;
292 int32_t SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo) override;
293
294 // Data
295 int32_t PdpContextListUpdated(
296 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList) override;
297 int32_t DataLinkCapabilityUpdated(
298 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability) override;
299 int32_t ActivatePdpContextResponse(
300 const RilRadioResponseInfo &responseInfo, const SetupDataCallResultInfo &setupDataCallResultInfo) override;
301 int32_t DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo) override;
302 int32_t GetPdpContextListResponse(
303 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList) override;
304 int32_t SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo) override;
305 int32_t SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo) override;
306 int32_t GetLinkBandwidthInfoResponse(
307 const RilRadioResponseInfo &responseInfo, const DataLinkBandwidthInfo &dataLinkBandwidthInfo) override;
308 int32_t SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo) override;
309 int32_t SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo);
310 int32_t GetLinkCapabilityResponse(
311 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability) override;
312 int32_t CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo) override;
313
314 // Modem
315 int32_t RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state) override;
316 int32_t VoiceRadioTechUpdated(
317 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology) override;
318 int32_t DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
319 int32_t ShutDownResponse(const RilRadioResponseInfo &responseInfo) override;
320 int32_t SetRadioStateResponse(const RilRadioResponseInfo &responseInfo) override;
321 int32_t GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state) override;
322 int32_t GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei) override;
323 int32_t GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv) override;
324 int32_t GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid) override;
325 int32_t GetVoiceRadioTechnologyResponse(
326 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology) override;
327 int32_t GetBasebandVersionResponse(
328 const RilRadioResponseInfo &responseInfo, const std::string &basebandVersion) override;
329
330 // Sim notice
331 int32_t SimStateUpdated(const RilRadioResponseInfo &responseInfo) override;
332 int32_t SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo) override;
333 int32_t SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
334 int32_t SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
335 int32_t SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
336 int32_t SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo) override;
337 int32_t SimRefreshNotify(const RilRadioResponseInfo &responseInfo) override;
SimRadioProtocolUpdated(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)338 int32_t SimRadioProtocolUpdated(
339 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override
340 {
341 return 0;
342 }
343 // Sim response
344 int32_t GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
345 int32_t GetSimStatusResponse(const RilRadioResponseInfo &responseInfo, const CardStatusInfo &result) override;
346 int32_t GetSimCardStatusResponse(const RilRadioResponseInfo &responseInfo,
347 const SimCardStatusInfo &result) override;
348 int32_t GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response) override;
349 int32_t GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus) override;
350 int32_t SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
351 int32_t ChangeSimPasswordResponse(
352 const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
353 int32_t UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
354 int32_t UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
355 int32_t UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
356 int32_t UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
357 int32_t SetActiveSimResponse(const RilRadioResponseInfo &responseInfo) override;
358 int32_t SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo) override;
359 int32_t SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo) override;
360 int32_t SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo) override;
361 int32_t SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo) override;
362 int32_t SetRadioProtocolResponse(
363 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override;
GetRadioProtocolResponse(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)364 int32_t GetRadioProtocolResponse(
365 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol) override
366 {
367 return 0;
368 }
369 int32_t SimOpenLogicalChannelResponse(const RilRadioResponseInfo &responseInfo,
370 const OpenLogicalChannelResponse &pOpenLogicalChannelResponse) override;
371 int32_t SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo) override;
372 int32_t SimTransmitApduLogicalChannelResponse(
373 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
374 int32_t SimTransmitApduBasicChannelResponse(
375 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
376 int32_t SimAuthenticationResponse(
377 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result) override;
378 int32_t UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus) override;
379 int32_t SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo) override;
380
381 // Network
382 int32_t NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
383 const CsRegStatusInfo &csRegStatusInfo) override;
384 int32_t NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
385 const PsRegStatusInfo &psRegStatusInfo) override;
386 int32_t SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi) override;
387 int32_t NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr) override;
388 int32_t NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr) override;
389 int32_t NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo,
390 const ChannelConfigInfoList &channelConfigInfoList) override;
391 int32_t NetworkCurrentCellUpdated(
392 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellListCurrentInfo) override;
393 int32_t NetworkCurrentCellUpdated_1_1(
394 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo) override;
395 int32_t NetworkCurrentCellUpdated_1_2(
396 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo) override;
397 int32_t ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn) override;
398 int32_t GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi) override;
399 int32_t GetCsRegStatusResponse(
400 const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo) override;
401 int32_t GetPsRegStatusResponse(
402 const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo) override;
403 int32_t GetOperatorInfoResponse(
404 const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo) override;
405 int32_t GetNetworkSearchInformationResponse(
406 const RilRadioResponseInfo &responseInfo, const AvailableNetworkList &availableNetworkList) override;
407 int32_t GetNetworkSelectionModeResponse(
408 const RilRadioResponseInfo &responseInfo, const SetNetworkModeInfo &setNetworkModeInfo) override;
409 int32_t SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo) override;
410 int32_t GetNeighboringCellInfoListResponse(
411 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo &cellInfoList) override;
412 int32_t GetNeighboringCellInfoListResponse_1_2(
413 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo_1_2 &cellInfoList) override;
414 int32_t GetCurrentCellInfoResponse(
415 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellInfoList) override;
416 int32_t GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo &responseInfo,
417 const CellListCurrentInfo_1_1 &cellListCurrentInfo) override;
418 int32_t GetCurrentCellInfoResponse_1_2(
419 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo) override;
420 int32_t SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo) override;
421 int32_t GetPreferredNetworkResponse(
422 const RilRadioResponseInfo &responseInfo, const PreferredNetworkTypeInfo &preferredNetworkTypeInfo) override;
423 int32_t GetPhysicalChannelConfigResponse(
424 const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList) override;
425 int32_t SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo) override;
426 int32_t SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo) override;
427 int32_t SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo) override;
428 int32_t GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state) override;
429 int32_t SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo) override;
430 int32_t GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode) override;
431 int32_t GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state) override;
432 int32_t GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds) override;
433
434 // Sms
435 int32_t NewSmsNotify(
436 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
437 int32_t NewCdmaSmsNotify(
438 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
439 int32_t SmsStatusReportNotify(
440 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo) override;
441 int32_t NewSmsStoredOnSimNotify(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t recordNumber,
442 int32_t indicationType) override;
443 int32_t CBConfigNotify(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
444 const CBConfigReportInfo &cellBroadConfigReportInfo) override;
445 int32_t SendGsmSmsResponse(
446 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
447 int32_t SendCdmaSmsResponse(
448 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
449 int32_t AddSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
450 int32_t DelSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
451 int32_t UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
452 int32_t AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
453 int32_t DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
454 int32_t UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo) override;
455 int32_t SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo) override;
456 int32_t GetSmscAddrResponse(
457 const RilRadioResponseInfo &responseInfo, const ServiceCenterAddress &serviceCenterAddress) override;
458 int32_t SetCBConfigResponse(const RilRadioResponseInfo &responseInfo) override;
459 int32_t GetCBConfigResponse(
460 const RilRadioResponseInfo &responseInfo, const CBConfigInfo &cellBroadcastInfo) override;
461 int32_t SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo) override;
462 int32_t GetCdmaCBConfigResponse(
463 const RilRadioResponseInfo &responseInfo, const CdmaCBConfigInfo &cdmaCBConfigInfo) override;
464 int32_t SendSmsMoreModeResponse(
465 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo) override;
466 int32_t SendSmsAckResponse(const RilRadioResponseInfo &responseInfo) override;
467
468 int32_t CommonErrorResponse(const RilRadioResponseInfo &responseInfo) override;
469
470 private:
471 std::mutex callbackMutex_;
472 std::condition_variable cv_;
473 HdiId hdiId_;
474 RilRadioResponseInfo resultInfo_;
475 };
476
477 class HdfRilHdiTest : public testing::Test {
478 public:
479 static void SetUpTestCase();
480 static void TearDownTestCase();
481 void SetUp();
482 void TearDown();
483 };
484
485 namespace {
486 sptr<OHOS::HDI::Ril::V1_3::IRil> g_rilInterface = nullptr;
487 RilCallback callback_;
488 constexpr static int32_t SLOTID_1 = 0;
489 constexpr static int32_t SLOTID_2 = 1;
490 constexpr static int32_t SUCCESS = 0;
491 constexpr static int32_t WAIT_TIME_SECOND = 20;
492 constexpr static int32_t WAIT_TIME_SECOND_LONG = 40;
493 constexpr static int32_t CID = 1;
494 constexpr static int32_t REASON = 2;
495 std::map<int32_t, int32_t> simState_;
496 int32_t currentChannelId_ = 1;
497 constexpr int32_t TEST_TOSCA = 0;
498 const std::string TEST_STORAGE_PDU = "1234";
499 const std::string TEST_SEND_PDU = "A10305810180F6000004F4F29C0E";
500 const std::string TEST_SMSC_PDU = "00";
501 const std::string TEST_CDMA_PDU = "pdu";
502 const std::string TEST_SMSC_ADDR = "00";
503 const std::string TEST_ID_LIST = "0,1,5,320-478,922";
504 const std::string TEST_DCS_LIST = "0-3,5";
505 const int32_t TEST_MODE = 0;
506 const bool TEST_RESULT = true;
507 int32_t currentSerialId = 0;
508 } // namespace
509
510 /**
511 ** common fun
512 **/
WaitFor(int32_t timeoutSecond)513 void WaitFor(int32_t timeoutSecond)
514 {
515 callback_.WaitFor(WAIT_TIME_SECOND);
516 }
517
GetBoolResult(HdiId hdiId_)518 bool GetBoolResult(HdiId hdiId_)
519 {
520 return callback_.GetBoolResult(hdiId_);
521 }
522
GetSerialId()523 int32_t GetSerialId()
524 {
525 currentSerialId = rand() % 10000000000;
526 return currentSerialId;
527 }
528
IsReady(int32_t slotId)529 bool IsReady(int32_t slotId)
530 {
531 if (g_rilInterface == nullptr) {
532 return false;
533 }
534 return simState_[slotId] != 0 && simState_[slotId] != -1;
535 }
536
537 /**
538 ** RilCallback implement
539 **/
540
NotifyAll()541 void RilCallback::NotifyAll()
542 {
543 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
544 if (resultInfo_.serial != currentSerialId) {
545 hdiId_ = HdiId::HREQ_NONE;
546 HDF_LOGI("NotifyAll currentSerialId : %{public}d, serial: %{public}d not equal", currentSerialId,
547 resultInfo_.serial);
548 return;
549 }
550 cv_.notify_all();
551 }
552
WaitFor(int32_t timeoutSecond)553 void RilCallback::WaitFor(int32_t timeoutSecond)
554 {
555 Clean();
556 std::unique_lock<std::mutex> callbackLock(callbackMutex_);
557 cv_.wait_for(callbackLock, std::chrono::seconds(timeoutSecond));
558 }
559
Clean()560 void RilCallback::Clean()
561 {
562 hdiId_ = HdiId::HREQ_NONE;
563 }
564
GetBoolResult(HdiId hdiId)565 bool RilCallback::GetBoolResult(HdiId hdiId)
566 {
567 HDF_LOGI("GetBoolResult hdiId: %{public}d, error: %{public}d", hdiId, (int32_t)resultInfo_.error);
568 bool ret = false;
569 if (hdiId_ == HdiId::HREQ_NONE) {
570 HDF_LOGE("response timeout, not implemented."
571 "hdiId: %d, current hdiId_: %{public}d",
572 (int32_t)hdiId, hdiId_);
573 ret = true;
574 Clean();
575 return ret;
576 }
577 if (hdiId_ != hdiId) {
578 ret = false;
579 HDF_LOGE(
580 "GetBoolResult hdiId does not match. hdiId: %{public}d, current hdiId: %{public}d", (int32_t)hdiId, hdiId_);
581 Clean();
582 return ret;
583 }
584 ret = true;
585 Clean();
586 return ret;
587 }
588
589 // SIM
SimStateUpdated(const RilRadioResponseInfo & responseInfo)590 int32_t RilCallback::SimStateUpdated(const RilRadioResponseInfo &responseInfo)
591 {
592 HDF_LOGI("SimStateUpdated notice : slotId = %{public}d", responseInfo.slotId);
593 g_rilInterface->GetSimStatus(responseInfo.slotId, GetSerialId());
594 return 0;
595 }
596
SimStkSessionEndNotify(const RilRadioResponseInfo & responseInfo)597 int32_t RilCallback::SimStkSessionEndNotify(const RilRadioResponseInfo &responseInfo)
598 {
599 HDF_LOGI("SimStkSessionEndNotify notice : slotId = %{public}d", responseInfo.slotId);
600 return 0;
601 }
602
SimStkProactiveNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)603 int32_t RilCallback::SimStkProactiveNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
604 {
605 HDF_LOGI("SimStkProactiveNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId,
606 response.c_str());
607 return 0;
608 }
609
SimStkAlphaNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)610 int32_t RilCallback::SimStkAlphaNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
611 {
612 HDF_LOGI(
613 "SimStkAlphaNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId, response.c_str());
614 return 0;
615 }
616
SimStkEventNotify(const RilRadioResponseInfo & responseInfo,const std::string & response)617 int32_t RilCallback::SimStkEventNotify(const RilRadioResponseInfo &responseInfo, const std::string &response)
618 {
619 HDF_LOGI(
620 "SimStkEventNotify notice : slotId = %{public}d, response = %{public}s", responseInfo.slotId, response.c_str());
621 return 0;
622 }
623
SimStkCallSetupNotify(const RilRadioResponseInfo & responseInfo)624 int32_t RilCallback::SimStkCallSetupNotify(const RilRadioResponseInfo &responseInfo)
625 {
626 HDF_LOGI("SimStkCallSetupNotify notice : slotId = %{public}d", responseInfo.slotId);
627 return 0;
628 }
629
SimRefreshNotify(const RilRadioResponseInfo & responseInfo)630 int32_t RilCallback::SimRefreshNotify(const RilRadioResponseInfo &responseInfo)
631 {
632 HDF_LOGI("SimRefreshNotify notice : slotId = %{public}d", responseInfo.slotId);
633 return 0;
634 }
635
GetSimStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const HDI::Ril::V1_1::CardStatusInfo & result)636 int32_t RilCallback::GetSimStatusResponse(
637 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const HDI::Ril::V1_1::CardStatusInfo &result)
638 {
639 HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, simState = %{public}d",
640 responseInfo.slotId, result.simType, result.simState);
641 simState_[responseInfo.slotId] = result.simState;
642 HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, simState_[responseInfo.slotId]);
643 hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
644 resultInfo_ = responseInfo;
645 NotifyAll();
646 return 0;
647 }
648
GetSimCardStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const HDI::Ril::V1_3::SimCardStatusInfo & result)649 int32_t RilCallback::GetSimCardStatusResponse(const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo,
650 const HDI::Ril::V1_3::SimCardStatusInfo &result)
651 {
652 HDF_LOGI("GetBoolResult GetSimStatus result : slotId = %{public}d, simType = %{public}d, simState = %{public}d",
653 responseInfo.slotId, result.simType, result.simState);
654 simState_[responseInfo.slotId] = result.simState;
655 HDF_LOGI("IsReady %{public}d %{public}d", responseInfo.slotId, simState_[responseInfo.slotId]);
656 hdiId_ = HdiId::HREQ_SIM_GET_SIM_STATUS;
657 resultInfo_ = responseInfo;
658 NotifyAll();
659 return 0;
660 }
661
GetSimIOResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)662 int32_t RilCallback::GetSimIOResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
663 {
664 HDF_LOGI("GetBoolResult GetSimIO result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s", result.sw1,
665 result.sw2, result.response.c_str());
666 hdiId_ = HdiId::HREQ_SIM_GET_SIM_IO;
667 resultInfo_ = responseInfo;
668 NotifyAll();
669 return 0;
670 }
671
GetImsiResponse(const RilRadioResponseInfo & responseInfo,const std::string & response)672 int32_t RilCallback::GetImsiResponse(const RilRadioResponseInfo &responseInfo, const std::string &response)
673 {
674 HDF_LOGI("GetBoolResult GetImsi result : response = %{public}s", response.c_str());
675 hdiId_ = HdiId::HREQ_SIM_GET_IMSI;
676 resultInfo_ = responseInfo;
677 NotifyAll();
678 return 0;
679 }
GetSimLockStatusResponse(const RilRadioResponseInfo & responseInfo,int32_t simLockStatus)680 int32_t RilCallback::GetSimLockStatusResponse(const RilRadioResponseInfo &responseInfo, int32_t simLockStatus)
681 {
682 HDF_LOGI("GetBoolResult GetSimLockStatus result : simLockStatus = %{public}d", simLockStatus);
683 hdiId_ = HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS;
684 resultInfo_ = responseInfo;
685 NotifyAll();
686 return 0;
687 }
SetSimLockResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)688 int32_t RilCallback::SetSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
689 {
690 HDF_LOGI("GetBoolResult SetSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
691 lockStatus.remain);
692 hdiId_ = HdiId::HREQ_SIM_SET_SIM_LOCK;
693 resultInfo_ = responseInfo;
694 NotifyAll();
695 return 0;
696 }
ChangeSimPasswordResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)697 int32_t RilCallback::ChangeSimPasswordResponse(
698 const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
699 {
700 HDF_LOGI("GetBoolResult ChangeSimPassword result : result = %{public}d, remain = %{public}d", lockStatus.result,
701 lockStatus.remain);
702 hdiId_ = HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD;
703 resultInfo_ = responseInfo;
704 NotifyAll();
705 return 0;
706 }
UnlockPinResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)707 int32_t RilCallback::UnlockPinResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
708 {
709 HDF_LOGI("GetBoolResult UnlockPin result : result = %{public}d, remain = %{public}d", lockStatus.result,
710 lockStatus.remain);
711 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN;
712 resultInfo_ = responseInfo;
713 NotifyAll();
714 return 0;
715 }
UnlockPukResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)716 int32_t RilCallback::UnlockPukResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
717 {
718 HDF_LOGI("GetBoolResult UnlockPuk result : result = %{public}d, remain = %{public}d", lockStatus.result,
719 lockStatus.remain);
720 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK;
721 resultInfo_ = responseInfo;
722 NotifyAll();
723 return 0;
724 }
UnlockPin2Response(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)725 int32_t RilCallback::UnlockPin2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
726 {
727 HDF_LOGI("GetBoolResult UnlockPin2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
728 lockStatus.remain);
729 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PIN2;
730 resultInfo_ = responseInfo;
731 NotifyAll();
732 return 0;
733 }
UnlockPuk2Response(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)734 int32_t RilCallback::UnlockPuk2Response(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
735 {
736 HDF_LOGI("GetBoolResult UnlockPuk2 result : result = %{public}d, remain = %{public}d", lockStatus.result,
737 lockStatus.remain);
738 hdiId_ = HdiId::HREQ_SIM_UNLOCK_PUK2;
739 resultInfo_ = responseInfo;
740 NotifyAll();
741 return 0;
742 }
743
SetActiveSimResponse(const RilRadioResponseInfo & responseInfo)744 int32_t RilCallback::SetActiveSimResponse(const RilRadioResponseInfo &responseInfo)
745 {
746 HDF_LOGI("GetBoolResult SetActiveSim result");
747 hdiId_ = HdiId::HREQ_SIM_SET_ACTIVE_SIM;
748 resultInfo_ = responseInfo;
749 NotifyAll();
750 return 0;
751 }
752
SimStkSendTerminalResponseResponse(const RilRadioResponseInfo & responseInfo)753 int32_t RilCallback::SimStkSendTerminalResponseResponse(const RilRadioResponseInfo &responseInfo)
754 {
755 HDF_LOGI("GetBoolResult SimStkSendTerminalResponse result");
756 hdiId_ = HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE;
757 resultInfo_ = responseInfo;
758 NotifyAll();
759 return 0;
760 }
761
SimStkSendEnvelopeResponse(const RilRadioResponseInfo & responseInfo)762 int32_t RilCallback::SimStkSendEnvelopeResponse(const RilRadioResponseInfo &responseInfo)
763 {
764 HDF_LOGI("GetBoolResult SimStkSendEnvelope result");
765 hdiId_ = HdiId::HREQ_SIM_STK_SEND_ENVELOPE;
766 resultInfo_ = responseInfo;
767 NotifyAll();
768 return 0;
769 }
770
SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo & responseInfo)771 int32_t RilCallback::SimStkSendCallSetupRequestResultResponse(const RilRadioResponseInfo &responseInfo)
772 {
773 HDF_LOGI("GetBoolResult SimStkSendCallSetupRequestResult result");
774 hdiId_ = HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT;
775 resultInfo_ = responseInfo;
776 NotifyAll();
777 return 0;
778 }
779
SimStkIsReadyResponse(const RilRadioResponseInfo & responseInfo)780 int32_t RilCallback::SimStkIsReadyResponse(const RilRadioResponseInfo &responseInfo)
781 {
782 HDF_LOGI("GetBoolResult SimStkIsReady result");
783 hdiId_ = HdiId::HREQ_SIM_STK_IS_READY;
784 resultInfo_ = responseInfo;
785 NotifyAll();
786 return 0;
787 }
788
SetRadioProtocolResponse(const RilRadioResponseInfo & responseInfo,const RadioProtocol & radioProtocol)789 int32_t RilCallback::SetRadioProtocolResponse(
790 const RilRadioResponseInfo &responseInfo, const RadioProtocol &radioProtocol)
791 {
792 HDF_LOGI("GetBoolResult SetRadioProtocol result : phase = %{public}d, slotId = %{public}d", radioProtocol.phase,
793 radioProtocol.slotId);
794 hdiId_ = HdiId::HREQ_SIM_RADIO_PROTOCOL;
795 resultInfo_ = responseInfo;
796 NotifyAll();
797 return 0;
798 }
799
SimOpenLogicalChannelResponse(const RilRadioResponseInfo & responseInfo,const OpenLogicalChannelResponse & pOpenLogicalChannelResponse)800 int32_t RilCallback::SimOpenLogicalChannelResponse(
801 const RilRadioResponseInfo &responseInfo, const OpenLogicalChannelResponse &pOpenLogicalChannelResponse)
802 {
803 HDF_LOGI("GetBoolResult SimOpenLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, channelId = %{public}d, "
804 "response = %{public}s",
805 pOpenLogicalChannelResponse.sw1, pOpenLogicalChannelResponse.sw2, pOpenLogicalChannelResponse.channelId,
806 pOpenLogicalChannelResponse.response.c_str());
807 currentChannelId_ = pOpenLogicalChannelResponse.channelId;
808 hdiId_ = HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL;
809 resultInfo_ = responseInfo;
810 NotifyAll();
811 return 0;
812 }
813
SimCloseLogicalChannelResponse(const RilRadioResponseInfo & responseInfo)814 int32_t RilCallback::SimCloseLogicalChannelResponse(const RilRadioResponseInfo &responseInfo)
815 {
816 HDF_LOGI("GetBoolResult SimCloseLogicalChannel result");
817 hdiId_ = HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL;
818 resultInfo_ = responseInfo;
819 NotifyAll();
820 return 0;
821 }
822
SimTransmitApduLogicalChannelResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)823 int32_t RilCallback::SimTransmitApduLogicalChannelResponse(
824 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
825 {
826 HDF_LOGI("GetBoolResult SimTransmitApduLogicalChannel result : sw1 = %{public}d, sw2 = %{public}d, response = "
827 "%{public}s",
828 result.sw1, result.sw2, result.response.c_str());
829 hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL;
830 resultInfo_ = responseInfo;
831 NotifyAll();
832 return 0;
833 }
834
SimTransmitApduBasicChannelResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)835 int32_t RilCallback::SimTransmitApduBasicChannelResponse(
836 const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
837 {
838 HDF_LOGI(
839 "GetBoolResult SimTransmitApduBasicChannel result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
840 result.sw1, result.sw2, result.response.c_str());
841 hdiId_ = HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL;
842 resultInfo_ = responseInfo;
843 NotifyAll();
844 return 0;
845 }
SimAuthenticationResponse(const RilRadioResponseInfo & responseInfo,const IccIoResultInfo & result)846 int32_t RilCallback::SimAuthenticationResponse(const RilRadioResponseInfo &responseInfo, const IccIoResultInfo &result)
847 {
848 HDF_LOGI("GetBoolResult SimAuthentication result : sw1 = %{public}d, sw2 = %{public}d, response = %{public}s",
849 result.sw1, result.sw2, result.response.c_str());
850 hdiId_ = HdiId::HREQ_SIM_AUTHENTICATION;
851 resultInfo_ = responseInfo;
852 NotifyAll();
853 return 0;
854 }
855
UnlockSimLockResponse(const RilRadioResponseInfo & responseInfo,const LockStatusResp & lockStatus)856 int32_t RilCallback::UnlockSimLockResponse(const RilRadioResponseInfo &responseInfo, const LockStatusResp &lockStatus)
857 {
858 HDF_LOGI("GetBoolResult UnlockSimLock result : result = %{public}d, remain = %{public}d", lockStatus.result,
859 lockStatus.remain);
860 hdiId_ = HdiId::HREQ_SIM_UNLOCK_SIM_LOCK;
861 resultInfo_ = responseInfo;
862 NotifyAll();
863 return 0;
864 }
865
SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo & responseInfo)866 int32_t RilCallback::SendSimMatchedOperatorInfoResponse(const RilRadioResponseInfo &responseInfo)
867 {
868 HDF_LOGI("GetBoolResult SendSimMatchedOperatorInfo result");
869 hdiId_ = HdiId::HREQ_SIM_SEND_NCFG_OPER_INFO;
870 resultInfo_ = responseInfo;
871 NotifyAll();
872 return 0;
873 }
874
875 // Network
NetworkCsRegStatusUpdated(const RilRadioResponseInfo & responseInfo,const CsRegStatusInfo & csRegStatusInfo)876 int32_t RilCallback::NetworkCsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
877 const CsRegStatusInfo &csRegStatusInfo)
878 {
879 HDF_LOGI("RilCallback::NetworkCsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, "
880 "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
881 csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
882 csRegStatusInfo.radioTechnology);
883 return 0;
884 }
885
NetworkPsRegStatusUpdated(const RilRadioResponseInfo & responseInfo,const PsRegStatusInfo & psRegStatusInfo)886 int32_t RilCallback::NetworkPsRegStatusUpdated(const RilRadioResponseInfo &responseInfo,
887 const PsRegStatusInfo &psRegStatusInfo)
888 {
889 HDF_LOGI(
890 "RilCallback::NetworkPsRegStatusUpdated notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
891 "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
892 psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
893 psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
894 psRegStatusInfo.isEnDcAvailable);
895 return 0;
896 }
897
SignalStrengthUpdated(const RilRadioResponseInfo & responseInfo,const Rssi & rssi)898 int32_t RilCallback::SignalStrengthUpdated(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
899 {
900 HDF_LOGI("RilCallback::SignalStrengthUpdated rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
901 return 0;
902 }
903
NetworkTimeZoneUpdated(const RilRadioResponseInfo & responseInfo,const std::string & timeZoneStr)904 int32_t RilCallback::NetworkTimeZoneUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeZoneStr)
905 {
906 HDF_LOGI("RilCallback::NetworkTimeZoneUpdated timeZone:%{public}s", timeZoneStr.c_str());
907 return 0;
908 }
909
NetworkTimeUpdated(const RilRadioResponseInfo & responseInfo,const std::string & timeStr)910 int32_t RilCallback::NetworkTimeUpdated(const RilRadioResponseInfo &responseInfo, const std::string &timeStr)
911 {
912 HDF_LOGI("RilCallback::NetworkTimeZoneUpdated time:%{public}s", timeStr.c_str());
913 return 0;
914 }
915
NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo & responseInfo,const ChannelConfigInfoList & channelConfigInfoList)916 int32_t RilCallback::NetworkPhyChnlCfgUpdated(const RilRadioResponseInfo &responseInfo,
917 const ChannelConfigInfoList &channelConfigInfoList)
918 {
919 HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated itemNum:%{public}d", channelConfigInfoList.itemNum);
920 for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
921 HDF_LOGI("RilCallback::NetworkPhyChnlCfgUpdated cellConnStatus:%{public}d, "
922 "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
923 "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
924 "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
925 phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
926 phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
927 phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
928 for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
929 HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
930 }
931 }
932 return 0;
933 }
934
NetworkCurrentCellUpdated(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo & cellListCurrentInfo)935 int32_t RilCallback::NetworkCurrentCellUpdated(
936 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellListCurrentInfo)
937 {
938 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated itemNum:%{public}d", cellListCurrentInfo.itemNum);
939 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
940 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
941 info.ratType, info.mcc, info.mnc);
942 switch (static_cast<RatType>(info.ratType)) {
943 case RatType::NETWORK_TYPE_LTE:
944 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
945 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
946 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
947 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
948 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
949 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
950 break;
951 case RatType::NETWORK_TYPE_GSM:
952 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
953 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
954 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
955 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
956 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
957 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
958 break;
959 case RatType::NETWORK_TYPE_WCDMA:
960 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
961 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
962 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
963 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
964 break;
965 case RatType::NETWORK_TYPE_NR:
966 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
967 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
968 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
969 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
970 break;
971 default:
972 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated invalid ratType");
973 }
974 }
975 return 0;
976 }
977
NetworkCurrentCellUpdated_1_1(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_1 & cellListCurrentInfo)978 int32_t RilCallback::NetworkCurrentCellUpdated_1_1(
979 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)
980 {
981 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
982 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
983 HDF_LOGI("RilCallback::NetworkCurrentCellUpdated_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
984 info.ratType, info.mcc, info.mnc);
985 switch (static_cast<RatType>(info.ratType)) {
986 case RatType::NETWORK_TYPE_LTE:
987 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
988 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
989 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
990 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
991 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
992 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
993 break;
994 case RatType::NETWORK_TYPE_GSM:
995 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
996 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
997 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
998 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
999 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1000 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1001 break;
1002 case RatType::NETWORK_TYPE_WCDMA:
1003 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1004 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1005 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1006 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1007 break;
1008 case RatType::NETWORK_TYPE_NR:
1009 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1010 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1011 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1012 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1013 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1014 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1015 break;
1016 default:
1017 HDF_LOGE("RilCallback::NetworkCurrentCellUpdated_1_1 invalid ratType");
1018 }
1019 }
1020 return 0;
1021 }
1022
NetworkCurrentCellUpdated_1_2(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_2 & cellListCurrentInfo)1023 int32_t RilCallback::NetworkCurrentCellUpdated_1_2(
1024 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)
1025 {
1026 HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
1027 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1028 HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
1029 switch (static_cast<RatType>(info.ratType)) {
1030 case RatType::NETWORK_TYPE_LTE:
1031 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1032 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1033 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1034 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1035 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1036 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1037 break;
1038 case RatType::NETWORK_TYPE_GSM:
1039 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1040 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1041 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1042 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1043 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1044 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1045 break;
1046 case RatType::NETWORK_TYPE_WCDMA:
1047 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1048 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1049 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1050 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1051 break;
1052 case RatType::NETWORK_TYPE_NR:
1053 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1054 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1055 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1056 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1057 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1058 break;
1059 default:
1060 HDF_LOGE("invalid ratType");
1061 break;
1062 }
1063 }
1064 return 0;
1065 }
1066
ResidentNetworkUpdated(const RilRadioResponseInfo & responseInfo,const std::string & plmn)1067 int32_t RilCallback::ResidentNetworkUpdated(const RilRadioResponseInfo &responseInfo, const std::string &plmn)
1068 {
1069 HDF_LOGI("RilCallback::ResidentNetworkUpdated plmn:%{public}s", plmn.c_str());
1070 return 0;
1071 }
1072
GetSignalStrengthResponse(const RilRadioResponseInfo & responseInfo,const Rssi & rssi)1073 int32_t RilCallback::GetSignalStrengthResponse(const RilRadioResponseInfo &responseInfo, const Rssi &rssi)
1074 {
1075 HDF_LOGI("RilCallback::GetSignalStrengthResponse rxlev:%{public}d rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
1076 hdiId_ = HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH;
1077 resultInfo_ = responseInfo;
1078 NotifyAll();
1079 return 0;
1080 }
1081
GetCsRegStatusResponse(const RilRadioResponseInfo & responseInfo,const CsRegStatusInfo & csRegStatusInfo)1082 int32_t RilCallback::GetCsRegStatusResponse(
1083 const RilRadioResponseInfo &responseInfo, const CsRegStatusInfo &csRegStatusInfo)
1084 {
1085 HDF_LOGI("RilCallback::GetCsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, "
1086 "lacCode:%{public}d, cellId:%{public}d, radioTechnology:%{public}d",
1087 csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
1088 csRegStatusInfo.radioTechnology);
1089 hdiId_ = HdiId::HREQ_NETWORK_GET_CS_REG_STATUS;
1090 resultInfo_ = responseInfo;
1091 NotifyAll();
1092 return 0;
1093 }
1094
GetPsRegStatusResponse(const RilRadioResponseInfo & responseInfo,const PsRegStatusInfo & psRegStatusInfo)1095 int32_t RilCallback::GetPsRegStatusResponse(
1096 const RilRadioResponseInfo &responseInfo, const PsRegStatusInfo &psRegStatusInfo)
1097 {
1098 HDF_LOGI(
1099 "RilCallback::GetPsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, lacCode:%{public}d, "
1100 "cellId:%{public}d, tech:%{public}d, nrRestricted:%{public}d, nrAvailable:%{public}d, enDcAvailable:%{public}d",
1101 psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
1102 psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
1103 psRegStatusInfo.isEnDcAvailable);
1104 hdiId_ = HdiId::HREQ_NETWORK_GET_PS_REG_STATUS;
1105 resultInfo_ = responseInfo;
1106 NotifyAll();
1107 return 0;
1108 }
1109
GetOperatorInfoResponse(const RilRadioResponseInfo & responseInfo,const OperatorInfo & operatorInfo)1110 int32_t RilCallback::GetOperatorInfoResponse(
1111 const RilRadioResponseInfo &responseInfo, const OperatorInfo &operatorInfo)
1112 {
1113 HDF_LOGI("RilCallback::GetOperatorInfoResponse longName:%{public}s, shortName:%{public}s, numeric:%{public}s",
1114 operatorInfo.longName.c_str(), operatorInfo.shortName.c_str(), operatorInfo.numeric.c_str());
1115 hdiId_ = HdiId::HREQ_NETWORK_GET_OPERATOR_INFO;
1116 resultInfo_ = responseInfo;
1117 NotifyAll();
1118 return 0;
1119 }
1120
GetNetworkSearchInformationResponse(const RilRadioResponseInfo & responseInfo,const AvailableNetworkList & availableNetworkList)1121 int32_t RilCallback::GetNetworkSearchInformationResponse(
1122 const RilRadioResponseInfo &responseInfo, const AvailableNetworkList &availableNetworkList)
1123 {
1124 HDF_LOGI("RilCallback::GetNetworkSearchInformationResponse itemNum:%{public}d", availableNetworkList.itemNum);
1125 for (auto availableInfo : availableNetworkList.availableNetworkInfo) {
1126 HDF_LOGI("status:%{public}d", availableInfo.status);
1127 HDF_LOGI("numeric:%{public}s", availableInfo.numeric.c_str());
1128 HDF_LOGI("shortName:%{public}s", availableInfo.shortName.c_str());
1129 HDF_LOGI("longName:%{public}s", availableInfo.longName.c_str());
1130 HDF_LOGI("rat:%{public}d", availableInfo.rat);
1131 }
1132 hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION;
1133 resultInfo_ = responseInfo;
1134 NotifyAll();
1135 return 0;
1136 }
1137
GetNetworkSelectionModeResponse(const RilRadioResponseInfo & responseInfo,const SetNetworkModeInfo & setNetworkModeInfo)1138 int32_t RilCallback::GetNetworkSelectionModeResponse(
1139 const RilRadioResponseInfo &responseInfo, const SetNetworkModeInfo &setNetworkModeInfo)
1140 {
1141 HDF_LOGI("RilCallback::GetNetworkSelectionModeResponse selectMode:%{public}d", setNetworkModeInfo.selectMode);
1142 hdiId_ = HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE;
1143 resultInfo_ = responseInfo;
1144 NotifyAll();
1145 return 0;
1146 }
1147
SetNetworkSelectionModeResponse(const RilRadioResponseInfo & responseInfo)1148 int32_t RilCallback::SetNetworkSelectionModeResponse(const RilRadioResponseInfo &responseInfo)
1149 {
1150 HDF_LOGI("RilCallback::SetNetworkSelectionModeResponse error:%{public}d", responseInfo.error);
1151 hdiId_ = HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE;
1152 resultInfo_ = responseInfo;
1153 NotifyAll();
1154 return 0;
1155 }
1156
GetNeighboringCellInfoListResponse(const RilRadioResponseInfo & responseInfo,const CellListNearbyInfo & cellInfoList)1157 int32_t RilCallback::GetNeighboringCellInfoListResponse(
1158 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo &cellInfoList)
1159 {
1160 HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse itemNum:%{public}d", cellInfoList.itemNum);
1161 for (auto info : cellInfoList.cellNearbyInfo) {
1162 HDF_LOGI("RilCallback::GetNeighboringCellInfoListResponse ratType:%{public}d", info.ratType);
1163 switch (static_cast<RatType>(info.ratType)) {
1164 case RatType::NETWORK_TYPE_LTE:
1165 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1166 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1167 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1168 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1169 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
1170 break;
1171 case RatType::NETWORK_TYPE_GSM:
1172 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1173 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1174 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1175 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1176 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1177 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1178 break;
1179 case RatType::NETWORK_TYPE_WCDMA:
1180 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1181 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1182 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1183 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1184 break;
1185 case RatType::NETWORK_TYPE_NR:
1186 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1187 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1188 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1189 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1190 break;
1191 default:
1192 HDF_LOGE("RilCallback::GetNeighboringCellInfoListResponse invalid ratType");
1193 }
1194 }
1195 hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
1196 resultInfo_ = responseInfo;
1197 NotifyAll();
1198 return 0;
1199 }
1200
GetNeighboringCellInfoListResponse_1_2(const RilRadioResponseInfo & responseInfo,const CellListNearbyInfo_1_2 & cellInfoList)1201 int32_t RilCallback::GetNeighboringCellInfoListResponse_1_2(
1202 const RilRadioResponseInfo &responseInfo, const CellListNearbyInfo_1_2 &cellInfoList)
1203 {
1204 HDF_LOGI("itemNum:%{public}d", cellInfoList.itemNum);
1205 for (auto info : cellInfoList.cellNearbyInfo) {
1206 HDF_LOGI("ratType:%{public}d", info.ratType);
1207 switch (static_cast<RatType>(info.ratType)) {
1208 case RatType::NETWORK_TYPE_LTE:
1209 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1210 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1211 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1212 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1213 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rxlev);
1214 break;
1215 case RatType::NETWORK_TYPE_GSM:
1216 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1217 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1218 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1219 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1220 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1221 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1222 break;
1223 case RatType::NETWORK_TYPE_WCDMA:
1224 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1225 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1226 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1227 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1228 break;
1229 case RatType::NETWORK_TYPE_NR:
1230 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1231 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1232 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1233 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1234 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1235 break;
1236 default:
1237 HDF_LOGE("invalid ratType");
1238 break;
1239 }
1240 }
1241 hdiId_ = HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST;
1242 resultInfo_ = responseInfo;
1243 NotifyAll();
1244 return 0;
1245 }
1246
GetCurrentCellInfoResponse(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo & cellInfoList)1247 int32_t RilCallback::GetCurrentCellInfoResponse(
1248 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo &cellInfoList)
1249 {
1250 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse itemNum:%{public}d", cellInfoList.itemNum);
1251 for (auto info : cellInfoList.cellCurrentInfo) {
1252 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
1253 info.ratType, info.mcc, info.mnc);
1254 switch (static_cast<RatType>(info.ratType)) {
1255 case RatType::NETWORK_TYPE_LTE:
1256 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1257 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1258 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1259 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1260 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1261 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1262 break;
1263 case RatType::NETWORK_TYPE_GSM:
1264 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1265 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1266 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1267 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1268 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1269 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1270 break;
1271 case RatType::NETWORK_TYPE_WCDMA:
1272 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1273 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1274 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1275 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1276 break;
1277 case RatType::NETWORK_TYPE_NR:
1278 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1279 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1280 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1281 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1282 break;
1283 default:
1284 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse invalid ratType");
1285 }
1286 }
1287 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1288 resultInfo_ = responseInfo;
1289 NotifyAll();
1290 return 0;
1291 }
1292
GetCurrentCellInfoResponse_1_1(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_1 & cellListCurrentInfo)1293 int32_t RilCallback::GetCurrentCellInfoResponse_1_1(
1294 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_1 &cellListCurrentInfo)
1295 {
1296 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 itemNum:%{public}d", cellListCurrentInfo.itemNum);
1297 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1298 HDF_LOGI("RilCallback::GetCurrentCellInfoResponse_1_1 ratType:%{public}d, mcc:%{public}d, mnc:%{public}d",
1299 info.ratType, info.mcc, info.mnc);
1300 switch (static_cast<RatType>(info.ratType)) {
1301 case RatType::NETWORK_TYPE_LTE:
1302 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1303 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1304 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1305 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1306 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1307 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1308 break;
1309 case RatType::NETWORK_TYPE_GSM:
1310 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1311 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1312 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1313 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1314 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1315 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1316 break;
1317 case RatType::NETWORK_TYPE_WCDMA:
1318 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1319 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1320 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1321 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1322 break;
1323 case RatType::NETWORK_TYPE_NR:
1324 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1325 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1326 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1327 HDF_LOGI("ecno:%{public}d", info.serviceCells.nr.nci);
1328 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1329 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1330 break;
1331 default:
1332 HDF_LOGE("RilCallback::GetCurrentCellInfoResponse_1_1 invalid ratType");
1333 }
1334 }
1335 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1336 resultInfo_ = responseInfo;
1337 NotifyAll();
1338 return 0;
1339 }
1340
GetCurrentCellInfoResponse_1_2(const RilRadioResponseInfo & responseInfo,const CellListCurrentInfo_1_2 & cellListCurrentInfo)1341 int32_t RilCallback::GetCurrentCellInfoResponse_1_2(
1342 const RilRadioResponseInfo &responseInfo, const CellListCurrentInfo_1_2 &cellListCurrentInfo)
1343 {
1344 HDF_LOGI("itemNum:%{public}d", cellListCurrentInfo.itemNum);
1345 for (auto info : cellListCurrentInfo.cellCurrentInfo) {
1346 HDF_LOGI("ratType:%{public}d, mcc:%{public}d, mnc:%{public}d", info.ratType, info.mcc, info.mnc);
1347 switch (static_cast<RatType>(info.ratType)) {
1348 case RatType::NETWORK_TYPE_LTE:
1349 HDF_LOGI("cellId:%{public}d", info.serviceCells.lte.cellId);
1350 HDF_LOGI("arfcn:%{public}d", info.serviceCells.lte.arfcn);
1351 HDF_LOGI("pci:%{public}d", info.serviceCells.lte.pci);
1352 HDF_LOGI("rsrp:%{public}d", info.serviceCells.lte.rsrp);
1353 HDF_LOGI("rsrq:%{public}d", info.serviceCells.lte.rsrq);
1354 HDF_LOGI("rxlev:%{public}d", info.serviceCells.lte.rssi);
1355 break;
1356 case RatType::NETWORK_TYPE_GSM:
1357 HDF_LOGI("band:%{public}d", info.serviceCells.gsm.band);
1358 HDF_LOGI("arfcn:%{public}d", info.serviceCells.gsm.arfcn);
1359 HDF_LOGI("bsic:%{public}d", info.serviceCells.gsm.bsic);
1360 HDF_LOGI("cellId:%{public}d", info.serviceCells.gsm.cellId);
1361 HDF_LOGI("rxlev:%{public}d", info.serviceCells.gsm.rxlev);
1362 HDF_LOGI("lac:%{public}d", info.serviceCells.gsm.lac);
1363 break;
1364 case RatType::NETWORK_TYPE_WCDMA:
1365 HDF_LOGI("arfcn:%{public}d", info.serviceCells.wcdma.arfcn);
1366 HDF_LOGI("psc:%{public}d", info.serviceCells.wcdma.psc);
1367 HDF_LOGI("rscp:%{public}d", info.serviceCells.wcdma.rscp);
1368 HDF_LOGI("ecno:%{public}d", info.serviceCells.wcdma.ecno);
1369 break;
1370 case RatType::NETWORK_TYPE_NR:
1371 HDF_LOGI("arfcn:%{public}d", info.serviceCells.nr.nrArfcn);
1372 HDF_LOGI("psc:%{public}d", info.serviceCells.nr.pci);
1373 HDF_LOGI("rscp:%{public}d", info.serviceCells.nr.tac);
1374 HDF_LOGI("rsrp:%{public}d", info.serviceCells.nr.rsrp);
1375 HDF_LOGI("rsrq:%{public}d", info.serviceCells.nr.rsrq);
1376 break;
1377 default:
1378 HDF_LOGE("invalid ratType");
1379 break;
1380 }
1381 }
1382 hdiId_ = HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO;
1383 resultInfo_ = responseInfo;
1384 NotifyAll();
1385 return 0;
1386 }
1387
SetPreferredNetworkResponse(const RilRadioResponseInfo & responseInfo)1388 int32_t RilCallback::SetPreferredNetworkResponse(const RilRadioResponseInfo &responseInfo)
1389 {
1390 HDF_LOGI("RilCallback::SetPreferredNetworkResponse error:%{public}d", responseInfo.error);
1391 hdiId_ = HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK;
1392 resultInfo_ = responseInfo;
1393 NotifyAll();
1394 return 0;
1395 }
1396
GetPreferredNetworkResponse(const RilRadioResponseInfo & responseInfo,const PreferredNetworkTypeInfo & preferredNetworkTypeInfo)1397 int32_t RilCallback::GetPreferredNetworkResponse(
1398 const RilRadioResponseInfo &responseInfo, const PreferredNetworkTypeInfo &preferredNetworkTypeInfo)
1399 {
1400 HDF_LOGI("RilCallback::GetPreferredNetworkResponse type:%{public}d", preferredNetworkTypeInfo.preferredNetworkType);
1401 hdiId_ = HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK;
1402 resultInfo_ = responseInfo;
1403 NotifyAll();
1404 return 0;
1405 }
1406
GetPhysicalChannelConfigResponse(const RilRadioResponseInfo & responseInfo,const ChannelConfigInfoList & channelConfigInfoList)1407 int32_t RilCallback::GetPhysicalChannelConfigResponse(
1408 const RilRadioResponseInfo &responseInfo, const ChannelConfigInfoList &channelConfigInfoList)
1409 {
1410 HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse itemNum:%{public}d", channelConfigInfoList.itemNum);
1411 for (PhysicalChannelConfig phyChnlCfg : channelConfigInfoList.channelConfigInfos) {
1412 HDF_LOGI("RilCallback::GetPhysicalChannelConfigResponse cellConnStatus:%{public}d, "
1413 "cellBandwidthDownlinkKhz:%{public}d, cellBandwidthUplinkKhz:%{public}d, physicalCellId:%{public}d, "
1414 "ratType:%{public}d, freqRange:%{public}d, downlinkChannelNum:%{public}d, "
1415 "uplinkChannelNum:%{public}d, contextIdNum:%{public}d",
1416 phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
1417 phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
1418 phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
1419 for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
1420 HDF_LOGI("contextIds[%{public}d]:%{public}d", j, phyChnlCfg.contextIds[j]);
1421 }
1422 }
1423 hdiId_ = HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG;
1424 resultInfo_ = responseInfo;
1425 NotifyAll();
1426 return 0;
1427 }
1428
SetLocateUpdatesResponse(const RilRadioResponseInfo & responseInfo)1429 int32_t RilCallback::SetLocateUpdatesResponse(const RilRadioResponseInfo &responseInfo)
1430 {
1431 HDF_LOGI("RilCallback::SetLocateUpdatesResponse error:%{public}d", responseInfo.error);
1432 hdiId_ = HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES;
1433 resultInfo_ = responseInfo;
1434 NotifyAll();
1435 return 0;
1436 }
1437
SetNotificationFilterResponse(const RilRadioResponseInfo & responseInfo)1438 int32_t RilCallback::SetNotificationFilterResponse(const RilRadioResponseInfo &responseInfo)
1439 {
1440 HDF_LOGI("RilCallback::SetNotificationFilterResponse error:%{public}d", responseInfo.error);
1441 hdiId_ = HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER;
1442 resultInfo_ = responseInfo;
1443 NotifyAll();
1444 return 0;
1445 }
1446
SetDeviceStateResponse(const RilRadioResponseInfo & responseInfo)1447 int32_t RilCallback::SetDeviceStateResponse(const RilRadioResponseInfo &responseInfo)
1448 {
1449 HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1450 hdiId_ = HdiId::HREQ_NETWORK_SET_DEVICE_STATE;
1451 resultInfo_ = responseInfo;
1452 NotifyAll();
1453 return 0;
1454 }
1455
GetRrcConnectionStateResponse(const RilRadioResponseInfo & responseInfo,int32_t state)1456 int32_t RilCallback::GetRrcConnectionStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1457 {
1458 HDF_LOGI("RilCallback::GetRrcConnectionStateResponse state:%{public}d", state);
1459 hdiId_ = HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE;
1460 resultInfo_ = responseInfo;
1461 NotifyAll();
1462 return 0;
1463 }
1464
SetNrOptionModeResponse(const RilRadioResponseInfo & responseInfo)1465 int32_t RilCallback::SetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo)
1466 {
1467 HDF_LOGI("RilCallback::SetDeviceStateResponse error:%{public}d", responseInfo.error);
1468 hdiId_ = HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE;
1469 resultInfo_ = responseInfo;
1470 NotifyAll();
1471 return 0;
1472 }
1473
GetNrOptionModeResponse(const RilRadioResponseInfo & responseInfo,int32_t state)1474 int32_t RilCallback::GetNrOptionModeResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1475 {
1476 HDF_LOGI("RilCallback::GetNrOptionModeResponse state:%{public}d", state);
1477 hdiId_ = HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE;
1478 resultInfo_ = responseInfo;
1479 NotifyAll();
1480 return 0;
1481 }
1482
GetRrcConnectionStateUpdated(const RilRadioResponseInfo & responseInfo,int32_t state)1483 int32_t RilCallback::GetRrcConnectionStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1484 {
1485 HDF_LOGI("RilCallback::GetRrcConnectionStateUpdated state:%{public}d", state);
1486 return 0;
1487 }
1488
GetNrSsbIdResponse(const RilRadioResponseInfo & responseInfo,const NrCellSsbIds & nrCellSsbIds)1489 int32_t RilCallback::GetNrSsbIdResponse(const RilRadioResponseInfo &responseInfo, const NrCellSsbIds &nrCellSsbIds)
1490 {
1491 int32_t ssbListNum = 0;
1492 int32_t nbCellNum = 0;
1493 HDF_LOGE("rsrp:%{public}d", nrCellSsbIds.rsrp);
1494 HDF_LOGE("sinr:%{public}d", nrCellSsbIds.sinr);
1495 for (auto info : nrCellSsbIds.sCellSsbList) {
1496 ssbListNum = ssbListNum + 1;
1497 HDF_LOGE("sCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, info.rsrp);
1498 }
1499 HDF_LOGE("nbCellCount:%{public}d", nrCellSsbIds.nbCellCount);
1500 for (auto info : nrCellSsbIds.nbCellSsbList) {
1501 nbCellNum = nbCellNum + 1;
1502 HDF_LOGE("nbCellNum:%{public}d, rsrp:%{public}d, sinr:%{public}d", nbCellNum, info.rsrp, info.sinr);
1503 ssbListNum = 0;
1504 for (auto infoNbCell : info.ssbIdList) {
1505 ssbListNum = ssbListNum + 1;
1506 HDF_LOGE("nbCellSsbNum:%{public}d, rsrp:%{public}d", ssbListNum, infoNbCell.rsrp);
1507 }
1508 }
1509 hdiId_ = HdiId::HREQ_NETWORK_GET_NR_SSBID_INFO;
1510 resultInfo_ = responseInfo;
1511 NotifyAll();
1512 return 0;
1513 }
1514
1515 // Call
CallEmergencyNotice(const RilRadioResponseInfo & responseInfo,const EmergencyInfoList & emergencyInfoList)1516 int32_t RilCallback::CallEmergencyNotice(
1517 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)
1518 {
1519 HDF_LOGI("GetBoolResult CallEmergencyNotice callSize : %{public}d", emergencyInfoList.callSize);
1520 return 0;
1521 }
1522
CallStateUpdated(const RilRadioResponseInfo & responseInfo)1523 int32_t RilCallback::CallStateUpdated(const RilRadioResponseInfo &responseInfo)
1524 {
1525 HDF_LOGI("GetBoolResult CallStateUpdated slotId : %{public}d, type: %{public}d", responseInfo.slotId,
1526 responseInfo.type);
1527 return 0;
1528 }
1529
CallRingbackVoiceNotice(const RilRadioResponseInfo & responseInfo,const RingbackVoice & ringbackVoice)1530 int32_t RilCallback::CallRingbackVoiceNotice(
1531 const RilRadioResponseInfo &responseInfo, const RingbackVoice &ringbackVoice)
1532 {
1533 HDF_LOGI("GetBoolResult CallRingbackVoiceNotice slotId : %{public}d, ringbackVoice: %{public}d",
1534 responseInfo.slotId, ringbackVoice.status);
1535 return 0;
1536 }
1537
CallSrvccStatusNotice(const RilRadioResponseInfo & responseInfo,const SrvccStatus & srvccStatus)1538 int32_t RilCallback::CallSrvccStatusNotice(const RilRadioResponseInfo &responseInfo, const SrvccStatus &srvccStatus)
1539 {
1540 HDF_LOGI("GetBoolResult CallSrvccStatusNotice slotId : %{public}d, srvccStatus: %{public}d",
1541 responseInfo.slotId, srvccStatus.status);
1542 return 0;
1543 }
1544
CallUssdNotice(const RilRadioResponseInfo & responseInfo,const UssdNoticeInfo & ussdNoticeInfo)1545 int32_t RilCallback::CallUssdNotice(const RilRadioResponseInfo &responseInfo, const UssdNoticeInfo &ussdNoticeInfo)
1546 {
1547 HDF_LOGI("GetBoolResult CallUssdNotice slotId : %{public}d, ussdNoticeInfo m: %{public}d, str: %{public}s",
1548 responseInfo.slotId, ussdNoticeInfo.type, ussdNoticeInfo.message.c_str());
1549 return 0;
1550 }
1551
CallSsNotice(const RilRadioResponseInfo & responseInfo,const SsNoticeInfo & ssNoticeInfo)1552 int32_t RilCallback::CallSsNotice(const RilRadioResponseInfo &responseInfo, const SsNoticeInfo &ssNoticeInfo)
1553 {
1554 HDF_LOGI("GetBoolResult CallSsNotice slotId : %{public}d, result: %{public}d, serviceType: %{public}d,"
1555 "requestType: %{public}d, serviceClass: %{public}d", responseInfo.slotId, ssNoticeInfo.result,
1556 ssNoticeInfo.serviceType, ssNoticeInfo.requestType, ssNoticeInfo.serviceClass);
1557 return 0;
1558 }
1559
CallRsrvccStatusNotify(const RilRadioResponseInfo & responseInfo)1560 int32_t RilCallback::CallRsrvccStatusNotify(const RilRadioResponseInfo &responseInfo)
1561 {
1562 HDF_LOGI("GetBoolResult CallRsrvccStatusNotify slotId : %{public}d", responseInfo.slotId);
1563 return 0;
1564 }
1565
GetEmergencyCallListResponse(const RilRadioResponseInfo & responseInfo,const EmergencyInfoList & emergencyInfoList)1566 int32_t RilCallback::GetEmergencyCallListResponse(
1567 const RilRadioResponseInfo &responseInfo, const EmergencyInfoList &emergencyInfoList)
1568 {
1569 HDF_LOGI("GetBoolResult emergencyInfoList callSize : %{public}d", emergencyInfoList.callSize);
1570 hdiId_ = HdiId::HREQ_CALL_GET_EMERGENCY_LIST;
1571 resultInfo_ = responseInfo;
1572 NotifyAll();
1573 return 0;
1574 }
1575
SetEmergencyCallListResponse(const RilRadioResponseInfo & responseInfo)1576 int32_t RilCallback::SetEmergencyCallListResponse(const RilRadioResponseInfo &responseInfo)
1577 {
1578 HDF_LOGI("GetBoolResult SetEmergencyCallListResponse");
1579 hdiId_ = HdiId::HREQ_CALL_SET_EMERGENCY_LIST;
1580 resultInfo_ = responseInfo;
1581 NotifyAll();
1582 return 0;
1583 }
1584
GetCallListResponse(const RilRadioResponseInfo & responseInfo,const CallInfoList & callList)1585 int32_t RilCallback::GetCallListResponse(const RilRadioResponseInfo &responseInfo, const CallInfoList &callList)
1586 {
1587 HDF_LOGI("GetBoolResult CallInfoList callSize : %{public}d", callList.callSize);
1588 hdiId_ = HdiId::HREQ_CALL_GET_CALL_LIST;
1589 resultInfo_ = responseInfo;
1590 NotifyAll();
1591 return 0;
1592 }
1593
DialResponse(const RilRadioResponseInfo & responseInfo)1594 int32_t RilCallback::DialResponse(const RilRadioResponseInfo &responseInfo)
1595 {
1596 HDF_LOGI("GetBoolResult DialResponse");
1597 hdiId_ = HdiId::HREQ_CALL_DIAL;
1598 resultInfo_ = responseInfo;
1599 NotifyAll();
1600 return 0;
1601 }
1602
HangupResponse(const RilRadioResponseInfo & responseInfo)1603 int32_t RilCallback::HangupResponse(const RilRadioResponseInfo &responseInfo)
1604 {
1605 HDF_LOGI("GetBoolResult HangupResponse");
1606 hdiId_ = HdiId::HREQ_CALL_HANGUP;
1607 resultInfo_ = responseInfo;
1608 NotifyAll();
1609 return 0;
1610 }
1611
RejectResponse(const RilRadioResponseInfo & responseInfo)1612 int32_t RilCallback::RejectResponse(const RilRadioResponseInfo &responseInfo)
1613 {
1614 HDF_LOGI("GetBoolResult RejectResponse");
1615 hdiId_ = HdiId::HREQ_CALL_REJECT;
1616 resultInfo_ = responseInfo;
1617 NotifyAll();
1618 return 0;
1619 }
1620
AnswerResponse(const RilRadioResponseInfo & responseInfo)1621 int32_t RilCallback::AnswerResponse(const RilRadioResponseInfo &responseInfo)
1622 {
1623 HDF_LOGI("GetBoolResult AnswerResponse");
1624 hdiId_ = HdiId::HREQ_CALL_ANSWER;
1625 resultInfo_ = responseInfo;
1626 NotifyAll();
1627 return 0;
1628 }
1629
HoldCallResponse(const RilRadioResponseInfo & responseInfo)1630 int32_t RilCallback::HoldCallResponse(const RilRadioResponseInfo &responseInfo)
1631 {
1632 HDF_LOGI("GetBoolResult HoldCallResponse");
1633 hdiId_ = HdiId::HREQ_CALL_HOLD_CALL;
1634 resultInfo_ = responseInfo;
1635 NotifyAll();
1636 return 0;
1637 }
1638
UnHoldCallResponse(const RilRadioResponseInfo & responseInfo)1639 int32_t RilCallback::UnHoldCallResponse(const RilRadioResponseInfo &responseInfo)
1640 {
1641 HDF_LOGI("GetBoolResult UnHoldCallResponse");
1642 hdiId_ = HdiId::HREQ_CALL_UNHOLD_CALL;
1643 resultInfo_ = responseInfo;
1644 NotifyAll();
1645 return 0;
1646 }
1647
SwitchCallResponse(const RilRadioResponseInfo & responseInfo)1648 int32_t RilCallback::SwitchCallResponse(const RilRadioResponseInfo &responseInfo)
1649 {
1650 HDF_LOGI("GetBoolResult SwitchCallResponse");
1651 hdiId_ = HdiId::HREQ_CALL_SWITCH_CALL;
1652 resultInfo_ = responseInfo;
1653 NotifyAll();
1654 return 0;
1655 }
1656
GetClipResponse(const RilRadioResponseInfo & responseInfo,const GetClipResult & getClipResult)1657 int32_t RilCallback::GetClipResponse(const RilRadioResponseInfo &responseInfo, const GetClipResult &getClipResult)
1658 {
1659 HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clipStat: %{public}d", getClipResult.result,
1660 getClipResult.action, getClipResult.clipStat);
1661 hdiId_ = HdiId::HREQ_CALL_GET_CLIP;
1662 resultInfo_ = responseInfo;
1663 NotifyAll();
1664 return 0;
1665 }
1666
SetClipResponse(const RilRadioResponseInfo & responseInfo)1667 int32_t RilCallback::SetClipResponse(const RilRadioResponseInfo &responseInfo)
1668 {
1669 HDF_LOGI("GetBoolResult SetClipResponse");
1670 hdiId_ = HdiId::HREQ_CALL_SET_CLIP;
1671 resultInfo_ = responseInfo;
1672 NotifyAll();
1673 return 0;
1674 }
1675
CombineConferenceResponse(const RilRadioResponseInfo & responseInfo)1676 int32_t RilCallback::CombineConferenceResponse(const RilRadioResponseInfo &responseInfo)
1677 {
1678 HDF_LOGI("GetBoolResult CombineConferenceResponse");
1679 hdiId_ = HdiId::HREQ_CALL_COMBINE_CONFERENCE;
1680 resultInfo_ = responseInfo;
1681 NotifyAll();
1682 return 0;
1683 }
1684
SeparateConferenceResponse(const RilRadioResponseInfo & responseInfo)1685 int32_t RilCallback::SeparateConferenceResponse(const RilRadioResponseInfo &responseInfo)
1686 {
1687 HDF_LOGI("GetBoolResult SeparateConferenceResponse");
1688 hdiId_ = HdiId::HREQ_CALL_SEPARATE_CONFERENCE;
1689 resultInfo_ = responseInfo;
1690 NotifyAll();
1691 return 0;
1692 }
1693
CallSupplementResponse(const RilRadioResponseInfo & responseInfo)1694 int32_t RilCallback::CallSupplementResponse(const RilRadioResponseInfo &responseInfo)
1695 {
1696 HDF_LOGI("GetBoolResult CallSupplementResponse");
1697 hdiId_ = HdiId::HREQ_CALL_CALL_SUPPLEMENT;
1698 resultInfo_ = responseInfo;
1699 NotifyAll();
1700 return 0;
1701 }
1702
GetCallWaitingResponse(const RilRadioResponseInfo & responseInfo,const CallWaitResult & callWaitResult)1703 int32_t RilCallback::GetCallWaitingResponse(
1704 const RilRadioResponseInfo &responseInfo, const CallWaitResult &callWaitResult)
1705 {
1706 HDF_LOGI("GetBoolResult GetCallWaitingResponse result: %{public}d, status: %{public}d, classCw: %{public}d",
1707 callWaitResult.result, callWaitResult.status, callWaitResult.classCw);
1708 hdiId_ = HdiId::HREQ_CALL_GET_CALL_WAITING;
1709 resultInfo_ = responseInfo;
1710 NotifyAll();
1711 return 0;
1712 }
1713
SetCallWaitingResponse(const RilRadioResponseInfo & responseInfo)1714 int32_t RilCallback::SetCallWaitingResponse(const RilRadioResponseInfo &responseInfo)
1715 {
1716 HDF_LOGI("GetBoolResult SetCallWaitingResponse");
1717 hdiId_ = HdiId::HREQ_CALL_SET_CALL_WAITING;
1718 resultInfo_ = responseInfo;
1719 NotifyAll();
1720 return 0;
1721 }
1722
GetCallTransferInfoResponse(const RilRadioResponseInfo & responseInfo,const CallForwardQueryInfoList & cFQueryList)1723 int32_t RilCallback::GetCallTransferInfoResponse(
1724 const RilRadioResponseInfo &responseInfo, const CallForwardQueryInfoList &cFQueryList)
1725 {
1726 HDF_LOGI("GetBoolResult GetCallTransferInfoResponse cFQueryList: %{public}d", cFQueryList.callSize);
1727 hdiId_ = HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO;
1728 resultInfo_ = responseInfo;
1729 NotifyAll();
1730 return 0;
1731 }
1732
SetCallTransferInfoResponse(const RilRadioResponseInfo & responseInfo)1733 int32_t RilCallback::SetCallTransferInfoResponse(const RilRadioResponseInfo &responseInfo)
1734 {
1735 HDF_LOGI("GetBoolResult SetCallTransferInfoResponse");
1736 hdiId_ = HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO;
1737 resultInfo_ = responseInfo;
1738 NotifyAll();
1739 return 0;
1740 }
1741
GetCallRestrictionResponse(const RilRadioResponseInfo & responseInfo,const CallRestrictionResult & result)1742 int32_t RilCallback::GetCallRestrictionResponse(
1743 const RilRadioResponseInfo &responseInfo, const CallRestrictionResult &result)
1744 {
1745 HDF_LOGI("GetBoolResult result: %{public}d, status: %{public}d, classCw: %{public}d", result.result, result.status,
1746 result.classCw);
1747 hdiId_ = HdiId::HREQ_CALL_GET_CALL_RESTRICTION;
1748 resultInfo_ = responseInfo;
1749 NotifyAll();
1750 return 0;
1751 }
SetCallRestrictionResponse(const RilRadioResponseInfo & responseInfo)1752 int32_t RilCallback::SetCallRestrictionResponse(const RilRadioResponseInfo &responseInfo)
1753 {
1754 HDF_LOGI("GetBoolResult SetCallRestrictionResponse");
1755 hdiId_ = HdiId::HREQ_CALL_SET_CALL_RESTRICTION;
1756 resultInfo_ = responseInfo;
1757 NotifyAll();
1758 return 0;
1759 }
GetClirResponse(const RilRadioResponseInfo & responseInfo,const GetClirResult & getClirResult)1760 int32_t RilCallback::GetClirResponse(const RilRadioResponseInfo &responseInfo, const GetClirResult &getClirResult)
1761 {
1762 HDF_LOGI("GetBoolResult result: %{public}d, action: %{public}d, clirStat: %{public}d", getClirResult.result,
1763 getClirResult.action, getClirResult.clirStat);
1764 hdiId_ = HdiId::HREQ_CALL_GET_CLIR;
1765 resultInfo_ = responseInfo;
1766 NotifyAll();
1767 return 0;
1768 }
1769
SetClirResponse(const RilRadioResponseInfo & responseInfo)1770 int32_t RilCallback::SetClirResponse(const RilRadioResponseInfo &responseInfo)
1771 {
1772 HDF_LOGI("GetBoolResult SetClirResponse");
1773 hdiId_ = HdiId::HREQ_CALL_SET_CLIR;
1774 resultInfo_ = responseInfo;
1775 NotifyAll();
1776 return 0;
1777 }
1778
StartDtmfResponse(const RilRadioResponseInfo & responseInfo)1779 int32_t RilCallback::StartDtmfResponse(const RilRadioResponseInfo &responseInfo)
1780 {
1781 HDF_LOGI("GetBoolResult StartDtmfResponse");
1782 hdiId_ = HdiId::HREQ_CALL_START_DTMF;
1783 resultInfo_ = responseInfo;
1784 NotifyAll();
1785 return 0;
1786 }
1787
SendDtmfResponse(const RilRadioResponseInfo & responseInfo)1788 int32_t RilCallback::SendDtmfResponse(const RilRadioResponseInfo &responseInfo)
1789 {
1790 HDF_LOGI("GetBoolResult SendDtmfResponse");
1791 hdiId_ = HdiId::HREQ_CALL_SEND_DTMF;
1792 resultInfo_ = responseInfo;
1793 NotifyAll();
1794 return 0;
1795 }
1796
StopDtmfResponse(const RilRadioResponseInfo & responseInfo)1797 int32_t RilCallback::StopDtmfResponse(const RilRadioResponseInfo &responseInfo)
1798 {
1799 HDF_LOGI("GetBoolResult StopDtmfResponse");
1800 hdiId_ = HdiId::HREQ_CALL_STOP_DTMF;
1801 resultInfo_ = responseInfo;
1802 NotifyAll();
1803 return 0;
1804 }
1805
GetCallPreferenceModeResponse(const RilRadioResponseInfo & responseInfo,int32_t mode)1806 int32_t RilCallback::GetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo, int32_t mode)
1807 {
1808 HDF_LOGI("GetBoolResult GetCallPreferenceModeResponse mode: %{public}d", mode);
1809 hdiId_ = HdiId::HREQ_CALL_GET_CALL_PREFERENCE;
1810 resultInfo_ = responseInfo;
1811 NotifyAll();
1812 return 0;
1813 }
1814
SetCallPreferenceModeResponse(const RilRadioResponseInfo & responseInfo)1815 int32_t RilCallback::SetCallPreferenceModeResponse(const RilRadioResponseInfo &responseInfo)
1816 {
1817 HDF_LOGI("GetBoolResult SetCallPreferenceModeResponse");
1818 hdiId_ = HdiId::HREQ_CALL_SET_CALL_PREFERENCE;
1819 resultInfo_ = responseInfo;
1820 NotifyAll();
1821 return 0;
1822 }
1823
SetUssdResponse(const RilRadioResponseInfo & responseInfo)1824 int32_t RilCallback::SetUssdResponse(const RilRadioResponseInfo &responseInfo)
1825 {
1826 HDF_LOGI("GetBoolResult SetUssdResponse");
1827 hdiId_ = HdiId::HREQ_CALL_SET_USSD;
1828 resultInfo_ = responseInfo;
1829 NotifyAll();
1830 return 0;
1831 }
1832
GetUssdResponse(const RilRadioResponseInfo & responseInfo,int32_t cusd)1833 int32_t RilCallback::GetUssdResponse(const RilRadioResponseInfo &responseInfo, int32_t cusd)
1834 {
1835 HDF_LOGI("GetBoolResult GetUssdResponse cusd: %{public}d", cusd);
1836 hdiId_ = HdiId::HREQ_CALL_GET_USSD;
1837 resultInfo_ = responseInfo;
1838 NotifyAll();
1839 return 0;
1840 }
1841
SetMuteResponse(const RilRadioResponseInfo & responseInfo)1842 int32_t RilCallback::SetMuteResponse(const RilRadioResponseInfo &responseInfo)
1843 {
1844 HDF_LOGI("GetBoolResult SetMuteResponse");
1845 hdiId_ = HdiId::HREQ_CALL_SET_MUTE;
1846 resultInfo_ = responseInfo;
1847 NotifyAll();
1848 return 0;
1849 }
1850
GetMuteResponse(const RilRadioResponseInfo & responseInfo,int32_t mute)1851 int32_t RilCallback::GetMuteResponse(const RilRadioResponseInfo &responseInfo, int32_t mute)
1852 {
1853 HDF_LOGI("GetBoolResult GetMuteResponse mute: %{public}d", mute);
1854 hdiId_ = HdiId::HREQ_CALL_GET_MUTE;
1855 resultInfo_ = responseInfo;
1856 NotifyAll();
1857 return 0;
1858 }
1859
GetCallFailReasonResponse(const RilRadioResponseInfo & responseInfo,int32_t callFail)1860 int32_t RilCallback::GetCallFailReasonResponse(const RilRadioResponseInfo &responseInfo, int32_t callFail)
1861 {
1862 HDF_LOGI("GetBoolResult GetCallFailReasonResponse callFail: %{public}d", callFail);
1863 hdiId_ = HdiId::HREQ_CALL_GET_FAIL_REASON;
1864 resultInfo_ = responseInfo;
1865 NotifyAll();
1866 return 0;
1867 }
1868
SetBarringPasswordResponse(const RilRadioResponseInfo & responseInfo)1869 int32_t RilCallback::SetBarringPasswordResponse(const RilRadioResponseInfo &responseInfo)
1870 {
1871 HDF_LOGI("GetBoolResult SetBarringPasswordResponse");
1872 hdiId_ = HdiId::HREQ_CALL_SET_BARRING_PASSWORD;
1873 resultInfo_ = responseInfo;
1874 NotifyAll();
1875 return 0;
1876 }
1877
CloseUnFinishedUssdResponse(const RilRadioResponseInfo & responseInfo)1878 int32_t RilCallback::CloseUnFinishedUssdResponse(const RilRadioResponseInfo &responseInfo)
1879 {
1880 HDF_LOGI("GetBoolResult CloseUnFinishedUssdResponse");
1881 hdiId_ = HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD;
1882 resultInfo_ = responseInfo;
1883 NotifyAll();
1884 return 0;
1885 }
1886
SetVonrSwitchResponse(const RilRadioResponseInfo & responseInfo)1887 int32_t RilCallback::SetVonrSwitchResponse(const RilRadioResponseInfo &responseInfo)
1888 {
1889 HDF_LOGI("GetBoolResult SetVonrSwitchResponse");
1890 hdiId_ = HdiId::HREQ_SET_VONR_SWITCH;
1891 resultInfo_ = responseInfo;
1892 NotifyAll();
1893 return 0;
1894 }
1895
1896 /**
1897 * modem
1898 **/
RadioStateUpdated(const RilRadioResponseInfo & responseInfo,int32_t state)1899 int32_t RilCallback::RadioStateUpdated(const RilRadioResponseInfo &responseInfo, int32_t state)
1900 {
1901 HDF_LOGI("RadioStateUpdated state : %{public}d", state);
1902 return 0;
1903 }
1904
VoiceRadioTechUpdated(const RilRadioResponseInfo & responseInfo,const VoiceRadioTechnology & voiceRadioTechnology)1905 int32_t RilCallback::VoiceRadioTechUpdated(
1906 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)
1907 {
1908 HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
1909 "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
1910 "%{public}s actName : %{public}s",
1911 voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
1912 voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
1913 voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(), voiceRadioTechnology.actName.c_str());
1914 return 0;
1915 }
1916
DsdsModeUpdated(const RilRadioResponseInfo & responseInfo,int32_t mode)1917 int32_t RilCallback::DsdsModeUpdated(const RilRadioResponseInfo &responseInfo, int32_t mode)
1918 {
1919 HDF_LOGI("DsdsModeUpdated mode : %{public}d", mode);
1920 return 0;
1921 }
1922
ShutDownResponse(const RilRadioResponseInfo & responseInfo)1923 int32_t RilCallback::ShutDownResponse(const RilRadioResponseInfo &responseInfo)
1924 {
1925 HDF_LOGI("ShutDownResponse");
1926 hdiId_ = HdiId::HREQ_MODEM_SHUT_DOWN;
1927 resultInfo_ = responseInfo;
1928 NotifyAll();
1929 return 0;
1930 }
1931
SetRadioStateResponse(const RilRadioResponseInfo & responseInfo)1932 int32_t RilCallback::SetRadioStateResponse(const RilRadioResponseInfo &responseInfo)
1933 {
1934 HDF_LOGI("SetRadioStateResponse");
1935 hdiId_ = HdiId::HREQ_MODEM_SET_RADIO_STATUS;
1936 resultInfo_ = responseInfo;
1937 NotifyAll();
1938 return 0;
1939 }
1940
GetRadioStateResponse(const RilRadioResponseInfo & responseInfo,int32_t state)1941 int32_t RilCallback::GetRadioStateResponse(const RilRadioResponseInfo &responseInfo, int32_t state)
1942 {
1943 HDF_LOGI("GetRadioStateResponse state : %{public}d", state);
1944 hdiId_ = HdiId::HREQ_MODEM_GET_RADIO_STATUS;
1945 resultInfo_ = responseInfo;
1946 NotifyAll();
1947 return 0;
1948 }
1949
GetImeiResponse(const RilRadioResponseInfo & responseInfo,const std::string & imei)1950 int32_t RilCallback::GetImeiResponse(const RilRadioResponseInfo &responseInfo, const std::string &imei)
1951 {
1952 HDF_LOGI("GetImeiResponse imei : %{public}s", imei.c_str());
1953 hdiId_ = HdiId::HREQ_MODEM_GET_IMEI;
1954 resultInfo_ = responseInfo;
1955 NotifyAll();
1956 return 0;
1957 }
1958
GetImeiSvResponse(const RilRadioResponseInfo & responseInfo,const std::string & imeiSv)1959 int32_t RilCallback::GetImeiSvResponse(const RilRadioResponseInfo &responseInfo, const std::string &imeiSv)
1960 {
1961 hdiId_ = HdiId::HREQ_MODEM_GET_IMEISV;
1962 resultInfo_ = responseInfo;
1963 NotifyAll();
1964 return 0;
1965 }
1966
GetMeidResponse(const RilRadioResponseInfo & responseInfo,const std::string & meid)1967 int32_t RilCallback::GetMeidResponse(const RilRadioResponseInfo &responseInfo, const std::string &meid)
1968 {
1969 HDF_LOGI("GetMeidResponse meid : %{public}s", meid.c_str());
1970 hdiId_ = HdiId::HREQ_MODEM_GET_MEID;
1971 resultInfo_ = responseInfo;
1972 NotifyAll();
1973 return 0;
1974 }
1975
GetVoiceRadioTechnologyResponse(const RilRadioResponseInfo & responseInfo,const VoiceRadioTechnology & voiceRadioTechnology)1976 int32_t RilCallback::GetVoiceRadioTechnologyResponse(
1977 const RilRadioResponseInfo &responseInfo, const VoiceRadioTechnology &voiceRadioTechnology)
1978 {
1979 HDF_LOGI("GetVoiceRadioTechnologyResponse srvStatus : %{public}d srvDomain : %{public}d roamStatus: %{public}d "
1980 "simStatus : %{public}d lockStatus : %{public}d sysMode : %{public}d actType : %{public}d sysModeName : "
1981 "%{public}s actName : %{public}s",
1982 voiceRadioTechnology.srvStatus, voiceRadioTechnology.srvDomain, voiceRadioTechnology.roamStatus,
1983 voiceRadioTechnology.simStatus, voiceRadioTechnology.lockStatus, voiceRadioTechnology.sysMode,
1984 voiceRadioTechnology.actType, voiceRadioTechnology.sysModeName.c_str(), voiceRadioTechnology.actName.c_str());
1985 hdiId_ = HdiId::HREQ_MODEM_GET_VOICE_RADIO;
1986 resultInfo_ = responseInfo;
1987 NotifyAll();
1988 return 0;
1989 }
1990
GetBasebandVersionResponse(const RilRadioResponseInfo & responseInfo,const std::string & basebandVersion)1991 int32_t RilCallback::GetBasebandVersionResponse(
1992 const RilRadioResponseInfo &responseInfo, const std::string &basebandVersion)
1993 {
1994 HDF_LOGI("GetBasebandVersionResponse basebandVersion : %{public}s", basebandVersion.c_str());
1995 hdiId_ = HdiId::HREQ_MODEM_GET_BASEBAND_VERSION;
1996 resultInfo_ = responseInfo;
1997 NotifyAll();
1998 return 0;
1999 }
2000
2001 // Data
PdpContextListUpdated(const RilRadioResponseInfo & responseInfo,const DataCallResultList & dataCallResultList)2002 int32_t RilCallback::PdpContextListUpdated(
2003 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)
2004 {
2005 HDF_LOGI("RilCallback::PdpContextListUpdated size:%{public}d", dataCallResultList.size);
2006 for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
2007 HDF_LOGI(
2008 "RilCallback::PdpContextListUpdated flag:%{public}d reason:%{public}d retryTime:%{public}d "
2009 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2010 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2011 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2012 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2013 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2014 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2015 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2016 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2017 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2018 setupDataCallResultInfo.pduSessionId);
2019 }
2020 return 0;
2021 }
2022
DataLinkCapabilityUpdated(const RilRadioResponseInfo & responseInfo,const DataLinkCapability & dataLinkCapability)2023 int32_t RilCallback::DataLinkCapabilityUpdated(
2024 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)
2025 {
2026 HDF_LOGI(
2027 "RilCallback::DataLinkCapabilityUpdated primaryDownlinkKbps:%{public}d primaryUplinkKbps:%{public}d "
2028 "secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
2029 dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
2030 dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
2031 return 0;
2032 }
2033
ActivatePdpContextResponse(const RilRadioResponseInfo & responseInfo,const SetupDataCallResultInfo & setupDataCallResultInfo)2034 int32_t RilCallback::ActivatePdpContextResponse(
2035 const RilRadioResponseInfo &responseInfo, const SetupDataCallResultInfo &setupDataCallResultInfo)
2036 {
2037 HDF_LOGI("RilCallback::ActivatePdpContextResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
2038 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2039 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2040 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2041 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2042 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2043 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2044 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2045 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2046 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2047 setupDataCallResultInfo.pduSessionId);
2048 hdiId_ = HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT;
2049 resultInfo_ = responseInfo;
2050 NotifyAll();
2051 return 0;
2052 }
2053
DeactivatePdpContextResponse(const RilRadioResponseInfo & responseInfo)2054 int32_t RilCallback::DeactivatePdpContextResponse(const RilRadioResponseInfo &responseInfo)
2055 {
2056 HDF_LOGI("RilCallback::DeactivatePdpContextResponse error:%{public}d", responseInfo.error);
2057 hdiId_ = HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT;
2058 resultInfo_ = responseInfo;
2059 NotifyAll();
2060 return 0;
2061 }
2062
GetPdpContextListResponse(const RilRadioResponseInfo & responseInfo,const DataCallResultList & dataCallResultList)2063 int32_t RilCallback::GetPdpContextListResponse(
2064 const RilRadioResponseInfo &responseInfo, const DataCallResultList &dataCallResultList)
2065 {
2066 HDF_LOGI("RilCallback::GetPdpContextListResponse size:%{public}d", dataCallResultList.size);
2067 for (auto &setupDataCallResultInfo : dataCallResultList.dcList) {
2068 HDF_LOGI(
2069 "RilCallback::GetPdpContextListResponse flag:%{public}d reason:%{public}d retryTime:%{public}d "
2070 "cid:%{public}d active:%{public}d type:%{public}s netPortName:%{public}s address:%{public}s "
2071 "dns:%{public}s dnsSec:%{public}s gateway:%{public}s maxTransferUnit:%{public}d pCscfPrimAddr:%{public}s "
2072 "pCscfSecAddr:%{public}s pduSessionId:%{public}d",
2073 setupDataCallResultInfo.flag, setupDataCallResultInfo.reason, setupDataCallResultInfo.retryTime,
2074 setupDataCallResultInfo.cid, setupDataCallResultInfo.active, setupDataCallResultInfo.type.c_str(),
2075 setupDataCallResultInfo.netPortName.c_str(), setupDataCallResultInfo.address.c_str(),
2076 setupDataCallResultInfo.dns.c_str(), setupDataCallResultInfo.dnsSec.c_str(),
2077 setupDataCallResultInfo.gateway.c_str(), setupDataCallResultInfo.maxTransferUnit,
2078 setupDataCallResultInfo.pCscfPrimAddr.c_str(), setupDataCallResultInfo.pCscfSecAddr.c_str(),
2079 setupDataCallResultInfo.pduSessionId);
2080 }
2081 hdiId_ = HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST;
2082 resultInfo_ = responseInfo;
2083 NotifyAll();
2084 return 0;
2085 }
2086
SetInitApnInfoResponse(const RilRadioResponseInfo & responseInfo)2087 int32_t RilCallback::SetInitApnInfoResponse(const RilRadioResponseInfo &responseInfo)
2088 {
2089 HDF_LOGI("RilCallback::SetInitApnInfoResponse error:%{public}d", responseInfo.error);
2090 hdiId_ = HdiId::HREQ_DATA_SET_INIT_APN_INFO;
2091 resultInfo_ = responseInfo;
2092 NotifyAll();
2093 return 0;
2094 }
2095
SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo & responseInfo)2096 int32_t RilCallback::SetLinkBandwidthReportingRuleResponse(const RilRadioResponseInfo &responseInfo)
2097 {
2098 HDF_LOGI("RilCallback::SetLinkBandwidthReportingRuleResponse error:%{public}d", responseInfo.error);
2099 hdiId_ = HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE;
2100 resultInfo_ = responseInfo;
2101 NotifyAll();
2102 return 0;
2103 }
2104
GetLinkBandwidthInfoResponse(const RilRadioResponseInfo & responseInfo,const DataLinkBandwidthInfo & dataLinkBandwidthInfo)2105 int32_t RilCallback::GetLinkBandwidthInfoResponse(
2106 const RilRadioResponseInfo &responseInfo, const DataLinkBandwidthInfo &dataLinkBandwidthInfo)
2107 {
2108 HDF_LOGI(
2109 "RilCallback::GetLinkBandwidthInfoResponse serial:%{public}d cid:%{public}d qi:%{public}d dlGfbr:%{public}d "
2110 "ulGfbr:%{public}d dlMfbr:%{public}d ulMfbr:%{public}d ulSambr:%{public}d dlSambr:%{public}d "
2111 "averagingWindow:%{public}d",
2112 dataLinkBandwidthInfo.serial, dataLinkBandwidthInfo.cid, dataLinkBandwidthInfo.qi, dataLinkBandwidthInfo.dlGfbr,
2113 dataLinkBandwidthInfo.ulGfbr, dataLinkBandwidthInfo.dlMfbr, dataLinkBandwidthInfo.ulMfbr,
2114 dataLinkBandwidthInfo.ulSambr, dataLinkBandwidthInfo.dlSambr, dataLinkBandwidthInfo.averagingWindow);
2115 hdiId_ = HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO;
2116 resultInfo_ = responseInfo;
2117 NotifyAll();
2118 return 0;
2119 }
2120
SetDataPermittedResponse(const RilRadioResponseInfo & responseInfo)2121 int32_t RilCallback::SetDataPermittedResponse(const RilRadioResponseInfo &responseInfo)
2122 {
2123 HDF_LOGI("RilCallback::SetDataPermittedResponse error:%{public}d", responseInfo.error);
2124 hdiId_ = HdiId::HREQ_DATA_SET_DATA_PERMITTED;
2125 resultInfo_ = responseInfo;
2126 NotifyAll();
2127 return 0;
2128 }
2129
SetDataProfileInfoResponse(const RilRadioResponseInfo & responseInfo)2130 int32_t RilCallback::SetDataProfileInfoResponse(const RilRadioResponseInfo &responseInfo)
2131 {
2132 HDF_LOGI("RilCallback::SetDataProfileInfoResponse error:%{public}d", responseInfo.error);
2133 hdiId_ = HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO;
2134 resultInfo_ = responseInfo;
2135 NotifyAll();
2136 return 0;
2137 }
2138
GetLinkCapabilityResponse(const RilRadioResponseInfo & responseInfo,const DataLinkCapability & dataLinkCapability)2139 int32_t RilCallback::GetLinkCapabilityResponse(
2140 const RilRadioResponseInfo &responseInfo, const DataLinkCapability &dataLinkCapability)
2141 {
2142 HDF_LOGI(
2143 "RilCallbackTest::GetLinkCapabilityResponse primaryDownlinkKbps:%{public}d "
2144 "primaryUplinkKbps:%{public}d secondaryDownlinkKbps:%{public}d secondaryUplinkKbps:%{public}d",
2145 dataLinkCapability.primaryDownlinkKbps, dataLinkCapability.primaryUplinkKbps,
2146 dataLinkCapability.secondaryDownlinkKbps, dataLinkCapability.secondaryUplinkKbps);
2147 hdiId_ = HdiId::HREQ_DATA_GET_LINK_CAPABILITY;
2148 resultInfo_ = responseInfo;
2149 NotifyAll();
2150 return 0;
2151 }
2152
CleanAllConnectionsResponse(const RilRadioResponseInfo & responseInfo)2153 int32_t RilCallback::CleanAllConnectionsResponse(const RilRadioResponseInfo &responseInfo)
2154 {
2155 HDF_LOGI("RilCallback::CleanAllConnectionsResponse error:%{public}d", responseInfo.error);
2156 hdiId_ = HdiId::HREQ_DATA_CLEAN_ALL_CONNECTIONS;
2157 resultInfo_ = responseInfo;
2158 NotifyAll();
2159 return 0;
2160 }
2161 // Sms
NewSmsNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2162 int32_t RilCallback::NewSmsNotify(
2163 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2164 {
2165 HDF_LOGI("RilCallback::NewSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2166 return 0;
2167 }
2168
NewCdmaSmsNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2169 int32_t RilCallback::NewCdmaSmsNotify(
2170 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2171 {
2172 HDF_LOGI("RilCallback::NewCdmaSmsNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2173 return 0;
2174 }
2175
SmsStatusReportNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const SmsMessageInfo & smsMessageInfo)2176 int32_t RilCallback::SmsStatusReportNotify(
2177 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const SmsMessageInfo &smsMessageInfo)
2178 {
2179 HDF_LOGI("RilCallback::SmsStatusReportNotify smsMessageInfo size : %{public}d", smsMessageInfo.size);
2180 return 0;
2181 }
2182
NewSmsStoredOnSimNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,int32_t recordNumber,int32_t indicationType)2183 int32_t RilCallback::NewSmsStoredOnSimNotify(
2184 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, int32_t recordNumber, int32_t indicationType)
2185 {
2186 HDF_LOGI("RilCallback::NewSmsStoredOnSimNotify recordNumber : %{public}d, indicationType : %{public}d",
2187 recordNumber, indicationType);
2188 return 0;
2189 }
2190
CBConfigNotify(const HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const CBConfigReportInfo & cellBroadConfigReportInfo)2191 int32_t RilCallback::CBConfigNotify(
2192 const HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const CBConfigReportInfo &cellBroadConfigReportInfo)
2193 {
2194 HDF_LOGI("RilCallback::CBConfigNotify cellBroadConfigReportInfo dcs : %{public}s",
2195 cellBroadConfigReportInfo.dcs.c_str());
2196 return 0;
2197 }
2198
SendGsmSmsResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2199 int32_t RilCallback::SendGsmSmsResponse(
2200 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2201 {
2202 HDF_LOGI("RilCallback::SendGsmSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2203 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2204 hdiId_ = HdiId::HREQ_SMS_SEND_GSM_SMS;
2205 resultInfo_ = responseInfo;
2206 NotifyAll();
2207 return 0;
2208 }
2209
SendCdmaSmsResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2210 int32_t RilCallback::SendCdmaSmsResponse(
2211 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2212 {
2213 HDF_LOGI("RilCallback::SendCdmaSmsResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2214 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2215 hdiId_ = HdiId::HREQ_SMS_SEND_CDMA_SMS;
2216 resultInfo_ = responseInfo;
2217 NotifyAll();
2218 return 0;
2219 }
2220
AddSimMessageResponse(const RilRadioResponseInfo & responseInfo)2221 int32_t RilCallback::AddSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2222 {
2223 HDF_LOGI("RilCallback::AddSimMessageResponse error : %{public}d", responseInfo.error);
2224 hdiId_ = HdiId::HREQ_SMS_ADD_SIM_MESSAGE;
2225 resultInfo_ = responseInfo;
2226 NotifyAll();
2227 return 0;
2228 }
2229
DelSimMessageResponse(const RilRadioResponseInfo & responseInfo)2230 int32_t RilCallback::DelSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2231 {
2232 HDF_LOGI("RilCallback::DelSimMessageResponse error : %{public}d", responseInfo.error);
2233 hdiId_ = HdiId::HREQ_SMS_DEL_SIM_MESSAGE;
2234 resultInfo_ = responseInfo;
2235 NotifyAll();
2236 return 0;
2237 }
UpdateSimMessageResponse(const RilRadioResponseInfo & responseInfo)2238 int32_t RilCallback::UpdateSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2239 {
2240 HDF_LOGI("RilCallback::UpdateSimMessageResponse error : %{public}d", responseInfo.error);
2241 hdiId_ = HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE;
2242 resultInfo_ = responseInfo;
2243 NotifyAll();
2244 return 0;
2245 }
2246
AddCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2247 int32_t RilCallback::AddCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2248 {
2249 HDF_LOGI("RilCallback::AddCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2250 hdiId_ = HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE;
2251 resultInfo_ = responseInfo;
2252 NotifyAll();
2253 return 0;
2254 }
2255
DelCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2256 int32_t RilCallback::DelCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2257 {
2258 HDF_LOGI("RilCallback::DelCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2259 hdiId_ = HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE;
2260 resultInfo_ = responseInfo;
2261 NotifyAll();
2262 return 0;
2263 }
2264
UpdateCdmaSimMessageResponse(const RilRadioResponseInfo & responseInfo)2265 int32_t RilCallback::UpdateCdmaSimMessageResponse(const RilRadioResponseInfo &responseInfo)
2266 {
2267 HDF_LOGI("RilCallback::UpdateCdmaSimMessageResponse error : %{public}d", responseInfo.error);
2268 hdiId_ = HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE;
2269 resultInfo_ = responseInfo;
2270 NotifyAll();
2271 return 0;
2272 }
2273
SetSmscAddrResponse(const RilRadioResponseInfo & responseInfo)2274 int32_t RilCallback::SetSmscAddrResponse(const RilRadioResponseInfo &responseInfo)
2275 {
2276 HDF_LOGI("RilCallback::SetSmscAddrResponse error : %{public}d", responseInfo.error);
2277 hdiId_ = HdiId::HREQ_SMS_SET_SMSC_ADDR;
2278 resultInfo_ = responseInfo;
2279 NotifyAll();
2280 return 0;
2281 }
2282
GetSmscAddrResponse(const RilRadioResponseInfo & responseInfo,const ServiceCenterAddress & serviceCenterAddress)2283 int32_t RilCallback::GetSmscAddrResponse(
2284 const RilRadioResponseInfo &responseInfo, const ServiceCenterAddress &serviceCenterAddress)
2285 {
2286 HDF_LOGI("RilCallback::GetSmscAddrResponse serviceCenterAddress tosca : %{public}d, address : %{public}s",
2287 serviceCenterAddress.tosca, serviceCenterAddress.address.c_str());
2288 hdiId_ = HdiId::HREQ_SMS_GET_SMSC_ADDR;
2289 resultInfo_ = responseInfo;
2290 NotifyAll();
2291 return 0;
2292 }
2293
SetCBConfigResponse(const RilRadioResponseInfo & responseInfo)2294 int32_t RilCallback::SetCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2295 {
2296 HDF_LOGI("RilCallback::SetCBConfigResponse error : %{public}d", responseInfo.error);
2297 hdiId_ = HdiId::HREQ_SMS_SET_CB_CONFIG;
2298 resultInfo_ = responseInfo;
2299 NotifyAll();
2300 return 0;
2301 }
2302
GetCBConfigResponse(const RilRadioResponseInfo & responseInfo,const CBConfigInfo & cellBroadcastInfo)2303 int32_t RilCallback::GetCBConfigResponse(
2304 const RilRadioResponseInfo &responseInfo, const CBConfigInfo &cellBroadcastInfo)
2305 {
2306 HDF_LOGI("RilCallback::GetCBConfigResponse cellBroadcastInfo mids : %{public}s, dcss: %{public}s",
2307 cellBroadcastInfo.mids.c_str(), cellBroadcastInfo.dcss.c_str());
2308 hdiId_ = HdiId::HREQ_SMS_GET_CB_CONFIG;
2309 resultInfo_ = responseInfo;
2310 NotifyAll();
2311 return 0;
2312 }
2313
SetCdmaCBConfigResponse(const RilRadioResponseInfo & responseInfo)2314 int32_t RilCallback::SetCdmaCBConfigResponse(const RilRadioResponseInfo &responseInfo)
2315 {
2316 HDF_LOGI("RilCallback::SetCdmaCBConfigResponse error : %{public}d", responseInfo.error);
2317 hdiId_ = HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG;
2318 resultInfo_ = responseInfo;
2319 NotifyAll();
2320 return 0;
2321 }
2322
GetCdmaCBConfigResponse(const RilRadioResponseInfo & responseInfo,const CdmaCBConfigInfo & cdmaCBConfigInfo)2323 int32_t RilCallback::GetCdmaCBConfigResponse(
2324 const RilRadioResponseInfo &responseInfo, const CdmaCBConfigInfo &cdmaCBConfigInfo)
2325 {
2326 HDF_LOGI("RilCallback::GetCdmaCBConfigResponse cdmaCBConfigInfo service : %{public}d, language : %{public}d, "
2327 "checked: %{public}d",
2328 cdmaCBConfigInfo.service, cdmaCBConfigInfo.language, cdmaCBConfigInfo.checked);
2329 hdiId_ = HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG;
2330 resultInfo_ = responseInfo;
2331 NotifyAll();
2332 return 0;
2333 }
2334
SendSmsMoreModeResponse(const RilRadioResponseInfo & responseInfo,const SendSmsResultInfo & sendSmsResultInfo)2335 int32_t RilCallback::SendSmsMoreModeResponse(
2336 const RilRadioResponseInfo &responseInfo, const SendSmsResultInfo &sendSmsResultInfo)
2337 {
2338 HDF_LOGI("RilCallback::SendSmsMoreModeResponse sendSmsResultInfo pdu : %{public}s, error : %{public}d",
2339 sendSmsResultInfo.pdu.c_str(), sendSmsResultInfo.errCode);
2340 hdiId_ = HdiId::HREQ_SMS_SEND_SMS_MORE_MODE;
2341 resultInfo_ = responseInfo;
2342 NotifyAll();
2343 return 0;
2344 }
2345
SendSmsAckResponse(const RilRadioResponseInfo & responseInfo)2346 int32_t RilCallback::SendSmsAckResponse(const RilRadioResponseInfo &responseInfo)
2347 {
2348 HDF_LOGI("RilCallback::SendSmsAckResponse error:%{public}d", responseInfo.error);
2349 hdiId_ = HdiId::HREQ_SMS_SEND_SMS_ACK;
2350 resultInfo_ = responseInfo;
2351 NotifyAll();
2352 return 0;
2353 }
2354
CommonErrorResponse(const RilRadioResponseInfo & responseInfo)2355 int32_t RilCallback::CommonErrorResponse(const RilRadioResponseInfo &responseInfo)
2356 {
2357 HDF_LOGI(
2358 "RilCallback::CommonErrorResponse type:%{public}d error:%{public}d", responseInfo.type, responseInfo.error);
2359 return 0;
2360 }
2361
2362 /**
2363 ** HdfRilHdiTest implement
2364 **/
SetUpTestCase()2365 void HdfRilHdiTest::SetUpTestCase() {}
2366
TearDownTestCase()2367 void HdfRilHdiTest::TearDownTestCase() {}
2368
SetUp()2369 void HdfRilHdiTest::SetUp() {}
2370
TearDown()2371 void HdfRilHdiTest::TearDown() {}
2372
2373 /**
2374 ** Xts Test
2375 **/
2376
2377 HWTEST_F(HdfRilHdiTest, CheckRilInstanceIsEmpty, Function | MediumTest | Level1)
2378 {
2379 g_rilInterface = OHOS::HDI::Ril::V1_3::IRil::Get();
2380 if (g_rilInterface != nullptr) {
2381 g_rilInterface->SetCallback1_3(&callback_);
2382 }
2383 }
2384
2385 HWTEST_F(HdfRilHdiTest, SendRilAck, Function | MediumTest | Level1)
2386 {
2387 if (g_rilInterface == nullptr) {
2388 return;
2389 }
2390 int32_t ret = g_rilInterface->SendRilAck();
2391 EXPECT_EQ(SUCCESS, ret);
2392 }
2393
2394 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimStatus_V1_0100, Function | MediumTest | Level3)
2395 {
2396 if (g_rilInterface == nullptr) {
2397 return;
2398 }
2399 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_1, GetSerialId());
2400 if (ret != 2) {
2401 WaitFor(WAIT_TIME_SECOND);
2402 EXPECT_EQ(SUCCESS, ret);
2403 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
2404 } else {
2405 return;
2406 }
2407 }
2408
2409 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimStatus_V1_0200, Function | MediumTest | Level3)
2410 {
2411 if (g_rilInterface == nullptr) {
2412 return;
2413 }
2414 int32_t ret = g_rilInterface->GetSimStatus(SLOTID_2, GetSerialId());
2415 if (ret != 2) {
2416 WaitFor(WAIT_TIME_SECOND);
2417 EXPECT_EQ(SUCCESS, ret);
2418 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_STATUS));
2419 } else {
2420 return;
2421 }
2422 }
2423
2424 // Call
2425 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetEmergencyCallList_V1_0100, Function | MediumTest | Level3)
2426 {
2427 if (!IsReady(SLOTID_1)) {
2428 return;
2429 }
2430 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_1, GetSerialId());
2431 WaitFor(WAIT_TIME_SECOND);
2432 EXPECT_EQ(SUCCESS, ret);
2433 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_EMERGENCY_LIST));
2434 }
2435
2436 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetEmergencyCallList_V1_0200, Function | MediumTest | Level3)
2437 {
2438 if (!IsReady(SLOTID_2)) {
2439 return;
2440 }
2441 int32_t ret = g_rilInterface->GetEmergencyCallList(SLOTID_2, GetSerialId());
2442 WaitFor(WAIT_TIME_SECOND);
2443 EXPECT_EQ(SUCCESS, ret);
2444 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_EMERGENCY_LIST));
2445 }
2446
2447 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetEmergencyCallList_V1_0100, Function | MediumTest | Level3)
2448 {
2449 if (!IsReady(SLOTID_1)) {
2450 return;
2451 }
2452 EmergencyInfoList emergencyInfoList;
2453 EmergencyCall emergencyInfo = {};
2454 emergencyInfo.index = 1;
2455 emergencyInfo.total = 1;
2456 emergencyInfo.eccNum = "120";
2457 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
2458 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
2459 emergencyInfo.mcc = "460";
2460 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
2461 emergencyInfoList.calls.push_back(emergencyInfo);
2462 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_1, GetSerialId(), emergencyInfoList);
2463 WaitFor(WAIT_TIME_SECOND);
2464 EXPECT_EQ(SUCCESS, ret);
2465 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_EMERGENCY_LIST));
2466 }
2467
2468 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetEmergencyCallList_V2_0100, Function | MediumTest | Level3)
2469 {
2470 if (!IsReady(SLOTID_2)) {
2471 return;
2472 }
2473 EmergencyInfoList emergencyInfoList;
2474 EmergencyCall emergencyInfo = {};
2475 emergencyInfo.index = 1;
2476 emergencyInfo.total = 1;
2477 emergencyInfo.eccNum = "120";
2478 emergencyInfo.eccType = EccType::TYPE_CATEGORY;
2479 emergencyInfo.simpresent = SimpresentType::TYPE_HAS_CARD;
2480 emergencyInfo.mcc = "460";
2481 emergencyInfo.abnormalService = AbnormalServiceType::TYPE_ALL;
2482 emergencyInfoList.calls.push_back(emergencyInfo);
2483 int32_t ret = g_rilInterface->SetEmergencyCallList(SLOTID_2, GetSerialId(), emergencyInfoList);
2484 WaitFor(WAIT_TIME_SECOND);
2485 EXPECT_EQ(SUCCESS, ret);
2486 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_EMERGENCY_LIST));
2487 }
2488
2489 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallList_V1_0100, Function | MediumTest | Level3)
2490 {
2491 if (!IsReady(SLOTID_1)) {
2492 return;
2493 }
2494 int32_t ret = g_rilInterface->GetCallList(SLOTID_1, GetSerialId());
2495 WaitFor(WAIT_TIME_SECOND);
2496 EXPECT_EQ(SUCCESS, ret);
2497 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_LIST));
2498 }
2499
2500 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallList_V1_0200, Function | MediumTest | Level3)
2501 {
2502 if (!IsReady(SLOTID_2)) {
2503 return;
2504 }
2505 int32_t ret = g_rilInterface->GetCallList(SLOTID_2, GetSerialId());
2506 WaitFor(WAIT_TIME_SECOND);
2507 EXPECT_EQ(SUCCESS, ret);
2508 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_LIST));
2509 }
2510
2511 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Dial_V1_0100, Function | MediumTest | Level3)
2512 {
2513 if (!IsReady(SLOTID_1)) {
2514 return;
2515 }
2516 DialInfo dialInfo = {};
2517 dialInfo.address = "10086";
2518 dialInfo.clir = 0;
2519 int32_t ret = g_rilInterface->Dial(SLOTID_1, GetSerialId(), dialInfo);
2520 WaitFor(WAIT_TIME_SECOND);
2521 EXPECT_EQ(SUCCESS, ret);
2522 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_DIAL));
2523 }
2524
2525 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Dial_V1_0200, Function | MediumTest | Level3)
2526 {
2527 if (!IsReady(SLOTID_2)) {
2528 return;
2529 }
2530 DialInfo dialInfo = {};
2531 dialInfo.address = "10086";
2532 dialInfo.clir = 0;
2533 int32_t ret = g_rilInterface->Dial(SLOTID_2, GetSerialId(), dialInfo);
2534 WaitFor(WAIT_TIME_SECOND);
2535 EXPECT_EQ(SUCCESS, ret);
2536 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_DIAL));
2537 }
2538
2539 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Reject_V1_0100, Function | MediumTest | Level3)
2540 {
2541 if (!IsReady(SLOTID_1)) {
2542 return;
2543 }
2544 int32_t ret = g_rilInterface->Reject(SLOTID_1, GetSerialId());
2545 WaitFor(WAIT_TIME_SECOND);
2546 EXPECT_EQ(SUCCESS, ret);
2547 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_REJECT));
2548 }
2549
2550 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Reject_V1_0200, Function | MediumTest | Level3)
2551 {
2552 if (!IsReady(SLOTID_2)) {
2553 return;
2554 }
2555 int32_t ret = g_rilInterface->Reject(SLOTID_2, GetSerialId());
2556 WaitFor(WAIT_TIME_SECOND);
2557 EXPECT_EQ(SUCCESS, ret);
2558 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_REJECT));
2559 }
2560
2561 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Hangup_V1_0100, Function | MediumTest | Level3)
2562 {
2563 if (!IsReady(SLOTID_1)) {
2564 return;
2565 }
2566 int32_t ret = g_rilInterface->Hangup(SLOTID_1, GetSerialId(), 0);
2567 WaitFor(WAIT_TIME_SECOND);
2568 EXPECT_EQ(SUCCESS, ret);
2569 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HANGUP));
2570 }
2571
2572 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Hangup_V1_0200, Function | MediumTest | Level3)
2573 {
2574 if (!IsReady(SLOTID_2)) {
2575 return;
2576 }
2577 int32_t ret = g_rilInterface->Hangup(SLOTID_2, GetSerialId(), 0);
2578 WaitFor(WAIT_TIME_SECOND);
2579 EXPECT_EQ(SUCCESS, ret);
2580 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HANGUP));
2581 }
2582
2583 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Answer_V1_0100, Function | MediumTest | Level3)
2584 {
2585 if (!IsReady(SLOTID_1)) {
2586 return;
2587 }
2588 int32_t ret = g_rilInterface->Answer(SLOTID_1, GetSerialId());
2589 WaitFor(WAIT_TIME_SECOND);
2590 EXPECT_EQ(SUCCESS, ret);
2591 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_ANSWER));
2592 }
2593
2594 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_Answer_V1_0200, Function | MediumTest | Level3)
2595 {
2596 if (!IsReady(SLOTID_2)) {
2597 return;
2598 }
2599 int32_t ret = g_rilInterface->Answer(SLOTID_2, GetSerialId());
2600 WaitFor(WAIT_TIME_SECOND);
2601 EXPECT_EQ(SUCCESS, ret);
2602 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_ANSWER));
2603 }
2604
2605 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_HoldCall_V1_0100, Function | MediumTest | Level3)
2606 {
2607 if (!IsReady(SLOTID_1)) {
2608 return;
2609 }
2610 int32_t ret = g_rilInterface->HoldCall(SLOTID_1, GetSerialId());
2611 WaitFor(WAIT_TIME_SECOND);
2612 EXPECT_EQ(SUCCESS, ret);
2613 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HOLD_CALL));
2614 }
2615
2616 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_HoldCall_V1_0200, Function | MediumTest | Level3)
2617 {
2618 if (!IsReady(SLOTID_2)) {
2619 return;
2620 }
2621 int32_t ret = g_rilInterface->HoldCall(SLOTID_2, GetSerialId());
2622 WaitFor(WAIT_TIME_SECOND);
2623 EXPECT_EQ(SUCCESS, ret);
2624 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_HOLD_CALL));
2625 }
2626
2627 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnHoldCall_V1_0100, Function | MediumTest | Level3)
2628 {
2629 if (!IsReady(SLOTID_1)) {
2630 return;
2631 }
2632 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_1, GetSerialId());
2633 WaitFor(WAIT_TIME_SECOND);
2634 EXPECT_EQ(SUCCESS, ret);
2635 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_UNHOLD_CALL));
2636 }
2637
2638 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnHoldCall_V1_0200, Function | MediumTest | Level3)
2639 {
2640 if (!IsReady(SLOTID_2)) {
2641 return;
2642 }
2643 int32_t ret = g_rilInterface->UnHoldCall(SLOTID_2, GetSerialId());
2644 WaitFor(WAIT_TIME_SECOND);
2645 EXPECT_EQ(SUCCESS, ret);
2646 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_UNHOLD_CALL));
2647 }
2648
2649 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SwitchCall_V1_0100, Function | MediumTest | Level3)
2650 {
2651 if (!IsReady(SLOTID_1)) {
2652 return;
2653 }
2654 int32_t ret = g_rilInterface->SwitchCall(SLOTID_1, GetSerialId());
2655 WaitFor(WAIT_TIME_SECOND);
2656 EXPECT_EQ(SUCCESS, ret);
2657 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SWITCH_CALL));
2658 }
2659
2660 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SwitchCall_V1_0200, Function | MediumTest | Level3)
2661 {
2662 if (!IsReady(SLOTID_2)) {
2663 return;
2664 }
2665 int32_t ret = g_rilInterface->SwitchCall(SLOTID_2, GetSerialId());
2666 WaitFor(WAIT_TIME_SECOND);
2667 EXPECT_EQ(SUCCESS, ret);
2668 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SWITCH_CALL));
2669 }
2670
2671 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CombineConference_V1_0100, Function | MediumTest | Level3)
2672 {
2673 if (!IsReady(SLOTID_1)) {
2674 return;
2675 }
2676 int32_t ret = g_rilInterface->CombineConference(SLOTID_1, GetSerialId(), 0);
2677 WaitFor(WAIT_TIME_SECOND);
2678 EXPECT_EQ(SUCCESS, ret);
2679 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_COMBINE_CONFERENCE));
2680 }
2681
2682 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CombineConference_V1_0200, Function | MediumTest | Level3)
2683 {
2684 if (!IsReady(SLOTID_2)) {
2685 return;
2686 }
2687 int32_t ret = g_rilInterface->CombineConference(SLOTID_2, GetSerialId(), 0);
2688 WaitFor(WAIT_TIME_SECOND);
2689 EXPECT_EQ(SUCCESS, ret);
2690 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_COMBINE_CONFERENCE));
2691 }
2692
2693 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SeparateConference_V1_0100, Function | MediumTest | Level3)
2694 {
2695 if (!IsReady(SLOTID_1)) {
2696 return;
2697 }
2698 int32_t ret = g_rilInterface->SeparateConference(SLOTID_1, GetSerialId(), 1, 0);
2699 WaitFor(WAIT_TIME_SECOND);
2700 EXPECT_EQ(SUCCESS, ret);
2701 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEPARATE_CONFERENCE));
2702 }
2703
2704 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SeparateConference_V1_0200, Function | MediumTest | Level3)
2705 {
2706 if (!IsReady(SLOTID_2)) {
2707 return;
2708 }
2709 int32_t ret = g_rilInterface->SeparateConference(SLOTID_2, GetSerialId(), 1, 0);
2710 WaitFor(WAIT_TIME_SECOND);
2711 EXPECT_EQ(SUCCESS, ret);
2712 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEPARATE_CONFERENCE));
2713 }
2714
2715 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallWaiting_V1_0100, Function | MediumTest | Level3)
2716 {
2717 if (!IsReady(SLOTID_1)) {
2718 return;
2719 }
2720 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_1, GetSerialId());
2721 WaitFor(WAIT_TIME_SECOND);
2722 EXPECT_EQ(SUCCESS, ret);
2723 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_WAITING));
2724 }
2725
2726 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallWaiting_V1_0200, Function | MediumTest | Level3)
2727 {
2728 if (!IsReady(SLOTID_2)) {
2729 return;
2730 }
2731 int32_t ret = g_rilInterface->GetCallWaiting(SLOTID_2, GetSerialId());
2732 WaitFor(WAIT_TIME_SECOND);
2733 EXPECT_EQ(SUCCESS, ret);
2734 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_WAITING));
2735 }
2736
2737 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallWaiting_V1_0100, Function | MediumTest | Level3)
2738 {
2739 if (!IsReady(SLOTID_1)) {
2740 return;
2741 }
2742 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_1, GetSerialId(), 0);
2743 WaitFor(WAIT_TIME_SECOND);
2744 EXPECT_EQ(SUCCESS, ret);
2745 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_WAITING));
2746 }
2747
2748 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallWaiting_V1_0200, Function | MediumTest | Level3)
2749 {
2750 if (!IsReady(SLOTID_2)) {
2751 return;
2752 }
2753 int32_t ret = g_rilInterface->SetCallWaiting(SLOTID_2, GetSerialId(), 0);
2754 WaitFor(WAIT_TIME_SECOND);
2755 EXPECT_EQ(SUCCESS, ret);
2756 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_WAITING));
2757 }
2758
2759 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallTransferInfo_V1_0100, Function | MediumTest | Level3)
2760 {
2761 if (!IsReady(SLOTID_1)) {
2762 return;
2763 }
2764 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_1, GetSerialId(), 1);
2765 WaitFor(WAIT_TIME_SECOND);
2766 EXPECT_EQ(SUCCESS, ret);
2767 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO));
2768 }
2769
2770 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallTransferInfo_V1_0200, Function | MediumTest | Level3)
2771 {
2772 if (!IsReady(SLOTID_2)) {
2773 return;
2774 }
2775 int32_t ret = g_rilInterface->GetCallTransferInfo(SLOTID_2, GetSerialId(), 1);
2776 WaitFor(WAIT_TIME_SECOND);
2777 EXPECT_EQ(SUCCESS, ret);
2778 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_TRANSFER_INFO));
2779 }
2780
2781 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallTransferInfo_V1_0100, Function | MediumTest | Level3)
2782 {
2783 if (!IsReady(SLOTID_1)) {
2784 return;
2785 }
2786 CallForwardSetInfo callForwardSetInfo = {};
2787 callForwardSetInfo.reason = 1;
2788 callForwardSetInfo.mode = 1;
2789 callForwardSetInfo.classx = 1;
2790 callForwardSetInfo.number = "10086";
2791 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_1, GetSerialId(), callForwardSetInfo);
2792 WaitFor(WAIT_TIME_SECOND);
2793 EXPECT_EQ(SUCCESS, ret);
2794 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO));
2795 }
2796
2797 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallTransferInfo_V1_0200, Function | MediumTest | Level3)
2798 {
2799 if (!IsReady(SLOTID_2)) {
2800 return;
2801 }
2802 CallForwardSetInfo callForwardSetInfo = {};
2803 callForwardSetInfo.reason = 1;
2804 callForwardSetInfo.mode = 1;
2805 callForwardSetInfo.classx = 1;
2806 callForwardSetInfo.number = "10086";
2807 int32_t ret = g_rilInterface->SetCallTransferInfo(SLOTID_2, GetSerialId(), callForwardSetInfo);
2808 WaitFor(WAIT_TIME_SECOND);
2809 EXPECT_EQ(SUCCESS, ret);
2810 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_TRANSFER_INFO));
2811 }
2812
2813 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallRestriction_V1_0100, Function | MediumTest | Level3)
2814 {
2815 if (!IsReady(SLOTID_1)) {
2816 return;
2817 }
2818 std::string fac = "AO";
2819 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_1, GetSerialId(), fac);
2820 WaitFor(WAIT_TIME_SECOND);
2821 EXPECT_EQ(SUCCESS, ret);
2822 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_RESTRICTION));
2823 }
2824
2825 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallRestriction_V1_0200, Function | MediumTest | Level3)
2826 {
2827 if (!IsReady(SLOTID_2)) {
2828 return;
2829 }
2830 std::string fac = "AO";
2831 int32_t ret = g_rilInterface->GetCallRestriction(SLOTID_2, GetSerialId(), fac);
2832 WaitFor(WAIT_TIME_SECOND);
2833 EXPECT_EQ(SUCCESS, ret);
2834 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_RESTRICTION));
2835 }
2836
2837 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallRestriction_V1_0100, Function | MediumTest | Level3)
2838 {
2839 if (!IsReady(SLOTID_1)) {
2840 return;
2841 }
2842 CallRestrictionInfo callRestrictionInfo = {};
2843 callRestrictionInfo.fac = "AO";
2844 callRestrictionInfo.mode = 1;
2845 callRestrictionInfo.password = "123456";
2846 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_1, GetSerialId(), callRestrictionInfo);
2847 WaitFor(WAIT_TIME_SECOND);
2848 EXPECT_EQ(SUCCESS, ret);
2849 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_RESTRICTION));
2850 }
2851
2852 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallRestriction_V1_0200, Function | MediumTest | Level3)
2853 {
2854 if (!IsReady(SLOTID_2)) {
2855 return;
2856 }
2857 CallRestrictionInfo callRestrictionInfo = {};
2858 callRestrictionInfo.fac = "AO";
2859 callRestrictionInfo.mode = 1;
2860 callRestrictionInfo.password = "123456";
2861 int32_t ret = g_rilInterface->SetCallRestriction(SLOTID_2, GetSerialId(), callRestrictionInfo);
2862 WaitFor(WAIT_TIME_SECOND);
2863 EXPECT_EQ(SUCCESS, ret);
2864 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_RESTRICTION));
2865 }
2866
2867 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClip_V1_0100, Function | MediumTest | Level3)
2868 {
2869 if (!IsReady(SLOTID_1)) {
2870 return;
2871 }
2872 int32_t ret = g_rilInterface->GetClip(SLOTID_1, GetSerialId());
2873 WaitFor(WAIT_TIME_SECOND);
2874 EXPECT_EQ(SUCCESS, ret);
2875 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIP));
2876 }
2877
2878 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClip_V1_0200, Function | MediumTest | Level3)
2879 {
2880 if (!IsReady(SLOTID_2)) {
2881 return;
2882 }
2883 int32_t ret = g_rilInterface->GetClip(SLOTID_2, GetSerialId());
2884 WaitFor(WAIT_TIME_SECOND);
2885 EXPECT_EQ(SUCCESS, ret);
2886 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIP));
2887 }
2888
2889 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClip_V1_0100, Function | MediumTest | Level3)
2890 {
2891 if (!IsReady(SLOTID_1)) {
2892 return;
2893 }
2894 int32_t ret = g_rilInterface->SetClip(SLOTID_1, GetSerialId(), 1);
2895 WaitFor(WAIT_TIME_SECOND);
2896 EXPECT_EQ(SUCCESS, ret);
2897 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIP));
2898 }
2899
2900 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClip_V1_0200, Function | MediumTest | Level3)
2901 {
2902 if (!IsReady(SLOTID_2)) {
2903 return;
2904 }
2905 int32_t ret = g_rilInterface->SetClip(SLOTID_2, GetSerialId(), 1);
2906 WaitFor(WAIT_TIME_SECOND);
2907 EXPECT_EQ(SUCCESS, ret);
2908 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIP));
2909 }
2910
2911 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClir_V1_0100, Function | MediumTest | Level3)
2912 {
2913 if (!IsReady(SLOTID_1)) {
2914 return;
2915 }
2916 int32_t ret = g_rilInterface->GetClir(SLOTID_1, GetSerialId());
2917 WaitFor(WAIT_TIME_SECOND);
2918 EXPECT_EQ(SUCCESS, ret);
2919 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIR));
2920 }
2921
2922 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetClir_V1_0200, Function | MediumTest | Level3)
2923 {
2924 if (!IsReady(SLOTID_2)) {
2925 return;
2926 }
2927 int32_t ret = g_rilInterface->GetClir(SLOTID_2, GetSerialId());
2928 WaitFor(WAIT_TIME_SECOND);
2929 EXPECT_EQ(SUCCESS, ret);
2930 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CLIR));
2931 }
2932
2933 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClir_V1_0100, Function | MediumTest | Level3)
2934 {
2935 if (!IsReady(SLOTID_1)) {
2936 return;
2937 }
2938 int32_t ret = g_rilInterface->SetClir(SLOTID_1, GetSerialId(), 1);
2939 WaitFor(WAIT_TIME_SECOND);
2940 EXPECT_EQ(SUCCESS, ret);
2941 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIR));
2942 }
2943
2944 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetClir_V1_0200, Function | MediumTest | Level3)
2945 {
2946 if (!IsReady(SLOTID_2)) {
2947 return;
2948 }
2949 int32_t ret = g_rilInterface->SetClir(SLOTID_2, GetSerialId(), 1);
2950 WaitFor(WAIT_TIME_SECOND);
2951 EXPECT_EQ(SUCCESS, ret);
2952 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CLIR));
2953 }
2954
2955 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallPreferenceMode_V1_0100, Function | MediumTest | Level3)
2956 {
2957 if (!IsReady(SLOTID_1)) {
2958 return;
2959 }
2960 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_1, GetSerialId(), 1);
2961 WaitFor(WAIT_TIME_SECOND);
2962 EXPECT_EQ(SUCCESS, ret);
2963 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_PREFERENCE));
2964 }
2965
2966 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCallPreferenceMode_V1_0200, Function | MediumTest | Level3)
2967 {
2968 if (!IsReady(SLOTID_2)) {
2969 return;
2970 }
2971 int32_t ret = g_rilInterface->SetCallPreferenceMode(SLOTID_2, GetSerialId(), 1);
2972 WaitFor(WAIT_TIME_SECOND);
2973 EXPECT_EQ(SUCCESS, ret);
2974 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_CALL_PREFERENCE));
2975 }
2976
2977 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallPreferenceMode_V1_0100, Function | MediumTest | Level3)
2978 {
2979 if (!IsReady(SLOTID_1)) {
2980 return;
2981 }
2982 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_1, GetSerialId());
2983 WaitFor(WAIT_TIME_SECOND);
2984 EXPECT_EQ(SUCCESS, ret);
2985 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_PREFERENCE));
2986 }
2987
2988 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallPreferenceMode_V1_0200, Function | MediumTest | Level3)
2989 {
2990 if (!IsReady(SLOTID_2)) {
2991 return;
2992 }
2993 int32_t ret = g_rilInterface->GetCallPreferenceMode(SLOTID_2, GetSerialId());
2994 WaitFor(WAIT_TIME_SECOND);
2995 EXPECT_EQ(SUCCESS, ret);
2996 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_CALL_PREFERENCE));
2997 }
2998
2999 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetUssd_V1_0100, Function | MediumTest | Level3)
3000 {
3001 if (!IsReady(SLOTID_1)) {
3002 return;
3003 }
3004 int32_t ret = g_rilInterface->SetUssd(SLOTID_1, GetSerialId(), "12345678");
3005 WaitFor(WAIT_TIME_SECOND);
3006 EXPECT_EQ(SUCCESS, ret);
3007 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_USSD));
3008 }
3009
3010 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetUssd_V1_0200, Function | MediumTest | Level3)
3011 {
3012 if (!IsReady(SLOTID_2)) {
3013 return;
3014 }
3015 int32_t ret = g_rilInterface->SetUssd(SLOTID_2, GetSerialId(), "12345678");
3016 WaitFor(WAIT_TIME_SECOND);
3017 EXPECT_EQ(SUCCESS, ret);
3018 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_USSD));
3019 }
3020
3021 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetUssd_V1_0100, Function | MediumTest | Level3)
3022 {
3023 if (!IsReady(SLOTID_1)) {
3024 return;
3025 }
3026 int32_t ret = g_rilInterface->GetUssd(SLOTID_1, GetSerialId());
3027 WaitFor(WAIT_TIME_SECOND);
3028 EXPECT_EQ(SUCCESS, ret);
3029 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_USSD));
3030 }
3031
3032 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetUssd_V1_0200, Function | MediumTest | Level3)
3033 {
3034 if (!IsReady(SLOTID_2)) {
3035 return;
3036 }
3037 int32_t ret = g_rilInterface->GetUssd(SLOTID_2, GetSerialId());
3038 WaitFor(WAIT_TIME_SECOND);
3039 EXPECT_EQ(SUCCESS, ret);
3040 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_USSD));
3041 }
3042
3043 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetMute_V1_0100, Function | MediumTest | Level3)
3044 {
3045 if (!IsReady(SLOTID_1)) {
3046 return;
3047 }
3048 int32_t ret = g_rilInterface->SetMute(SLOTID_1, GetSerialId(), 1);
3049 WaitFor(WAIT_TIME_SECOND);
3050 EXPECT_EQ(SUCCESS, ret);
3051 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_MUTE));
3052 }
3053
3054 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetMute_V1_0200, Function | MediumTest | Level3)
3055 {
3056 if (!IsReady(SLOTID_2)) {
3057 return;
3058 }
3059 int32_t ret = g_rilInterface->SetMute(SLOTID_2, GetSerialId(), 1);
3060 WaitFor(WAIT_TIME_SECOND);
3061 EXPECT_EQ(SUCCESS, ret);
3062 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_MUTE));
3063 }
3064
3065 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMute_V1_0100, Function | MediumTest | Level3)
3066 {
3067 if (!IsReady(SLOTID_1)) {
3068 return;
3069 }
3070 int32_t ret = g_rilInterface->GetMute(SLOTID_1, GetSerialId());
3071 WaitFor(WAIT_TIME_SECOND);
3072 EXPECT_EQ(SUCCESS, ret);
3073 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_MUTE));
3074 }
3075
3076 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMute_V1_0200, Function | MediumTest | Level3)
3077 {
3078 if (!IsReady(SLOTID_2)) {
3079 return;
3080 }
3081 int32_t ret = g_rilInterface->GetMute(SLOTID_2, GetSerialId());
3082 WaitFor(WAIT_TIME_SECOND);
3083 EXPECT_EQ(SUCCESS, ret);
3084 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_MUTE));
3085 }
3086
3087 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallFailReason_V1_0100, Function | MediumTest | Level3)
3088 {
3089 if (!IsReady(SLOTID_1)) {
3090 return;
3091 }
3092 int32_t ret = g_rilInterface->GetCallFailReason(SLOTID_1, GetSerialId());
3093 WaitFor(WAIT_TIME_SECOND);
3094 EXPECT_EQ(SUCCESS, ret);
3095 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_FAIL_REASON));
3096 }
3097
3098 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCallFailReason_V1_0200, Function | MediumTest | Level3)
3099 {
3100 if (!IsReady(SLOTID_2)) {
3101 return;
3102 }
3103 int32_t ret = g_rilInterface->GetCallFailReason(SLOTID_2, GetSerialId());
3104 WaitFor(WAIT_TIME_SECOND);
3105 EXPECT_EQ(SUCCESS, ret);
3106 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_GET_FAIL_REASON));
3107 }
3108
3109 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CallSupplement_V1_0100, Function | MediumTest | Level3)
3110 {
3111 if (!IsReady(SLOTID_1)) {
3112 return;
3113 }
3114 int32_t ret = g_rilInterface->CallSupplement(SLOTID_1, GetSerialId(), 1);
3115 WaitFor(WAIT_TIME_SECOND);
3116 EXPECT_EQ(SUCCESS, ret);
3117 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CALL_SUPPLEMENT));
3118 }
3119
3120 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CallSupplement_V1_0200, Function | MediumTest | Level3)
3121 {
3122 if (!IsReady(SLOTID_2)) {
3123 return;
3124 }
3125 int32_t ret = g_rilInterface->CallSupplement(SLOTID_2, GetSerialId(), 1);
3126 WaitFor(WAIT_TIME_SECOND);
3127 EXPECT_EQ(SUCCESS, ret);
3128 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CALL_SUPPLEMENT));
3129 }
3130
3131 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDtmf_V1_0100, Function | MediumTest | Level3)
3132 {
3133 if (!IsReady(SLOTID_1)) {
3134 return;
3135 }
3136 DtmfInfo dtmfInfo = {};
3137 dtmfInfo.callId = 0;
3138 dtmfInfo.dtmfKey = "#";
3139 dtmfInfo.onLength = 300;
3140 dtmfInfo.offLength = 0;
3141 dtmfInfo.stringLength = 1;
3142 int32_t ret = g_rilInterface->SendDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3143 WaitFor(WAIT_TIME_SECOND);
3144 EXPECT_EQ(SUCCESS, ret);
3145 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEND_DTMF));
3146 }
3147
3148 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDtmf_V1_0200, Function | MediumTest | Level3)
3149 {
3150 if (!IsReady(SLOTID_2)) {
3151 return;
3152 }
3153 DtmfInfo dtmfInfo = {};
3154 dtmfInfo.callId = 0;
3155 dtmfInfo.dtmfKey = "#";
3156 dtmfInfo.onLength = 1;
3157 dtmfInfo.offLength = 0;
3158 dtmfInfo.stringLength = 1;
3159 int32_t ret = g_rilInterface->SendDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3160 WaitFor(WAIT_TIME_SECOND);
3161 EXPECT_EQ(SUCCESS, ret);
3162 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SEND_DTMF));
3163 }
3164
3165 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StartDtmf_V1_0100, Function | MediumTest | Level3)
3166 {
3167 if (!IsReady(SLOTID_1)) {
3168 return;
3169 }
3170 DtmfInfo dtmfInfo = {};
3171 dtmfInfo.callId = 0;
3172 dtmfInfo.dtmfKey = "#";
3173 int32_t ret = g_rilInterface->StartDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3174 WaitFor(WAIT_TIME_SECOND);
3175 EXPECT_EQ(SUCCESS, ret);
3176 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_START_DTMF));
3177 }
3178
3179 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StartDtmf_V1_0200, Function | MediumTest | Level3)
3180 {
3181 if (!IsReady(SLOTID_2)) {
3182 return;
3183 }
3184 DtmfInfo dtmfInfo = {};
3185 dtmfInfo.callId = 0;
3186 dtmfInfo.dtmfKey = "#";
3187 int32_t ret = g_rilInterface->StartDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3188 WaitFor(WAIT_TIME_SECOND);
3189 EXPECT_EQ(SUCCESS, ret);
3190 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_START_DTMF));
3191 }
3192
3193 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StopDtmf_V1_0100, Function | MediumTest | Level3)
3194 {
3195 if (!IsReady(SLOTID_1)) {
3196 return;
3197 }
3198 DtmfInfo dtmfInfo = {};
3199 dtmfInfo.callId = 0;
3200 dtmfInfo.dtmfKey = "#";
3201 int32_t ret = g_rilInterface->StopDtmf(SLOTID_1, GetSerialId(), dtmfInfo);
3202 WaitFor(WAIT_TIME_SECOND);
3203 EXPECT_EQ(SUCCESS, ret);
3204 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_STOP_DTMF));
3205 }
3206
3207 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_StopDtmf_V1_0200, Function | MediumTest | Level3)
3208 {
3209 if (!IsReady(SLOTID_2)) {
3210 return;
3211 }
3212 DtmfInfo dtmfInfo = {};
3213 dtmfInfo.callId = 0;
3214 dtmfInfo.dtmfKey = "#";
3215 int32_t ret = g_rilInterface->StopDtmf(SLOTID_2, GetSerialId(), dtmfInfo);
3216 WaitFor(WAIT_TIME_SECOND);
3217 EXPECT_EQ(SUCCESS, ret);
3218 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_STOP_DTMF));
3219 }
3220
3221 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetBarringPassword_V1_0100, Function | MediumTest | Level3)
3222 {
3223 if (!IsReady(SLOTID_1)) {
3224 return;
3225 }
3226 SetBarringInfo setBarringInfo = {};
3227 setBarringInfo.fac = "AB";
3228 setBarringInfo.oldPassword = "1234";
3229 setBarringInfo.newPassword = "2345";
3230 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_1, GetSerialId(), setBarringInfo);
3231 WaitFor(WAIT_TIME_SECOND);
3232 EXPECT_EQ(SUCCESS, ret);
3233 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_BARRING_PASSWORD));
3234 }
3235
3236 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetBarringPassword_V1_0200, Function | MediumTest | Level3)
3237 {
3238 if (!IsReady(SLOTID_2)) {
3239 return;
3240 }
3241 SetBarringInfo setBarringInfo = {};
3242 setBarringInfo.fac = "AB";
3243 setBarringInfo.oldPassword = "1234";
3244 setBarringInfo.newPassword = "2345";
3245 int32_t ret = g_rilInterface->SetBarringPassword(SLOTID_2, GetSerialId(), setBarringInfo);
3246 WaitFor(WAIT_TIME_SECOND);
3247 EXPECT_EQ(SUCCESS, ret);
3248 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_SET_BARRING_PASSWORD));
3249 }
3250
3251 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CloseUnFinishedUssd_V1_0100, Function | MediumTest | Level3)
3252 {
3253 if (!IsReady(SLOTID_1)) {
3254 return;
3255 }
3256 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_1, GetSerialId());
3257 WaitFor(WAIT_TIME_SECOND);
3258 EXPECT_EQ(SUCCESS, ret);
3259 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD));
3260 }
3261
3262 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_CloseUnFinishedUssd_V1_0200, Function | MediumTest | Level3)
3263 {
3264 if (!IsReady(SLOTID_2)) {
3265 return;
3266 }
3267 int32_t ret = g_rilInterface->CloseUnFinishedUssd(SLOTID_2, GetSerialId());
3268 WaitFor(WAIT_TIME_SECOND);
3269 EXPECT_EQ(SUCCESS, ret);
3270 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_CALL_CLOSE_UNFINISHED_USSD));
3271 }
3272
3273 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetVonrSwitch_V1_0100, Function | MediumTest | Level3)
3274 {
3275 if (!IsReady(SLOTID_1)) {
3276 return;
3277 }
3278 int32_t ret = g_rilInterface->SetVonrSwitch(SLOTID_1, GetSerialId(), 1);
3279 WaitFor(WAIT_TIME_SECOND);
3280 EXPECT_EQ(SUCCESS, ret);
3281 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SET_VONR_SWITCH));
3282 }
3283
3284 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetVonrSwitch_V1_0200, Function | MediumTest | Level3)
3285 {
3286 if (!IsReady(SLOTID_2)) {
3287 return;
3288 }
3289 int32_t ret = g_rilInterface->SetVonrSwitch(SLOTID_2, GetSerialId(), 1);
3290 WaitFor(WAIT_TIME_SECOND);
3291 EXPECT_EQ(SUCCESS, ret);
3292 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SET_VONR_SWITCH));
3293 }
3294
3295 // Network
3296 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSignalStrength_V1_0100, Function | MediumTest | Level3)
3297 {
3298 if (!IsReady(SLOTID_1)) {
3299 return;
3300 }
3301 int32_t ret = g_rilInterface->GetSignalStrength(SLOTID_1, GetSerialId());
3302 WaitFor(WAIT_TIME_SECOND);
3303 EXPECT_EQ(SUCCESS, ret);
3304 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH));
3305 }
3306
3307 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSignalStrength_V1_0200, Function | MediumTest | Level3)
3308 {
3309 if (!IsReady(SLOTID_2)) {
3310 return;
3311 }
3312 int32_t ret = g_rilInterface->GetSignalStrength(SLOTID_2, GetSerialId());
3313 WaitFor(WAIT_TIME_SECOND);
3314 EXPECT_EQ(SUCCESS, ret);
3315 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_SIGNAL_STRENGTH));
3316 }
3317
3318 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCsRegStatus_V1_0100, Function | MediumTest | Level3)
3319 {
3320 if (!IsReady(SLOTID_1)) {
3321 return;
3322 }
3323 int32_t ret = g_rilInterface->GetCsRegStatus(SLOTID_1, GetSerialId());
3324 WaitFor(WAIT_TIME_SECOND);
3325 EXPECT_EQ(SUCCESS, ret);
3326 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CS_REG_STATUS));
3327 }
3328
3329 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCsRegStatus_V1_0200, Function | MediumTest | Level3)
3330 {
3331 if (!IsReady(SLOTID_2)) {
3332 return;
3333 }
3334 int32_t ret = g_rilInterface->GetCsRegStatus(SLOTID_2, GetSerialId());
3335 WaitFor(WAIT_TIME_SECOND);
3336 EXPECT_EQ(SUCCESS, ret);
3337 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CS_REG_STATUS));
3338 }
3339
3340 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPsRegStatus_V1_0100, Function | MediumTest | Level3)
3341 {
3342 if (!IsReady(SLOTID_1)) {
3343 return;
3344 }
3345 int32_t ret = g_rilInterface->GetPsRegStatus(SLOTID_1, GetSerialId());
3346 WaitFor(WAIT_TIME_SECOND);
3347 EXPECT_EQ(SUCCESS, ret);
3348 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PS_REG_STATUS));
3349 }
3350
3351 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPsRegStatus_V1_0200, Function | MediumTest | Level3)
3352 {
3353 if (!IsReady(SLOTID_2)) {
3354 return;
3355 }
3356 int32_t ret = g_rilInterface->GetPsRegStatus(SLOTID_2, GetSerialId());
3357 WaitFor(WAIT_TIME_SECOND);
3358 EXPECT_EQ(SUCCESS, ret);
3359 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PS_REG_STATUS));
3360 }
3361
3362 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetOperatorInfo_V1_0100, Function | MediumTest | Level3)
3363 {
3364 if (!IsReady(SLOTID_1)) {
3365 return;
3366 }
3367 int32_t ret = g_rilInterface->GetOperatorInfo(SLOTID_1, GetSerialId());
3368 WaitFor(WAIT_TIME_SECOND);
3369 EXPECT_EQ(SUCCESS, ret);
3370 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_OPERATOR_INFO));
3371 }
3372
3373 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetOperatorInfo_V1_0200, Function | MediumTest | Level3)
3374 {
3375 if (!IsReady(SLOTID_2)) {
3376 return;
3377 }
3378 int32_t ret = g_rilInterface->GetOperatorInfo(SLOTID_2, GetSerialId());
3379 WaitFor(WAIT_TIME_SECOND);
3380 EXPECT_EQ(SUCCESS, ret);
3381 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_OPERATOR_INFO));
3382 }
3383
3384 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSearchInformation_V1_0100, Function | MediumTest | Level3)
3385 {
3386 if (!IsReady(SLOTID_1)) {
3387 return;
3388 }
3389 int32_t ret = g_rilInterface->GetNetworkSearchInformation(SLOTID_1, GetSerialId());
3390 WaitFor(WAIT_TIME_SECOND);
3391 EXPECT_EQ(SUCCESS, ret);
3392 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION));
3393 }
3394
3395 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSearchInformation_V1_0200, Function | MediumTest | Level3)
3396 {
3397 if (!IsReady(SLOTID_2)) {
3398 return;
3399 }
3400 int32_t ret = g_rilInterface->GetNetworkSearchInformation(SLOTID_2, GetSerialId());
3401 WaitFor(WAIT_TIME_SECOND);
3402 EXPECT_EQ(SUCCESS, ret);
3403 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION));
3404 }
3405
3406 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSelectionMode_V1_0100, Function | MediumTest | Level3)
3407 {
3408 if (!IsReady(SLOTID_1)) {
3409 return;
3410 }
3411 int32_t ret = g_rilInterface->GetNetworkSelectionMode(SLOTID_1, GetSerialId());
3412 WaitFor(WAIT_TIME_SECOND);
3413 EXPECT_EQ(SUCCESS, ret);
3414 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE));
3415 }
3416
3417 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNetworkSelectionMode_V1_0200, Function | MediumTest | Level3)
3418 {
3419 if (!IsReady(SLOTID_2)) {
3420 return;
3421 }
3422 int32_t ret = g_rilInterface->GetNetworkSelectionMode(SLOTID_2, GetSerialId());
3423 WaitFor(WAIT_TIME_SECOND);
3424 EXPECT_EQ(SUCCESS, ret);
3425 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NETWORK_SELECTION_MODE));
3426 }
3427
3428 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNetworkSelectionMode_V1_0100, Function | MediumTest | Level3)
3429 {
3430 if (!IsReady(SLOTID_1)) {
3431 return;
3432 }
3433 SetNetworkModeInfo setNetworkModeInfo;
3434 setNetworkModeInfo.selectMode = static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO);
3435 setNetworkModeInfo.oper = "46000";
3436 int32_t ret = g_rilInterface->SetNetworkSelectionMode(SLOTID_1, GetSerialId(), setNetworkModeInfo);
3437 WaitFor(WAIT_TIME_SECOND);
3438 EXPECT_EQ(SUCCESS, ret);
3439 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE));
3440 }
3441
3442 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNetworkSelectionMode_V1_0200, Function | MediumTest | Level3)
3443 {
3444 if (!IsReady(SLOTID_2)) {
3445 return;
3446 }
3447 SetNetworkModeInfo setNetworkModeInfo;
3448 setNetworkModeInfo.selectMode = static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO);
3449 setNetworkModeInfo.oper = "46000";
3450 int32_t ret = g_rilInterface->SetNetworkSelectionMode(SLOTID_2, GetSerialId(), setNetworkModeInfo);
3451 WaitFor(WAIT_TIME_SECOND);
3452 EXPECT_EQ(SUCCESS, ret);
3453 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NETWORK_SELECTION_MODE));
3454 }
3455
3456 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetPreferredNetwork_V1_0100, Function | MediumTest | Level3)
3457 {
3458 if (!IsReady(SLOTID_1)) {
3459 return;
3460 }
3461 int32_t ret = g_rilInterface->SetPreferredNetwork(
3462 SLOTID_1, GetSerialId(), static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE));
3463 WaitFor(WAIT_TIME_SECOND);
3464 EXPECT_EQ(SUCCESS, ret);
3465 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK));
3466 }
3467
3468 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetPreferredNetwork_V1_0200, Function | MediumTest | Level3)
3469 {
3470 if (!IsReady(SLOTID_2)) {
3471 return;
3472 }
3473 int32_t ret = g_rilInterface->SetPreferredNetwork(
3474 SLOTID_2, GetSerialId(), static_cast<int32_t>(PreferredNetworkMode::CORE_NETWORK_MODE_LTE));
3475 WaitFor(WAIT_TIME_SECOND);
3476 EXPECT_EQ(SUCCESS, ret);
3477 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_PREFERRED_NETWORK));
3478 }
3479
3480 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPreferredNetwork_V1_0100, Function | MediumTest | Level3)
3481 {
3482 if (!IsReady(SLOTID_1)) {
3483 return;
3484 }
3485 int32_t ret = g_rilInterface->GetPreferredNetwork(SLOTID_1, GetSerialId());
3486 WaitFor(WAIT_TIME_SECOND);
3487 EXPECT_EQ(SUCCESS, ret);
3488 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK));
3489 }
3490
3491 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPreferredNetwork_V1_0200, Function | MediumTest | Level3)
3492 {
3493 if (!IsReady(SLOTID_2)) {
3494 return;
3495 }
3496 int32_t ret = g_rilInterface->GetPreferredNetwork(SLOTID_2, GetSerialId());
3497 WaitFor(WAIT_TIME_SECOND);
3498 EXPECT_EQ(SUCCESS, ret);
3499 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PREFERRED_NETWORK));
3500 }
3501
3502 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCellInfoList_V1_0100, Function | MediumTest | Level3)
3503 {
3504 if (!IsReady(SLOTID_1)) {
3505 return;
3506 }
3507 int32_t ret = g_rilInterface->GetNeighboringCellInfoList(SLOTID_1, GetSerialId());
3508 WaitFor(WAIT_TIME_SECOND);
3509 EXPECT_EQ(SUCCESS, ret);
3510 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST));
3511 }
3512
3513 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCellInfoList_V1_0200, Function | MediumTest | Level3)
3514 {
3515 if (!IsReady(SLOTID_2)) {
3516 return;
3517 }
3518 int32_t ret = g_rilInterface->GetNeighboringCellInfoList(SLOTID_2, GetSerialId());
3519 WaitFor(WAIT_TIME_SECOND);
3520 EXPECT_EQ(SUCCESS, ret);
3521 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST));
3522 }
3523
3524 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCurrentCellInfo_V1_0100, Function | MediumTest | Level3)
3525 {
3526 if (!IsReady(SLOTID_1)) {
3527 return;
3528 }
3529 int32_t ret = g_rilInterface->GetCurrentCellInfo(SLOTID_1, GetSerialId());
3530 WaitFor(WAIT_TIME_SECOND);
3531 EXPECT_EQ(SUCCESS, ret);
3532 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO));
3533 }
3534
3535 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCurrentCellInfo_V1_0200, Function | MediumTest | Level3)
3536 {
3537 if (!IsReady(SLOTID_2)) {
3538 return;
3539 }
3540 int32_t ret = g_rilInterface->GetCurrentCellInfo(SLOTID_2, GetSerialId());
3541 WaitFor(WAIT_TIME_SECOND);
3542 EXPECT_EQ(SUCCESS, ret);
3543 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_CURRENT_CELL_INFO));
3544 }
3545
3546 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPhysicalChannelConfig_V1_0100, Function | MediumTest | Level3)
3547 {
3548 if (!IsReady(SLOTID_1)) {
3549 return;
3550 }
3551 int32_t ret = g_rilInterface->GetPhysicalChannelConfig(SLOTID_1, GetSerialId());
3552 WaitFor(WAIT_TIME_SECOND);
3553 EXPECT_EQ(SUCCESS, ret);
3554 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG));
3555 }
3556
3557 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPhysicalChannelConfig_V1_0200, Function | MediumTest | Level3)
3558 {
3559 if (!IsReady(SLOTID_2)) {
3560 return;
3561 }
3562 int32_t ret = g_rilInterface->GetPhysicalChannelConfig(SLOTID_2, GetSerialId());
3563 WaitFor(WAIT_TIME_SECOND);
3564 EXPECT_EQ(SUCCESS, ret);
3565 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG));
3566 }
3567
3568 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLocateUpdates_V1_0100, Function | MediumTest | Level3)
3569 {
3570 if (!IsReady(SLOTID_1)) {
3571 return;
3572 }
3573 int32_t ret =
3574 g_rilInterface->SetLocateUpdates(SLOTID_1, GetSerialId(), RilRegNotifyMode::REG_NOTIFY_STAT_LAC_CELLID);
3575 WaitFor(WAIT_TIME_SECOND);
3576 EXPECT_EQ(SUCCESS, ret);
3577 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES));
3578 }
3579
3580 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLocateUpdates_V1_0200, Function | MediumTest | Level3)
3581 {
3582 if (!IsReady(SLOTID_2)) {
3583 return;
3584 }
3585 int32_t ret =
3586 g_rilInterface->SetLocateUpdates(SLOTID_2, GetSerialId(), RilRegNotifyMode::REG_NOTIFY_STAT_LAC_CELLID);
3587 WaitFor(WAIT_TIME_SECOND);
3588 EXPECT_EQ(SUCCESS, ret);
3589 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_LOCATE_UPDATES));
3590 }
3591
3592 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNotificationFilter_V1_0100, Function | MediumTest | Level3)
3593 {
3594 if (!IsReady(SLOTID_1)) {
3595 return;
3596 }
3597 int32_t ret = g_rilInterface->SetNotificationFilter(
3598 SLOTID_1, GetSerialId(), static_cast<int32_t>(NotificationFilter::NOTIFICATION_FILTER_ALL));
3599 WaitFor(WAIT_TIME_SECOND);
3600 EXPECT_EQ(SUCCESS, ret);
3601 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER));
3602 }
3603
3604 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNotificationFilter_V1_0200, Function | MediumTest | Level3)
3605 {
3606 if (!IsReady(SLOTID_2)) {
3607 return;
3608 }
3609 int32_t ret = g_rilInterface->SetNotificationFilter(
3610 SLOTID_2, GetSerialId(), static_cast<int32_t>(NotificationFilter::NOTIFICATION_FILTER_ALL));
3611 WaitFor(WAIT_TIME_SECOND);
3612 EXPECT_EQ(SUCCESS, ret);
3613 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NOTIFICATION_FILTER));
3614 }
3615
3616 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDeviceState_V1_0100, Function | MediumTest | Level3)
3617 {
3618 if (!IsReady(SLOTID_1)) {
3619 return;
3620 }
3621 int32_t ret = g_rilInterface->SetDeviceState(
3622 SLOTID_1, GetSerialId(), static_cast<int32_t>(DeviceStateType::LOW_DATA_STATE), 0);
3623 WaitFor(WAIT_TIME_SECOND);
3624 EXPECT_EQ(SUCCESS, ret);
3625 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_DEVICE_STATE));
3626 }
3627
3628 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDeviceState_V1_0200, Function | MediumTest | Level3)
3629 {
3630 if (!IsReady(SLOTID_2)) {
3631 return;
3632 }
3633 int32_t ret = g_rilInterface->SetDeviceState(
3634 SLOTID_2, GetSerialId(), static_cast<int32_t>(DeviceStateType::LOW_DATA_STATE), 0);
3635 WaitFor(WAIT_TIME_SECOND);
3636 EXPECT_EQ(SUCCESS, ret);
3637 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_DEVICE_STATE));
3638 }
3639
3640 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRrcConnectionState_V1_0100, Function | MediumTest | Level3)
3641 {
3642 if (!IsReady(SLOTID_1)) {
3643 return;
3644 }
3645 int32_t ret = g_rilInterface->GetRrcConnectionState(SLOTID_1, GetSerialId());
3646 WaitFor(WAIT_TIME_SECOND);
3647 EXPECT_EQ(SUCCESS, ret);
3648 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE));
3649 }
3650
3651 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRrcConnectionState_V1_0200, Function | MediumTest | Level3)
3652 {
3653 if (!IsReady(SLOTID_2)) {
3654 return;
3655 }
3656 int32_t ret = g_rilInterface->GetRrcConnectionState(SLOTID_2, GetSerialId());
3657 WaitFor(WAIT_TIME_SECOND);
3658 EXPECT_EQ(SUCCESS, ret);
3659 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_RRC_CONNECTION_STATE));
3660 }
3661
3662 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNrOptionMode_V1_0100, Function | MediumTest | Level3)
3663 {
3664 if (!IsReady(SLOTID_1)) {
3665 return;
3666 }
3667 int32_t ret =
3668 g_rilInterface->SetNrOptionMode(SLOTID_1, GetSerialId(), static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA));
3669 WaitFor(WAIT_TIME_SECOND);
3670 EXPECT_EQ(SUCCESS, ret);
3671 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE));
3672 }
3673
3674 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetNrOptionMode_V1_0200, Function | MediumTest | Level3)
3675 {
3676 if (!IsReady(SLOTID_2)) {
3677 return;
3678 }
3679 int32_t ret =
3680 g_rilInterface->SetNrOptionMode(SLOTID_2, GetSerialId(), static_cast<int32_t>(NrMode::NR_MODE_NSA_AND_SA));
3681 WaitFor(WAIT_TIME_SECOND);
3682 EXPECT_EQ(SUCCESS, ret);
3683 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_SET_NR_OPTION_MODE));
3684 }
3685
3686 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNrOptionMode_V1_0100, Function | MediumTest | Level3)
3687 {
3688 if (!IsReady(SLOTID_1)) {
3689 return;
3690 }
3691 int32_t ret = g_rilInterface->GetNrOptionMode(SLOTID_1, GetSerialId());
3692 WaitFor(WAIT_TIME_SECOND);
3693 EXPECT_EQ(SUCCESS, ret);
3694 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE));
3695 }
3696
3697 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetNrOptionMode_V1_0200, Function | MediumTest | Level3)
3698 {
3699 if (!IsReady(SLOTID_2)) {
3700 return;
3701 }
3702 int32_t ret = g_rilInterface->GetNrOptionMode(SLOTID_2, GetSerialId());
3703 WaitFor(WAIT_TIME_SECOND);
3704 EXPECT_EQ(SUCCESS, ret);
3705 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_NETWORK_GET_NR_OPTION_MODE));
3706 }
3707
3708 /**
3709 * modem Test
3710 **/
3711 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ShutDown_V1_0100, Function | MediumTest | Level3)
3712 {
3713 if (!IsReady(SLOTID_1)) {
3714 return;
3715 }
3716 int32_t ret = g_rilInterface->ShutDown(SLOTID_1, GetSerialId());
3717 WaitFor(WAIT_TIME_SECOND);
3718 EXPECT_EQ(SUCCESS, ret);
3719 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SHUT_DOWN));
3720 }
3721
3722 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ShutDown_V1_0200, Function | MediumTest | Level3)
3723 {
3724 if (!IsReady(SLOTID_2)) {
3725 return;
3726 }
3727 int32_t ret = g_rilInterface->ShutDown(SLOTID_2, GetSerialId());
3728 WaitFor(WAIT_TIME_SECOND);
3729 EXPECT_EQ(SUCCESS, ret);
3730 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SHUT_DOWN));
3731 }
3732
3733 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioState_V1_0100, Function | MediumTest | Level3)
3734 {
3735 if (!IsReady(SLOTID_1)) {
3736 return;
3737 }
3738 int32_t ret = g_rilInterface->SetRadioState(SLOTID_1, GetSerialId(), 1, 0);
3739 WaitFor(WAIT_TIME_SECOND);
3740 EXPECT_EQ(SUCCESS, ret);
3741 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SET_RADIO_STATUS));
3742 }
3743
3744 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioState_V1_0200, Function | MediumTest | Level3)
3745 {
3746 if (!IsReady(SLOTID_2)) {
3747 return;
3748 }
3749 int32_t ret = g_rilInterface->SetRadioState(SLOTID_1, GetSerialId(), 1, 0);
3750 WaitFor(WAIT_TIME_SECOND);
3751 EXPECT_EQ(SUCCESS, ret);
3752 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_SET_RADIO_STATUS));
3753 }
3754
3755 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRadioState_V1_0100, Function | MediumTest | Level3)
3756 {
3757 if (!IsReady(SLOTID_1)) {
3758 return;
3759 }
3760 int32_t ret = g_rilInterface->GetRadioState(SLOTID_1, GetSerialId());
3761 WaitFor(WAIT_TIME_SECOND);
3762 EXPECT_EQ(SUCCESS, ret);
3763 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_RADIO_STATUS));
3764 }
3765
3766 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetRadioState_V1_0200, Function | MediumTest | Level3)
3767 {
3768 if (!IsReady(SLOTID_2)) {
3769 return;
3770 }
3771 int32_t ret = g_rilInterface->GetRadioState(SLOTID_2, GetSerialId());
3772 WaitFor(WAIT_TIME_SECOND);
3773 EXPECT_EQ(SUCCESS, ret);
3774 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_RADIO_STATUS));
3775 }
3776
3777 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImei_V1_0100, Function | MediumTest | Level3)
3778 {
3779 if (!IsReady(SLOTID_1)) {
3780 return;
3781 }
3782 int32_t ret = g_rilInterface->GetImei(SLOTID_1, GetSerialId());
3783 WaitFor(WAIT_TIME_SECOND);
3784 EXPECT_EQ(SUCCESS, ret);
3785 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEI));
3786 }
3787
3788 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImei_V1_0200, Function | MediumTest | Level3)
3789 {
3790 if (!IsReady(SLOTID_2)) {
3791 return;
3792 }
3793 int32_t ret = g_rilInterface->GetImei(SLOTID_2, GetSerialId());
3794 WaitFor(WAIT_TIME_SECOND);
3795 EXPECT_EQ(SUCCESS, ret);
3796 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEI));
3797 }
3798
3799 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImeiSv_V1_0100, Function | MediumTest | Level3)
3800 {
3801 if (!IsReady(SLOTID_1)) {
3802 return;
3803 }
3804 int32_t ret = g_rilInterface->GetImeiSv(SLOTID_1, GetSerialId());
3805 WaitFor(WAIT_TIME_SECOND);
3806 EXPECT_EQ(SUCCESS, ret);
3807 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEISV));
3808 }
3809
3810 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImeiSv_V1_0200, Function | MediumTest | Level3)
3811 {
3812 if (!IsReady(SLOTID_2)) {
3813 return;
3814 }
3815 int32_t ret = g_rilInterface->GetImeiSv(SLOTID_2, GetSerialId());
3816 WaitFor(WAIT_TIME_SECOND);
3817 EXPECT_EQ(SUCCESS, ret);
3818 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_IMEISV));
3819 }
3820
3821 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMeid_V1_0100, Function | MediumTest | Level3)
3822 {
3823 if (!IsReady(SLOTID_1)) {
3824 return;
3825 }
3826 int32_t ret = g_rilInterface->GetMeid(SLOTID_1, GetSerialId());
3827 WaitFor(WAIT_TIME_SECOND);
3828 EXPECT_EQ(SUCCESS, ret);
3829 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_MEID));
3830 }
3831
3832 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetMeid_V1_0200, Function | MediumTest | Level3)
3833 {
3834 if (!IsReady(SLOTID_2)) {
3835 return;
3836 }
3837 int32_t ret = g_rilInterface->GetMeid(SLOTID_2, GetSerialId());
3838 WaitFor(WAIT_TIME_SECOND);
3839 EXPECT_EQ(SUCCESS, ret);
3840 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_MEID));
3841 }
3842
3843 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetBasebandVersion_V1_0100, Function | MediumTest | Level3)
3844 {
3845 if (!IsReady(SLOTID_1)) {
3846 return;
3847 }
3848 int32_t ret = g_rilInterface->GetBasebandVersion(SLOTID_1, GetSerialId());
3849 WaitFor(WAIT_TIME_SECOND);
3850 EXPECT_EQ(SUCCESS, ret);
3851 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_BASEBAND_VERSION));
3852 }
3853
3854 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetBasebandVersion_V1_0200, Function | MediumTest | Level3)
3855 {
3856 if (!IsReady(SLOTID_2)) {
3857 return;
3858 }
3859 int32_t ret = g_rilInterface->GetBasebandVersion(SLOTID_2, GetSerialId());
3860 WaitFor(WAIT_TIME_SECOND);
3861 EXPECT_EQ(SUCCESS, ret);
3862 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_BASEBAND_VERSION));
3863 }
3864
3865 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetVoiceRadioTechnology_V1_0100, Function | MediumTest | Level3)
3866 {
3867 if (!IsReady(SLOTID_1)) {
3868 return;
3869 }
3870 int32_t ret = g_rilInterface->GetVoiceRadioTechnology(SLOTID_1, GetSerialId());
3871 WaitFor(WAIT_TIME_SECOND);
3872 EXPECT_EQ(SUCCESS, ret);
3873 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_VOICE_RADIO));
3874 }
3875
3876 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetVoiceRadioTechnology_V1_0200, Function | MediumTest | Level3)
3877 {
3878 if (!IsReady(SLOTID_2)) {
3879 return;
3880 }
3881 int32_t ret = g_rilInterface->GetVoiceRadioTechnology(SLOTID_2, GetSerialId());
3882 WaitFor(WAIT_TIME_SECOND);
3883 EXPECT_EQ(SUCCESS, ret);
3884 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_MODEM_GET_VOICE_RADIO));
3885 }
3886
3887 // Data
3888 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ActivatePdpContext_V1_0100, Function | MediumTest | Level3)
3889 {
3890 if (!IsReady(SLOTID_1)) {
3891 return;
3892 }
3893 int32_t serialId = GetSerialId();
3894 DataProfileDataInfo dataProfileInfo;
3895 dataProfileInfo.profileId = 0;
3896 dataProfileInfo.password = "";
3897 dataProfileInfo.authenticationType = 0;
3898 dataProfileInfo.userName = "";
3899 dataProfileInfo.apn = "cmnet";
3900 dataProfileInfo.protocol = "IPV4V6";
3901 dataProfileInfo.roamingProtocol = "IPV4V6";
3902 DataCallInfo dataCallInfo;
3903 dataCallInfo.serial = serialId;
3904 dataCallInfo.radioTechnology = 0;
3905 dataCallInfo.dataProfileInfo = dataProfileInfo;
3906 dataCallInfo.roamingAllowed = true;
3907 dataCallInfo.isRoaming = false;
3908 int32_t ret = g_rilInterface->ActivatePdpContext(SLOTID_1, serialId, dataCallInfo);
3909 WaitFor(WAIT_TIME_SECOND);
3910 EXPECT_EQ(SUCCESS, ret);
3911 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT));
3912 }
3913
3914 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ActivatePdpContext_V1_0200, Function | MediumTest | Level3)
3915 {
3916 if (!IsReady(SLOTID_2)) {
3917 return;
3918 }
3919 int32_t serialId = GetSerialId();
3920 DataProfileDataInfo dataProfileInfo;
3921 dataProfileInfo.profileId = 0;
3922 dataProfileInfo.password = "";
3923 dataProfileInfo.authenticationType = 0;
3924 dataProfileInfo.userName = "";
3925 dataProfileInfo.apn = "cmnet";
3926 dataProfileInfo.protocol = "IPV4V6";
3927 dataProfileInfo.roamingProtocol = "IPV4V6";
3928 DataCallInfo dataCallInfo;
3929 dataCallInfo.serial = serialId;
3930 dataCallInfo.radioTechnology = 0;
3931 dataCallInfo.dataProfileInfo = dataProfileInfo;
3932 dataCallInfo.roamingAllowed = true;
3933 dataCallInfo.isRoaming = false;
3934 int32_t ret = g_rilInterface->ActivatePdpContext(SLOTID_2, serialId, dataCallInfo);
3935 WaitFor(WAIT_TIME_SECOND);
3936 EXPECT_EQ(SUCCESS, ret);
3937 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_ACTIVATE_PDP_CONTEXT));
3938 }
3939
3940 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DeactivatePdpContext_V1_0100, Function | MediumTest | Level3)
3941 {
3942 if (!IsReady(SLOTID_1)) {
3943 return;
3944 }
3945 int32_t serialId = GetSerialId();
3946 UniInfo uniInfo;
3947 uniInfo.serial = serialId;
3948 uniInfo.gsmIndex = CID;
3949 uniInfo.arg1 = REASON;
3950 int32_t ret = g_rilInterface->DeactivatePdpContext(SLOTID_1, serialId, uniInfo);
3951 WaitFor(WAIT_TIME_SECOND);
3952 EXPECT_EQ(SUCCESS, ret);
3953 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT));
3954 }
3955
3956 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DeactivatePdpContext_V1_0200, Function | MediumTest | Level3)
3957 {
3958 if (!IsReady(SLOTID_2)) {
3959 return;
3960 }
3961 int32_t serialId = GetSerialId();
3962 UniInfo uniInfo;
3963 uniInfo.serial = serialId;
3964 uniInfo.gsmIndex = CID;
3965 uniInfo.arg1 = REASON;
3966 int32_t ret = g_rilInterface->DeactivatePdpContext(SLOTID_2, serialId, uniInfo);
3967 WaitFor(WAIT_TIME_SECOND);
3968 EXPECT_EQ(SUCCESS, ret);
3969 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_DEACTIVATE_PDP_CONTEXT));
3970 }
3971
3972 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPdpContextList_V1_0100, Function | MediumTest | Level3)
3973 {
3974 if (!IsReady(SLOTID_1)) {
3975 return;
3976 }
3977 int32_t serialId = GetSerialId();
3978 UniInfo uniInfo;
3979 uniInfo.serial = serialId;
3980 int32_t ret = g_rilInterface->GetPdpContextList(SLOTID_1, serialId, uniInfo);
3981 WaitFor(WAIT_TIME_SECOND);
3982 EXPECT_EQ(SUCCESS, ret);
3983 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST));
3984 }
3985
3986 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetPdpContextList_V1_0200, Function | MediumTest | Level3)
3987 {
3988 if (!IsReady(SLOTID_2)) {
3989 return;
3990 }
3991 int32_t serialId = GetSerialId();
3992 UniInfo uniInfo;
3993 uniInfo.serial = serialId;
3994 int32_t ret = g_rilInterface->GetPdpContextList(SLOTID_2, serialId, uniInfo);
3995 WaitFor(WAIT_TIME_SECOND);
3996 EXPECT_EQ(SUCCESS, ret);
3997 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_PDP_CONTEXT_LIST));
3998 }
3999
4000 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetInitApnInfo_V1_0100, Function | MediumTest | Level3)
4001 {
4002 if (!IsReady(SLOTID_1)) {
4003 return;
4004 }
4005 int32_t serialId = GetSerialId();
4006 DataProfileDataInfo dataProfileInfo;
4007 dataProfileInfo.profileId = 0;
4008 dataProfileInfo.password = "";
4009 dataProfileInfo.authenticationType = 0;
4010 dataProfileInfo.userName = "";
4011 dataProfileInfo.apn = "cmnet";
4012 dataProfileInfo.protocol = "IPV4V6";
4013 dataProfileInfo.roamingProtocol = "IPV4V6";
4014 dataProfileInfo.serial = serialId;
4015 int32_t ret = g_rilInterface->SetInitApnInfo(SLOTID_1, serialId, dataProfileInfo);
4016 WaitFor(WAIT_TIME_SECOND_LONG);
4017 EXPECT_EQ(SUCCESS, ret);
4018 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_INIT_APN_INFO));
4019 }
4020
4021 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetInitApnInfo_V1_0200, Function | MediumTest | Level3)
4022 {
4023 if (!IsReady(SLOTID_2)) {
4024 return;
4025 }
4026 int32_t serialId = GetSerialId();
4027 DataProfileDataInfo dataProfileInfo;
4028 dataProfileInfo.profileId = 0;
4029 dataProfileInfo.password = "";
4030 dataProfileInfo.authenticationType = 0;
4031 dataProfileInfo.userName = "";
4032 dataProfileInfo.apn = "cmnet";
4033 dataProfileInfo.protocol = "IPV4V6";
4034 dataProfileInfo.roamingProtocol = "IPV4V6";
4035 dataProfileInfo.serial = serialId;
4036 int32_t ret = g_rilInterface->SetInitApnInfo(SLOTID_2, serialId, dataProfileInfo);
4037 WaitFor(WAIT_TIME_SECOND_LONG);
4038 EXPECT_EQ(SUCCESS, ret);
4039 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_INIT_APN_INFO));
4040 }
4041
4042 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkBandwidthInfo_V1_0100, Function | MediumTest | Level3)
4043 {
4044 if (!IsReady(SLOTID_1)) {
4045 return;
4046 }
4047 int32_t ret = g_rilInterface->GetLinkBandwidthInfo(SLOTID_1, GetSerialId(), CID);
4048 WaitFor(WAIT_TIME_SECOND);
4049 EXPECT_EQ(SUCCESS, ret);
4050 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO));
4051 }
4052
4053 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkBandwidthInfo_V1_0200, Function | MediumTest | Level3)
4054 {
4055 if (!IsReady(SLOTID_2)) {
4056 return;
4057 }
4058 int32_t ret = g_rilInterface->GetLinkBandwidthInfo(SLOTID_2, GetSerialId(), CID);
4059 WaitFor(WAIT_TIME_SECOND);
4060 EXPECT_EQ(SUCCESS, ret);
4061 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_GET_LINK_BANDWIDTH_INFO));
4062 }
4063
4064 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLinkBandwidthReportingRule_V1_0100, Function | MediumTest | Level3)
4065 {
4066 if (!IsReady(SLOTID_1)) {
4067 return;
4068 }
4069 int32_t serialId = GetSerialId();
4070 const int32_t BANDWIDTH_HYSTERESIS_MS = 3000;
4071 const int32_t BANDWIDTH_HYSTERESIS_KBPS = 50;
4072 const int32_t MAX_UPLINK_LINK_BANDWIDTH[] = { 100, 500, 1000, 5000, 10000, 20000, 50000, 100000, 200000 };
4073 uint32_t uplinkKbpsSize = sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4074 const int32_t MAX_DOWNLINK_LINK_BANDWIDTH[] = { 100, // VoIP
4075 500, // Web
4076 1000, // SD
4077 5000, // HD
4078 10000, // file
4079 20000, // 4K
4080 50000, // LTE
4081 100000,
4082 200000, // 5G
4083 500000, 1000000 };
4084 uint32_t downlinkKbpsSize = sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4085 DataLinkBandwidthReportingRule dLinkBandwidth;
4086 dLinkBandwidth.serial = serialId;
4087 dLinkBandwidth.rat = static_cast<int32_t>(RatType::NETWORK_TYPE_LTE);
4088 dLinkBandwidth.delayMs = BANDWIDTH_HYSTERESIS_MS;
4089 dLinkBandwidth.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4090 dLinkBandwidth.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4091 dLinkBandwidth.maximumUplinkKbpsSize = uplinkKbpsSize;
4092 dLinkBandwidth.maximumDownlinkKbpsSize = downlinkKbpsSize;
4093 for (uint32_t i = 0; i < uplinkKbpsSize; i++) {
4094 dLinkBandwidth.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
4095 }
4096 for (uint32_t i = 0; i < downlinkKbpsSize; i++) {
4097 dLinkBandwidth.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
4098 }
4099 int32_t ret = g_rilInterface->SetLinkBandwidthReportingRule(SLOTID_1, GetSerialId(), dLinkBandwidth);
4100 WaitFor(WAIT_TIME_SECOND);
4101 EXPECT_EQ(SUCCESS, ret);
4102 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE));
4103 }
4104
4105 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetLinkBandwidthReportingRule_V1_0200, Function | MediumTest | Level3)
4106 {
4107 if (!IsReady(SLOTID_2)) {
4108 return;
4109 }
4110 int32_t serialId = GetSerialId();
4111 const int32_t BANDWIDTH_HYSTERESIS_MS = 3000;
4112 const int32_t BANDWIDTH_HYSTERESIS_KBPS = 50;
4113 const int32_t MAX_UPLINK_LINK_BANDWIDTH[] = { 100, 500, 1000, 5000, 10000, 20000, 50000, 100000, 200000 };
4114 uint32_t uplinkKbpsSize = sizeof(MAX_UPLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4115 const int32_t MAX_DOWNLINK_LINK_BANDWIDTH[] = { 100, // VoIP
4116 500, // Web
4117 1000, // SD
4118 5000, // HD
4119 10000, // file
4120 20000, // 4K
4121 50000, // LTE
4122 100000,
4123 200000, // 5G
4124 500000, 1000000 };
4125 uint32_t downlinkKbpsSize = sizeof(MAX_DOWNLINK_LINK_BANDWIDTH) / sizeof(int32_t);
4126 DataLinkBandwidthReportingRule dLinkBandwidth;
4127 dLinkBandwidth.serial = serialId;
4128 dLinkBandwidth.rat = static_cast<int32_t>(RatType::NETWORK_TYPE_LTE);
4129 dLinkBandwidth.delayMs = BANDWIDTH_HYSTERESIS_MS;
4130 dLinkBandwidth.delayUplinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4131 dLinkBandwidth.delayDownlinkKbps = BANDWIDTH_HYSTERESIS_KBPS;
4132 dLinkBandwidth.maximumUplinkKbpsSize = uplinkKbpsSize;
4133 dLinkBandwidth.maximumDownlinkKbpsSize = downlinkKbpsSize;
4134 for (uint32_t i = 0; i < uplinkKbpsSize; i++) {
4135 dLinkBandwidth.maximumUplinkKbps.push_back(MAX_UPLINK_LINK_BANDWIDTH[i]);
4136 }
4137 for (uint32_t i = 0; i < downlinkKbpsSize; i++) {
4138 dLinkBandwidth.maximumDownlinkKbps.push_back(MAX_DOWNLINK_LINK_BANDWIDTH[i]);
4139 }
4140 int32_t ret = g_rilInterface->SetLinkBandwidthReportingRule(SLOTID_2, GetSerialId(), dLinkBandwidth);
4141 WaitFor(WAIT_TIME_SECOND);
4142 EXPECT_EQ(SUCCESS, ret);
4143 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_LINK_BANDWIDTH_REPORTING_RULE));
4144 }
4145
4146 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataPermitted_V1_0100, Function | MediumTest | Level3)
4147 {
4148 if (!IsReady(SLOTID_1)) {
4149 return;
4150 }
4151 int32_t ret = g_rilInterface->SetDataPermitted(SLOTID_1, GetSerialId(), 1);
4152 WaitFor(WAIT_TIME_SECOND);
4153 EXPECT_EQ(SUCCESS, ret);
4154 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PERMITTED));
4155 }
4156
4157 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataPermitted_V1_0200, Function | MediumTest | Level3)
4158 {
4159 if (!IsReady(SLOTID_2)) {
4160 return;
4161 }
4162 int32_t ret = g_rilInterface->SetDataPermitted(SLOTID_2, GetSerialId(), 1);
4163 WaitFor(WAIT_TIME_SECOND);
4164 EXPECT_EQ(SUCCESS, ret);
4165 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PERMITTED));
4166 }
4167
4168 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataProfileInfo_V1_0100, Function | MediumTest | Level3)
4169 {
4170 if (!IsReady(SLOTID_1)) {
4171 return;
4172 }
4173 int32_t serialId = GetSerialId();
4174 DataProfilesInfo dataProfilesInfo;
4175 dataProfilesInfo.serial = serialId;
4176 dataProfilesInfo.profilesSize = 1;
4177 DataProfileDataInfo dataProfileInfo;
4178 dataProfileInfo.profileId = 0;
4179 dataProfileInfo.password = "";
4180 dataProfileInfo.authenticationType = 0;
4181 dataProfileInfo.userName = "";
4182 dataProfileInfo.apn = "cmnet";
4183 dataProfileInfo.protocol = "IPV4V6";
4184 dataProfileInfo.roamingProtocol = "IPV4V6";
4185 dataProfileInfo.serial = serialId;
4186 dataProfilesInfo.profiles.push_back(dataProfileInfo);
4187 int32_t ret = g_rilInterface->SetDataProfileInfo(SLOTID_1, serialId, dataProfilesInfo);
4188 WaitFor(WAIT_TIME_SECOND_LONG);
4189 EXPECT_EQ(SUCCESS, ret);
4190 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO));
4191 }
4192
4193 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetDataProfileInfo_V1_0200, Function | MediumTest | Level3)
4194 {
4195 if (!IsReady(SLOTID_2)) {
4196 return;
4197 }
4198 int32_t serialId = GetSerialId();
4199 DataProfilesInfo dataProfilesInfo;
4200 dataProfilesInfo.serial = serialId;
4201 dataProfilesInfo.profilesSize = 1;
4202 DataProfileDataInfo dataProfileInfo;
4203 dataProfileInfo.profileId = 0;
4204 dataProfileInfo.password = "";
4205 dataProfileInfo.authenticationType = 0;
4206 dataProfileInfo.userName = "";
4207 dataProfileInfo.apn = "cmnet";
4208 dataProfileInfo.protocol = "IPV4V6";
4209 dataProfileInfo.roamingProtocol = "IPV4V6";
4210 dataProfileInfo.serial = serialId;
4211 dataProfilesInfo.profiles.push_back(dataProfileInfo);
4212 int32_t ret = g_rilInterface->SetDataProfileInfo(SLOTID_2, serialId, dataProfilesInfo);
4213 WaitFor(WAIT_TIME_SECOND_LONG);
4214 EXPECT_EQ(SUCCESS, ret);
4215 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_DATA_SET_DATA_PROFILE_INFO));
4216 }
4217
4218 // SIM
4219 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimIO_V1_0100, Function | MediumTest | Level3)
4220 {
4221 if (!IsReady(SLOTID_1)) {
4222 return;
4223 }
4224 SimIoRequestInfo msg;
4225 msg.command = 0xc0;
4226 msg.fileId = 0x2FE2;
4227 msg.p1 = 0;
4228 msg.p2 = 0;
4229 msg.p3 = 15;
4230 msg.data = "";
4231 msg.path = "3F00";
4232 msg.pin2 = "";
4233 int32_t ret = g_rilInterface->GetSimIO(SLOTID_1, GetSerialId(), msg);
4234 WaitFor(WAIT_TIME_SECOND);
4235 EXPECT_EQ(SUCCESS, ret);
4236 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
4237 }
4238
4239 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimIO_V1_0200, Function | MediumTest | Level3)
4240 {
4241 if (!IsReady(SLOTID_2)) {
4242 return;
4243 }
4244 SimIoRequestInfo msg;
4245 msg.command = 0xC0;
4246 // ICCID
4247 msg.fileId = 0x2FE2;
4248 msg.p1 = 0;
4249 msg.p2 = 0;
4250 msg.p3 = 15;
4251 msg.data = "";
4252 msg.path = "3F00";
4253 msg.pin2 = "";
4254 int32_t ret = g_rilInterface->GetSimIO(SLOTID_2, GetSerialId(), msg);
4255 WaitFor(WAIT_TIME_SECOND);
4256 EXPECT_EQ(SUCCESS, ret);
4257 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_IO));
4258 }
4259
4260 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImsi_V1_0100, Function | MediumTest | Level3)
4261 {
4262 if (!IsReady(SLOTID_1)) {
4263 return;
4264 }
4265 int32_t ret = g_rilInterface->GetImsi(SLOTID_1, GetSerialId());
4266 WaitFor(WAIT_TIME_SECOND);
4267 EXPECT_EQ(SUCCESS, ret);
4268 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
4269 }
4270
4271 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetImsi_V1_0200, Function | MediumTest | Level3)
4272 {
4273 if (!IsReady(SLOTID_2)) {
4274 return;
4275 }
4276 int32_t ret = g_rilInterface->GetImsi(SLOTID_2, GetSerialId());
4277 WaitFor(WAIT_TIME_SECOND);
4278 EXPECT_EQ(SUCCESS, ret);
4279 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_IMSI));
4280 }
4281
4282 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetActiveSim_V1_0100, Function | MediumTest | Level3)
4283 {
4284 if (!IsReady(SLOTID_1)) {
4285 return;
4286 }
4287 int32_t enable = 1;
4288 int32_t index = 1; // ENTITY_CARD
4289 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_1, GetSerialId(), index, enable);
4290 WaitFor(WAIT_TIME_SECOND);
4291 EXPECT_EQ(SUCCESS, ret);
4292 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
4293 }
4294
4295 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetActiveSim_V1_0200, Function | MediumTest | Level3)
4296 {
4297 if (!IsReady(SLOTID_2)) {
4298 return;
4299 }
4300 int32_t enable = 1;
4301 int32_t index = 1; // ENTITY_CARD
4302 int32_t ret = g_rilInterface->SetActiveSim(SLOTID_2, GetSerialId(), index, enable);
4303 WaitFor(WAIT_TIME_SECOND);
4304 EXPECT_EQ(SUCCESS, ret);
4305 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_ACTIVE_SIM));
4306 }
4307
4308 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0100, Function | MediumTest | Level3)
4309 {
4310 if (!IsReady(SLOTID_1)) {
4311 return;
4312 }
4313 std::string cmd = "send terminal response";
4314 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_1, GetSerialId(), cmd);
4315 WaitFor(WAIT_TIME_SECOND);
4316 EXPECT_EQ(SUCCESS, ret);
4317 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
4318 }
4319
4320 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendTerminalResponse_V1_0200, Function | MediumTest | Level3)
4321 {
4322 if (!IsReady(SLOTID_2)) {
4323 return;
4324 }
4325 std::string cmd = "send terminal response";
4326 int32_t ret = g_rilInterface->SimStkSendTerminalResponse(SLOTID_2, GetSerialId(), cmd);
4327 WaitFor(WAIT_TIME_SECOND);
4328 EXPECT_EQ(SUCCESS, ret);
4329 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_TERMINAL_RESPONSE));
4330 }
4331
4332 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0100, Function | MediumTest | Level3)
4333 {
4334 if (!IsReady(SLOTID_1)) {
4335 return;
4336 }
4337 std::string cmd = "send envelope";
4338 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_1, GetSerialId(), cmd);
4339 WaitFor(WAIT_TIME_SECOND);
4340 EXPECT_EQ(SUCCESS, ret);
4341 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
4342 }
4343
4344 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendEnvelope_V1_0200, Function | MediumTest | Level3)
4345 {
4346 if (!IsReady(SLOTID_2)) {
4347 return;
4348 }
4349 std::string cmd = "send envelope";
4350 int32_t ret = g_rilInterface->SimStkSendEnvelope(SLOTID_2, GetSerialId(), cmd);
4351 WaitFor(WAIT_TIME_SECOND);
4352 EXPECT_EQ(SUCCESS, ret);
4353 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_ENVELOPE));
4354 }
4355
4356 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0100, Function | MediumTest | Level3)
4357 {
4358 if (!IsReady(SLOTID_1)) {
4359 return;
4360 }
4361 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_1, GetSerialId(), true);
4362 WaitFor(WAIT_TIME_SECOND);
4363 EXPECT_EQ(SUCCESS, ret);
4364 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
4365 }
4366
4367 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkSendCallSetupRequestResult_V1_0200, Function | MediumTest | Level3)
4368 {
4369 if (!IsReady(SLOTID_2)) {
4370 return;
4371 }
4372 int32_t ret = g_rilInterface->SimStkSendCallSetupRequestResult(SLOTID_2, GetSerialId(), true);
4373 WaitFor(WAIT_TIME_SECOND);
4374 EXPECT_EQ(SUCCESS, ret);
4375 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT));
4376 }
4377
4378 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkIsReady_V1_0100, Function | MediumTest | Level3)
4379 {
4380 if (!IsReady(SLOTID_1)) {
4381 return;
4382 }
4383 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_1, GetSerialId());
4384 WaitFor(WAIT_TIME_SECOND);
4385 EXPECT_EQ(SUCCESS, ret);
4386 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
4387 }
4388
4389 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimStkIsReady_V1_0200, Function | MediumTest | Level3)
4390 {
4391 if (!IsReady(SLOTID_2)) {
4392 return;
4393 }
4394 int32_t ret = g_rilInterface->SimStkIsReady(SLOTID_2, GetSerialId());
4395 WaitFor(WAIT_TIME_SECOND);
4396 EXPECT_EQ(SUCCESS, ret);
4397 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_STK_IS_READY));
4398 }
4399
4400 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioProtocol_V1_0100, Function | MediumTest | Level3)
4401 {
4402 if (!IsReady(SLOTID_1)) {
4403 return;
4404 }
4405 RadioProtocol protocol;
4406 protocol.slotId = SLOTID_1;
4407 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_1, GetSerialId(), protocol);
4408 WaitFor(WAIT_TIME_SECOND);
4409 EXPECT_EQ(SUCCESS, ret);
4410 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
4411 }
4412
4413 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetRadioProtocol_V1_0200, Function | MediumTest | Level3)
4414 {
4415 if (!IsReady(SLOTID_2)) {
4416 return;
4417 }
4418 RadioProtocol protocol;
4419 protocol.slotId = SLOTID_2;
4420 int32_t ret = g_rilInterface->SetRadioProtocol(SLOTID_2, GetSerialId(), protocol);
4421 WaitFor(WAIT_TIME_SECOND);
4422 EXPECT_EQ(SUCCESS, ret);
4423 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_RADIO_PROTOCOL));
4424 }
4425
4426 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0100, Function | MediumTest | Level3)
4427 {
4428 if (!IsReady(SLOTID_1)) {
4429 return;
4430 }
4431 std::string appID = "A00000015141434C00"; // ARAM_AID
4432 int32_t p2 = 0;
4433 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_1, GetSerialId(), appID, p2);
4434 WaitFor(WAIT_TIME_SECOND);
4435 EXPECT_EQ(SUCCESS, ret);
4436 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
4437 }
4438
4439 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0100, Function | MediumTest | Level3)
4440 {
4441 if (!IsReady(SLOTID_1)) {
4442 return;
4443 }
4444 ApduSimIORequestInfo reqInfo;
4445 reqInfo.channelId = currentChannelId_;
4446 reqInfo.type = 0x80; // CLA
4447 reqInfo.instruction = 0xCA; // COMMAND;
4448 reqInfo.p1 = 0xFF;
4449 reqInfo.p2 = 0x40;
4450 reqInfo.p3 = 0x00;
4451 reqInfo.data = "";
4452 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_1, GetSerialId(), reqInfo);
4453 WaitFor(WAIT_TIME_SECOND);
4454 EXPECT_EQ(SUCCESS, ret);
4455 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
4456 }
4457
4458 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0100, Function | MediumTest | Level3)
4459 {
4460 if (!IsReady(SLOTID_1)) {
4461 return;
4462 }
4463 int32_t ret = g_rilInterface->SimCloseLogicalChannel(SLOTID_1, GetSerialId(), currentChannelId_);
4464 WaitFor(WAIT_TIME_SECOND);
4465 EXPECT_EQ(SUCCESS, ret);
4466 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
4467 }
4468
4469 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimOpenLogicalChannel_V1_0200, Function | MediumTest | Level3)
4470 {
4471 if (!IsReady(SLOTID_2)) {
4472 return;
4473 }
4474 std::string appID = "A00000015141434C00"; // ARAM_AID
4475 int32_t p2 = 0;
4476 int32_t ret = g_rilInterface->SimOpenLogicalChannel(SLOTID_2, GetSerialId(), appID, p2);
4477 WaitFor(WAIT_TIME_SECOND);
4478 EXPECT_EQ(SUCCESS, ret);
4479 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_OPEN_LOGICAL_CHANNEL));
4480 }
4481
4482 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduLogicalChannel_V1_0200, Function | MediumTest | Level3)
4483 {
4484 if (!IsReady(SLOTID_2)) {
4485 return;
4486 }
4487 ApduSimIORequestInfo reqInfo;
4488 reqInfo.channelId = currentChannelId_;
4489 reqInfo.type = 0x80; // CLA
4490 reqInfo.instruction = 0xCA; // COMMAND;
4491 reqInfo.p1 = 0xFF;
4492 reqInfo.p2 = 0x40;
4493 reqInfo.p3 = 0x00;
4494 reqInfo.data = "";
4495 int32_t ret = g_rilInterface->SimTransmitApduLogicalChannel(SLOTID_2, GetSerialId(), reqInfo);
4496 WaitFor(WAIT_TIME_SECOND);
4497 EXPECT_EQ(SUCCESS, ret);
4498 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL));
4499 }
4500
4501 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimCloseLogicalChannel_V1_0200, Function | MediumTest | Level3)
4502 {
4503 if (!IsReady(SLOTID_2)) {
4504 return;
4505 }
4506 int32_t ret = g_rilInterface->SimCloseLogicalChannel(SLOTID_2, GetSerialId(), currentChannelId_);
4507 WaitFor(WAIT_TIME_SECOND);
4508 EXPECT_EQ(SUCCESS, ret);
4509 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CLOSE_LOGICAL_CHANNEL));
4510 }
4511
4512 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0100, Function | MediumTest | Level3)
4513 {
4514 if (!IsReady(SLOTID_1)) {
4515 return;
4516 }
4517 ApduSimIORequestInfo reqInfo;
4518 reqInfo.type = 0x80; // CLA
4519 reqInfo.instruction = 0xCA; // COMMAND;
4520 reqInfo.p1 = 0xFF;
4521 reqInfo.p2 = 0x40;
4522 reqInfo.p3 = 0x00;
4523 reqInfo.data = "";
4524 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_1, GetSerialId(), reqInfo);
4525 WaitFor(WAIT_TIME_SECOND);
4526 EXPECT_EQ(SUCCESS, ret);
4527 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
4528 }
4529
4530 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimTransmitApduBasicChannel_V1_0200, Function | MediumTest | Level3)
4531 {
4532 if (!IsReady(SLOTID_2)) {
4533 return;
4534 }
4535 ApduSimIORequestInfo reqInfo;
4536 reqInfo.type = 0x80; // CLA
4537 reqInfo.instruction = 0xCA; // COMMAND;
4538 reqInfo.p1 = 0xFF;
4539 reqInfo.p2 = 0x40;
4540 reqInfo.p3 = 0x00;
4541 reqInfo.data = "";
4542 int32_t ret = g_rilInterface->SimTransmitApduBasicChannel(SLOTID_2, GetSerialId(), reqInfo);
4543 WaitFor(WAIT_TIME_SECOND);
4544 EXPECT_EQ(SUCCESS, ret);
4545 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL));
4546 }
4547
4548 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimAuthentication_V1_0100, Function | MediumTest | Level3)
4549 {
4550 if (!IsReady(SLOTID_1)) {
4551 return;
4552 }
4553 SimAuthenticationRequestInfo simAuthInfo;
4554 simAuthInfo.aid = "aid";
4555 simAuthInfo.authData = "authData";
4556 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_1, GetSerialId(), simAuthInfo);
4557 WaitFor(WAIT_TIME_SECOND);
4558 EXPECT_EQ(SUCCESS, ret);
4559 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
4560 }
4561
4562 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SimAuthentication_V1_0200, Function | MediumTest | Level3)
4563 {
4564 if (!IsReady(SLOTID_2)) {
4565 return;
4566 }
4567 SimAuthenticationRequestInfo simAuthInfo;
4568 simAuthInfo.aid = "aid";
4569 simAuthInfo.authData = "authData";
4570 int32_t ret = g_rilInterface->SimAuthentication(SLOTID_2, GetSerialId(), simAuthInfo);
4571 WaitFor(WAIT_TIME_SECOND);
4572 EXPECT_EQ(SUCCESS, ret);
4573 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_AUTHENTICATION));
4574 }
4575
4576 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimLockStatus_V1_0100, Function | MediumTest | Level3)
4577 {
4578 #ifdef TEL_TEST_PIN_PUK
4579 if (!IsReady(SLOTID_1)) {
4580 return;
4581 }
4582 SimLockInfo simLockInfo;
4583 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4584 simLockInfo.mode = 2; // MODE
4585 simLockInfo.classx = 0;
4586 constexpr const char *FAC_PIN_LOCK = "SC";
4587 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_1, GetSerialId(), simLockInfo);
4588 WaitFor(WAIT_TIME_SECOND);
4589 EXPECT_EQ(SUCCESS, ret);
4590 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
4591 #endif
4592 ASSERT_TRUE(true);
4593 }
4594
4595 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSimLockStatus_V1_0200, Function | MediumTest | Level3)
4596 {
4597 #ifdef TEL_TEST_PIN_PUK
4598 if (!IsReady(SLOTID_2)) {
4599 return;
4600 }
4601 SimLockInfo simLockInfo;
4602 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4603 simLockInfo.mode = 2; // MODE
4604 simLockInfo.classx = 0;
4605 constexpr const char *FAC_PIN_LOCK = "SC";
4606 int32_t ret = g_rilInterface->GetSimLockStatus(SLOTID_2, GetSerialId(), simLockInfo);
4607 WaitFor(WAIT_TIME_SECOND);
4608 EXPECT_EQ(SUCCESS, ret);
4609 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_GET_SIM_LOCK_STATUS));
4610 #endif
4611 ASSERT_TRUE(true);
4612 }
4613
4614 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSimLock_V1_0100, Function | MediumTest | Level3)
4615 {
4616 #ifdef TEL_TEST_PIN_PUK
4617 if (!IsReady(SLOTID_1)) {
4618 return;
4619 }
4620 SimLockInfo simLockInfo;
4621 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4622 simLockInfo.mode = 2; // MODE
4623 simLockInfo.classx = 0;
4624 simLockInfo.passwd = "1234";
4625 constexpr const char *FAC_PIN_LOCK = "SC";
4626 int32_t ret = g_rilInterface->SetSimLock(SLOTID_1, GetSerialId(), simLockInfo);
4627 WaitFor(WAIT_TIME_SECOND);
4628 EXPECT_EQ(SUCCESS, ret);
4629 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
4630 #endif
4631 ASSERT_TRUE(true);
4632 }
4633
4634 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSimLock_V1_0200, Function | MediumTest | Level3)
4635 {
4636 #ifdef TEL_TEST_PIN_PUK
4637 if (!IsReady(SLOTID_2)) {
4638 return;
4639 }
4640 SimLockInfo simLockInfo;
4641 simLockInfo.fac = "SC"; // FAC_PIN_LOCK
4642 simLockInfo.mode = 2; // MODE
4643 simLockInfo.classx = 0;
4644 simLockInfo.passwd = "1234";
4645 constexpr const char *FAC_PIN_LOCK = "SC";
4646 int32_t ret = g_rilInterface->SetSimLock(SLOTID_2, GetSerialId(), simLockInfo);
4647 WaitFor(WAIT_TIME_SECOND);
4648 EXPECT_EQ(SUCCESS, ret);
4649 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_SET_SIM_LOCK));
4650 #endif
4651 ASSERT_TRUE(true);
4652 }
4653
4654 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ChangeSimPassword_V1_0100, Function | MediumTest | Level3)
4655 {
4656 #ifdef TEL_TEST_PIN_PUK
4657 if (!IsReady(SLOTID_1)) {
4658 return;
4659 }
4660 ISimPasswordInfo simPassword;
4661 simPassword.fac = "SC"; // FAC_PIN_LOCK
4662 simPassword.oldPassword = "1234";
4663 simPassword.newPassword = "1234";
4664 simPassword.passwordLength = 4;
4665 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_1, GetSerialId(), simPassword);
4666 WaitFor(WAIT_TIME_SECOND);
4667 EXPECT_EQ(SUCCESS, ret);
4668 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
4669 #endif
4670 ASSERT_TRUE(true);
4671 }
4672
4673 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_ChangeSimPassword_V1_0200, Function | MediumTest | Level3)
4674 {
4675 #ifdef TEL_TEST_PIN_PUK
4676 if (!IsReady(SLOTID_2)) {
4677 return;
4678 }
4679 ISimPasswordInfo simPassword;
4680 simPassword.fac = "SC"; // FAC_PIN_LOCK
4681 simPassword.oldPassword = "1234";
4682 simPassword.newPassword = "1234";
4683 simPassword.passwordLength = 4;
4684 int32_t ret = g_rilInterface->ChangeSimPassword(SLOTID_2, GetSerialId(), simPassword);
4685 WaitFor(WAIT_TIME_SECOND);
4686 EXPECT_EQ(SUCCESS, ret);
4687 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_CHANGE_SIM_PASSWORD));
4688 #endif
4689 ASSERT_TRUE(true);
4690 }
4691
4692 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin_V1_0100, Function | MediumTest | Level3)
4693 {
4694 #ifdef TEL_TEST_PIN_PUK
4695 if (!IsReady(SLOTID_1)) {
4696 return;
4697 }
4698 std::string pin = "1234";
4699 int32_t ret = g_rilInterface->UnlockPin(SLOTID_1, GetSerialId(), pin);
4700 WaitFor(WAIT_TIME_SECOND);
4701 EXPECT_EQ(SUCCESS, ret);
4702 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
4703 #endif
4704 ASSERT_TRUE(true);
4705 }
4706
4707 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin_V1_0200, Function | MediumTest | Level3)
4708 {
4709 #ifdef TEL_TEST_PIN_PUK
4710 if (!IsReady(SLOTID_2)) {
4711 return;
4712 }
4713 std::string pin = "1234";
4714 int32_t ret = g_rilInterface->UnlockPin(SLOTID_2, GetSerialId(), pin);
4715 WaitFor(WAIT_TIME_SECOND);
4716 EXPECT_EQ(SUCCESS, ret);
4717 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN));
4718 #endif
4719 ASSERT_TRUE(true);
4720 }
4721
4722 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk_V1_0100, Function | MediumTest | Level3)
4723 {
4724 #ifdef TEL_TEST_PIN_PUK
4725 if (!IsReady(SLOTID_1)) {
4726 return;
4727 }
4728 std::string puk = "42014264";
4729 std::string pin = "1234";
4730 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_1, GetSerialId(), puk, pin);
4731 WaitFor(WAIT_TIME_SECOND);
4732 EXPECT_EQ(SUCCESS, ret);
4733 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
4734 #endif
4735 ASSERT_TRUE(true);
4736 }
4737
4738 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk_V1_0200, Function | MediumTest | Level3)
4739 {
4740 #ifdef TEL_TEST_PIN_PUK
4741 if (!IsReady(SLOTID_2)) {
4742 return;
4743 }
4744 std::string puk = "42014264";
4745 std::string pin = "1234";
4746 int32_t ret = g_rilInterface->UnlockPuk(SLOTID_2, GetSerialId(), puk, pin);
4747 WaitFor(WAIT_TIME_SECOND);
4748 EXPECT_EQ(SUCCESS, ret);
4749 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK));
4750 #endif
4751 ASSERT_TRUE(true);
4752 }
4753
4754 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin2_V1_0100, Function | MediumTest | Level3)
4755 {
4756 #ifdef TEL_TEST_PIN_PUK
4757 if (!IsReady(SLOTID_1)) {
4758 return;
4759 }
4760 std::string pin2 = "1234";
4761 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_1, GetSerialId(), pin2);
4762 WaitFor(WAIT_TIME_SECOND);
4763 EXPECT_EQ(SUCCESS, ret);
4764 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
4765 #endif
4766 ASSERT_TRUE(true);
4767 }
4768
4769 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPin2_V1_0200, Function | MediumTest | Level3)
4770 {
4771 #ifdef TEL_TEST_PIN_PUK
4772 if (!IsReady(SLOTID_2)) {
4773 return;
4774 }
4775 std::string pin2 = "1234";
4776 int32_t ret = g_rilInterface->UnlockPin2(SLOTID_2, GetSerialId(), pin2);
4777 WaitFor(WAIT_TIME_SECOND);
4778 EXPECT_EQ(SUCCESS, ret);
4779 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PIN2));
4780 #endif
4781 ASSERT_TRUE(true);
4782 }
4783
4784 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk2_V1_0100, Function | MediumTest | Level3)
4785 {
4786 #ifdef TEL_TEST_PIN_PUK
4787 if (!IsReady(SLOTID_1)) {
4788 return;
4789 }
4790 std::string puk2 = "42014264";
4791 std::string pin2 = "1234";
4792 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_1, GetSerialId(), puk2, pin2);
4793 WaitFor(WAIT_TIME_SECOND);
4794 EXPECT_EQ(SUCCESS, ret);
4795 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
4796 #endif
4797 ASSERT_TRUE(true);
4798 }
4799
4800 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockPuk2_V1_0200, Function | MediumTest | Level3)
4801 {
4802 #ifdef TEL_TEST_PIN_PUK
4803 if (!IsReady(SLOTID_2)) {
4804 return;
4805 }
4806 std::string puk2 = "42014264";
4807 std::string pin2 = "1234";
4808 int32_t ret = g_rilInterface->UnlockPuk2(SLOTID_2, GetSerialId(), puk2, pin2);
4809 WaitFor(WAIT_TIME_SECOND);
4810 EXPECT_EQ(SUCCESS, ret);
4811 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_PUK2));
4812 #endif
4813 ASSERT_TRUE(true);
4814 }
4815
4816 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockSimLock_V1_0100, Function | MediumTest | Level3)
4817 {
4818 #ifdef TEL_TEST_PIN_PUK
4819 if (!IsReady(SLOTID_1)) {
4820 return;
4821 }
4822 int32_t lockType = 0;
4823 std::string key = "1234"; // PN_PIN_LOCK
4824 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_1, GetSerialId(), lockType, key);
4825 WaitFor(WAIT_TIME_SECOND);
4826 EXPECT_EQ(SUCCESS, ret);
4827 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
4828 #endif
4829 ASSERT_TRUE(true);
4830 }
4831
4832 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UnlockSimLock_V1_0200, Function | MediumTest | Level3)
4833 {
4834 #ifdef TEL_TEST_PIN_PUK
4835 if (!IsReady(SLOTID_2)) {
4836 return;
4837 }
4838 int32_t lockType = 0;
4839 std::string key = "1234"; // PN_PIN_LOCK
4840 int32_t ret = g_rilInterface->UnlockSimLock(SLOTID_2, GetSerialId(), lockType, key);
4841 WaitFor(WAIT_TIME_SECOND);
4842 EXPECT_EQ(SUCCESS, ret);
4843 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SIM_UNLOCK_SIM_LOCK));
4844 #endif
4845 ASSERT_TRUE(true);
4846 }
4847
4848 // Sms
4849 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddSimMessage_V1_0100, Function | MediumTest | Level3)
4850 {
4851 if (!IsReady(SLOTID_1)) {
4852 return;
4853 }
4854 SmsMessageIOInfo msgIoInfo;
4855 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4856 msgIoInfo.pdu = TEST_STORAGE_PDU;
4857 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4858 int32_t ret = g_rilInterface->AddSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4859 WaitFor(WAIT_TIME_SECOND_LONG);
4860 EXPECT_EQ(SUCCESS, ret);
4861 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_SIM_MESSAGE));
4862 }
4863
4864 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddSimMessage_V1_0200, Function | MediumTest | Level3)
4865 {
4866 if (!IsReady(SLOTID_2)) {
4867 return;
4868 }
4869 SmsMessageIOInfo msgIoInfo;
4870 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4871 msgIoInfo.pdu = TEST_STORAGE_PDU;
4872 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4873 int32_t ret = g_rilInterface->AddSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4874 WaitFor(WAIT_TIME_SECOND_LONG);
4875 EXPECT_EQ(SUCCESS, ret);
4876 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_SIM_MESSAGE));
4877 }
4878
4879 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateSimMessage_V1_0100, Function | MediumTest | Level3)
4880 {
4881 if (!IsReady(SLOTID_1)) {
4882 return;
4883 }
4884 SmsMessageIOInfo msgIoInfo;
4885 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4886 msgIoInfo.pdu = TEST_STORAGE_PDU;
4887 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4888 msgIoInfo.index = 0;
4889 int32_t ret = g_rilInterface->UpdateSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4890 WaitFor(WAIT_TIME_SECOND_LONG);
4891 EXPECT_EQ(SUCCESS, ret);
4892 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE));
4893 }
4894
4895 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateSimMessage_V1_0200, Function | MediumTest | Level3)
4896 {
4897 if (!IsReady(SLOTID_2)) {
4898 return;
4899 }
4900 SmsMessageIOInfo msgIoInfo;
4901 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4902 msgIoInfo.pdu = TEST_STORAGE_PDU;
4903 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4904 msgIoInfo.index = 0;
4905 int32_t ret = g_rilInterface->UpdateSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4906 WaitFor(WAIT_TIME_SECOND_LONG);
4907 EXPECT_EQ(SUCCESS, ret);
4908 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_SIM_MESSAGE));
4909 }
4910
4911 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelSimMessage_V1_0100, Function | MediumTest | Level3)
4912 {
4913 if (!IsReady(SLOTID_1)) {
4914 return;
4915 }
4916 int32_t index = 0;
4917 int32_t ret = g_rilInterface->DelSimMessage(SLOTID_1, GetSerialId(), index);
4918 WaitFor(WAIT_TIME_SECOND_LONG);
4919 EXPECT_EQ(SUCCESS, ret);
4920 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_SIM_MESSAGE));
4921 }
4922
4923 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelSimMessage_V1_0200, Function | MediumTest | Level3)
4924 {
4925 if (!IsReady(SLOTID_2)) {
4926 return;
4927 }
4928 int32_t index = 0;
4929 int32_t ret = g_rilInterface->DelSimMessage(SLOTID_2, GetSerialId(), index);
4930 WaitFor(WAIT_TIME_SECOND_LONG);
4931 EXPECT_EQ(SUCCESS, ret);
4932 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_SIM_MESSAGE));
4933 }
4934
4935 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
4936 {
4937 if (!IsReady(SLOTID_1)) {
4938 return;
4939 }
4940 SmsMessageIOInfo msgIoInfo;
4941 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4942 msgIoInfo.pdu = TEST_STORAGE_PDU;
4943 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4944 int32_t ret = g_rilInterface->AddCdmaSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4945 WaitFor(WAIT_TIME_SECOND_LONG);
4946 EXPECT_EQ(SUCCESS, ret);
4947 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE));
4948 }
4949
4950 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_AddCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
4951 {
4952 if (!IsReady(SLOTID_2)) {
4953 return;
4954 }
4955 SmsMessageIOInfo msgIoInfo;
4956 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4957 msgIoInfo.pdu = TEST_STORAGE_PDU;
4958 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4959 int32_t ret = g_rilInterface->AddCdmaSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4960 WaitFor(WAIT_TIME_SECOND_LONG);
4961 EXPECT_EQ(SUCCESS, ret);
4962 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_ADD_CDMA_SIM_MESSAGE));
4963 }
4964
4965 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
4966 {
4967 if (!IsReady(SLOTID_1)) {
4968 return;
4969 }
4970 SmsMessageIOInfo msgIoInfo;
4971 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4972 msgIoInfo.pdu = TEST_STORAGE_PDU;
4973 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4974 msgIoInfo.index = 0;
4975 int32_t ret = g_rilInterface->UpdateCdmaSimMessage(SLOTID_1, GetSerialId(), msgIoInfo);
4976 WaitFor(WAIT_TIME_SECOND_LONG);
4977 EXPECT_EQ(SUCCESS, ret);
4978 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE));
4979 }
4980
4981 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_UpdateCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
4982 {
4983 if (!IsReady(SLOTID_2)) {
4984 return;
4985 }
4986 SmsMessageIOInfo msgIoInfo;
4987 msgIoInfo.smscPdu = TEST_SMSC_PDU;
4988 msgIoInfo.pdu = TEST_STORAGE_PDU;
4989 msgIoInfo.state = static_cast<int32_t>(SimMessageStatus::SIM_MESSAGE_STATUS_SENT);
4990 msgIoInfo.index = 0;
4991 int32_t ret = g_rilInterface->UpdateCdmaSimMessage(SLOTID_2, GetSerialId(), msgIoInfo);
4992 WaitFor(WAIT_TIME_SECOND_LONG);
4993 EXPECT_EQ(SUCCESS, ret);
4994 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_UPDATE_CDMA_SIM_MESSAGE));
4995 }
4996
4997 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelCdmaSimMessage_V1_0100, Function | MediumTest | Level3)
4998 {
4999 if (!IsReady(SLOTID_1)) {
5000 return;
5001 }
5002 int32_t index = 0;
5003 int32_t ret = g_rilInterface->DelCdmaSimMessage(SLOTID_1, GetSerialId(), index);
5004 WaitFor(WAIT_TIME_SECOND_LONG);
5005 EXPECT_EQ(SUCCESS, ret);
5006 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE));
5007 }
5008
5009 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_DelCdmaSimMessage_V1_0200, Function | MediumTest | Level3)
5010 {
5011 if (!IsReady(SLOTID_2)) {
5012 return;
5013 }
5014 int32_t index = 0;
5015 int32_t ret = g_rilInterface->DelCdmaSimMessage(SLOTID_2, GetSerialId(), index);
5016 WaitFor(WAIT_TIME_SECOND_LONG);
5017 EXPECT_EQ(SUCCESS, ret);
5018 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_DEL_CDMA_SIM_MESSAGE));
5019 }
5020
5021 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSmscAddr_V1_0100, Function | MediumTest | Level3)
5022 {
5023 if (!IsReady(SLOTID_1)) {
5024 return;
5025 }
5026 ServiceCenterAddress address;
5027 address.address = TEST_SMSC_ADDR;
5028 address.tosca = TEST_TOSCA;
5029 int32_t ret = g_rilInterface->SetSmscAddr(SLOTID_1, GetSerialId(), address);
5030 WaitFor(WAIT_TIME_SECOND_LONG);
5031 EXPECT_EQ(SUCCESS, ret);
5032 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_SMSC_ADDR));
5033 }
5034
5035 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetSmscAddr_V1_0200, Function | MediumTest | Level3)
5036 {
5037 if (!IsReady(SLOTID_2)) {
5038 return;
5039 }
5040 ServiceCenterAddress address;
5041 address.address = TEST_SMSC_ADDR;
5042 address.tosca = TEST_TOSCA;
5043 int32_t ret = g_rilInterface->SetSmscAddr(SLOTID_2, GetSerialId(), address);
5044 WaitFor(WAIT_TIME_SECOND_LONG);
5045 EXPECT_EQ(SUCCESS, ret);
5046 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_SMSC_ADDR));
5047 }
5048
5049 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSmscAddr_V1_0100, Function | MediumTest | Level3)
5050 {
5051 if (!IsReady(SLOTID_1)) {
5052 return;
5053 }
5054 int32_t ret = g_rilInterface->GetSmscAddr(SLOTID_1, GetSerialId());
5055 WaitFor(WAIT_TIME_SECOND_LONG);
5056 EXPECT_EQ(SUCCESS, ret);
5057 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_SMSC_ADDR));
5058 }
5059
5060 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetSmscAddr_V1_0200, Function | MediumTest | Level3)
5061 {
5062 if (!IsReady(SLOTID_2)) {
5063 return;
5064 }
5065 int32_t ret = g_rilInterface->GetSmscAddr(SLOTID_2, GetSerialId());
5066 WaitFor(WAIT_TIME_SECOND_LONG);
5067 EXPECT_EQ(SUCCESS, ret);
5068 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_SMSC_ADDR));
5069 }
5070
5071 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCBConfig_V1_0100, Function | MediumTest | Level3)
5072 {
5073 if (!IsReady(SLOTID_1)) {
5074 return;
5075 }
5076 int32_t GSM_TYPE = 1;
5077 CBConfigInfo info;
5078 info.mode = GSM_TYPE;
5079 info.mids = TEST_ID_LIST;
5080 info.dcss = TEST_DCS_LIST;
5081 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_1, GetSerialId(), info);
5082 WaitFor(WAIT_TIME_SECOND_LONG);
5083 EXPECT_EQ(SUCCESS, ret);
5084 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CB_CONFIG));
5085 }
5086
5087 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCBConfig_V1_0200, Function | MediumTest | Level3)
5088 {
5089 if (!IsReady(SLOTID_2)) {
5090 return;
5091 }
5092 int32_t GSM_TYPE = 1;
5093 CBConfigInfo info;
5094 info.mode = GSM_TYPE;
5095 info.mids = TEST_ID_LIST;
5096 info.dcss = TEST_DCS_LIST;
5097 int32_t ret = g_rilInterface->SetCBConfig(SLOTID_2, GetSerialId(), info);
5098 WaitFor(WAIT_TIME_SECOND_LONG);
5099 EXPECT_EQ(SUCCESS, ret);
5100 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CB_CONFIG));
5101 }
5102
5103 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCBConfig_V1_0100, Function | MediumTest | Level3)
5104 {
5105 if (!IsReady(SLOTID_1)) {
5106 return;
5107 }
5108 int32_t ret = g_rilInterface->GetCBConfig(SLOTID_1, GetSerialId());
5109 WaitFor(WAIT_TIME_SECOND_LONG);
5110 EXPECT_EQ(SUCCESS, ret);
5111 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CB_CONFIG));
5112 }
5113
5114 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCBConfig_V1_0200, Function | MediumTest | Level3)
5115 {
5116 if (!IsReady(SLOTID_2)) {
5117 return;
5118 }
5119 int32_t ret = g_rilInterface->GetCBConfig(SLOTID_2, GetSerialId());
5120 WaitFor(WAIT_TIME_SECOND_LONG);
5121 EXPECT_EQ(SUCCESS, ret);
5122 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CB_CONFIG));
5123 }
5124
5125 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCdmaCBConfig_V1_0100, Function | MediumTest | Level3)
5126 {
5127 if (!IsReady(SLOTID_1)) {
5128 return;
5129 }
5130 CdmaCBConfigInfoList broadcastInfoList = {};
5131 int32_t ret = g_rilInterface->SetCdmaCBConfig(SLOTID_1, GetSerialId(), broadcastInfoList);
5132 WaitFor(WAIT_TIME_SECOND_LONG);
5133 EXPECT_EQ(SUCCESS, ret);
5134 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG));
5135 }
5136
5137 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SetCdmaCBConfig_V1_0200, Function | MediumTest | Level3)
5138 {
5139 if (!IsReady(SLOTID_2)) {
5140 return;
5141 }
5142 CdmaCBConfigInfoList broadcastInfoList = {};
5143 int32_t ret = g_rilInterface->SetCdmaCBConfig(SLOTID_2, GetSerialId(), broadcastInfoList);
5144 WaitFor(WAIT_TIME_SECOND_LONG);
5145 EXPECT_EQ(SUCCESS, ret);
5146 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SET_CDMA_CB_CONFIG));
5147 }
5148
5149 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCdmaCBConfig_V1_0100, Function | MediumTest | Level3)
5150 {
5151 if (!IsReady(SLOTID_1)) {
5152 return;
5153 }
5154 int32_t ret = g_rilInterface->GetCdmaCBConfig(SLOTID_1, GetSerialId());
5155 WaitFor(WAIT_TIME_SECOND_LONG);
5156 EXPECT_EQ(SUCCESS, ret);
5157 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG));
5158 }
5159
5160 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetCdmaCBConfig_V1_0200, Function | MediumTest | Level3)
5161 {
5162 if (!IsReady(SLOTID_2)) {
5163 return;
5164 }
5165 int32_t ret = g_rilInterface->GetCdmaCBConfig(SLOTID_2, GetSerialId());
5166 WaitFor(WAIT_TIME_SECOND_LONG);
5167 EXPECT_EQ(SUCCESS, ret);
5168 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_GET_CDMA_CB_CONFIG));
5169 }
5170
5171 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsMoreMode_V1_0100, Function | MediumTest | Level3)
5172 {
5173 if (!IsReady(SLOTID_1)) {
5174 return;
5175 }
5176 GsmSmsMessageInfo msg;
5177 msg.smscPdu = TEST_SMSC_PDU;
5178 msg.pdu = TEST_SEND_PDU;
5179 int32_t ret = g_rilInterface->SendSmsMoreMode(SLOTID_1, GetSerialId(), msg);
5180 WaitFor(WAIT_TIME_SECOND_LONG);
5181 EXPECT_EQ(SUCCESS, ret);
5182 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_MORE_MODE));
5183 }
5184
5185 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsMoreMode_V1_0200, Function | MediumTest | Level3)
5186 {
5187 if (!IsReady(SLOTID_2)) {
5188 return;
5189 }
5190 GsmSmsMessageInfo msg;
5191 msg.smscPdu = TEST_SMSC_PDU;
5192 msg.pdu = TEST_SEND_PDU;
5193 int32_t ret = g_rilInterface->SendSmsMoreMode(SLOTID_2, GetSerialId(), msg);
5194 WaitFor(WAIT_TIME_SECOND_LONG);
5195 EXPECT_EQ(SUCCESS, ret);
5196 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_MORE_MODE));
5197 }
5198
5199 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsAck_V1_0100, Function | MediumTest | Level3)
5200 {
5201 if (!IsReady(SLOTID_1)) {
5202 return;
5203 }
5204 ModeData data;
5205 data.result = TEST_RESULT;
5206 data.mode = TEST_MODE;
5207 int32_t ret = g_rilInterface->SendSmsAck(SLOTID_1, GetSerialId(), data);
5208 WaitFor(WAIT_TIME_SECOND_LONG);
5209 EXPECT_EQ(SUCCESS, ret);
5210 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_ACK));
5211 }
5212
5213 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendSmsAck_V1_0200, Function | MediumTest | Level3)
5214 {
5215 if (!IsReady(SLOTID_2)) {
5216 return;
5217 }
5218 ModeData data;
5219 data.result = TEST_RESULT;
5220 data.mode = TEST_MODE;
5221 int32_t ret = g_rilInterface->SendSmsAck(SLOTID_2, GetSerialId(), data);
5222 WaitFor(WAIT_TIME_SECOND_LONG);
5223 EXPECT_EQ(SUCCESS, ret);
5224 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_SMS_ACK));
5225 }
5226
5227 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendGsmSms_V1_0100, Function | MediumTest | Level3)
5228 {
5229 if (!IsReady(SLOTID_1)) {
5230 return;
5231 }
5232 GsmSmsMessageInfo msg;
5233 msg.smscPdu = TEST_SMSC_PDU;
5234 msg.pdu = TEST_SEND_PDU;
5235 int32_t ret = g_rilInterface->SendGsmSms(SLOTID_1, GetSerialId(), msg);
5236 WaitFor(WAIT_TIME_SECOND_LONG);
5237 EXPECT_EQ(SUCCESS, ret);
5238 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_GSM_SMS));
5239 }
5240
5241 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendGsmSms_V1_0200, Function | MediumTest | Level3)
5242 {
5243 if (!IsReady(SLOTID_2)) {
5244 return;
5245 }
5246 GsmSmsMessageInfo msg;
5247 msg.smscPdu = TEST_SMSC_PDU;
5248 msg.pdu = TEST_SEND_PDU;
5249 int32_t ret = g_rilInterface->SendGsmSms(SLOTID_2, GetSerialId(), msg);
5250 WaitFor(WAIT_TIME_SECOND_LONG);
5251 EXPECT_EQ(SUCCESS, ret);
5252 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_GSM_SMS));
5253 }
5254
5255 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendCdmaSms_V1_0100, Function | MediumTest | Level3)
5256 {
5257 if (!IsReady(SLOTID_1)) {
5258 return;
5259 }
5260 SendCdmaSmsMessageInfo msg;
5261 msg.smscPdu = TEST_CDMA_PDU;
5262 int32_t ret = g_rilInterface->SendCdmaSms(SLOTID_1, GetSerialId(), msg);
5263 WaitFor(WAIT_TIME_SECOND_LONG);
5264 EXPECT_EQ(SUCCESS, ret);
5265 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_CDMA_SMS));
5266 }
5267
5268 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendCdmaSms_V1_0200, Function | MediumTest | Level3)
5269 {
5270 if (!IsReady(SLOTID_2)) {
5271 return;
5272 }
5273 SendCdmaSmsMessageInfo msg;
5274 msg.smscPdu = TEST_CDMA_PDU;
5275 int32_t ret = g_rilInterface->SendCdmaSms(SLOTID_2, GetSerialId(), msg);
5276 WaitFor(WAIT_TIME_SECOND_LONG);
5277 EXPECT_EQ(SUCCESS, ret);
5278 ASSERT_TRUE(GetBoolResult(HdiId::HREQ_SMS_SEND_CDMA_SMS));
5279 }
5280
5281 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataSleepMode_V1_0100, Function | MediumTest | Level3)
5282 {
5283 if (!IsReady(SLOTID_1)) {
5284 return;
5285 }
5286 int32_t serialId = GetSerialId();
5287 DataSleepInfo dataSleepInfo;
5288 dataSleepInfo.sleepEnable = 1;
5289 int32_t ret = g_rilInterface->SendDataSleepMode(SLOTID_1, serialId, dataSleepInfo);
5290 WaitFor(WAIT_TIME_SECOND_LONG);
5291 EXPECT_GT(ret, -1);
5292 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_SLEEP_MODE);
5293 }
5294
5295 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataSleepMode_V1_0200, Function | MediumTest | Level3)
5296 {
5297 if (!IsReady(SLOTID_2)) {
5298 return;
5299 }
5300 int32_t serialId = GetSerialId();
5301 DataSleepInfo dataSleepInfo;
5302 dataSleepInfo.sleepEnable = 1;
5303 int32_t ret = g_rilInterface->SendDataSleepMode(SLOTID_2, serialId, dataSleepInfo);
5304 WaitFor(WAIT_TIME_SECOND_LONG);
5305 EXPECT_GT(ret, -1);
5306 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_SLEEP_MODE);
5307 }
5308
5309 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataPerformanceMode_V1_0100, Function | MediumTest | Level3)
5310 {
5311 if (!IsReady(SLOTID_1)) {
5312 return;
5313 }
5314 int32_t serialId = GetSerialId();
5315 DataPerformanceInfo dataPerformanceInfo;
5316 dataPerformanceInfo.performanceEnable = 0;
5317 dataPerformanceInfo.enforce = 1;
5318 int32_t ret = g_rilInterface->SendDataPerformanceMode(SLOTID_1, serialId, dataPerformanceInfo);
5319 WaitFor(WAIT_TIME_SECOND_LONG);
5320 EXPECT_GT(ret, -1);
5321 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_PERFORMANCE_MODE);
5322 }
5323
5324 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_SendDataPerformanceMode_V1_0200, Function | MediumTest | Level3)
5325 {
5326 if (!IsReady(SLOTID_2)) {
5327 return;
5328 }
5329 int32_t serialId = GetSerialId();
5330 DataPerformanceInfo dataPerformanceInfo;
5331 dataPerformanceInfo.performanceEnable = 0;
5332 dataPerformanceInfo.enforce = 1;
5333 int32_t ret = g_rilInterface->SendDataPerformanceMode(SLOTID_2, serialId, dataPerformanceInfo);
5334 WaitFor(WAIT_TIME_SECOND_LONG);
5335 EXPECT_GT(ret, -1);
5336 GetBoolResult(HdiId::HREQ_DATA_SEND_DATA_PERFORMANCE_MODE);
5337 }
5338
5339 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkCapability_V1_0100, Function | MediumTest | Level3)
5340 {
5341 if (!IsReady(SLOTID_1)) {
5342 return;
5343 }
5344 int32_t serialId = GetSerialId();
5345 int32_t ret = g_rilInterface->GetLinkCapability(SLOTID_1, serialId);
5346 WaitFor(WAIT_TIME_SECOND_LONG);
5347 EXPECT_GT(ret, -1);
5348 GetBoolResult(HdiId::HREQ_DATA_GET_LINK_CAPABILITY);
5349 }
5350
5351 HWTEST_F(HdfRilHdiTest, Telephony_DriverSystem_GetLinkCapability_V1_0200, Function | MediumTest | Level3)
5352 {
5353 if (!IsReady(SLOTID_2)) {
5354 return;
5355 }
5356 int32_t serialId = GetSerialId();
5357 int32_t ret = g_rilInterface->GetLinkCapability(SLOTID_2, serialId);
5358 WaitFor(WAIT_TIME_SECOND_LONG);
5359 EXPECT_GT(ret, -1);
5360 GetBoolResult(HdiId::HREQ_DATA_GET_LINK_CAPABILITY);
5361 }
5362