1/*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "hril_sim.h"
17
18#include "hril_notification.h"
19#include "hril_request.h"
20namespace OHOS {
21namespace Telephony {
22HRilSim::HRilSim(int32_t slotId) : HRilBase(slotId)
23{
24    AddNotificationHandlerToMap();
25    AddBasicHandlerToMap();
26    AddSimLockHandlerToMap();
27    AddStkHandlerToMap();
28}
29
30bool HRilSim::IsSimRespOrNotify(uint32_t code)
31{
32    return IsSimResponse(code) || IsSimNotification(code);
33}
34
35void HRilSim::RegisterSimFuncs(const HRilSimReq *simFuncs)
36{
37    simFuncs_ = simFuncs;
38}
39
40void HRilSim::AddBasicHandlerToMap()
41{
42    // response
43    respMemberFuncMap_[HREQ_SIM_GET_SIM_IO] =
44        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
45        size_t responseLen) { return GetSimIOResponse(requestNum, responseInfo, response, responseLen); };
46    respMemberFuncMap_[HREQ_SIM_GET_SIM_STATUS] =
47        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
48        size_t responseLen) { return GetSimCardStatusResponse(requestNum, responseInfo, response, responseLen); };
49    respMemberFuncMap_[HREQ_SIM_GET_IMSI] =
50        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
51        size_t responseLen) { return GetImsiResponse(requestNum, responseInfo, response, responseLen); };
52    respMemberFuncMap_[HREQ_SIM_SET_ACTIVE_SIM] =
53        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
54        size_t responseLen) { return SetActiveSimResponse(requestNum, responseInfo, response, responseLen); };
55    respMemberFuncMap_[HREQ_SIM_GET_RADIO_PROTOCOL] =
56        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
57        size_t responseLen) { return GetRadioProtocolResponse(requestNum, responseInfo, response, responseLen); };
58    respMemberFuncMap_[HREQ_SIM_SET_RADIO_PROTOCOL] =
59        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
60        size_t responseLen) { return SetRadioProtocolResponse(requestNum, responseInfo, response, responseLen); };
61    respMemberFuncMap_[HREQ_SIM_OPEN_LOGICAL_CHANNEL] =
62        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
63        size_t responseLen) { return SimOpenLogicalChannelResponse(requestNum, responseInfo, response, responseLen); };
64    respMemberFuncMap_[HREQ_SIM_CLOSE_LOGICAL_CHANNEL] =
65        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
66        size_t responseLen) { return SimCloseLogicalChannelResponse(requestNum, responseInfo, response, responseLen); };
67    respMemberFuncMap_[HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL] = [this](int32_t requestNum,
68        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
69        return SimTransmitApduLogicalChannelResponse(requestNum, responseInfo, response, responseLen);
70    };
71    respMemberFuncMap_[HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL] = [this](int32_t requestNum,
72        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
73        return SimTransmitApduBasicChannelResponse(requestNum, responseInfo, response, responseLen);
74    };
75    respMemberFuncMap_[HREQ_SIM_SEND_NCFG_OPER_INFO] = [this](int32_t requestNum,
76        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
77        return SendSimMatchedOperatorInfoResponse(requestNum, responseInfo, response, responseLen);
78    };
79}
80
81void HRilSim::AddSimLockHandlerToMap()
82{
83    respMemberFuncMap_[HREQ_SIM_GET_SIM_LOCK_STATUS] =
84        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
85        size_t responseLen) { return GetSimLockStatusResponse(requestNum, responseInfo, response, responseLen); };
86    respMemberFuncMap_[HREQ_SIM_SET_SIM_LOCK] =
87        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
88        size_t responseLen) { return SetSimLockResponse(requestNum, responseInfo, response, responseLen); };
89    respMemberFuncMap_[HREQ_SIM_CHANGE_SIM_PASSWORD] =
90        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
91        size_t responseLen) { return ChangeSimPasswordResponse(requestNum, responseInfo, response, responseLen); };
92    respMemberFuncMap_[HREQ_SIM_UNLOCK_PIN] =
93        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
94        size_t responseLen) { return UnlockPinResponse(requestNum, responseInfo, response, responseLen); };
95    respMemberFuncMap_[HREQ_SIM_UNLOCK_PUK] =
96        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
97        size_t responseLen) { return UnlockPukResponse(requestNum, responseInfo, response, responseLen); };
98    respMemberFuncMap_[HREQ_SIM_UNLOCK_PIN2] =
99        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
100        size_t responseLen) { return UnlockPin2Response(requestNum, responseInfo, response, responseLen); };
101    respMemberFuncMap_[HREQ_SIM_UNLOCK_PUK2] =
102        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
103        size_t responseLen) { return UnlockPuk2Response(requestNum, responseInfo, response, responseLen); };
104    respMemberFuncMap_[HREQ_SIM_AUTHENTICATION] =
105        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
106        size_t responseLen) { return SimAuthenticationResponse(requestNum, responseInfo, response, responseLen); };
107    respMemberFuncMap_[HREQ_SIM_UNLOCK_SIM_LOCK] =
108        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
109        size_t responseLen) { return UnlockSimLockResponse(requestNum, responseInfo, response, responseLen); };
110}
111
112void HRilSim::AddStkHandlerToMap()
113{
114    respMemberFuncMap_[HREQ_SIM_STK_SEND_TERMINAL_RESPONSE] = [this](int32_t requestNum,
115        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
116        return SimStkSendTerminalResponseResponse(requestNum, responseInfo, response, responseLen);
117    };
118    respMemberFuncMap_[HREQ_SIM_STK_SEND_ENVELOPE] =
119        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
120        size_t responseLen) { return SimStkSendEnvelopeResponse(requestNum, responseInfo, response, responseLen); };
121    respMemberFuncMap_[HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT] = [this](int32_t requestNum,
122        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
123        return SimStkSendCallSetupRequestResultResponse(requestNum, responseInfo, response, responseLen);
124    };
125    respMemberFuncMap_[HREQ_SIM_STK_IS_READY] =
126        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
127        size_t responseLen) { return SimStkIsReadyResponse(requestNum, responseInfo, response, responseLen); };
128}
129
130void HRilSim::AddNotificationHandlerToMap()
131{
132    // Notification
133    notiMemberFuncMap_[HNOTI_SIM_STATUS_CHANGED] =
134        [this](int32_t notifyType, HRilErrNumber error, const void *response,
135        size_t responseLen) { return SimStateUpdated(notifyType, error, response, responseLen); };
136    notiMemberFuncMap_[HNOTI_SIM_STK_SESSION_END_NOTIFY] =
137        [this](int32_t notifyType, HRilErrNumber error, const void *response,
138        size_t responseLen) { return SimStkSessionEndNotify(notifyType, error, response, responseLen); };
139    notiMemberFuncMap_[HNOTI_SIM_STK_PROACTIVE_NOTIFY] =
140        [this](int32_t notifyType, HRilErrNumber error, const void *response,
141        size_t responseLen) { return SimStkProactiveNotify(notifyType, error, response, responseLen); };
142    notiMemberFuncMap_[HNOTI_SIM_STK_ALPHA_NOTIFY] =
143        [this](int32_t notifyType, HRilErrNumber error, const void *response,
144        size_t responseLen) { return SimStkAlphaNotify(notifyType, error, response, responseLen); };
145    notiMemberFuncMap_[HNOTI_SIM_STK_EVENT_NOTIFY] =
146        [this](int32_t notifyType, HRilErrNumber error, const void *response,
147        size_t responseLen) { return SimStkEventNotify(notifyType, error, response, responseLen); };
148    notiMemberFuncMap_[HNOTI_SIM_STK_CALL_SETUP_NOTIFY] =
149        [this](int32_t notifyType, HRilErrNumber error, const void *response,
150        size_t responseLen) { return SimStkCallSetupNotify(notifyType, error, response, responseLen); };
151    notiMemberFuncMap_[HNOTI_SIM_REFRESH_NOTIFY] =
152        [this](int32_t notifyType, HRilErrNumber error, const void *response,
153        size_t responseLen) { return SimRefreshNotify(notifyType, error, response, responseLen); };
154    notiMemberFuncMap_[HNOTI_SIM_RADIO_PROTOCOL_UPDATED] =
155        [this](int32_t notifyType, HRilErrNumber error, const void *response,
156        size_t responseLen) { return SimRadioProtocolUpdated(notifyType, error, response, responseLen); };
157}
158
159int32_t HRilSim::GetSimIO(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimIoRequestInfo &simIO)
160{
161    std::unique_ptr<HRilSimIO> rilSimIO = std::make_unique<HRilSimIO>();
162    CopyToHRilSimIO(rilSimIO, simIO);
163    int32_t ret = RequestVendor(
164        serialId, HREQ_SIM_GET_SIM_IO, simFuncs_, &HRilSimReq::GetSimIO, rilSimIO.get(), sizeof(*rilSimIO));
165    SafeFrees(rilSimIO->data, rilSimIO->pathid, rilSimIO->pin2);
166    return ret;
167}
168
169int32_t HRilSim::GetSimStatus(int32_t serialId)
170{
171    return RequestVendor(serialId, HREQ_SIM_GET_SIM_STATUS, simFuncs_, &HRilSimReq::GetSimStatus);
172}
173
174int32_t HRilSim::GetImsi(int32_t serialId)
175{
176    return RequestVendor(serialId, HREQ_SIM_GET_IMSI, simFuncs_, &HRilSimReq::GetSimImsi);
177}
178
179int32_t HRilSim::GetSimLockStatus(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
180{
181    std::unique_ptr<HRilSimClock> rilSimLock = std::make_unique<HRilSimClock>();
182    CopyToHRilSimLock(rilSimLock, simLockInfo);
183    int32_t ret = RequestVendor(serialId, HREQ_SIM_GET_SIM_LOCK_STATUS, simFuncs_, &HRilSimReq::GetSimLockStatus,
184        rilSimLock.get(), sizeof(*rilSimLock));
185    SafeFrees(rilSimLock->fac, rilSimLock->passwd);
186    return ret;
187}
188
189int32_t HRilSim::SetSimLock(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
190{
191    std::unique_ptr<HRilSimClock> rilSimLock = std::make_unique<HRilSimClock>();
192    CopyToHRilSimLock(rilSimLock, simLockInfo);
193    int32_t ret = RequestVendor(
194        serialId, HREQ_SIM_SET_SIM_LOCK, simFuncs_, &HRilSimReq::SetSimLock, rilSimLock.get(), sizeof(*rilSimLock));
195    SafeFrees(rilSimLock->fac, rilSimLock->passwd);
196    return ret;
197}
198
199int32_t HRilSim::ChangeSimPassword(int32_t serialId, const OHOS::HDI::Ril::V1_1::SimPasswordInfo &simPassword)
200{
201    std::unique_ptr<HRilSimPassword> rilSimPassword = std::make_unique<HRilSimPassword>();
202    CopyToHRilSimPassword(rilSimPassword, simPassword);
203    int32_t ret = RequestVendor(serialId, HREQ_SIM_CHANGE_SIM_PASSWORD, simFuncs_, &HRilSimReq::ChangeSimPassword,
204        rilSimPassword.get(), sizeof(*rilSimPassword));
205    SafeFrees(rilSimPassword->fac, rilSimPassword->oldPassword, rilSimPassword->newPassword);
206    return ret;
207}
208
209int32_t HRilSim::UnlockPin(int32_t serialId, const std::string &pin)
210{
211    char *pinPoint = nullptr;
212    CopyToCharPoint(&pinPoint, pin);
213    int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PIN, simFuncs_, &HRilSimReq::UnlockPin, pinPoint);
214    SafeFrees(pinPoint);
215    return ret;
216}
217
218int32_t HRilSim::UnlockPuk(int32_t serialId, const std::string &puk, const std::string &pin)
219{
220    char *pukPoint = nullptr;
221    CopyToCharPoint(&pukPoint, puk);
222    char *pinPoint = nullptr;
223    CopyToCharPoint(&pinPoint, pin);
224    int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PUK, simFuncs_, &HRilSimReq::UnlockPuk, pukPoint, pinPoint);
225    SafeFrees(pukPoint, pinPoint);
226    return ret;
227}
228
229int32_t HRilSim::UnlockPin2(int32_t serialId, const std::string &pin2)
230{
231    char *pin2Point = nullptr;
232    CopyToCharPoint(&pin2Point, pin2);
233    int32_t ret = RequestVendor(serialId, HREQ_SIM_UNLOCK_PIN2, simFuncs_, &HRilSimReq::UnlockPin2, pin2Point);
234    SafeFrees(pin2Point);
235    return ret;
236}
237
238int32_t HRilSim::UnlockPuk2(int32_t serialId, const std::string &puk2, const std::string &pin2)
239{
240    char *puk2Point = nullptr;
241    CopyToCharPoint(&puk2Point, puk2);
242    char *pin2Point = nullptr;
243    CopyToCharPoint(&pin2Point, pin2);
244    int32_t ret =
245        RequestVendor(serialId, HREQ_SIM_UNLOCK_PUK2, simFuncs_, &HRilSimReq::UnlockPuk2, puk2Point, pin2Point);
246    SafeFrees(puk2Point, pin2Point);
247    return ret;
248}
249
250int32_t HRilSim::SetActiveSim(int32_t serialId, int32_t index, int32_t enable)
251{
252    return RequestVendor(serialId, HREQ_SIM_SET_ACTIVE_SIM, simFuncs_, &HRilSimReq::SetActiveSim, index, enable);
253}
254
255int32_t HRilSim::SimStkSendTerminalResponse(int32_t serialId, const std::string &strCmd)
256{
257    char *strCmdPoint = nullptr;
258    CopyToCharPoint(&strCmdPoint, strCmd);
259    int32_t ret = RequestVendor(
260        serialId, HREQ_SIM_STK_SEND_TERMINAL_RESPONSE, simFuncs_, &HRilSimReq::SimStkSendTerminalResponse, strCmdPoint);
261    SafeFrees(strCmdPoint);
262    return ret;
263}
264
265int32_t HRilSim::SimStkSendEnvelope(int32_t serialId, const std::string &strCmd)
266{
267    char *strCmdPoint = nullptr;
268    CopyToCharPoint(&strCmdPoint, strCmd);
269    int32_t ret =
270        RequestVendor(serialId, HREQ_SIM_STK_SEND_ENVELOPE, simFuncs_, &HRilSimReq::SimStkSendEnvelope, strCmdPoint);
271    SafeFrees(strCmdPoint);
272    return ret;
273}
274
275int32_t HRilSim::SimStkSendCallSetupRequestResult(int32_t serialId, int32_t accept)
276{
277    return RequestVendor(serialId, HREQ_SIM_STK_SEND_CALL_SETUP_REQUEST_RESULT, simFuncs_,
278        &HRilSimReq::SimStkSendCallSetupRequestResult, accept);
279}
280
281int32_t HRilSim::SimStkIsReady(int32_t serialId)
282{
283    return RequestVendor(serialId, HREQ_SIM_STK_IS_READY, simFuncs_, &HRilSimReq::SimStkIsReady);
284}
285
286int32_t HRilSim::GetRadioProtocol(int32_t serialId)
287{
288    TELEPHONY_LOGI("HRilSim::GetRadioProtocol slotId:%{public}d", GetSlotId());
289    return RequestVendor(serialId, HREQ_SIM_GET_RADIO_PROTOCOL, simFuncs_, &HRilSimReq::GetRadioProtocol);
290}
291
292int32_t HRilSim::SetRadioProtocol(int32_t serialId, const HDI::Ril::V1_1::RadioProtocol &radioProtocol)
293{
294    HRilRadioProtocol hrilRadioProtocol = {};
295    hrilRadioProtocol.sessionId = radioProtocol.sessionId;
296    hrilRadioProtocol.phase = static_cast<HRilRadioProtocolPhase>(radioProtocol.phase);
297    hrilRadioProtocol.technology = radioProtocol.technology;
298    hrilRadioProtocol.modemId = radioProtocol.modemId;
299    hrilRadioProtocol.status = static_cast<HRilRadioProtocolStatus>(radioProtocol.status);
300    TELEPHONY_LOGI("HRilSim::SetRadioProtocol slotId:%{public}d, serialId:%{public}d"
301        "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
302        GetSlotId(), serialId, hrilRadioProtocol.sessionId, hrilRadioProtocol.phase, hrilRadioProtocol.technology,
303        hrilRadioProtocol.modemId, hrilRadioProtocol.status);
304    return RequestVendor(serialId, HREQ_SIM_SET_RADIO_PROTOCOL, simFuncs_,
305        &HRilSimReq::SetRadioProtocol, &hrilRadioProtocol);
306}
307
308int32_t HRilSim::SimOpenLogicalChannel(int32_t serialId, const std::string &appID, int32_t p2)
309{
310    char *appIDPoint = nullptr;
311    CopyToCharPoint(&appIDPoint, appID);
312    int32_t ret = RequestVendor(
313        serialId, HREQ_SIM_OPEN_LOGICAL_CHANNEL, simFuncs_, &HRilSimReq::SimOpenLogicalChannel, appIDPoint, p2);
314    SafeFrees(appIDPoint);
315    return ret;
316}
317
318int32_t HRilSim::SimCloseLogicalChannel(int32_t serialId, int32_t channelId)
319{
320    return RequestVendor(
321        serialId, HREQ_SIM_CLOSE_LOGICAL_CHANNEL, simFuncs_, &HRilSimReq::SimCloseLogicalChannel, channelId);
322}
323
324int32_t HRilSim::SimTransmitApduLogicalChannel(
325    int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
326{
327    std::unique_ptr<HRilApduSimIO> rilApduSimIO = std::make_unique<HRilApduSimIO>();
328    CopyToHRilApduSimIO(rilApduSimIO, apduSimIO);
329    int32_t ret = RequestVendor(serialId, HREQ_SIM_TRANSMIT_APDU_LOGICAL_CHANNEL, simFuncs_,
330        &HRilSimReq::SimTransmitApduLogicalChannel, rilApduSimIO.get(), sizeof(*rilApduSimIO));
331    SafeFrees(rilApduSimIO->data);
332    return ret;
333}
334
335int32_t HRilSim::SimTransmitApduBasicChannel(
336    int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
337{
338    std::unique_ptr<HRilApduSimIO> rilApduSimIO = std::make_unique<HRilApduSimIO>();
339    CopyToHRilApduSimIO(rilApduSimIO, apduSimIO);
340    int32_t ret = RequestVendor(serialId, HREQ_SIM_TRANSMIT_APDU_BASIC_CHANNEL, simFuncs_,
341        &HRilSimReq::SimTransmitApduBasicChannel, rilApduSimIO.get(), sizeof(*rilApduSimIO));
342    SafeFrees(rilApduSimIO->data);
343    return ret;
344}
345
346int32_t HRilSim::SimAuthentication(
347    int32_t serialId, const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo &simAuthInfo)
348{
349    std::unique_ptr<HRilSimAuthenticationRequestInfo> rilSimAuthInfo =
350        std::make_unique<HRilSimAuthenticationRequestInfo>();
351    CopyToHRilSimAuthentication(rilSimAuthInfo, simAuthInfo);
352    int32_t ret = RequestVendor(serialId, HREQ_SIM_AUTHENTICATION, simFuncs_, &HRilSimReq::SimAuthentication,
353        rilSimAuthInfo.get(), sizeof(*rilSimAuthInfo));
354    SafeFrees(rilSimAuthInfo->aid, rilSimAuthInfo->data);
355    return ret;
356}
357
358int32_t HRilSim::UnlockSimLock(int32_t serialId, int32_t lockType, const std::string &key)
359{
360    char *keyPoint = nullptr;
361    CopyToCharPoint(&keyPoint, key);
362    int32_t ret =
363        RequestVendor(serialId, HREQ_SIM_UNLOCK_SIM_LOCK, simFuncs_, &HRilSimReq::UnlockSimLock, lockType, keyPoint);
364    SafeFrees(keyPoint);
365    return ret;
366}
367
368int32_t HRilSim::SendSimMatchedOperatorInfo(
369    int32_t serialId, const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo &ncfgOperatorInfo)
370{
371    std::unique_ptr<HRilNcfgOperatorInfo> rilNcfgOperatorInfo =
372        std::make_unique<HRilNcfgOperatorInfo>();
373    CopyToHRilNcfgOperatorInfo(rilNcfgOperatorInfo, ncfgOperatorInfo);
374    int32_t ret = RequestVendor(serialId, HREQ_SIM_SEND_NCFG_OPER_INFO, simFuncs_,
375        &HRilSimReq::SendSimMatchedOperatorInfo, rilNcfgOperatorInfo.get(), sizeof(*rilNcfgOperatorInfo));
376    SafeFrees(rilNcfgOperatorInfo->operName, rilNcfgOperatorInfo->operKey, rilNcfgOperatorInfo->reserve);
377    return ret;
378}
379
380int32_t HRilSim::GetSimIOResponse(
381    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
382{
383    HDI::Ril::V1_1::IccIoResultInfo result = {};
384    int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
385    if (ret != HRIL_ERR_SUCCESS) {
386        return ret;
387    }
388    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimIOResponse, result);
389}
390
391int32_t HRilSim::GetSimCardStatusResponse(
392    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
393{
394    HDI::Ril::V1_3::SimCardStatusInfo rilCardStatus = {};
395    if ((response == nullptr && responseLen != 0) ||
396        (response != nullptr && responseLen != sizeof(HRilCardState))) {
397        TELEPHONY_LOGE("Invalid response: Vendor exception!");
398        return HRIL_ERR_INVALID_PARAMETER;
399    }
400    if (response == nullptr && responseLen == 0) {
401        TELEPHONY_LOGE("response is null");
402        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
403            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
404        }
405        return Response(responseInfo, &HDI::Ril::V1_3::IRilCallback::GetSimCardStatusResponse, rilCardStatus);
406    }
407    const HRilCardState *curPtr = static_cast<const HRilCardState *>(response);
408    if (curPtr != nullptr) {
409        rilCardStatus.index = curPtr->index;
410        rilCardStatus.simType = curPtr->simType;
411        rilCardStatus.simState = curPtr->simState;
412        rilCardStatus.iccid = (curPtr->iccid == nullptr) ? "" :  curPtr->iccid;
413    }
414    return Response(responseInfo, &HDI::Ril::V1_3::IRilCallback::GetSimCardStatusResponse, rilCardStatus);
415}
416
417int32_t HRilSim::GetImsiResponse(
418    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
419{
420    int32_t ret = CheckCharData(response, responseLen);
421    if (ret != HRIL_ERR_SUCCESS) {
422        return ret;
423    }
424    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetImsiResponse, (const char *)response);
425}
426
427int32_t HRilSim::GetSimLockStatusResponse(
428    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
429{
430    int32_t simLockStatus = 0;
431    if (response == nullptr || responseLen != sizeof(int32_t)) {
432        TELEPHONY_LOGE("GetSimStatusResponse: Invalid response");
433        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
434            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
435        }
436        return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimLockStatusResponse, simLockStatus);
437    }
438    simLockStatus = *(static_cast<const int32_t *>(response));
439    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSimLockStatusResponse, simLockStatus);
440}
441
442int32_t HRilSim::SetSimLockResponse(
443    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
444{
445    HDI::Ril::V1_1::LockStatusResp result = {};
446    ResponseLockStatus(result, responseInfo, response, responseLen);
447    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetSimLockResponse, result);
448}
449
450int32_t HRilSim::ChangeSimPasswordResponse(
451    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
452{
453    HDI::Ril::V1_1::LockStatusResp result = {};
454    ResponseLockStatus(result, responseInfo, response, responseLen);
455    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::ChangeSimPasswordResponse, result);
456}
457
458int32_t HRilSim::UnlockPinResponse(
459    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
460{
461    HDI::Ril::V1_1::LockStatusResp result = {};
462    ResponseLockStatus(result, responseInfo, response, responseLen);
463    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPinResponse, result);
464}
465
466int32_t HRilSim::UnlockPukResponse(
467    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
468{
469    HDI::Ril::V1_1::LockStatusResp result = {};
470    ResponseLockStatus(result, responseInfo, response, responseLen);
471    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPukResponse, result);
472}
473
474int32_t HRilSim::UnlockPin2Response(
475    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
476{
477    HDI::Ril::V1_1::LockStatusResp result = {};
478    ResponseLockStatus(result, responseInfo, response, responseLen);
479    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPin2Response, result);
480}
481
482int32_t HRilSim::UnlockPuk2Response(
483    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
484{
485    HDI::Ril::V1_1::LockStatusResp result = {};
486    ResponseLockStatus(result, responseInfo, response, responseLen);
487    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockPuk2Response, result);
488}
489
490int32_t HRilSim::SetActiveSimResponse(
491    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
492{
493    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetActiveSimResponse);
494}
495
496int32_t HRilSim::SimStkSendTerminalResponseResponse(
497    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
498{
499    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendTerminalResponseResponse);
500}
501
502int32_t HRilSim::SimStkSendEnvelopeResponse(
503    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
504{
505    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendEnvelopeResponse);
506}
507
508int32_t HRilSim::SimStkSendCallSetupRequestResultResponse(
509    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
510{
511    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkSendCallSetupRequestResultResponse);
512}
513
514int32_t HRilSim::SimStkIsReadyResponse(
515    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
516{
517    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimStkIsReadyResponse);
518}
519
520int32_t HRilSim::GetRadioProtocolResponse(
521    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
522{
523    HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
524    if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
525        TELEPHONY_LOGE("GetRadioProtocolResponse response is invalid");
526        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
527            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
528        }
529    } else {
530        BuildRadioProtocol(radioProtocol, response);
531        TELEPHONY_LOGI("HRilSim::GetRadioProtocolResponse slotId:%{public}d, serial:%{public}d"
532            "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
533            GetSlotId(), responseInfo.serial, radioProtocol.sessionId, radioProtocol.phase, radioProtocol.technology,
534            radioProtocol.modemId, radioProtocol.status);
535    }
536    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetRadioProtocolResponse, radioProtocol);
537}
538
539int32_t HRilSim::SetRadioProtocolResponse(
540    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
541{
542    HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
543    if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
544        TELEPHONY_LOGE("SetRadioProtocolResponse response is invalid");
545        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
546            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
547        }
548    } else {
549        BuildRadioProtocol(radioProtocol, response);
550        TELEPHONY_LOGI("HRilSim::SetRadioProtocolResponse slotId:%{public}d, serial:%{public}d"
551            "sessionId:%{public}d, phase:%{public}d, technology:%{public}d, modemId:%{public}d, status:%{public}d",
552            GetSlotId(), responseInfo.serial, radioProtocol.sessionId, radioProtocol.phase, radioProtocol.technology,
553            radioProtocol.modemId, radioProtocol.status);
554    }
555    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetRadioProtocolResponse, radioProtocol);
556}
557
558int32_t HRilSim::SimOpenLogicalChannelResponse(
559    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
560{
561    HDI::Ril::V1_1::OpenLogicalChannelResponse pOpenLogicalChannelResponse = {};
562    if (response == nullptr || responseLen != sizeof(HRilOpenLogicalChannelResponse)) {
563        TELEPHONY_LOGE("Invalid response: response is nullptr");
564        return HRIL_ERR_INVALID_PARAMETER;
565    }
566    const HRilOpenLogicalChannelResponse *pRilResponse = static_cast<const HRilOpenLogicalChannelResponse *>(response);
567    pOpenLogicalChannelResponse.sw1 = pRilResponse->sw1;
568    pOpenLogicalChannelResponse.sw2 = pRilResponse->sw2;
569    pOpenLogicalChannelResponse.channelId = pRilResponse->channelId;
570    pOpenLogicalChannelResponse.response = (pRilResponse->response == nullptr) ? "" :  pRilResponse->response;
571    return Response(
572        responseInfo, &HDI::Ril::V1_1::IRilCallback::SimOpenLogicalChannelResponse, pOpenLogicalChannelResponse);
573}
574
575int32_t HRilSim::SimCloseLogicalChannelResponse(
576    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
577{
578    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimCloseLogicalChannelResponse);
579}
580
581int32_t HRilSim::SimTransmitApduLogicalChannelResponse(
582    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
583{
584    HDI::Ril::V1_1::IccIoResultInfo result = {};
585    int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
586    if (ret != HRIL_ERR_SUCCESS) {
587        return ret;
588    }
589    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimTransmitApduLogicalChannelResponse, result);
590}
591
592int32_t HRilSim::SimTransmitApduBasicChannelResponse(
593    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
594{
595    HDI::Ril::V1_1::IccIoResultInfo result = {};
596    int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
597    if (ret != HRIL_ERR_SUCCESS) {
598        return ret;
599    }
600    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimTransmitApduBasicChannelResponse, result);
601}
602
603int32_t HRilSim::SimAuthenticationResponse(
604    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
605{
606    HDI::Ril::V1_1::IccIoResultInfo result = {};
607    int32_t ret = BuildSimIOResp(result, responseInfo, response, responseLen);
608    if (ret != HRIL_ERR_SUCCESS) {
609        return ret;
610    }
611    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SimAuthenticationResponse, result);
612}
613
614int32_t HRilSim::UnlockSimLockResponse(
615    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
616{
617    HDI::Ril::V1_1::LockStatusResp result = {};
618    ResponseLockStatus(result, responseInfo, response, responseLen);
619    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::UnlockSimLockResponse, result);
620}
621
622HDI::Ril::V1_1::IccIoResultInfo HRilSim::ProcessIccIoResponse(
623    HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
624{
625    HDI::Ril::V1_1::IccIoResultInfo result = {};
626    if (response == nullptr || responseLen != sizeof(HRilSimIOResponse)) {
627        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
628            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
629        }
630        result.response = std::string("");
631        return result;
632    }
633    const HRilSimIOResponse *resp = static_cast<const HRilSimIOResponse *>(response);
634    result.sw1 = resp->sw1;
635    result.sw2 = resp->sw2;
636    result.response = (resp->response == nullptr) ? "" : std::string(resp->response);
637    return result;
638}
639
640int32_t HRilSim::SendSimMatchedOperatorInfoResponse(
641    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
642{
643    return Response(responseInfo, &HDI::Ril::V1_2::IRilCallback::SendSimMatchedOperatorInfoResponse);
644}
645
646int32_t HRilSim::SimStateUpdated(
647    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
648{
649    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStateUpdated);
650}
651
652int32_t HRilSim::SimStkSessionEndNotify(
653    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
654{
655    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkSessionEndNotify);
656}
657
658int32_t HRilSim::SimStkProactiveNotify(
659    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
660{
661    int32_t ret = CheckCharData(response, responseLen);
662    if (ret != HRIL_ERR_SUCCESS) {
663        return ret;
664    }
665    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkProactiveNotify, (const char *)response);
666}
667
668int32_t HRilSim::SimStkAlphaNotify(
669    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
670{
671    int32_t ret = CheckCharData(response, responseLen);
672    if (ret != HRIL_ERR_SUCCESS) {
673        return ret;
674    }
675    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkAlphaNotify, (const char *)response);
676}
677
678int32_t HRilSim::SimStkEventNotify(
679    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
680{
681    int32_t ret = CheckCharData(response, responseLen);
682    if (ret != HRIL_ERR_SUCCESS) {
683        return ret;
684    }
685    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkEventNotify, (const char *)response);
686}
687
688int32_t HRilSim::SimStkCallSetupNotify(
689    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
690{
691    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimStkCallSetupNotify);
692}
693
694int32_t HRilSim::SimRefreshNotify(
695    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
696{
697    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimRefreshNotify);
698}
699
700int32_t HRilSim::SimRadioProtocolUpdated(
701    int32_t notifyType, const HRilErrNumber error, const void *response, size_t responseLen)
702{
703    if (response == nullptr || responseLen != sizeof(HRilRadioProtocol)) {
704        TELEPHONY_LOGE("SimRadioProtocolUpdated response is invalid");
705        return HRIL_ERR_INVALID_PARAMETER;
706    }
707    HDI::Ril::V1_1::RadioProtocol radioProtocol = {};
708    BuildRadioProtocol(radioProtocol, response);
709    TELEPHONY_LOGI("SimRadioProtocolUpdated slotId:%{public}d, sessionId:%{public}d, phase:%{public}d, "
710        "technology:%{public}d, modemId:%{public}d, status:%{public}d",
711        radioProtocol.slotId, radioProtocol.sessionId, static_cast<int32_t>(radioProtocol.phase),
712        radioProtocol.technology, radioProtocol.modemId, static_cast<int32_t>(radioProtocol.status));
713    return Notify(notifyType, error, &HDI::Ril::V1_1::IRilCallback::SimRadioProtocolUpdated, radioProtocol);
714}
715
716bool HRilSim::IsSimResponse(uint32_t code)
717{
718    return ((code >= HREQ_SIM_BASE) && (code < HREQ_DATA_BASE));
719}
720
721bool HRilSim::IsSimNotification(uint32_t code)
722{
723    return ((code >= HNOTI_SIM_BASE) && (code < HNOTI_DATA_BASE));
724}
725
726void HRilSim::CopyToHRilSimIO(std::unique_ptr<HRilSimIO> &rilSimIO, const OHOS::HDI::Ril::V1_1::SimIoRequestInfo &simIO)
727{
728    rilSimIO->command = simIO.command;
729    rilSimIO->fileid = simIO.fileId;
730    rilSimIO->p1 = simIO.p1;
731    rilSimIO->p2 = simIO.p2;
732    rilSimIO->p3 = simIO.p3;
733    TELEPHONY_LOGD("CopyToHRilSimIO.data: %{public}zu, path: %{public}zu, pin2: %{public}zu", simIO.data.length(),
734        simIO.path.length(), simIO.pin2.length());
735    CopyToCharPoint(&(rilSimIO->data), simIO.data);
736    CopyToCharPoint(&(rilSimIO->pathid), simIO.path);
737    CopyToCharPoint(&(rilSimIO->pin2), simIO.pin2);
738}
739
740void HRilSim::CopyToHRilSimLock(
741    std::unique_ptr<HRilSimClock> &rilSimLock, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
742{
743    rilSimLock->mode = simLockInfo.mode;
744    rilSimLock->status = simLockInfo.status;
745    rilSimLock->classx = simLockInfo.classx;
746    CopyToCharPoint(&(rilSimLock->fac), simLockInfo.fac);
747    CopyToCharPoint(&(rilSimLock->passwd), simLockInfo.passwd);
748}
749
750void HRilSim::CopyToHRilSimPassword(
751    std::unique_ptr<HRilSimPassword> &rilSimPassword, const OHOS::HDI::Ril::V1_1::SimPasswordInfo &simPassword)
752{
753    CopyToCharPoint(&(rilSimPassword->fac), simPassword.fac);
754    CopyToCharPoint(&(rilSimPassword->oldPassword), simPassword.oldPassword);
755    CopyToCharPoint(&(rilSimPassword->newPassword), simPassword.newPassword);
756    rilSimPassword->passwordLength = simPassword.passwordLength;
757}
758
759void HRilSim::CopyToHRilApduSimIO(
760    std::unique_ptr<HRilApduSimIO> &rilApduSimIO, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
761{
762    rilApduSimIO->channelId = apduSimIO.channelId;
763    rilApduSimIO->type = apduSimIO.type;
764    rilApduSimIO->instruction = apduSimIO.instruction;
765    rilApduSimIO->p1 = apduSimIO.p1;
766    rilApduSimIO->p2 = apduSimIO.p2;
767    rilApduSimIO->p3 = apduSimIO.p3;
768    CopyToCharPoint(&(rilApduSimIO->data), apduSimIO.data);
769}
770
771void HRilSim::CopyToHRilSimAuthentication(std::unique_ptr<HRilSimAuthenticationRequestInfo> &rilSimAuthInfo,
772    const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo &simAuthInfo)
773{
774    rilSimAuthInfo->serial = simAuthInfo.serial;
775    CopyToCharPoint(&(rilSimAuthInfo->aid), simAuthInfo.aid);
776    CopyToCharPoint(&(rilSimAuthInfo->data), simAuthInfo.authData);
777}
778
779void HRilSim::CopyToHRilNcfgOperatorInfo(std::unique_ptr<HRilNcfgOperatorInfo> &rilNcfgOperatorInfo,
780    const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo &ncfgOperatorInfo)
781{
782    CopyToCharPoint(&(rilNcfgOperatorInfo->operName), ncfgOperatorInfo.operName);
783    CopyToCharPoint(&(rilNcfgOperatorInfo->operKey), ncfgOperatorInfo.operKey);
784    rilNcfgOperatorInfo->state = ncfgOperatorInfo.state;
785    CopyToCharPoint(&(rilNcfgOperatorInfo->reserve), ncfgOperatorInfo.reserve);
786}
787
788bool HRilSim::BuildLockStatusResp(const void *response, size_t responseLen, HDI::Ril::V1_1::LockStatusResp &lockStatus)
789{
790    if (response == nullptr || responseLen != sizeof(HRilLockStatus)) {
791        return false;
792    }
793    const HRilLockStatus *resp = static_cast<const HRilLockStatus *>(response);
794    lockStatus.result = resp->result;
795    lockStatus.remain = resp->remain;
796    return true;
797}
798
799void HRilSim::ResponseLockStatus(HDI::Ril::V1_1::LockStatusResp &lockStatus,
800    HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
801{
802    if (!BuildLockStatusResp(response, responseLen, lockStatus)) {
803        TELEPHONY_LOGE("Invalid ResponseLockStatus: response is error");
804        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
805            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
806        }
807    }
808}
809
810int32_t HRilSim::BuildSimIOResp(HDI::Ril::V1_1::IccIoResultInfo &result,
811    HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
812{
813    if ((response == nullptr && responseLen != 0) ||
814        (response != nullptr && responseLen != sizeof(HRilSimIOResponse))) {
815        TELEPHONY_LOGE("Invalid BuildSimIOResp: Vendor exception!");
816        return HRIL_ERR_INVALID_PARAMETER;
817    }
818    if (response == nullptr && responseLen == 0) {
819        TELEPHONY_LOGE("BuildSimIOResp response is null");
820        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
821            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
822        }
823    }
824    result = ProcessIccIoResponse(responseInfo, response, responseLen);
825    return HRIL_ERR_SUCCESS;
826}
827
828int32_t HRilSim::CheckCharData(const void *response, size_t responseLen)
829{
830    if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
831        TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
832        return HRIL_ERR_INVALID_PARAMETER;
833    }
834    if (response == nullptr && responseLen == 0) {
835        TELEPHONY_LOGE("response is null");
836        return HRIL_ERR_NULL_POINT;
837    }
838    return HRIL_ERR_SUCCESS;
839}
840
841void HRilSim::BuildRadioProtocol(HDI::Ril::V1_1::RadioProtocol &radioProtocol, const void *response)
842{
843    const HRilRadioProtocol *hrilRadioProtocol = static_cast<const HRilRadioProtocol *>(response);
844    radioProtocol.slotId = GetSlotId();
845    radioProtocol.sessionId = hrilRadioProtocol->sessionId;
846    radioProtocol.phase = static_cast<HDI::Ril::V1_1::RadioProtocolPhase>(hrilRadioProtocol->phase);
847    radioProtocol.technology = ConvertRadioProtocolTech(hrilRadioProtocol->technology);
848    radioProtocol.modemId = hrilRadioProtocol->modemId;
849    radioProtocol.status = static_cast<HDI::Ril::V1_1::RadioProtocolStatus>(hrilRadioProtocol->status);
850}
851
852int32_t HRilSim::ConvertRadioProtocolTech(int32_t tech)
853{
854    uint32_t radioProtocolTech = HRIL_RADIO_PROTOCOL_TECH_UNKNOWN;
855    for (uint32_t radioTech = RADIO_TECHNOLOGY_GSM; radioTech <= RADIO_TECHNOLOGY_NR; radioTech++) {
856        uint32_t protocolTech = 1 << radioTech;
857        if ((static_cast<uint32_t>(tech) & protocolTech) != 0) {
858            radioProtocolTech |= protocolTech;
859        }
860    }
861    return static_cast<int32_t>(radioProtocolTech);
862}
863} // namespace Telephony
864} // namespace OHOS
865