1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hril_modem.h"
17 
18 #include "hril_notification.h"
19 #include "hril_request.h"
20 
21 namespace OHOS {
22 namespace Telephony {
HRilModem(int32_t slotId)23 HRilModem::HRilModem(int32_t slotId) : HRilBase(slotId)
24 {
25     AddHandlerToMap();
26 }
27 
ShutDown(int32_t serialId)28 int32_t HRilModem::ShutDown(int32_t serialId)
29 {
30     return RequestVendor(serialId, HREQ_MODEM_SHUT_DOWN, modemFuncs_, &HRilModemReq::ShutDown);
31 }
32 
SetRadioState(int32_t serialId,int32_t fun,int32_t rst)33 int32_t HRilModem::SetRadioState(int32_t serialId, int32_t fun, int32_t rst)
34 {
35     return RequestVendor(serialId, HREQ_MODEM_SET_RADIO_STATUS, modemFuncs_, &HRilModemReq::SetRadioState, fun, rst);
36 }
37 
GetRadioState(int32_t serialId)38 int32_t HRilModem::GetRadioState(int32_t serialId)
39 {
40     return RequestVendor(serialId, HREQ_MODEM_GET_RADIO_STATUS, modemFuncs_, &HRilModemReq::GetRadioState);
41 }
42 
GetImei(int32_t serialId)43 int32_t HRilModem::GetImei(int32_t serialId)
44 {
45     return RequestVendor(serialId, HREQ_MODEM_GET_IMEI, modemFuncs_, &HRilModemReq::GetImei);
46 }
47 
GetImeiSv(int32_t serialId)48 int32_t HRilModem::GetImeiSv(int32_t serialId)
49 {
50     return RequestVendor(serialId, HREQ_MODEM_GET_IMEISV, modemFuncs_, &HRilModemReq::GetImeiSv);
51 }
52 
GetMeid(int32_t serialId)53 int32_t HRilModem::GetMeid(int32_t serialId)
54 {
55     return RequestVendor(serialId, HREQ_MODEM_GET_MEID, modemFuncs_, &HRilModemReq::GetMeid);
56 }
57 
GetVoiceRadioTechnology(int32_t serialId)58 int32_t HRilModem::GetVoiceRadioTechnology(int32_t serialId)
59 {
60     return RequestVendor(serialId, HREQ_MODEM_GET_VOICE_RADIO, modemFuncs_, &HRilModemReq::GetVoiceRadioTechnology);
61 }
62 
GetBasebandVersion(int32_t serialId)63 int32_t HRilModem::GetBasebandVersion(int32_t serialId)
64 {
65     return RequestVendor(serialId, HREQ_MODEM_GET_BASEBAND_VERSION, modemFuncs_, &HRilModemReq::GetBasebandVersion);
66 }
67 
RadioStateUpdated(const int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)68 int32_t HRilModem::RadioStateUpdated(
69     const int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
70 {
71     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
72         TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
73         return HRIL_ERR_INVALID_PARAMETER;
74     }
75     if (response == nullptr) {
76         TELEPHONY_LOGE("response is null");
77         return HRIL_ERR_NULL_POINT;
78     }
79     radioState_ = *(const int32_t *)response;
80     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::RadioStateUpdated, radioState_);
81 }
82 
VoiceRadioTechUpdated(const int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)83 int32_t HRilModem::VoiceRadioTechUpdated(
84     const int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
85 {
86     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(HRilVoiceRadioInfo)) != 0) {
87         TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
88         return HRIL_ERR_INVALID_PARAMETER;
89     }
90     if (response == nullptr) {
91         TELEPHONY_LOGE("response is null");
92         return HRIL_ERR_NULL_POINT;
93     }
94     HDI::Ril::V1_1::VoiceRadioTechnology voiceRadioTech = {};
95     BuildIVoiceRadioTechnology(voiceRadioTech, *(const HRilVoiceRadioInfo *)response);
96     return Notify(indType, error, &HDI::Ril::V1_1::IRilCallback::VoiceRadioTechUpdated, voiceRadioTech);
97 }
98 
DsdsModeUpdated(const int32_t indType,const HRilErrNumber error,const void * response,size_t responseLen)99 int32_t HRilModem::DsdsModeUpdated(
100     const int32_t indType, const HRilErrNumber error, const void *response, size_t responseLen)
101 {
102     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
103         TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
104         return HRIL_ERR_INVALID_PARAMETER;
105     }
106     if (response == nullptr) {
107         TELEPHONY_LOGE("response is null");
108         return HRIL_ERR_NULL_POINT;
109     }
110     return Notify(
111         indType, error, &HDI::Ril::V1_1::IRilCallback::DsdsModeUpdated, *(static_cast<const int32_t *>(response)));
112 }
113 
ShutDownResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)114 int32_t HRilModem::ShutDownResponse(
115     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
116 {
117     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::ShutDownResponse);
118 }
119 
SetRadioStateResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)120 int32_t HRilModem::SetRadioStateResponse(
121     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
122 {
123     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::SetRadioStateResponse);
124 }
125 
GetRadioStateResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)126 int32_t HRilModem::GetRadioStateResponse(
127     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
128 {
129     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(int32_t)) != 0) {
130         TELEPHONY_LOGE("Invalid parameter, responseLen:%{public}zu", responseLen);
131         return HRIL_ERR_INVALID_PARAMETER;
132     }
133     if (response == nullptr) {
134         TELEPHONY_LOGE("response is null");
135         return HRIL_ERR_NULL_POINT;
136     }
137     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetRadioStateResponse, *(const int32_t *)response);
138 }
139 
GetImeiResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)140 int32_t HRilModem::GetImeiResponse(
141     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
142 {
143     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
144         TELEPHONY_LOGE("GetImeiResponse:Invalid parameter, responseLen:%{public}zu", responseLen);
145         return HRIL_ERR_INVALID_PARAMETER;
146     }
147     if (response == nullptr) {
148         TELEPHONY_LOGE("response is null");
149         return HRIL_ERR_NULL_POINT;
150     }
151     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetImeiResponse, std::string((const char *)response));
152 }
153 
GetImeiSvResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)154 int32_t HRilModem::GetImeiSvResponse(
155     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
156 {
157     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
158         TELEPHONY_LOGE("GetImeiSvResponse:Invalid parameter, responseLen:%{public}zu", responseLen);
159         return HRIL_ERR_INVALID_PARAMETER;
160     }
161     if (response == nullptr) {
162         TELEPHONY_LOGE("response is null");
163         return HRIL_ERR_NULL_POINT;
164     }
165     return Response(
166         responseInfo, &HDI::Ril::V1_3::IRilCallback::GetImeiSvResponse, std::string((const char *)response));
167 }
168 
GetMeidResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)169 int32_t HRilModem::GetMeidResponse(
170     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
171 {
172     std::string meidResponse = "";
173     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
174         TELEPHONY_LOGE("GetMeidResponse:Invalid parameter, responseLen:%{public}zu", responseLen);
175         if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
176             responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
177         }
178     }
179     if (response == nullptr) {
180         TELEPHONY_LOGE("response is null");
181         if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
182             responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_NULL_POINT;
183         }
184     } else {
185         meidResponse = std::string((const char *)response);
186     }
187     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetMeidResponse, meidResponse);
188 }
189 
GetVoiceRadioTechnologyResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)190 int32_t HRilModem::GetVoiceRadioTechnologyResponse(
191     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
192 {
193     HDI::Ril::V1_1::VoiceRadioTechnology voiceRadioTech = {};
194     if (response == nullptr) {
195         TELEPHONY_LOGE("GetVoiceRadioTechnologyResponse Invalid response: nullptr");
196         if (responseInfo.error == HDI::Ril::V1_1::RilErrType::NONE) {
197             responseInfo.error = HDI::Ril::V1_1::RilErrType::RIL_ERR_INVALID_RESPONSE;
198         }
199     } else {
200         BuildIVoiceRadioTechnology(voiceRadioTech, *(const HRilVoiceRadioInfo *)response);
201     }
202     return Response(responseInfo, &HDI::Ril::V1_1::IRilCallback::GetVoiceRadioTechnologyResponse, voiceRadioTech);
203 }
204 
BuildIVoiceRadioTechnology(HDI::Ril::V1_1::VoiceRadioTechnology & voiceRadioTech,const HRilVoiceRadioInfo & hRiadioInfo)205 void HRilModem::BuildIVoiceRadioTechnology(
206     HDI::Ril::V1_1::VoiceRadioTechnology &voiceRadioTech, const HRilVoiceRadioInfo &hRiadioInfo)
207 {
208     voiceRadioTech.srvStatus = static_cast<OHOS::HDI::Ril::V1_1::RilSrvStatus>(hRiadioInfo.srvStatus);
209     voiceRadioTech.srvDomain = static_cast<OHOS::HDI::Ril::V1_1::RilSrvDomain>(hRiadioInfo.srvDomain);
210     voiceRadioTech.roamStatus = static_cast<OHOS::HDI::Ril::V1_1::RilRoamStatus>(hRiadioInfo.roamStatus);
211     voiceRadioTech.simStatus = static_cast<OHOS::HDI::Ril::V1_1::RilSimStatus>(hRiadioInfo.simStatus);
212     voiceRadioTech.lockStatus = static_cast<OHOS::HDI::Ril::V1_1::RilSimLockStatus>(hRiadioInfo.lockStatus);
213     voiceRadioTech.sysMode = static_cast<OHOS::HDI::Ril::V1_1::RilSysMode>(hRiadioInfo.sysMode);
214     voiceRadioTech.sysModeName = (hRiadioInfo.sysModeName == nullptr) ? "" : hRiadioInfo.sysModeName;
215     voiceRadioTech.actType = static_cast<OHOS::HDI::Ril::V1_1::RilRadioTech>(hRiadioInfo.actType);
216     voiceRadioTech.actName = (hRiadioInfo.actName == nullptr) ? "" : hRiadioInfo.actName;
217 }
218 
GetBasebandVersionResponse(int32_t requestNum,HDI::Ril::V1_1::RilRadioResponseInfo & responseInfo,const void * response,size_t responseLen)219 int32_t HRilModem::GetBasebandVersionResponse(
220     int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen)
221 {
222     if ((response == nullptr && responseLen != 0) || (responseLen % sizeof(char)) != 0) {
223         TELEPHONY_LOGE("GetBasebandVersionResponse:Invalid parameter, responseLen:%{public}zu", responseLen);
224         return HRIL_ERR_INVALID_PARAMETER;
225     }
226     if (response == nullptr) {
227         TELEPHONY_LOGE("response is null");
228         return HRIL_ERR_NULL_POINT;
229     }
230     return Response(
231         responseInfo, &HDI::Ril::V1_1::IRilCallback::GetBasebandVersionResponse, std::string((const char *)response));
232 }
233 
IsModemResponse(uint32_t code)234 bool HRilModem::IsModemResponse(uint32_t code)
235 {
236     return ((code >= HREQ_COMMON_BASE) && (code <= HREQ_MODEM_GET_VOICE_RADIO));
237 }
238 
IsModemNotification(uint32_t code)239 bool HRilModem::IsModemNotification(uint32_t code)
240 {
241     return ((code >= HNOTI_COMMON_BASE) && (code <= HNOTI_COMMON_END));
242 }
243 
IsModemRespOrNotify(uint32_t code)244 bool HRilModem::IsModemRespOrNotify(uint32_t code)
245 {
246     return IsModemResponse(code) || IsModemNotification(code);
247 }
248 
AddHandlerToMap()249 void HRilModem::AddHandlerToMap()
250 {
251     // indication
252     notiMemberFuncMap_[HNOTI_MODEM_RADIO_STATE_UPDATED] =
253         [this](int32_t notifyType, HRilErrNumber error, const void *response,
254         size_t responseLen) { return RadioStateUpdated(notifyType, error, response, responseLen); };
255     notiMemberFuncMap_[HNOTI_MODEM_VOICE_TECH_UPDATED] =
256         [this](int32_t notifyType, HRilErrNumber error, const void *response,
257         size_t responseLen) { return VoiceRadioTechUpdated(notifyType, error, response, responseLen); };
258     notiMemberFuncMap_[HNOTI_MODEM_DSDS_MODE_UPDATED] =
259         [this](int32_t notifyType, HRilErrNumber error, const void *response,
260         size_t responseLen) { return DsdsModeUpdated(notifyType, error, response, responseLen); };
261     // response
262     respMemberFuncMap_[HREQ_MODEM_SHUT_DOWN] =
263         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
264         size_t responseLen) { return ShutDownResponse(requestNum, responseInfo, response, responseLen); };
265     respMemberFuncMap_[HREQ_MODEM_SET_RADIO_STATUS] =
266         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
267         size_t responseLen) { return SetRadioStateResponse(requestNum, responseInfo, response, responseLen); };
268     respMemberFuncMap_[HREQ_MODEM_GET_RADIO_STATUS] =
269         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
270         size_t responseLen) { return GetRadioStateResponse(requestNum, responseInfo, response, responseLen); };
271     respMemberFuncMap_[HREQ_MODEM_GET_IMEI] =
272         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
273         size_t responseLen) { return GetImeiResponse(requestNum, responseInfo, response, responseLen); };
274     respMemberFuncMap_[HREQ_MODEM_GET_IMEISV] =
275         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
276         size_t responseLen) { return GetImeiSvResponse(requestNum, responseInfo, response, responseLen); };
277     respMemberFuncMap_[HREQ_MODEM_GET_MEID] =
278         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
279         size_t responseLen) { return GetMeidResponse(requestNum, responseInfo, response, responseLen); };
280     respMemberFuncMap_[HREQ_MODEM_GET_VOICE_RADIO] = [this](int32_t requestNum,
281         HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response, size_t responseLen) {
282         return GetVoiceRadioTechnologyResponse(requestNum, responseInfo, response, responseLen);
283     };
284     respMemberFuncMap_[HREQ_MODEM_GET_BASEBAND_VERSION] =
285         [this](int32_t requestNum, HDI::Ril::V1_1::RilRadioResponseInfo &responseInfo, const void *response,
286         size_t responseLen) { return GetBasebandVersionResponse(requestNum, responseInfo, response, responseLen); };
287 }
288 
RegisterModemFuncs(const HRilModemReq * modemFuncs)289 void HRilModem::RegisterModemFuncs(const HRilModemReq *modemFuncs)
290 {
291     modemFuncs_ = modemFuncs;
292 }
293 
GetLastRadioState()294 int32_t HRilModem::GetLastRadioState()
295 {
296     return radioState_;
297 }
298 } // namespace Telephony
299 } // namespace OHOS