1/*
2 * Copyright (C) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "hril_network.h"
17
18#include <sys/time.h>
19
20#include "hril_notification.h"
21#include "hril_request.h"
22
23namespace OHOS {
24namespace Telephony {
25enum class NetworkParameter : int32_t {
26    RESPONSE_VALUE = 3,
27    INVALID_RESPONSE_VALUE = 11,
28};
29const int64_t NANO_TO_SECOND = 1000000000;
30
31HRilNetwork::HRilNetwork(int32_t slotId) : HRilBase(slotId)
32{
33    AddNotificationToMap();
34    AddBasicHandlerToMap();
35    AddNetworkSearchHandlerToMap();
36}
37
38void HRilNetwork::AddNotificationToMap()
39{
40    // indication
41    notiMemberFuncMap_[HNOTI_NETWORK_CS_REG_STATUS_UPDATED] =
42        [this](int32_t notifyType, HRilErrNumber error, const void *response,
43        size_t responseLen) { return NetworkCsRegStatusUpdated(notifyType, error, response, responseLen); };
44    notiMemberFuncMap_[HNOTI_NETWORK_SIGNAL_STRENGTH_UPDATED] =
45        [this](int32_t notifyType, HRilErrNumber error, const void *response,
46        size_t responseLen) { return SignalStrengthUpdated(notifyType, error, response, responseLen); };
47    notiMemberFuncMap_[HNOTI_NETWORK_TIME_UPDATED] =
48        [this](int32_t notifyType, HRilErrNumber error, const void *response,
49        size_t responseLen) { return NetworkTimeUpdated(notifyType, error, response, responseLen); };
50    notiMemberFuncMap_[HNOTI_NETWORK_TIME_ZONE_UPDATED] =
51        [this](int32_t notifyType, HRilErrNumber error, const void *response,
52        size_t responseLen) { return NetworkTimeZoneUpdated(notifyType, error, response, responseLen); };
53    notiMemberFuncMap_[HNOTI_NETWORK_PS_REG_STATUS_UPDATED] =
54        [this](int32_t notifyType, HRilErrNumber error, const void *response,
55        size_t responseLen) { return NetworkPsRegStatusUpdated(notifyType, error, response, responseLen); };
56    notiMemberFuncMap_[HNOTI_NETWORK_PHY_CHNL_CFG_UPDATED] =
57        [this](int32_t notifyType, HRilErrNumber error, const void *response,
58        size_t responseLen) { return NetworkPhyChnlCfgUpdated(notifyType, error, response, responseLen); };
59    notiMemberFuncMap_[HNOTI_NETWORK_CURRENT_CELL_UPDATED] =
60        [this](int32_t notifyType, HRilErrNumber error, const void *response,
61        size_t responseLen) { return NetworkCurrentCellUpdated_1_2(notifyType, error, response, responseLen); };
62    notiMemberFuncMap_[HNOTI_NETWORK_RRC_CONNECTION_STATE_UPDATED] =
63        [this](int32_t notifyType, HRilErrNumber error, const void *response,
64        size_t responseLen) { return GetRrcConnectionStateUpdated(notifyType, error, response, responseLen); };
65    notiMemberFuncMap_[HNOTI_NETWORK_RESIDENT_NETWORK_UPDATED] =
66        [this](int32_t notifyType, HRilErrNumber error, const void *response,
67        size_t responseLen) { return ResidentNetworkUpdated(notifyType, error, response, responseLen); };
68}
69
70void HRilNetwork::AddBasicHandlerToMap()
71{
72    // Response
73    respMemberFuncMap_[HREQ_NETWORK_GET_SIGNAL_STRENGTH] =
74        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
75        size_t responseLen) { return GetSignalStrengthResponse(requestNum, responseInfo, response, responseLen); };
76    respMemberFuncMap_[HREQ_NETWORK_GET_CS_REG_STATUS] =
77        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
78        size_t responseLen) { return GetCsRegStatusResponse(requestNum, responseInfo, response, responseLen); };
79    respMemberFuncMap_[HREQ_NETWORK_GET_PS_REG_STATUS] =
80        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
81        size_t responseLen) { return GetPsRegStatusResponse(requestNum, responseInfo, response, responseLen); };
82    respMemberFuncMap_[HREQ_NETWORK_GET_OPERATOR_INFO] =
83        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
84        size_t responseLen) { return GetOperatorInfoResponse(requestNum, responseInfo, response, responseLen); };
85    respMemberFuncMap_[HREQ_NETWORK_SET_LOCATE_UPDATES] =
86        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
87        size_t responseLen) { return SetLocateUpdatesResponse(requestNum, responseInfo, response, responseLen); };
88    respMemberFuncMap_[HREQ_NETWORK_SET_NOTIFICATION_FILTER] =
89        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
90        size_t responseLen) { return SetNotificationFilterResponse(requestNum, responseInfo, response, responseLen); };
91    respMemberFuncMap_[HREQ_NETWORK_SET_DEVICE_STATE] =
92        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
93        size_t responseLen) { return SetDeviceStateResponse(requestNum, responseInfo, response, responseLen); };
94    respMemberFuncMap_[HREQ_NETWORK_SET_NR_OPTION_MODE] =
95        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
96        size_t responseLen) { return SetNrOptionModeResponse(requestNum, responseInfo, response, responseLen); };
97    respMemberFuncMap_[HREQ_NETWORK_GET_NR_OPTION_MODE] =
98        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
99        size_t responseLen) { return GetNrOptionModeResponse(requestNum, responseInfo, response, responseLen); };
100    respMemberFuncMap_[HREQ_NETWORK_GET_RRC_CONNECTION_STATE] =
101        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
102        size_t responseLen) { return GetRrcConnectionStateResponse(requestNum, responseInfo, response, responseLen); };
103    respMemberFuncMap_[HREQ_NETWORK_GET_NR_SSBID_INFO] =
104        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
105        size_t responseLen) { return GetNrSsbIdResponse(requestNum, responseInfo, response, responseLen); };
106}
107
108void HRilNetwork::AddNetworkSearchHandlerToMap()
109{
110    respMemberFuncMap_[HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION] = [this](int32_t requestNum,
111        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
112        return GetNetworkSearchInformationResponse(requestNum, responseInfo, response, responseLen);
113    };
114    respMemberFuncMap_[HREQ_NETWORK_GET_NETWORK_SELECTION_MODE] = [this](int32_t requestNum,
115        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
116        return GetNetworkSelectionModeResponse(requestNum, responseInfo, response, responseLen);
117    };
118    respMemberFuncMap_[HREQ_NETWORK_SET_NETWORK_SELECTION_MODE] = [this](int32_t requestNum,
119        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
120        return SetNetworkSelectionModeResponse(requestNum, responseInfo, response, responseLen);
121    };
122    respMemberFuncMap_[HREQ_NETWORK_SET_PREFERRED_NETWORK] =
123        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
124        size_t responseLen) { return SetPreferredNetworkResponse(requestNum, responseInfo, response, responseLen); };
125    respMemberFuncMap_[HREQ_NETWORK_GET_PREFERRED_NETWORK] =
126        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
127        size_t responseLen) { return GetPreferredNetworkResponse(requestNum, responseInfo, response, responseLen); };
128    respMemberFuncMap_[HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST] = [this](int32_t requestNum,
129        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
130        return GetNeighboringCellInfoListResponse_1_2(requestNum, responseInfo, response, responseLen);
131    };
132    respMemberFuncMap_[HREQ_NETWORK_GET_CURRENT_CELL_INFO] =
133        [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
134        size_t responseLen) { return GetCurrentCellInfoResponse_1_2(requestNum, responseInfo, response, responseLen); };
135    respMemberFuncMap_[HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG] = [this](int32_t requestNum,
136        HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
137        return GetPhysicalChannelConfigResponse(requestNum, responseInfo, response, responseLen);
138    };
139}
140
141int32_t HRilNetwork::GetSignalStrength(int32_t serialId)
142{
143    return RequestVendor(serialId, HREQ_NETWORK_GET_SIGNAL_STRENGTH, networkFuncs_, &HRilNetworkReq::GetSignalStrength);
144}
145
146int32_t HRilNetwork::GetCsRegStatus(int32_t serialId)
147{
148    return RequestVendor(serialId, HREQ_NETWORK_GET_CS_REG_STATUS, networkFuncs_, &HRilNetworkReq::GetCsRegStatus);
149}
150
151int32_t HRilNetwork::GetPsRegStatus(int32_t serialId)
152{
153    return RequestVendor(serialId, HREQ_NETWORK_GET_PS_REG_STATUS, networkFuncs_, &HRilNetworkReq::GetPsRegStatus);
154}
155
156int32_t HRilNetwork::GetOperatorInfo(int32_t serialId)
157{
158    return RequestVendor(serialId, HREQ_NETWORK_GET_OPERATOR_INFO, networkFuncs_, &HRilNetworkReq::GetOperatorInfo);
159}
160
161int32_t HRilNetwork::GetNeighboringCellInfoList(int32_t serialId)
162{
163    return RequestVendor(serialId, HREQ_NETWORK_GET_NEIGHBORING_CELLINFO_LIST, networkFuncs_,
164        &HRilNetworkReq::GetNeighboringCellInfoList);
165}
166
167int32_t HRilNetwork::GetCurrentCellInfo(int32_t serialId)
168{
169    return RequestVendor(
170        serialId, HREQ_NETWORK_GET_CURRENT_CELL_INFO, networkFuncs_, &HRilNetworkReq::GetCurrentCellInfo);
171}
172
173int32_t HRilNetwork::GetNetworkSearchInformation(int32_t serialId)
174{
175    return RequestVendor(serialId, HREQ_NETWORK_GET_NETWORK_SEARCH_INFORMATION, networkFuncs_,
176        &HRilNetworkReq::GetNetworkSearchInformation);
177}
178
179int32_t HRilNetwork::GetNetworkSelectionMode(int32_t serialId)
180{
181    return RequestVendor(serialId, HREQ_NETWORK_GET_NETWORK_SELECTION_MODE, networkFuncs_,
182        &HRilNetworkReq::GetNetworkSelectionMode);
183}
184
185int32_t HRilNetwork::SetNetworkSelectionMode(
186    int32_t serialId, const HDI::Ril::V1_1::SetNetworkModeInfo &networkModeInfo)
187{
188    HRilSetNetworkModeInfo setNetworkModeInfo = {};
189    setNetworkModeInfo.selectMode = networkModeInfo.selectMode;
190    ConvertToString(&setNetworkModeInfo.oper, networkModeInfo.oper);
191    TELEPHONY_LOGI("HRilNetwork::SetNetworkSelectionMode selectMode = %{public}d", setNetworkModeInfo.selectMode);
192    return RequestVendor(serialId, HREQ_NETWORK_SET_NETWORK_SELECTION_MODE, networkFuncs_,
193        &HRilNetworkReq::SetNetworkSelectionMode, &setNetworkModeInfo);
194}
195
196int32_t HRilNetwork::SetPreferredNetwork(int32_t serialId, int32_t preferredNetworkType)
197{
198    return RequestVendor(serialId, HREQ_NETWORK_SET_PREFERRED_NETWORK, networkFuncs_,
199        &HRilNetworkReq::SetPreferredNetwork, &preferredNetworkType);
200}
201
202int32_t HRilNetwork::GetPreferredNetwork(int32_t serialId)
203{
204    return RequestVendor(serialId, HREQ_NETWORK_GET_PREFERRED_NETWORK, networkFuncs_,
205        &HRilNetworkReq::GetPreferredNetwork);
206}
207
208int32_t HRilNetwork::GetPhysicalChannelConfig(int32_t serialId)
209{
210    return RequestVendor(serialId, HREQ_NETWORK_GET_PHYSICAL_CHANNEL_CONFIG, networkFuncs_,
211        &HRilNetworkReq::GetPhysicalChannelConfig);
212}
213
214int32_t HRilNetwork::SetLocateUpdates(int32_t serialId, const HDI::Ril::V1_1::RilRegNotifyMode mode)
215{
216    HRilRegNotifyMode regNotifyMode = static_cast<HRilRegNotifyMode>(mode);
217    if ((regNotifyMode < REG_NOT_NOTIFY) || (regNotifyMode > REG_NOTIFY_STAT_LAC_CELLID)) {
218        TELEPHONY_LOGE("SetLocateUpdates Invalid regNotifyMode parameter");
219        return HRIL_ERR_INVALID_PARAMETER;
220    }
221    return RequestVendor(serialId, HREQ_NETWORK_SET_LOCATE_UPDATES, networkFuncs_,
222        &HRilNetworkReq::SetLocateUpdates, static_cast<HRilRegNotifyMode>(mode));
223}
224
225int32_t HRilNetwork::SetNotificationFilter(int32_t serialId, int32_t newFilter)
226{
227    return RequestVendor(serialId, HREQ_NETWORK_SET_NOTIFICATION_FILTER, networkFuncs_,
228        &HRilNetworkReq::SetNotificationFilter, &newFilter);
229}
230
231int32_t HRilNetwork::SetDeviceState(int32_t serialId, int32_t deviceStateType, int32_t deviceStateOn)
232{
233    return RequestVendor(serialId, HREQ_NETWORK_SET_DEVICE_STATE, networkFuncs_,
234        &HRilNetworkReq::SetDeviceState, &deviceStateType, &deviceStateOn);
235}
236
237int32_t HRilNetwork::SetNrOptionMode(int32_t serialId, int32_t mode)
238{
239    return RequestVendor(
240        serialId, HREQ_NETWORK_SET_NR_OPTION_MODE, networkFuncs_, &HRilNetworkReq::SetNrOptionMode, &mode);
241}
242
243int32_t HRilNetwork::GetNrOptionMode(int32_t serialId)
244{
245    return RequestVendor(serialId, HREQ_NETWORK_GET_NR_OPTION_MODE, networkFuncs_, &HRilNetworkReq::GetNrOptionMode);
246}
247
248int32_t HRilNetwork::GetRrcConnectionState(int32_t serialId)
249{
250    return RequestVendor(
251        serialId, HREQ_NETWORK_GET_RRC_CONNECTION_STATE, networkFuncs_, &HRilNetworkReq::GetRrcConnectionState);
252}
253
254int32_t HRilNetwork::GetNrSsbId(int32_t serialId)
255{
256    return RequestVendor(
257        serialId, HREQ_NETWORK_GET_NR_SSBID_INFO, networkFuncs_, &HRilNetworkReq::GetNrSsbId);
258}
259
260int32_t HRilNetwork::GetSignalStrengthResponse(
261    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
262{
263    HDI::Ril::V1_1::Rssi rssi = {};
264    if (response == nullptr || responseLen != sizeof(HRilRssi)) {
265        TELEPHONY_LOGE("GetSignalStrengthResponse response is invalid");
266        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
267            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
268        }
269    } else {
270        ExchangeRilRssiToHdf(response, rssi);
271    }
272    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetSignalStrengthResponse, rssi);
273}
274
275int32_t HRilNetwork::GetCsRegStatusResponse(
276    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
277{
278    HDI::Ril::V1_1::CsRegStatusInfo csRegStatusInfo = {};
279    if (response == nullptr || responseLen != sizeof(HRilRegStatusInfo)) {
280        TELEPHONY_LOGE("GetCsRegStatusResponse response is invalid");
281        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
282            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
283        }
284    } else {
285        const HRilRegStatusInfo *hrilRegStatusInfo = static_cast<const HRilRegStatusInfo *>(response);
286        csRegStatusInfo.notifyType = hrilRegStatusInfo->notifyMode;
287        csRegStatusInfo.regStatus = static_cast<HDI::Ril::V1_1::RilRegStatus>(hrilRegStatusInfo->regStatus);
288        csRegStatusInfo.lacCode = hrilRegStatusInfo->lacCode;
289        csRegStatusInfo.cellId = hrilRegStatusInfo->cellId;
290        csRegStatusInfo.radioTechnology = static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilRegStatusInfo->actType);
291        TELEPHONY_LOGD("GetCsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, "
292                       "lacCode:%{private}d, cellId:%{private}d, radioTechnology:%{public}d",
293            csRegStatusInfo.notifyType, csRegStatusInfo.regStatus, csRegStatusInfo.lacCode, csRegStatusInfo.cellId,
294            csRegStatusInfo.radioTechnology);
295    }
296    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCsRegStatusResponse, csRegStatusInfo);
297}
298
299int32_t HRilNetwork::GetPsRegStatusResponse(
300    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
301{
302    HDI::Ril::V1_1::PsRegStatusInfo psRegStatusInfo = {};
303    if (response == nullptr || responseLen != sizeof(HRilRegStatusInfo)) {
304        TELEPHONY_LOGE("GetPsRegStatusResponse response is invalid");
305        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
306            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
307        }
308    } else {
309        const HRilRegStatusInfo *hrilRegStatusInfo = static_cast<const HRilRegStatusInfo *>(response);
310        psRegStatusInfo.notifyType = hrilRegStatusInfo->notifyMode;
311        psRegStatusInfo.regStatus = static_cast<HDI::Ril::V1_1::RilRegStatus>(hrilRegStatusInfo->regStatus);
312        psRegStatusInfo.lacCode = hrilRegStatusInfo->lacCode;
313        psRegStatusInfo.cellId = hrilRegStatusInfo->cellId;
314        psRegStatusInfo.radioTechnology = static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilRegStatusInfo->actType);
315        psRegStatusInfo.isDcNrRestricted = hrilRegStatusInfo->isDcNrRestricted;
316        psRegStatusInfo.isNrAvailable = hrilRegStatusInfo->isNrAvailable;
317        psRegStatusInfo.isEnDcAvailable = hrilRegStatusInfo->isEnDcAvailable;
318        TELEPHONY_LOGD(
319            "GetPsRegStatusResponse notifyType:%{public}d, regStatus:%{public}d, lacCode:%{private}d, "
320            "cellId:%{private}d, technology:%{public}d, isDcNrRestricted:%{private}d, isNrAvailable:%{private}d, "
321            "isEnDcAvailable:%{private}d",
322            psRegStatusInfo.notifyType, psRegStatusInfo.regStatus, psRegStatusInfo.lacCode, psRegStatusInfo.cellId,
323            psRegStatusInfo.radioTechnology, psRegStatusInfo.isDcNrRestricted, psRegStatusInfo.isNrAvailable,
324            psRegStatusInfo.isEnDcAvailable);
325    }
326    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetPsRegStatusResponse, psRegStatusInfo);
327}
328
329int32_t HRilNetwork::GetOperatorInfoResponse(
330    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
331{
332    HDI::Ril::V1_1::OperatorInfo operatorInfoResult = {};
333    if (response == nullptr || responseLen == 0) {
334        TELEPHONY_LOGE("GetOperatorInfoResponse response is invalid");
335        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
336            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
337        }
338    } else {
339        char **resp = static_cast<char **>(const_cast<void *>(response));
340        operatorInfoResult.longName = (resp[HRIL_LONE_NAME] == nullptr) ? "" : resp[HRIL_LONE_NAME];
341        operatorInfoResult.shortName = (resp[HRIL_SHORT_NAME] == nullptr) ? "" : resp[HRIL_SHORT_NAME];
342        operatorInfoResult.numeric = (resp[HRIL_NUMERIC] == nullptr) ? "" : resp[HRIL_NUMERIC];
343        TELEPHONY_LOGD("GetOperatorInfoResponse longName:%{public}s, shortName:%{public}s, numeric:%{public}s",
344            operatorInfoResult.longName.c_str(), operatorInfoResult.shortName.c_str(),
345            operatorInfoResult.numeric.c_str());
346    }
347    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetOperatorInfoResponse, operatorInfoResult);
348}
349
350int32_t HRilNetwork::GetNetworkSearchInformationResponse(
351    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
352{
353    HDI::Ril::V1_1::AvailableNetworkList availableNetworkList = {};
354    if (response == nullptr || responseLen == 0) {
355        TELEPHONY_LOGE("GetNetworkSearchInformationResponse response is invalid");
356        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
357            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
358        }
359    } else {
360        availableNetworkList.itemNum = 0;
361        BuildOperatorList(availableNetworkList, response, responseLen);
362    }
363    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetNetworkSearchInformationResponse,
364        availableNetworkList);
365}
366
367int32_t HRilNetwork::GetNetworkSelectionModeResponse(
368    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
369{
370    HDI::Ril::V1_1::SetNetworkModeInfo selectModeInfo = {};
371    if (response == nullptr || responseLen != sizeof(int32_t)) {
372        TELEPHONY_LOGE("GetNetworkSelectionModeResponse response is invalid");
373        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
374            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
375        }
376    } else {
377        int32_t *resp = static_cast<int32_t *>(const_cast<void *>(response));
378        selectModeInfo.selectMode = *resp;
379        TELEPHONY_LOGI("GetNetworkSelectionModeResponse selectMode: %{public}d", selectModeInfo.selectMode);
380    }
381    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetNetworkSelectionModeResponse, selectModeInfo);
382}
383
384int32_t HRilNetwork::SetNetworkSelectionModeResponse(
385    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
386{
387    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetNetworkSelectionModeResponse);
388}
389
390int32_t HRilNetwork::SetPreferredNetworkResponse(
391    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
392{
393    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetPreferredNetworkResponse);
394}
395
396int32_t HRilNetwork::GetPreferredNetworkResponse(
397    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
398{
399    HDI::Ril::V1_1::PreferredNetworkTypeInfo preferredNetworkTypeInfo = {};
400    if (response == nullptr || responseLen != sizeof(int32_t)) {
401        TELEPHONY_LOGE("GetPreferredNetworkResponse response is invalid");
402        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
403            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
404        }
405    } else {
406        int32_t *resp = static_cast<int32_t *>(const_cast<void *>(response));
407        preferredNetworkTypeInfo.preferredNetworkType = *resp;
408        TELEPHONY_LOGI("GetPreferredNetworkResponse preferredNetworkType: %{public}d", *resp);
409    }
410    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetPreferredNetworkResponse, preferredNetworkTypeInfo);
411}
412
413int32_t HRilNetwork::GetNeighboringCellInfoListResponse(
414    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
415{
416    HDI::Ril::V1_1::CellListNearbyInfo cellInfoList;
417    if (response == nullptr || responseLen != sizeof(CellInfoList)) {
418        TELEPHONY_LOGE("GetNeighboringCellInfoListResponse response is invalid");
419        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
420            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
421        }
422    } else {
423        cellInfoList.itemNum = 0;
424        cellInfoList.cellNearbyInfo.clear();
425        if (BuildNeighboringCellList(cellInfoList, response, responseLen) != 0) {
426            TELEPHONY_LOGE("GetNeighboringCellInfoListResponse BuildNeighboringCellList failed");
427            return HRIL_ERR_GENERIC_FAILURE;
428        }
429    }
430    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetNeighboringCellInfoListResponse, cellInfoList);
431}
432
433int32_t HRilNetwork::GetNeighboringCellInfoListResponse_1_2(
434    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
435{
436    HDI::Ril::V1_2::CellListNearbyInfo_1_2 cellInfoList;
437    if (response == nullptr || responseLen != sizeof(CellInfoList)) {
438        TELEPHONY_LOGE("response is invalid");
439        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
440            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
441        }
442    } else {
443        cellInfoList.itemNum = 0;
444        cellInfoList.cellNearbyInfo.clear();
445        if (BuildNeighboringCellList(cellInfoList, response, responseLen) != 0) {
446            TELEPHONY_LOGE("BuildNeighboringCellList failed");
447            return HRIL_ERR_GENERIC_FAILURE;
448        }
449    }
450    return Response(responseInfo, &HDI::Ril::V1_2::IRilCallback::GetNeighboringCellInfoListResponse_1_2, cellInfoList);
451}
452
453int32_t HRilNetwork::GetCurrentCellInfoResponse(
454    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
455{
456    HDI::Ril::V1_1::CellListCurrentInfo cellList;
457    if (response == nullptr || responseLen != sizeof(CurrentCellInfoList)) {
458        TELEPHONY_LOGE("GetCurrentCellInfoResponse response is invalid");
459        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
460            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
461        }
462    } else {
463        cellList.itemNum = 0;
464        cellList.cellCurrentInfo.clear();
465        if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
466            TELEPHONY_LOGE("GetCurrentCellInfoResponse BuildCurrentCellList failed");
467            return HRIL_ERR_GENERIC_FAILURE;
468        }
469    }
470    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCurrentCellInfoResponse, cellList);
471}
472
473int32_t HRilNetwork::GetCurrentCellInfoResponse_1_1(
474    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
475{
476    HDI::Ril::V1_1::CellListCurrentInfo_1_1 cellList;
477    if (response == nullptr || responseLen != sizeof(CurrentCellInfoList)) {
478        TELEPHONY_LOGE("response is invalid");
479        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
480            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
481        }
482    } else {
483        cellList.itemNum = 0;
484        cellList.cellCurrentInfo.clear();
485        if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
486            TELEPHONY_LOGE("BuildCurrentCellList failed");
487            return HRIL_ERR_GENERIC_FAILURE;
488        }
489    }
490    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetCurrentCellInfoResponse_1_1, cellList);
491}
492
493int32_t HRilNetwork::GetCurrentCellInfoResponse_1_2(
494    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
495{
496    HDI::Ril::V1_2::CellListCurrentInfo_1_2 cellList;
497    if (response == nullptr || responseLen != sizeof(CurrentCellInfoList)) {
498        TELEPHONY_LOGE("response is invalid");
499        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
500            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
501        }
502    } else {
503        cellList.itemNum = 0;
504        cellList.cellCurrentInfo.clear();
505        if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
506            TELEPHONY_LOGE("BuildCurrentCellList failed");
507            return HRIL_ERR_GENERIC_FAILURE;
508        }
509    }
510    return Response(responseInfo, &HDI::Ril::V1_2::IRilCallback::GetCurrentCellInfoResponse_1_2, cellList);
511}
512
513int32_t HRilNetwork::GetPhysicalChannelConfigResponse(
514    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
515{
516    HDI::Ril::V1_1::ChannelConfigInfoList phyChnlCfgList = {};
517    if (response == nullptr || responseLen != sizeof(HRilChannelConfigList)) {
518        TELEPHONY_LOGE("GetPhysicalChannelConfigResponse response is invalid");
519        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
520            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
521        }
522    } else {
523        phyChnlCfgList.itemNum = 0;
524        phyChnlCfgList.channelConfigInfos.clear();
525        const HRilChannelConfigList *hrilChannelConfigList = static_cast<const HRilChannelConfigList *>(response);
526        phyChnlCfgList.itemNum = hrilChannelConfigList->itemNum;
527        for (int32_t i = 0; i < phyChnlCfgList.itemNum; i++) {
528            HDI::Ril::V1_1::PhysicalChannelConfig phyChnlCfg;
529            phyChnlCfg.cellConnStatus = static_cast<HDI::Ril::V1_1::RilCellConnectionStatus>(
530                hrilChannelConfigList->channelConfigs[i].cellConnStatus);
531            phyChnlCfg.cellBandwidthDownlinkKhz = hrilChannelConfigList->channelConfigs[i].cellBandwidthDownlinkKhz;
532            phyChnlCfg.cellBandwidthUplinkKhz = hrilChannelConfigList->channelConfigs[i].cellBandwidthUplinkKhz;
533            phyChnlCfg.ratType =
534                static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilChannelConfigList->channelConfigs[i].ratType);
535            phyChnlCfg.freqRange = hrilChannelConfigList->channelConfigs[i].freqRange;
536            phyChnlCfg.downlinkChannelNum = hrilChannelConfigList->channelConfigs[i].downlinkChannelNum;
537            phyChnlCfg.uplinkChannelNum = hrilChannelConfigList->channelConfigs[i].uplinkChannelNum;
538            phyChnlCfg.physicalCellId = hrilChannelConfigList->channelConfigs[i].physicalCellId;
539            phyChnlCfg.contextIdNum = hrilChannelConfigList->channelConfigs[i].contextIdNum;
540            TELEPHONY_LOGI(
541                "GetPhysicalChannelConfigResponse cellConnStatus:%{private}d, "
542                "cellBandwidthDownlinkKhz:%{private}d, cellBandwidthUplinkKhz:%{private}d, physicalCellId:%{private}d, "
543                "ratType:%{private}d, freqRange:%{private}d, downlinkChannelNum:%{private}d, "
544                "uplinkChannelNum:%{private}d, contextIdNum:%{private}d",
545                phyChnlCfg.cellConnStatus, phyChnlCfg.cellBandwidthDownlinkKhz, phyChnlCfg.cellBandwidthUplinkKhz,
546                phyChnlCfg.ratType, phyChnlCfg.freqRange, phyChnlCfg.downlinkChannelNum, phyChnlCfg.uplinkChannelNum,
547                phyChnlCfg.physicalCellId, phyChnlCfg.contextIdNum);
548            for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
549                phyChnlCfg.contextIds.push_back(hrilChannelConfigList->channelConfigs[i].contextIds[j]);
550                TELEPHONY_LOGI("contextIds:%{public}d---contextId:%{private}d", j, phyChnlCfg.contextIds[j]);
551            }
552            phyChnlCfgList.channelConfigInfos.push_back(phyChnlCfg);
553        }
554        TELEPHONY_LOGI("GetPhysicalChannelConfigResponse itemNum:%{public}d", phyChnlCfgList.itemNum);
555    }
556    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetPhysicalChannelConfigResponse, phyChnlCfgList);
557}
558
559int32_t HRilNetwork::SetLocateUpdatesResponse(
560    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
561{
562    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetLocateUpdatesResponse);
563}
564
565int32_t HRilNetwork::SetNotificationFilterResponse(
566    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
567{
568    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetNotificationFilterResponse);
569}
570
571int32_t HRilNetwork::SetDeviceStateResponse(
572    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
573{
574    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetDeviceStateResponse);
575}
576
577int32_t HRilNetwork::SetNrOptionModeResponse(
578    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
579{
580    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetNrOptionModeResponse);
581}
582
583int32_t HRilNetwork::GetNrOptionModeResponse(
584    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
585{
586    int32_t nrOptionMode = 0;
587    if (response == nullptr || responseLen != sizeof(int32_t)) {
588        TELEPHONY_LOGE("GetNrOptionModeResponse response is invalid");
589        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
590            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
591        }
592    } else {
593        nrOptionMode = *(static_cast<const int32_t *>(response));
594        TELEPHONY_LOGI("GetNrOptionModeResponse nrOptionMode: %{public}d", nrOptionMode);
595    }
596    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetNrOptionModeResponse, nrOptionMode);
597}
598
599int32_t HRilNetwork::GetRrcConnectionStateResponse(
600    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
601{
602    int32_t rrcConnectionState = 0;
603    if (response == nullptr || responseLen != sizeof(int32_t)) {
604        TELEPHONY_LOGE("GetRrcConnectionStateResponse response is invalid");
605        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
606            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
607        }
608    } else {
609        rrcConnectionState = *(static_cast<const int32_t *>(response));
610        TELEPHONY_LOGD("GetRrcConnectionStateResponse rrcConnectionState: %{public}d", rrcConnectionState);
611    }
612    return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetRrcConnectionStateResponse, rrcConnectionState);
613}
614
615int32_t HRilNetwork::GetNrSsbIdResponse(
616    int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
617{
618    HDI::Ril::V1_2::NrCellSsbIds nrCellSsbIds;
619    if (response == nullptr || responseLen != sizeof(NrCellSsbIdsVendor)) {
620        TELEPHONY_LOGE("Response is invalid");
621        if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
622            responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
623        }
624    } else {
625        nrCellSsbIds.arfcn = 0;
626        nrCellSsbIds.cid = 0;
627        nrCellSsbIds.pic = 0;
628        nrCellSsbIds.rsrp = 0;
629        nrCellSsbIds.sinr = 0;
630        nrCellSsbIds.timeAdvance = 0;
631        nrCellSsbIds.sCellSsbList.clear();
632        nrCellSsbIds.nbCellCount = 0;
633        nrCellSsbIds.nbCellSsbList.clear();
634        if (BuildNrCellSsbIdsInfo(nrCellSsbIds, response, responseLen) != 0) {
635            TELEPHONY_LOGE("BuildNrCellSsbIdsInfo failed");
636            return HRIL_ERR_GENERIC_FAILURE;
637        }
638    }
639    return Response(responseInfo, &HDI::Ril::V1_2::IRilCallback::GetNrSsbIdResponse, nrCellSsbIds);
640}
641
642int32_t HRilNetwork::NetworkCsRegStatusUpdated(
643    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
644{
645    if (response == nullptr || responseLen != sizeof(HRilRegStatusInfo)) {
646        TELEPHONY_LOGE("response is invalid");
647        return HRIL_ERR_INVALID_PARAMETER;
648    }
649    HDI::Ril::V1_1::CsRegStatusInfo regStatusInfoNotify = {};
650    const HRilRegStatusInfo *hrilRegStatusInfo = static_cast<const HRilRegStatusInfo *>(response);
651    regStatusInfoNotify.notifyType = hrilRegStatusInfo->notifyMode;
652    regStatusInfoNotify.regStatus = static_cast<HDI::Ril::V1_1::RilRegStatus>(hrilRegStatusInfo->regStatus);
653    regStatusInfoNotify.lacCode = hrilRegStatusInfo->lacCode;
654    regStatusInfoNotify.cellId = hrilRegStatusInfo->cellId;
655    regStatusInfoNotify.radioTechnology = static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilRegStatusInfo->actType);
656    TELEPHONY_LOGD("notifyType:%{public}d, regStatus:%{public}d, "
657                   "lacCode:%{private}d, cellId:%{private}d, radioTechnology:%{public}d",
658        regStatusInfoNotify.notifyType, regStatusInfoNotify.regStatus, regStatusInfoNotify.lacCode,
659        regStatusInfoNotify.cellId, regStatusInfoNotify.radioTechnology);
660    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkCsRegStatusUpdated, regStatusInfoNotify);
661}
662
663int32_t HRilNetwork::NetworkPsRegStatusUpdated(
664    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
665{
666    if (response == nullptr || responseLen != sizeof(HRilRegStatusInfo)) {
667        TELEPHONY_LOGE("response is invalid");
668        return HRIL_ERR_INVALID_PARAMETER;
669    }
670    HDI::Ril::V1_1::PsRegStatusInfo regStatusInfoNotify = {};
671    const HRilRegStatusInfo *hrilRegStatusInfo = static_cast<const HRilRegStatusInfo *>(response);
672    regStatusInfoNotify.notifyType = hrilRegStatusInfo->notifyMode;
673    regStatusInfoNotify.regStatus = static_cast<HDI::Ril::V1_1::RilRegStatus>(hrilRegStatusInfo->regStatus);
674    regStatusInfoNotify.lacCode = hrilRegStatusInfo->lacCode;
675    regStatusInfoNotify.cellId = hrilRegStatusInfo->cellId;
676    regStatusInfoNotify.radioTechnology = static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilRegStatusInfo->actType);
677    regStatusInfoNotify.isDcNrRestricted = hrilRegStatusInfo->isDcNrRestricted;
678    regStatusInfoNotify.isNrAvailable = hrilRegStatusInfo->isNrAvailable;
679    regStatusInfoNotify.isEnDcAvailable = hrilRegStatusInfo->isEnDcAvailable;
680    TELEPHONY_LOGD(
681        "notifyType:%{public}d, regStatus:%{public}d, lacCode:%{private}d, cellId:%{private}d, "
682        "radioTechnology:%{public}d, isDcNrRestricted:%{private}d, isNrAvailable:%{private}d, "
683        "isEnDcAvailable:%{private}d",
684        regStatusInfoNotify.notifyType, regStatusInfoNotify.regStatus, regStatusInfoNotify.lacCode,
685        regStatusInfoNotify.cellId, regStatusInfoNotify.radioTechnology, regStatusInfoNotify.isDcNrRestricted,
686        regStatusInfoNotify.isNrAvailable, regStatusInfoNotify.isEnDcAvailable);
687    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkPsRegStatusUpdated, regStatusInfoNotify);
688}
689
690int32_t HRilNetwork::SignalStrengthUpdated(
691    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
692{
693    if (response == nullptr || responseLen != sizeof(HRilRssi)) {
694        TELEPHONY_LOGE("SignalStrengthUpdated response is invalid");
695        return HRIL_ERR_INVALID_PARAMETER;
696    }
697    HDI::Ril::V1_1::Rssi rssi = {};
698    ExchangeRilRssiToHdf(response, rssi);
699    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::SignalStrengthUpdated, rssi);
700}
701
702int32_t HRilNetwork::NetworkTimeUpdated(
703    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
704{
705    if (response == nullptr) {
706        TELEPHONY_LOGE("NetworkTimeUpdated response is invalid");
707        return HRIL_ERR_INVALID_PARAMETER;
708    }
709    int64_t nitzRecvTime = 0;
710    struct timespec tv {};
711    if (clock_gettime(CLOCK_BOOTTIME, &tv) < 0) {
712        nitzRecvTime = 0;
713    } else {
714        nitzRecvTime = tv.tv_sec * NANO_TO_SECOND + tv.tv_nsec;
715    }
716    std::string str = ";" + std::to_string(nitzRecvTime);
717    std::string nitzStr = (char *)response;
718    nitzStr += str;
719    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkTimeUpdated, (const char *)(nitzStr.data()));
720}
721
722int32_t HRilNetwork::NetworkTimeZoneUpdated(
723    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
724{
725    if (response == nullptr) {
726        TELEPHONY_LOGE("NetworkTimeZoneUpdated response is invalid");
727        return HRIL_ERR_INVALID_PARAMETER;
728    }
729    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkTimeZoneUpdated, (const char *)response);
730}
731
732int32_t HRilNetwork::NetworkPhyChnlCfgUpdated(
733    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
734{
735    if (response == nullptr || responseLen != sizeof(HRilChannelConfigList)) {
736        TELEPHONY_LOGE("NetworkPhyChnlCfgUpdated response is invalid");
737        return HRIL_ERR_INVALID_PARAMETER;
738    }
739    HDI::Ril::V1_1::ChannelConfigInfoList phyChnlCfgList = {};
740    phyChnlCfgList.itemNum = 0;
741    phyChnlCfgList.channelConfigInfos.clear();
742    const HRilChannelConfigList *hrilChannelConfigList = static_cast<const HRilChannelConfigList *>(response);
743    phyChnlCfgList.itemNum = hrilChannelConfigList->itemNum;
744    for (int32_t i = 0; i < phyChnlCfgList.itemNum; i++) {
745        HDI::Ril::V1_1::PhysicalChannelConfig phyChnlCfg;
746        phyChnlCfg.cellConnStatus = static_cast<HDI::Ril::V1_1::RilCellConnectionStatus>(
747            hrilChannelConfigList->channelConfigs[i].cellConnStatus);
748        phyChnlCfg.cellBandwidthDownlinkKhz = hrilChannelConfigList->channelConfigs[i].cellBandwidthDownlinkKhz;
749        phyChnlCfg.cellBandwidthUplinkKhz = hrilChannelConfigList->channelConfigs[i].cellBandwidthUplinkKhz;
750        phyChnlCfg.ratType =
751            static_cast<HDI::Ril::V1_1::RilRadioTech>(hrilChannelConfigList->channelConfigs[i].ratType);
752        phyChnlCfg.freqRange = hrilChannelConfigList->channelConfigs[i].freqRange;
753        phyChnlCfg.downlinkChannelNum = hrilChannelConfigList->channelConfigs[i].downlinkChannelNum;
754        phyChnlCfg.uplinkChannelNum = hrilChannelConfigList->channelConfigs[i].uplinkChannelNum;
755        phyChnlCfg.physicalCellId = hrilChannelConfigList->channelConfigs[i].physicalCellId;
756        phyChnlCfg.contextIdNum = hrilChannelConfigList->channelConfigs[i].contextIdNum;
757        for (int32_t j = 0; j < phyChnlCfg.contextIdNum; j++) {
758            phyChnlCfg.contextIds.push_back(hrilChannelConfigList->channelConfigs[i].contextIds[j]);
759        }
760        phyChnlCfgList.channelConfigInfos.push_back(phyChnlCfg);
761    }
762    TELEPHONY_LOGI("NetworkPhyChnlCfgUpdated itemNum:%{public}d", phyChnlCfgList.itemNum);
763    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkPhyChnlCfgUpdated, phyChnlCfgList);
764}
765
766int32_t HRilNetwork::NetworkCurrentCellUpdated(
767    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
768{
769    if (response == nullptr || responseLen != sizeof(HRilRegStatusInfo)) {
770        TELEPHONY_LOGE("NetworkCurrentCellUpdated response is invalid");
771        return HRIL_ERR_INVALID_PARAMETER;
772    }
773    HDI::Ril::V1_1::CellListCurrentInfo cellList;
774    cellList.itemNum = 0;
775    cellList.cellCurrentInfo.clear();
776    if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
777        TELEPHONY_LOGE("NetworkCurrentCellUpdated BuildCurrentCellList failed");
778        return HRIL_ERR_GENERIC_FAILURE;
779    }
780    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkCurrentCellUpdated, cellList);
781}
782
783int32_t HRilNetwork::NetworkCurrentCellUpdated_1_2(
784    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
785{
786    if (response == nullptr || responseLen != sizeof(CurrentCellInfoList)) {
787        TELEPHONY_LOGE("response is invalid");
788        return HRIL_ERR_INVALID_PARAMETER;
789    }
790    HDI::Ril::V1_2::CellListCurrentInfo_1_2 cellList;
791    cellList.itemNum = 0;
792    cellList.cellCurrentInfo.clear();
793    if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
794        TELEPHONY_LOGE("BuildCurrentCellInfoList failed");
795        return HRIL_ERR_GENERIC_FAILURE;
796    }
797    return Notify(indType, error, &HDI::Ril::V1_2::IRilCallback::NetworkCurrentCellUpdated_1_2, cellList);
798}
799
800int32_t HRilNetwork::GetRrcConnectionStateUpdated(
801    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
802{
803    if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
804        TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
805        return HRIL_ERR_INVALID_PARAMETER;
806    }
807    if (response == nullptr) {
808        TELEPHONY_LOGE("response is null");
809        return HRIL_ERR_NULL_POINT;
810    }
811    return Notify(
812        indType, error, &HDI::Ril::V1_1::IRilCallback::GetRrcConnectionStateUpdated, *(const int32_t *)response);
813}
814
815int32_t HRilNetwork::NetworkCurrentCellUpdated_1_1(
816    int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
817{
818    if (response == nullptr || responseLen != sizeof(CurrentCellInfoList)) {
819        TELEPHONY_LOGE("response is invalid");
820        return HRIL_ERR_INVALID_PARAMETER;
821    }
822    HDI::Ril::V1_1::CellListCurrentInfo_1_1 cellList;
823    cellList.itemNum = 0;
824    cellList.cellCurrentInfo.clear();
825    if (BuildCurrentCellList(cellList, response, responseLen) != 0) {
826        TELEPHONY_LOGE("BuildCurrentCellList failed");
827        return HRIL_ERR_GENERIC_FAILURE;
828    }
829    return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::NetworkCurrentCellUpdated_1_1, cellList);
830}
831
832int32_t HRilNetwork::ResidentNetworkUpdated(int32_t indType, const HRilErrNumber error, const void *response,
833    size_t responseLen)
834{
835    if (response == nullptr) {
836        TELEPHONY_LOGE("ResidentNetworkUpdated response is invalid");
837        return HRIL_ERR_INVALID_PARAMETER;
838    }
839    return Notify(indType, error, &HDI::Ril::V1_2::IRilCallback::ResidentNetworkUpdated, (const char *)response);
840}
841
842void HRilNetwork::ExchangeRilRssiToHdf(const void *response, HDI::Ril::V1_1::Rssi &rssi)
843{
844    HRilRssi *rilRssi = (HRilRssi *)response;
845    rssi.gw.rxlev = rilRssi->gsmRssi.rxlev;
846    rssi.gw.ber = rilRssi->gsmRssi.ber;
847    rssi.cdma.absoluteRssi = rilRssi->cdmaRssi.absoluteRssi;
848    rssi.cdma.ecno = rilRssi->cdmaRssi.ecno;
849    rssi.wcdma.rxlev = rilRssi->wcdmaRssi.rxlev;
850    rssi.wcdma.ber = rilRssi->wcdmaRssi.ber;
851    rssi.wcdma.ecio = rilRssi->wcdmaRssi.ecio;
852    rssi.wcdma.rscp = rilRssi->wcdmaRssi.rscp;
853    rssi.lte.rxlev = rilRssi->lteRssi.rxlev;
854    rssi.lte.rsrp = rilRssi->lteRssi.rsrp;
855    rssi.lte.rsrq = rilRssi->lteRssi.rsrq;
856    rssi.lte.snr = rilRssi->lteRssi.snr;
857    rssi.tdScdma.rscp = rilRssi->tdScdmaRssi.rscp;
858    rssi.nr.rsrp = rilRssi->nrRssi.rsrp;
859    rssi.nr.rsrq = rilRssi->nrRssi.rsrq;
860    rssi.nr.sinr = rilRssi->nrRssi.sinr;
861    TELEPHONY_LOGD("ExchangeRilRssiToHdf rxlev:%{public}d, rsrp:%{public}d", rssi.lte.rxlev, rssi.lte.rsrp);
862}
863
864void HRilNetwork::BuildOperatorList(
865    HDI::Ril::V1_1::AvailableNetworkList &availableNetworkList, const void *response, size_t responseLen)
866{
867    size_t numStrings = responseLen / sizeof(AvailableOperInfo *);
868    HDI::Ril::V1_1::AvailableNetworkInfo operInfo = {};
869    availableNetworkList.itemNum = numStrings;
870    TELEPHONY_LOGI(
871        "BuildOperatorList availableNetworkList.itemNum: %{public}lu", static_cast<unsigned long>(numStrings));
872    for (size_t i = 0; i < numStrings; i++) {
873        AvailableOperInfo *curPtr = ((AvailableOperInfo **)response)[i];
874        if (curPtr != nullptr) {
875            operInfo.status = curPtr->status;
876            TELEPHONY_LOGI("operInfo.status:%{public}d", curPtr->status);
877            operInfo.longName = (curPtr->longName == nullptr) ? "" : curPtr->longName;
878            TELEPHONY_LOGI("operInfo.longName:%{public}s", curPtr->longName);
879            operInfo.numeric = (curPtr->numeric == nullptr) ? "" : curPtr->numeric;
880            TELEPHONY_LOGI("operInfo.numeric:%{public}s", curPtr->numeric);
881            operInfo.shortName = (curPtr->shortName == nullptr) ? "" : curPtr->shortName;
882            TELEPHONY_LOGI("operInfo.shortName:%{public}s", curPtr->shortName);
883            operInfo.rat = curPtr->rat;
884            TELEPHONY_LOGI("operInfo.rat:%{public}d", curPtr->rat);
885            availableNetworkList.availableNetworkInfo.push_back(operInfo);
886        }
887    }
888}
889
890void HRilNetwork::FillCellNearbyInfo(HDI::Ril::V1_1::CellNearbyInfo &cellInfo, const CellInfo *cellPtr)
891{
892    cellInfo.ratType = cellPtr->ratType;
893    switch (cellPtr->ratType) {
894        case NETWORK_TYPE_GSM:
895            cellInfo.serviceCells.gsm.band = cellPtr->ServiceCellParas.gsm.band;
896            cellInfo.serviceCells.gsm.arfcn = cellPtr->ServiceCellParas.gsm.arfcn;
897            cellInfo.serviceCells.gsm.bsic = cellPtr->ServiceCellParas.gsm.bsic;
898            cellInfo.serviceCells.gsm.cellId = cellPtr->ServiceCellParas.gsm.cellId;
899            cellInfo.serviceCells.gsm.lac = cellPtr->ServiceCellParas.gsm.lac;
900            cellInfo.serviceCells.gsm.rxlev = cellPtr->ServiceCellParas.gsm.rxlev;
901            break;
902        case NETWORK_TYPE_LTE:
903            cellInfo.serviceCells.lte.arfcn = cellPtr->ServiceCellParas.lte.arfcn;
904            cellInfo.serviceCells.lte.pci = cellPtr->ServiceCellParas.lte.pci;
905            cellInfo.serviceCells.lte.rsrp = cellPtr->ServiceCellParas.lte.rsrp;
906            cellInfo.serviceCells.lte.rsrq = cellPtr->ServiceCellParas.lte.rsrq;
907            cellInfo.serviceCells.lte.rxlev = cellPtr->ServiceCellParas.lte.rxlev;
908            break;
909        case NETWORK_TYPE_WCDMA:
910            cellInfo.serviceCells.wcdma.arfcn = cellPtr->ServiceCellParas.wcdma.arfcn;
911            cellInfo.serviceCells.wcdma.psc = cellPtr->ServiceCellParas.wcdma.psc;
912            cellInfo.serviceCells.wcdma.rscp = cellPtr->ServiceCellParas.wcdma.rscp;
913            cellInfo.serviceCells.wcdma.ecno = cellPtr->ServiceCellParas.wcdma.ecno;
914            break;
915        case NETWORK_TYPE_CDMA:
916            FillCellNearbyInfoCdma(cellInfo, cellPtr);
917            break;
918        case NETWORK_TYPE_TDSCDMA:
919            FillCellNearbyInfoTdscdma(cellInfo, cellPtr);
920            break;
921        case NETWORK_TYPE_NR:
922            cellInfo.serviceCells.nr.nrArfcn = cellPtr->ServiceCellParas.nr.nrArfcn;
923            cellInfo.serviceCells.nr.pci = cellPtr->ServiceCellParas.nr.pci;
924            cellInfo.serviceCells.nr.tac = cellPtr->ServiceCellParas.nr.tac;
925            cellInfo.serviceCells.nr.nci = cellPtr->ServiceCellParas.nr.nci;
926            break;
927        default:
928            cellInfo.serviceCells.gsm.band = 0;
929            cellInfo.serviceCells.gsm.arfcn = 0;
930            cellInfo.serviceCells.gsm.bsic = 0;
931            cellInfo.serviceCells.gsm.cellId = 0;
932            cellInfo.serviceCells.gsm.lac = 0;
933            cellInfo.serviceCells.gsm.rxlev = 0;
934            break;
935    }
936}
937
938void HRilNetwork::FillCellNearbyInfoTdscdma(HDI::Ril::V1_1::CellNearbyInfo &cellInfo, const CellInfo *hrilCellPtr)
939{
940    cellInfo.serviceCells.tdscdma.arfcn = hrilCellPtr->ServiceCellParas.tdscdma.arfcn;
941    cellInfo.serviceCells.tdscdma.syncId = hrilCellPtr->ServiceCellParas.tdscdma.syncId;
942    cellInfo.serviceCells.tdscdma.sc = hrilCellPtr->ServiceCellParas.tdscdma.sc;
943    cellInfo.serviceCells.tdscdma.cellId = hrilCellPtr->ServiceCellParas.tdscdma.cellId;
944    cellInfo.serviceCells.tdscdma.lac = hrilCellPtr->ServiceCellParas.tdscdma.lac;
945    cellInfo.serviceCells.tdscdma.rscp = hrilCellPtr->ServiceCellParas.tdscdma.rscp;
946    cellInfo.serviceCells.tdscdma.drx = hrilCellPtr->ServiceCellParas.tdscdma.drx;
947    cellInfo.serviceCells.tdscdma.rac = hrilCellPtr->ServiceCellParas.tdscdma.rac;
948    cellInfo.serviceCells.tdscdma.cpid = hrilCellPtr->ServiceCellParas.tdscdma.cpid;
949}
950
951void HRilNetwork::FillCellNearbyInfoCdma(HDI::Ril::V1_1::CellNearbyInfo &cellInfo, const CellInfo *hrilCellPtr)
952{
953    cellInfo.serviceCells.cdma.systemId = hrilCellPtr->ServiceCellParas.cdma.systemId;
954    cellInfo.serviceCells.cdma.networkId = hrilCellPtr->ServiceCellParas.cdma.networkId;
955    cellInfo.serviceCells.cdma.baseId = hrilCellPtr->ServiceCellParas.cdma.baseId;
956    cellInfo.serviceCells.cdma.zoneId = hrilCellPtr->ServiceCellParas.cdma.zoneId;
957    cellInfo.serviceCells.cdma.pilotPn = hrilCellPtr->ServiceCellParas.cdma.pilotPn;
958    cellInfo.serviceCells.cdma.pilotStrength = hrilCellPtr->ServiceCellParas.cdma.pilotStrength;
959    cellInfo.serviceCells.cdma.channel = hrilCellPtr->ServiceCellParas.cdma.channel;
960    cellInfo.serviceCells.cdma.longitude = hrilCellPtr->ServiceCellParas.cdma.longitude;
961    cellInfo.serviceCells.cdma.latitude = hrilCellPtr->ServiceCellParas.cdma.latitude;
962}
963
964void HRilNetwork::FillCellNearbyInfo(HDI::Ril::V1_2::CellNearbyInfo_1_2 &cellInfo, const CellInfo *cellPtr)
965{
966    cellInfo.ratType = cellPtr->ratType;
967    switch (cellPtr->ratType) {
968        case NETWORK_TYPE_GSM:
969            cellInfo.serviceCells.gsm.band = cellPtr->ServiceCellParas.gsm.band;
970            cellInfo.serviceCells.gsm.arfcn = cellPtr->ServiceCellParas.gsm.arfcn;
971            cellInfo.serviceCells.gsm.bsic = cellPtr->ServiceCellParas.gsm.bsic;
972            cellInfo.serviceCells.gsm.cellId = cellPtr->ServiceCellParas.gsm.cellId;
973            cellInfo.serviceCells.gsm.lac = cellPtr->ServiceCellParas.gsm.lac;
974            cellInfo.serviceCells.gsm.rxlev = cellPtr->ServiceCellParas.gsm.rxlev;
975            break;
976        case NETWORK_TYPE_LTE:
977            cellInfo.serviceCells.lte.arfcn = cellPtr->ServiceCellParas.lte.arfcn;
978            cellInfo.serviceCells.lte.pci = cellPtr->ServiceCellParas.lte.pci;
979            cellInfo.serviceCells.lte.rsrp = cellPtr->ServiceCellParas.lte.rsrp;
980            cellInfo.serviceCells.lte.rsrq = cellPtr->ServiceCellParas.lte.rsrq;
981            cellInfo.serviceCells.lte.rxlev = cellPtr->ServiceCellParas.lte.rxlev;
982            break;
983        case NETWORK_TYPE_WCDMA:
984            cellInfo.serviceCells.wcdma.arfcn = cellPtr->ServiceCellParas.wcdma.arfcn;
985            cellInfo.serviceCells.wcdma.psc = cellPtr->ServiceCellParas.wcdma.psc;
986            cellInfo.serviceCells.wcdma.rscp = cellPtr->ServiceCellParas.wcdma.rscp;
987            cellInfo.serviceCells.wcdma.ecno = cellPtr->ServiceCellParas.wcdma.ecno;
988            break;
989        case NETWORK_TYPE_CDMA:
990            FillCellNearbyInfoCdma(cellInfo, cellPtr);
991            break;
992        case NETWORK_TYPE_TDSCDMA:
993            FillCellNearbyInfoTdscdma(cellInfo, cellPtr);
994            break;
995        case NETWORK_TYPE_NR:
996            cellInfo.serviceCells.nr.nrArfcn = cellPtr->ServiceCellParas.nr.nrArfcn;
997            cellInfo.serviceCells.nr.pci = cellPtr->ServiceCellParas.nr.pci;
998            cellInfo.serviceCells.nr.tac = cellPtr->ServiceCellParas.nr.tac;
999            cellInfo.serviceCells.nr.nci = cellPtr->ServiceCellParas.nr.nci;
1000            cellInfo.serviceCells.nr.rsrp = cellPtr->ServiceCellParas.nr.rsrp;
1001            cellInfo.serviceCells.nr.rsrq = cellPtr->ServiceCellParas.nr.rsrq;
1002            break;
1003        default:
1004            cellInfo.serviceCells.gsm.band = 0;
1005            cellInfo.serviceCells.gsm.arfcn = 0;
1006            cellInfo.serviceCells.gsm.bsic = 0;
1007            cellInfo.serviceCells.gsm.cellId = 0;
1008            cellInfo.serviceCells.gsm.lac = 0;
1009            cellInfo.serviceCells.gsm.rxlev = 0;
1010            break;
1011    }
1012}
1013
1014void HRilNetwork::FillCellNearbyInfoTdscdma(HDI::Ril::V1_2::CellNearbyInfo_1_2 &cellInfo, const CellInfo *hrilCellPtr)
1015{
1016    cellInfo.serviceCells.tdscdma.arfcn = hrilCellPtr->ServiceCellParas.tdscdma.arfcn;
1017    cellInfo.serviceCells.tdscdma.syncId = hrilCellPtr->ServiceCellParas.tdscdma.syncId;
1018    cellInfo.serviceCells.tdscdma.sc = hrilCellPtr->ServiceCellParas.tdscdma.sc;
1019    cellInfo.serviceCells.tdscdma.cellId = hrilCellPtr->ServiceCellParas.tdscdma.cellId;
1020    cellInfo.serviceCells.tdscdma.lac = hrilCellPtr->ServiceCellParas.tdscdma.lac;
1021    cellInfo.serviceCells.tdscdma.rscp = hrilCellPtr->ServiceCellParas.tdscdma.rscp;
1022    cellInfo.serviceCells.tdscdma.drx = hrilCellPtr->ServiceCellParas.tdscdma.drx;
1023    cellInfo.serviceCells.tdscdma.rac = hrilCellPtr->ServiceCellParas.tdscdma.rac;
1024    cellInfo.serviceCells.tdscdma.cpid = hrilCellPtr->ServiceCellParas.tdscdma.cpid;
1025}
1026
1027void HRilNetwork::FillCellNearbyInfoCdma(HDI::Ril::V1_2::CellNearbyInfo_1_2 &cellInfo, const CellInfo *hrilCellPtr)
1028{
1029    cellInfo.serviceCells.cdma.systemId = hrilCellPtr->ServiceCellParas.cdma.systemId;
1030    cellInfo.serviceCells.cdma.networkId = hrilCellPtr->ServiceCellParas.cdma.networkId;
1031    cellInfo.serviceCells.cdma.baseId = hrilCellPtr->ServiceCellParas.cdma.baseId;
1032    cellInfo.serviceCells.cdma.zoneId = hrilCellPtr->ServiceCellParas.cdma.zoneId;
1033    cellInfo.serviceCells.cdma.pilotPn = hrilCellPtr->ServiceCellParas.cdma.pilotPn;
1034    cellInfo.serviceCells.cdma.pilotStrength = hrilCellPtr->ServiceCellParas.cdma.pilotStrength;
1035    cellInfo.serviceCells.cdma.channel = hrilCellPtr->ServiceCellParas.cdma.channel;
1036    cellInfo.serviceCells.cdma.longitude = hrilCellPtr->ServiceCellParas.cdma.longitude;
1037    cellInfo.serviceCells.cdma.latitude = hrilCellPtr->ServiceCellParas.cdma.latitude;
1038}
1039
1040int32_t HRilNetwork::BuildNeighboringCellList(
1041    HDI::Ril::V1_1::CellListNearbyInfo &cellInfoList, const void *response, size_t responseLen)
1042{
1043    const CellInfoList *temp = reinterpret_cast<const CellInfoList *>(response);
1044    cellInfoList.itemNum = temp->itemNum;
1045    TELEPHONY_LOGI("cellInfoList.itemNum = %{public}d", cellInfoList.itemNum);
1046    for (int32_t i = 0; i < temp->itemNum; i++) {
1047        HDI::Ril::V1_1::CellNearbyInfo cellInfo;
1048        CellInfo *cell = temp->cellNearbyInfo + i;
1049        if (cell == nullptr) {
1050            TELEPHONY_LOGE("cell is nullptr");
1051            return HRIL_ERR_GENERIC_FAILURE;
1052        }
1053        FillCellNearbyInfo(cellInfo, cell);
1054        cellInfoList.cellNearbyInfo.push_back(cellInfo);
1055    }
1056    return HRIL_ERR_SUCCESS;
1057}
1058
1059int32_t HRilNetwork::BuildNeighboringCellList(
1060    HDI::Ril::V1_2::CellListNearbyInfo_1_2 &cellInfoList, const void *response, size_t responseLen)
1061{
1062    const CellInfoList *temp = reinterpret_cast<const CellInfoList *>(response);
1063    cellInfoList.itemNum = temp->itemNum;
1064    TELEPHONY_LOGI("cellInfoList.itemNum = %{public}d", cellInfoList.itemNum);
1065    for (int32_t i = 0; i < temp->itemNum; i++) {
1066        HDI::Ril::V1_2::CellNearbyInfo_1_2 cellInfo;
1067        CellInfo *cell = temp->cellNearbyInfo + i;
1068        if (cell == nullptr) {
1069            TELEPHONY_LOGE("cell is nullptr");
1070            return HRIL_ERR_GENERIC_FAILURE;
1071        }
1072        FillCellNearbyInfo(cellInfo, cell);
1073        cellInfoList.cellNearbyInfo.push_back(cellInfo);
1074    }
1075    return HRIL_ERR_SUCCESS;
1076}
1077
1078void HRilNetwork::FillCellInfoType(
1079    HDI::Ril::V1_1::CurrentCellInfo &cellInfo, const CurrentCellInfoVendor *hrilCellInfoVendor)
1080{
1081    if (hrilCellInfoVendor->ratType == NETWORK_TYPE_WCDMA) {
1082        cellInfo.serviceCells.wcdma.arfcn = hrilCellInfoVendor->ServiceCellParas.wcdma.arfcn;
1083        cellInfo.serviceCells.wcdma.cellId = hrilCellInfoVendor->ServiceCellParas.wcdma.cellId;
1084        cellInfo.serviceCells.wcdma.psc = hrilCellInfoVendor->ServiceCellParas.wcdma.psc;
1085        cellInfo.serviceCells.wcdma.lac = hrilCellInfoVendor->ServiceCellParas.wcdma.lac;
1086        cellInfo.serviceCells.wcdma.rxlev = hrilCellInfoVendor->ServiceCellParas.wcdma.rxlev;
1087        cellInfo.serviceCells.wcdma.rscp = hrilCellInfoVendor->ServiceCellParas.wcdma.rscp;
1088        cellInfo.serviceCells.wcdma.ecno = hrilCellInfoVendor->ServiceCellParas.wcdma.ecno;
1089        cellInfo.serviceCells.wcdma.ura = hrilCellInfoVendor->ServiceCellParas.wcdma.ura;
1090        cellInfo.serviceCells.wcdma.drx = hrilCellInfoVendor->ServiceCellParas.wcdma.drx;
1091    } else if (hrilCellInfoVendor->ratType == NETWORK_TYPE_CDMA) {
1092        cellInfo.serviceCells.cdma.systemId = hrilCellInfoVendor->ServiceCellParas.cdma.systemId;
1093        cellInfo.serviceCells.cdma.networkId = hrilCellInfoVendor->ServiceCellParas.cdma.networkId;
1094        cellInfo.serviceCells.cdma.baseId = hrilCellInfoVendor->ServiceCellParas.cdma.baseId;
1095        cellInfo.serviceCells.cdma.zoneId = hrilCellInfoVendor->ServiceCellParas.cdma.zoneId;
1096        cellInfo.serviceCells.cdma.pilotPn = hrilCellInfoVendor->ServiceCellParas.cdma.pilotPn;
1097        cellInfo.serviceCells.cdma.pilotStrength = hrilCellInfoVendor->ServiceCellParas.cdma.pilotStrength;
1098        cellInfo.serviceCells.cdma.channel = hrilCellInfoVendor->ServiceCellParas.cdma.channel;
1099        cellInfo.serviceCells.cdma.longitude = hrilCellInfoVendor->ServiceCellParas.cdma.longitude;
1100        cellInfo.serviceCells.cdma.latitude = hrilCellInfoVendor->ServiceCellParas.cdma.latitude;
1101    } else if (hrilCellInfoVendor->ratType == NETWORK_TYPE_TDSCDMA) {
1102        cellInfo.serviceCells.tdscdma.arfcn = hrilCellInfoVendor->ServiceCellParas.tdscdma.arfcn;
1103        cellInfo.serviceCells.tdscdma.syncId = hrilCellInfoVendor->ServiceCellParas.tdscdma.syncId;
1104        cellInfo.serviceCells.tdscdma.sc = hrilCellInfoVendor->ServiceCellParas.tdscdma.sc;
1105        cellInfo.serviceCells.tdscdma.cellId = hrilCellInfoVendor->ServiceCellParas.tdscdma.cellId;
1106        cellInfo.serviceCells.tdscdma.lac = hrilCellInfoVendor->ServiceCellParas.tdscdma.lac;
1107        cellInfo.serviceCells.tdscdma.rscp = hrilCellInfoVendor->ServiceCellParas.tdscdma.rscp;
1108        cellInfo.serviceCells.tdscdma.drx = hrilCellInfoVendor->ServiceCellParas.tdscdma.drx;
1109        cellInfo.serviceCells.tdscdma.rac = hrilCellInfoVendor->ServiceCellParas.tdscdma.rac;
1110        cellInfo.serviceCells.tdscdma.cpid = hrilCellInfoVendor->ServiceCellParas.tdscdma.cpid;
1111    }
1112}
1113
1114void HRilNetwork::FillCellInfoType(
1115    HDI::Ril::V1_1::CurrentCellInfo_1_1 &cellInfo, const CurrentCellInfoVendor *hrilCellInfoVendor)
1116{
1117    switch (hrilCellInfoVendor->ratType) {
1118        case NETWORK_TYPE_WCDMA:
1119            cellInfo.serviceCells.wcdma.arfcn = hrilCellInfoVendor->ServiceCellParas.wcdma.arfcn;
1120            cellInfo.serviceCells.wcdma.cellId = hrilCellInfoVendor->ServiceCellParas.wcdma.cellId;
1121            cellInfo.serviceCells.wcdma.psc = hrilCellInfoVendor->ServiceCellParas.wcdma.psc;
1122            cellInfo.serviceCells.wcdma.lac = hrilCellInfoVendor->ServiceCellParas.wcdma.lac;
1123            cellInfo.serviceCells.wcdma.rxlev = hrilCellInfoVendor->ServiceCellParas.wcdma.rxlev;
1124            cellInfo.serviceCells.wcdma.rscp = hrilCellInfoVendor->ServiceCellParas.wcdma.rscp;
1125            cellInfo.serviceCells.wcdma.ecno = hrilCellInfoVendor->ServiceCellParas.wcdma.ecno;
1126            cellInfo.serviceCells.wcdma.ura = hrilCellInfoVendor->ServiceCellParas.wcdma.ura;
1127            cellInfo.serviceCells.wcdma.drx = hrilCellInfoVendor->ServiceCellParas.wcdma.drx;
1128            break;
1129        case NETWORK_TYPE_CDMA:
1130            cellInfo.serviceCells.cdma.systemId = hrilCellInfoVendor->ServiceCellParas.cdma.systemId;
1131            cellInfo.serviceCells.cdma.networkId = hrilCellInfoVendor->ServiceCellParas.cdma.networkId;
1132            cellInfo.serviceCells.cdma.baseId = hrilCellInfoVendor->ServiceCellParas.cdma.baseId;
1133            cellInfo.serviceCells.cdma.zoneId = hrilCellInfoVendor->ServiceCellParas.cdma.zoneId;
1134            cellInfo.serviceCells.cdma.pilotPn = hrilCellInfoVendor->ServiceCellParas.cdma.pilotPn;
1135            cellInfo.serviceCells.cdma.pilotStrength = hrilCellInfoVendor->ServiceCellParas.cdma.pilotStrength;
1136            cellInfo.serviceCells.cdma.channel = hrilCellInfoVendor->ServiceCellParas.cdma.channel;
1137            cellInfo.serviceCells.cdma.longitude = hrilCellInfoVendor->ServiceCellParas.cdma.longitude;
1138            cellInfo.serviceCells.cdma.latitude = hrilCellInfoVendor->ServiceCellParas.cdma.latitude;
1139            break;
1140        case NETWORK_TYPE_TDSCDMA:
1141            cellInfo.serviceCells.tdscdma.arfcn = hrilCellInfoVendor->ServiceCellParas.tdscdma.arfcn;
1142            cellInfo.serviceCells.tdscdma.syncId = hrilCellInfoVendor->ServiceCellParas.tdscdma.syncId;
1143            cellInfo.serviceCells.tdscdma.sc = hrilCellInfoVendor->ServiceCellParas.tdscdma.sc;
1144            cellInfo.serviceCells.tdscdma.cellId = hrilCellInfoVendor->ServiceCellParas.tdscdma.cellId;
1145            cellInfo.serviceCells.tdscdma.lac = hrilCellInfoVendor->ServiceCellParas.tdscdma.lac;
1146            cellInfo.serviceCells.tdscdma.rscp = hrilCellInfoVendor->ServiceCellParas.tdscdma.rscp;
1147            cellInfo.serviceCells.tdscdma.drx = hrilCellInfoVendor->ServiceCellParas.tdscdma.drx;
1148            cellInfo.serviceCells.tdscdma.rac = hrilCellInfoVendor->ServiceCellParas.tdscdma.rac;
1149            cellInfo.serviceCells.tdscdma.cpid = hrilCellInfoVendor->ServiceCellParas.tdscdma.cpid;
1150            break;
1151        case NETWORK_TYPE_NR:
1152            cellInfo.serviceCells.nr.nrArfcn = hrilCellInfoVendor->ServiceCellParas.nr.nrArfcn;
1153            cellInfo.serviceCells.nr.pci = hrilCellInfoVendor->ServiceCellParas.nr.pci;
1154            cellInfo.serviceCells.nr.tac = hrilCellInfoVendor->ServiceCellParas.nr.tac;
1155            cellInfo.serviceCells.nr.nci = hrilCellInfoVendor->ServiceCellParas.nr.nci;
1156            cellInfo.serviceCells.nr.rsrp = hrilCellInfoVendor->ServiceCellParas.nr.rsrp;
1157            cellInfo.serviceCells.nr.rsrq = hrilCellInfoVendor->ServiceCellParas.nr.rsrq;
1158            break;
1159        default:
1160            break;
1161    }
1162}
1163
1164void HRilNetwork::FillCellInfoType(
1165    HDI::Ril::V1_2::CurrentCellInfo_1_2 &cellInfo, const CurrentCellInfoVendor *hrilCellInfoVendor)
1166{
1167    switch (hrilCellInfoVendor->ratType) {
1168        case NETWORK_TYPE_WCDMA:
1169            cellInfo.serviceCells.wcdma.arfcn = hrilCellInfoVendor->ServiceCellParas.wcdma.arfcn;
1170            cellInfo.serviceCells.wcdma.cellId = hrilCellInfoVendor->ServiceCellParas.wcdma.cellId;
1171            cellInfo.serviceCells.wcdma.psc = hrilCellInfoVendor->ServiceCellParas.wcdma.psc;
1172            cellInfo.serviceCells.wcdma.lac = hrilCellInfoVendor->ServiceCellParas.wcdma.lac;
1173            cellInfo.serviceCells.wcdma.rxlev = hrilCellInfoVendor->ServiceCellParas.wcdma.rxlev;
1174            cellInfo.serviceCells.wcdma.rscp = hrilCellInfoVendor->ServiceCellParas.wcdma.rscp;
1175            cellInfo.serviceCells.wcdma.ecno = hrilCellInfoVendor->ServiceCellParas.wcdma.ecno;
1176            cellInfo.serviceCells.wcdma.ura = hrilCellInfoVendor->ServiceCellParas.wcdma.ura;
1177            cellInfo.serviceCells.wcdma.drx = hrilCellInfoVendor->ServiceCellParas.wcdma.drx;
1178            break;
1179        case NETWORK_TYPE_CDMA:
1180            cellInfo.serviceCells.cdma.systemId = hrilCellInfoVendor->ServiceCellParas.cdma.systemId;
1181            cellInfo.serviceCells.cdma.networkId = hrilCellInfoVendor->ServiceCellParas.cdma.networkId;
1182            cellInfo.serviceCells.cdma.baseId = hrilCellInfoVendor->ServiceCellParas.cdma.baseId;
1183            cellInfo.serviceCells.cdma.zoneId = hrilCellInfoVendor->ServiceCellParas.cdma.zoneId;
1184            cellInfo.serviceCells.cdma.pilotPn = hrilCellInfoVendor->ServiceCellParas.cdma.pilotPn;
1185            cellInfo.serviceCells.cdma.pilotStrength = hrilCellInfoVendor->ServiceCellParas.cdma.pilotStrength;
1186            cellInfo.serviceCells.cdma.channel = hrilCellInfoVendor->ServiceCellParas.cdma.channel;
1187            cellInfo.serviceCells.cdma.longitude = hrilCellInfoVendor->ServiceCellParas.cdma.longitude;
1188            cellInfo.serviceCells.cdma.latitude = hrilCellInfoVendor->ServiceCellParas.cdma.latitude;
1189            break;
1190        case NETWORK_TYPE_TDSCDMA:
1191            cellInfo.serviceCells.tdscdma.arfcn = hrilCellInfoVendor->ServiceCellParas.tdscdma.arfcn;
1192            cellInfo.serviceCells.tdscdma.syncId = hrilCellInfoVendor->ServiceCellParas.tdscdma.syncId;
1193            cellInfo.serviceCells.tdscdma.sc = hrilCellInfoVendor->ServiceCellParas.tdscdma.sc;
1194            cellInfo.serviceCells.tdscdma.cellId = hrilCellInfoVendor->ServiceCellParas.tdscdma.cellId;
1195            cellInfo.serviceCells.tdscdma.lac = hrilCellInfoVendor->ServiceCellParas.tdscdma.lac;
1196            cellInfo.serviceCells.tdscdma.rscp = hrilCellInfoVendor->ServiceCellParas.tdscdma.rscp;
1197            cellInfo.serviceCells.tdscdma.drx = hrilCellInfoVendor->ServiceCellParas.tdscdma.drx;
1198            cellInfo.serviceCells.tdscdma.rac = hrilCellInfoVendor->ServiceCellParas.tdscdma.rac;
1199            cellInfo.serviceCells.tdscdma.cpid = hrilCellInfoVendor->ServiceCellParas.tdscdma.cpid;
1200            break;
1201        case NETWORK_TYPE_NR:
1202            cellInfo.serviceCells.nr.nrArfcn = hrilCellInfoVendor->ServiceCellParas.nr.nrArfcn;
1203            cellInfo.serviceCells.nr.pci = hrilCellInfoVendor->ServiceCellParas.nr.pci;
1204            cellInfo.serviceCells.nr.tac = hrilCellInfoVendor->ServiceCellParas.nr.tac;
1205            cellInfo.serviceCells.nr.nci = hrilCellInfoVendor->ServiceCellParas.nr.nci;
1206            cellInfo.serviceCells.nr.rsrp = hrilCellInfoVendor->ServiceCellParas.nr.rsrp;
1207            cellInfo.serviceCells.nr.rsrq = hrilCellInfoVendor->ServiceCellParas.nr.rsrq;
1208            break;
1209        default:
1210            break;
1211    }
1212}
1213
1214void HRilNetwork::FillCurrentCellInfo(
1215    HDI::Ril::V1_1::CurrentCellInfo &cellInfo, const CurrentCellInfoVendor *cellInfoVendor)
1216{
1217    cellInfo.ratType = cellInfoVendor->ratType;
1218    cellInfo.mcc = cellInfoVendor->mcc;
1219    cellInfo.mnc = cellInfoVendor->mnc;
1220    switch (cellInfoVendor->ratType) {
1221        case NETWORK_TYPE_GSM:
1222            cellInfo.serviceCells.gsm.band = cellInfoVendor->ServiceCellParas.gsm.band;
1223            cellInfo.serviceCells.gsm.arfcn = cellInfoVendor->ServiceCellParas.gsm.arfcn;
1224            cellInfo.serviceCells.gsm.bsic = cellInfoVendor->ServiceCellParas.gsm.bsic;
1225            cellInfo.serviceCells.gsm.cellId = cellInfoVendor->ServiceCellParas.gsm.cellId;
1226            cellInfo.serviceCells.gsm.lac = cellInfoVendor->ServiceCellParas.gsm.lac;
1227            cellInfo.serviceCells.gsm.rxlev = cellInfoVendor->ServiceCellParas.gsm.rxlev;
1228            cellInfo.serviceCells.gsm.rxQuality = cellInfoVendor->ServiceCellParas.gsm.rxQuality;
1229            cellInfo.serviceCells.gsm.ta = cellInfoVendor->ServiceCellParas.gsm.ta;
1230            break;
1231        case NETWORK_TYPE_LTE:
1232            cellInfo.serviceCells.lte.arfcn = cellInfoVendor->ServiceCellParas.lte.arfcn;
1233            cellInfo.serviceCells.lte.cellId = cellInfoVendor->ServiceCellParas.lte.cellId;
1234            cellInfo.serviceCells.lte.pci = cellInfoVendor->ServiceCellParas.lte.pci;
1235            cellInfo.serviceCells.lte.tac = cellInfoVendor->ServiceCellParas.lte.tac;
1236            cellInfo.serviceCells.lte.rsrp = cellInfoVendor->ServiceCellParas.lte.rsrp;
1237            cellInfo.serviceCells.lte.rsrq = cellInfoVendor->ServiceCellParas.lte.rsrq;
1238            cellInfo.serviceCells.lte.rssi = cellInfoVendor->ServiceCellParas.lte.rssi;
1239            break;
1240        case NETWORK_TYPE_WCDMA:
1241        case NETWORK_TYPE_CDMA:
1242        case NETWORK_TYPE_TDSCDMA:
1243            FillCellInfoType(cellInfo, cellInfoVendor);
1244            break;
1245        case NETWORK_TYPE_NR:
1246            cellInfo.serviceCells.nr.nrArfcn = cellInfoVendor->ServiceCellParas.nr.nrArfcn;
1247            cellInfo.serviceCells.nr.pci = cellInfoVendor->ServiceCellParas.nr.pci;
1248            cellInfo.serviceCells.nr.tac = cellInfoVendor->ServiceCellParas.nr.tac;
1249            cellInfo.serviceCells.nr.nci = cellInfoVendor->ServiceCellParas.nr.nci;
1250            break;
1251        default:
1252            cellInfo.serviceCells.wcdma.arfcn = 0;
1253            cellInfo.serviceCells.wcdma.cellId = 0;
1254            cellInfo.serviceCells.wcdma.psc = 0;
1255            cellInfo.serviceCells.wcdma.lac = 0;
1256            cellInfo.serviceCells.wcdma.rxlev = 0;
1257            cellInfo.serviceCells.wcdma.rscp = 0;
1258            cellInfo.serviceCells.wcdma.ecno = 0;
1259            cellInfo.serviceCells.wcdma.drx = 0;
1260            cellInfo.serviceCells.wcdma.ura = 0;
1261            break;
1262    }
1263}
1264
1265void HRilNetwork::FillCurrentCellInfo(
1266    HDI::Ril::V1_1::CurrentCellInfo_1_1 &cellInfo, const CurrentCellInfoVendor *cellInfoVendor)
1267{
1268    cellInfo.ratType = cellInfoVendor->ratType;
1269    cellInfo.mcc = cellInfoVendor->mcc;
1270    cellInfo.mnc = cellInfoVendor->mnc;
1271    switch (cellInfoVendor->ratType) {
1272        case NETWORK_TYPE_GSM:
1273            cellInfo.serviceCells.gsm.band = cellInfoVendor->ServiceCellParas.gsm.band;
1274            cellInfo.serviceCells.gsm.arfcn = cellInfoVendor->ServiceCellParas.gsm.arfcn;
1275            cellInfo.serviceCells.gsm.bsic = cellInfoVendor->ServiceCellParas.gsm.bsic;
1276            cellInfo.serviceCells.gsm.cellId = cellInfoVendor->ServiceCellParas.gsm.cellId;
1277            cellInfo.serviceCells.gsm.lac = cellInfoVendor->ServiceCellParas.gsm.lac;
1278            cellInfo.serviceCells.gsm.rxlev = cellInfoVendor->ServiceCellParas.gsm.rxlev;
1279            cellInfo.serviceCells.gsm.rxQuality = cellInfoVendor->ServiceCellParas.gsm.rxQuality;
1280            cellInfo.serviceCells.gsm.ta = cellInfoVendor->ServiceCellParas.gsm.ta;
1281            break;
1282        case NETWORK_TYPE_LTE:
1283            cellInfo.serviceCells.lte.arfcn = cellInfoVendor->ServiceCellParas.lte.arfcn;
1284            cellInfo.serviceCells.lte.cellId = cellInfoVendor->ServiceCellParas.lte.cellId;
1285            cellInfo.serviceCells.lte.pci = cellInfoVendor->ServiceCellParas.lte.pci;
1286            cellInfo.serviceCells.lte.tac = cellInfoVendor->ServiceCellParas.lte.tac;
1287            cellInfo.serviceCells.lte.rsrp = cellInfoVendor->ServiceCellParas.lte.rsrp;
1288            cellInfo.serviceCells.lte.rsrq = cellInfoVendor->ServiceCellParas.lte.rsrq;
1289            cellInfo.serviceCells.lte.rssi = cellInfoVendor->ServiceCellParas.lte.rssi;
1290            break;
1291        case NETWORK_TYPE_WCDMA:
1292        case NETWORK_TYPE_CDMA:
1293        case NETWORK_TYPE_TDSCDMA:
1294        case NETWORK_TYPE_NR:
1295            FillCellInfoType(cellInfo, cellInfoVendor);
1296            break;
1297        default:
1298            cellInfo.serviceCells.wcdma.arfcn = 0;
1299            cellInfo.serviceCells.wcdma.cellId = 0;
1300            cellInfo.serviceCells.wcdma.psc = 0;
1301            cellInfo.serviceCells.wcdma.lac = 0;
1302            cellInfo.serviceCells.wcdma.rxlev = 0;
1303            cellInfo.serviceCells.wcdma.rscp = 0;
1304            cellInfo.serviceCells.wcdma.ecno = 0;
1305            cellInfo.serviceCells.wcdma.drx = 0;
1306            cellInfo.serviceCells.wcdma.ura = 0;
1307            break;
1308    }
1309}
1310
1311void HRilNetwork::FillCurrentCellInfo(
1312    HDI::Ril::V1_2::CurrentCellInfo_1_2 &cellInfo, const CurrentCellInfoVendor *cellInfoVendor)
1313{
1314    cellInfo.ratType = cellInfoVendor->ratType;
1315    cellInfo.mcc = cellInfoVendor->mcc;
1316    cellInfo.mnc = cellInfoVendor->mnc;
1317    switch (cellInfoVendor->ratType) {
1318        case NETWORK_TYPE_GSM:
1319            cellInfo.serviceCells.gsm.band = cellInfoVendor->ServiceCellParas.gsm.band;
1320            cellInfo.serviceCells.gsm.arfcn = cellInfoVendor->ServiceCellParas.gsm.arfcn;
1321            cellInfo.serviceCells.gsm.bsic = cellInfoVendor->ServiceCellParas.gsm.bsic;
1322            cellInfo.serviceCells.gsm.cellId = cellInfoVendor->ServiceCellParas.gsm.cellId;
1323            cellInfo.serviceCells.gsm.lac = cellInfoVendor->ServiceCellParas.gsm.lac;
1324            cellInfo.serviceCells.gsm.rxlev = cellInfoVendor->ServiceCellParas.gsm.rxlev;
1325            cellInfo.serviceCells.gsm.rxQuality = cellInfoVendor->ServiceCellParas.gsm.rxQuality;
1326            cellInfo.serviceCells.gsm.ta = cellInfoVendor->ServiceCellParas.gsm.ta;
1327            break;
1328        case NETWORK_TYPE_LTE:
1329            cellInfo.serviceCells.lte.arfcn = cellInfoVendor->ServiceCellParas.lte.arfcn;
1330            cellInfo.serviceCells.lte.cellId = cellInfoVendor->ServiceCellParas.lte.cellId;
1331            cellInfo.serviceCells.lte.pci = cellInfoVendor->ServiceCellParas.lte.pci;
1332            cellInfo.serviceCells.lte.tac = cellInfoVendor->ServiceCellParas.lte.tac;
1333            cellInfo.serviceCells.lte.rsrp = cellInfoVendor->ServiceCellParas.lte.rsrp;
1334            cellInfo.serviceCells.lte.rsrq = cellInfoVendor->ServiceCellParas.lte.rsrq;
1335            cellInfo.serviceCells.lte.rssi = cellInfoVendor->ServiceCellParas.lte.rssi;
1336            break;
1337        case NETWORK_TYPE_WCDMA:
1338        case NETWORK_TYPE_CDMA:
1339        case NETWORK_TYPE_TDSCDMA:
1340        case NETWORK_TYPE_NR:
1341            FillCellInfoType(cellInfo, cellInfoVendor);
1342            break;
1343        default:
1344            cellInfo.serviceCells.wcdma.arfcn = 0;
1345            cellInfo.serviceCells.wcdma.cellId = 0;
1346            cellInfo.serviceCells.wcdma.psc = 0;
1347            cellInfo.serviceCells.wcdma.lac = 0;
1348            cellInfo.serviceCells.wcdma.rxlev = 0;
1349            cellInfo.serviceCells.wcdma.rscp = 0;
1350            cellInfo.serviceCells.wcdma.ecno = 0;
1351            cellInfo.serviceCells.wcdma.drx = 0;
1352            cellInfo.serviceCells.wcdma.ura = 0;
1353            break;
1354    }
1355}
1356
1357int32_t HRilNetwork::BuildCurrentCellList(HDI::Ril::V1_1::CellListCurrentInfo &cellInfoList,
1358    const void *response, size_t responseLen)
1359{
1360    const CurrentCellInfoList *temp = reinterpret_cast<const CurrentCellInfoList *>(response);
1361    cellInfoList.itemNum = temp->itemNum;
1362    TELEPHONY_LOGI("BuildCurrentCellList cellInfoList.itemNum = %{public}d", cellInfoList.itemNum);
1363    for (int32_t i = 0; i < temp->itemNum; i++) {
1364        HDI::Ril::V1_1::CurrentCellInfo cellInfo;
1365        CurrentCellInfoVendor *cell = temp->currentCellInfo + i;
1366        if (cell == nullptr) {
1367            TELEPHONY_LOGE("BuildCurrentCellList cell is nullptr");
1368            return HRIL_ERR_GENERIC_FAILURE;
1369        }
1370        FillCurrentCellInfo(cellInfo, cell);
1371        cellInfoList.cellCurrentInfo.push_back(cellInfo);
1372    }
1373    return HRIL_ERR_SUCCESS;
1374}
1375
1376int32_t HRilNetwork::BuildCurrentCellList(
1377    HDI::Ril::V1_1::CellListCurrentInfo_1_1 &cellInfoList, const void *response, size_t responseLen)
1378{
1379    const CurrentCellInfoList *temp = reinterpret_cast<const CurrentCellInfoList *>(response);
1380    cellInfoList.itemNum = temp->itemNum;
1381    TELEPHONY_LOGI("cellInfoList.itemNum = %{public}d", cellInfoList.itemNum);
1382    for (int32_t i = 0; i < temp->itemNum; i++) {
1383        HDI::Ril::V1_1::CurrentCellInfo_1_1 cellInfo;
1384        CurrentCellInfoVendor *cell = temp->currentCellInfo + i;
1385        if (cell == nullptr) {
1386            TELEPHONY_LOGE("cell is nullptr");
1387            return HRIL_ERR_GENERIC_FAILURE;
1388        }
1389        FillCurrentCellInfo(cellInfo, cell);
1390        cellInfoList.cellCurrentInfo.push_back(cellInfo);
1391    }
1392    return HRIL_ERR_SUCCESS;
1393}
1394
1395int32_t HRilNetwork::BuildCurrentCellList(
1396    HDI::Ril::V1_2::CellListCurrentInfo_1_2 &cellInfoList, const void *response, size_t responseLen)
1397{
1398    const CurrentCellInfoList *temp = reinterpret_cast<const CurrentCellInfoList *>(response);
1399    cellInfoList.itemNum = temp->itemNum;
1400    TELEPHONY_LOGD("cellInfoList.itemNum = %{public}d", cellInfoList.itemNum);
1401    for (int32_t i = 0; i < temp->itemNum; i++) {
1402        HDI::Ril::V1_2::CurrentCellInfo_1_2 cellInfo;
1403        CurrentCellInfoVendor *cell = temp->currentCellInfo + i;
1404        if (cell == nullptr) {
1405            TELEPHONY_LOGE("cell is nullptr");
1406            return HRIL_ERR_GENERIC_FAILURE;
1407        }
1408        FillCurrentCellInfo(cellInfo, cell);
1409        cellInfoList.cellCurrentInfo.push_back(cellInfo);
1410    }
1411    return HRIL_ERR_SUCCESS;
1412}
1413
1414int32_t HRilNetwork::BuildNrCellSsbIdsInfo(HDI::Ril::V1_2::NrCellSsbIds &nrCellSsbIds,
1415    const void *response, size_t responseLen)
1416{
1417    const NrCellSsbIdsVendor *temp = reinterpret_cast<const NrCellSsbIdsVendor *>(response);
1418    if (temp->nbCellCount > MAX_NBCELL_COUNT) {
1419        TELEPHONY_LOGE("NbCellCount > max size 4");
1420        return HRIL_ERR_GENERIC_FAILURE;
1421    }
1422    nrCellSsbIds.arfcn = temp->arfcn;
1423    nrCellSsbIds.cid = temp->cid;
1424    nrCellSsbIds.pic = temp->pic;
1425    nrCellSsbIds.rsrp = temp->rsrp;
1426    nrCellSsbIds.sinr = temp->sinr;
1427    nrCellSsbIds.timeAdvance = temp->timeAdvance;
1428    nrCellSsbIds.nbCellCount = temp->nbCellCount;
1429    for (int32_t i = 0; i < SCELL_SSB_LIST; i++) {
1430        HDI::Ril::V1_2::SsbIdInfo ssbIdInfo = {0};
1431        SsbIdInfoVendor *sCellSsbList = temp->sCellSsbList + i;
1432        ssbIdInfo.ssbId = sCellSsbList->ssbId;
1433        ssbIdInfo.rsrp = sCellSsbList->rsrp;
1434        nrCellSsbIds.sCellSsbList.push_back(ssbIdInfo);
1435    }
1436    for (int32_t i = 0; i < temp->nbCellCount; i++) {
1437        HDI::Ril::V1_2::NeighboringCellSsbInfo neighboringCellSsbInfo;
1438        neighboringCellSsbInfo.pci = temp->nbCellSsbList[i].pci;
1439        neighboringCellSsbInfo.arfcn = temp->nbCellSsbList[i].arfcn;
1440        neighboringCellSsbInfo.rsrp = temp->nbCellSsbList[i].rsrp;
1441        neighboringCellSsbInfo.sinr = temp->nbCellSsbList[i].sinr;
1442        for (int32_t j = 0; j < NBCELL_SSB_LIST; j++) {
1443            HDI::Ril::V1_2::SsbIdInfo ssbIdInfo = {0};
1444            SsbIdInfoVendor *sCellSsbList = temp->nbCellSsbList[i].ssbIdList + j;
1445            ssbIdInfo.ssbId = sCellSsbList->ssbId;
1446            ssbIdInfo.rsrp = sCellSsbList->rsrp;
1447            neighboringCellSsbInfo.ssbIdList.push_back(ssbIdInfo);
1448        }
1449        nrCellSsbIds.nbCellSsbList.push_back(neighboringCellSsbInfo);
1450    }
1451    return HRIL_ERR_SUCCESS;
1452}
1453
1454bool HRilNetwork::IsNetworkResponse(uint32_t code)
1455{
1456    return ((code >= HREQ_NETWORK_BASE) && (code < HREQ_COMMON_BASE));
1457}
1458
1459bool HRilNetwork::IsNetworkNotification(uint32_t code)
1460{
1461    return ((code >= HNOTI_NETWORK_BASE) && (code < HNOTI_COMMON_BASE));
1462}
1463
1464bool HRilNetwork::IsNetworkRespOrNotify(uint32_t code)
1465{
1466    return IsNetworkResponse(code) || IsNetworkNotification(code);
1467}
1468
1469void HRilNetwork::RegisterNetworkFuncs(const HRilNetworkReq *networkFuncs)
1470{
1471    networkFuncs_ = networkFuncs;
1472}
1473} // namespace Telephony
1474} // namespace OHOS
1475