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