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