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