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 "network_utils.h"
17
18 #include <cinttypes>
19
20 #include "tel_ril_network_parcel.h"
21 #include "network_search_manager.h"
22
23 namespace OHOS {
24 namespace Telephony {
25
26 // group
27 static const int32_t GSM = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_GSM);
28 static const int32_t CDMA = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_1XRTT);
29 static const int32_t EVDO = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_EVDO) |
30 static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_EHRPD);
31 static const int32_t WCDMA = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_WCDMA) |
32 static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_HSPA) |
33 static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_HSPAP);
34 static const int32_t TDSCDMA = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_TD_SCDMA);
35 static const int32_t LTE = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_LTE) |
36 static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_LTE_CA);
37 static const int32_t NR = static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_NR);
38
39 // generation
40 static const int32_t RAF_2G = GSM | CDMA;
41 static const int32_t RAF_3G = WCDMA | EVDO | TDSCDMA;
42 static const int32_t RAF_4G = LTE;
43 static const int32_t RAF_5G = NR;
44 // auto mode , support all radio mode
45 static const int32_t RAF_AUTO = RAF_2G | RAF_3G | RAF_4G | RAF_5G;
46
47 static const std::map<int32_t, PreferredNetworkMode> mapNetworkModeFromRaf = {
48 { GSM, PreferredNetworkMode::CORE_NETWORK_MODE_GSM },
49 { WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA },
50 { LTE, PreferredNetworkMode::CORE_NETWORK_MODE_LTE },
51 { LTE | WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA },
52 { LTE | WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM },
53 { CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_CDMA },
54 { WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA_GSM },
55 { EVDO, PreferredNetworkMode::CORE_NETWORK_MODE_EVDO },
56 { EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_EVDO_CDMA },
57 { WCDMA | GSM | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA },
58 { LTE | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_EVDO_CDMA },
59 { LTE | WCDMA | GSM | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA },
60 { TDSCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA },
61 { TDSCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_GSM },
62 { TDSCDMA | WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA },
63 { TDSCDMA | WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM },
64 { LTE | TDSCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA },
65 { LTE | TDSCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_GSM },
66 { LTE | TDSCDMA | WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA },
67 { LTE | TDSCDMA | WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM },
68 { TDSCDMA | WCDMA | GSM | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA },
69 { LTE | TDSCDMA | WCDMA | GSM | EVDO | CDMA,
70 PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA },
71 { NR, PreferredNetworkMode::CORE_NETWORK_MODE_NR },
72 { NR | LTE, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE },
73 { NR | LTE | WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA },
74 { NR | LTE | WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM },
75 { NR | LTE | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_EVDO_CDMA },
76 { NR | LTE | WCDMA | GSM | EVDO | CDMA, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA },
77 { NR | LTE | TDSCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA },
78 { NR | LTE | TDSCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_GSM },
79 { NR | LTE | TDSCDMA | WCDMA, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA },
80 { NR | LTE | TDSCDMA | WCDMA | GSM, PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM },
81 { NR | LTE | TDSCDMA | WCDMA | GSM | EVDO | CDMA,
82 PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA },
83 };
84
85 static const int32_t ALL_RAF[] = { GSM, CDMA, EVDO, WCDMA, TDSCDMA, LTE, NR };
86
GetNetworkModeFromRaf(int32_t raf)87 PreferredNetworkMode NetworkUtils::GetNetworkModeFromRaf(int32_t raf)
88 {
89 for (int32_t i = 0; i < static_cast<int32_t>(sizeof(ALL_RAF) / sizeof(ALL_RAF[0])); i++) {
90 if (static_cast<uint32_t>(ALL_RAF[i]) & static_cast<uint32_t>(raf)) {
91 raf = static_cast<int32_t>(static_cast<uint32_t>(ALL_RAF[i]) | static_cast<uint32_t>(raf));
92 }
93 }
94
95 auto iter = mapNetworkModeFromRaf.find(raf);
96 if (iter != mapNetworkModeFromRaf.end()) {
97 return iter->second;
98 }
99 return PreferredNetworkMode::CORE_NETWORK_MODE_AUTO;
100 }
101
102 static const std::map<PreferredNetworkMode, int32_t> mapRafFromNetworkMode = {
103 { PreferredNetworkMode::CORE_NETWORK_MODE_AUTO, RAF_AUTO },
104 { PreferredNetworkMode::CORE_NETWORK_MODE_GSM, GSM },
105 { PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA, WCDMA },
106 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE, LTE },
107 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA, LTE | WCDMA },
108 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM, LTE | WCDMA | GSM },
109 { PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA_GSM, WCDMA | GSM },
110 { PreferredNetworkMode::CORE_NETWORK_MODE_CDMA, CDMA },
111 { PreferredNetworkMode::CORE_NETWORK_MODE_EVDO, EVDO },
112 { PreferredNetworkMode::CORE_NETWORK_MODE_EVDO_CDMA, EVDO | CDMA },
113 { PreferredNetworkMode::CORE_NETWORK_MODE_WCDMA_GSM_EVDO_CDMA, WCDMA | GSM | EVDO | CDMA },
114 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_EVDO_CDMA, LTE | EVDO | CDMA },
115 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_WCDMA_GSM_EVDO_CDMA, LTE | WCDMA | GSM | EVDO | CDMA },
116 { PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA, TDSCDMA },
117 { PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_GSM, TDSCDMA | GSM },
118 { PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA, TDSCDMA | WCDMA },
119 { PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM, TDSCDMA | WCDMA | GSM },
120 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA, LTE | TDSCDMA },
121 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_GSM, LTE | TDSCDMA | GSM },
122 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA, LTE | TDSCDMA | WCDMA },
123 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM, LTE | TDSCDMA | WCDMA | GSM },
124 { PreferredNetworkMode::CORE_NETWORK_MODE_TDSCDMA_WCDMA_GSM_EVDO_CDMA, TDSCDMA | WCDMA | GSM | EVDO | CDMA },
125 { PreferredNetworkMode::CORE_NETWORK_MODE_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA,
126 LTE | TDSCDMA | WCDMA | GSM | EVDO | CDMA },
127 { PreferredNetworkMode::CORE_NETWORK_MODE_NR, NR },
128 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE, NR | LTE },
129 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA, NR | LTE | WCDMA },
130 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM, NR | LTE | WCDMA | GSM },
131 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_EVDO_CDMA, NR | LTE | EVDO | CDMA },
132 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_WCDMA_GSM_EVDO_CDMA, NR | LTE | WCDMA | GSM | EVDO | CDMA },
133 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA, NR | LTE | TDSCDMA },
134 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_GSM, NR | LTE | TDSCDMA | GSM },
135 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA, NR | LTE | TDSCDMA | WCDMA },
136 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM, NR | LTE | TDSCDMA | WCDMA | GSM },
137 { PreferredNetworkMode::CORE_NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA_GSM_EVDO_CDMA,
138 NR | LTE | TDSCDMA | WCDMA | GSM | EVDO | CDMA },
139 };
140
141 std::unordered_map<int64_t, std::shared_ptr<NetworkSearchCallbackInfo>> NetworkUtils::networkSearchCacheMap_;
142 std::mutex NetworkUtils::callbackMapMutex_;
143 std::atomic<int64_t> NetworkUtils::callbackIndex64bit_ = MIN_INDEX;
GetRafFromNetworkMode(PreferredNetworkMode PreferredNetworkMode)144 int32_t NetworkUtils::GetRafFromNetworkMode(PreferredNetworkMode PreferredNetworkMode)
145 {
146 auto iter = mapRafFromNetworkMode.find(PreferredNetworkMode);
147 if (iter != mapRafFromNetworkMode.end()) {
148 return iter->second;
149 }
150 return static_cast<int32_t>(RadioProtocolTech::RADIO_PROTOCOL_TECH_UNKNOWN);
151 }
152
SplitString(const std::string & inputString,const std::string & flag)153 std::vector<std::string> NetworkUtils::SplitString(const std::string &inputString, const std::string &flag)
154 {
155 std::vector<std::string> result;
156 if (inputString.empty()) {
157 TELEPHONY_LOGE("inputString is null");
158 return result;
159 }
160 std::string::size_type start = 0;
161 std::string::size_type position = 0;
162 while ((position = inputString.find(flag, start)) != std::string::npos) {
163 result.push_back(inputString.substr(start, position - start));
164 start = position + flag.size();
165 }
166 if (start != inputString.size()) {
167 result.push_back(inputString.substr(start, inputString.size() - start));
168 }
169 return result;
170 }
171
AddNetworkSearchCallBack(int64_t index,std::shared_ptr<NetworkSearchCallbackInfo> & callback)172 bool NetworkUtils::AddNetworkSearchCallBack(int64_t index, std::shared_ptr<NetworkSearchCallbackInfo> &callback)
173 {
174 TELEPHONY_LOGI("NetworkUtils::AddNetworkSearchCallBack index=(%{public}" PRId64 ")", index);
175 if (callback != nullptr) {
176 std::lock_guard<std::mutex> guard(callbackMapMutex_);
177 auto result = networkSearchCacheMap_.emplace(index, callback);
178 return result.second;
179 }
180 TELEPHONY_LOGE("NetworkUtils::AddNetworkSearchCallBack callback is null!");
181 return false;
182 }
183
GetCallbackIndex64bit()184 int64_t NetworkUtils::GetCallbackIndex64bit()
185 {
186 if (callbackIndex64bit_ > MAX_INDEX || callbackIndex64bit_ < MIN_INDEX) {
187 callbackIndex64bit_ = MIN_INDEX;
188 }
189 return ++callbackIndex64bit_;
190 }
191
FindNetworkSearchCallback(int64_t index)192 std::shared_ptr<NetworkSearchCallbackInfo> NetworkUtils::FindNetworkSearchCallback(int64_t index)
193 {
194 TELEPHONY_LOGI("NetworkUtils::FindNetworkSearchCallback index=%{public}" PRId64 "", index);
195
196 std::lock_guard<std::mutex> guard(callbackMapMutex_);
197 auto iter = networkSearchCacheMap_.find(index);
198 if (iter != networkSearchCacheMap_.end()) {
199 std::shared_ptr<NetworkSearchCallbackInfo> callback = iter->second;
200 return callback;
201 }
202 return nullptr;
203 }
204
RemoveCallbackFromMap(int64_t index)205 bool NetworkUtils::RemoveCallbackFromMap(int64_t index)
206 {
207 TELEPHONY_LOGI("NetworkUtils::RemoveCallbackFromMap index=%{public}" PRId64 "", index);
208 std::lock_guard<std::mutex> guard(callbackMapMutex_);
209 return (networkSearchCacheMap_.erase(index));
210 }
211
212 const std::map<RadioEvent, RilFunc_Event> EventSender::mapFunctions_ = {
213 { RadioEvent::RADIO_GET_NETWORK_SELECTION_MODE,
__anond46b825d0102() 214 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &result) {
215 return rilManager->GetNetworkSelectionMode(slotId, result);
216 } },
217 { RadioEvent::RADIO_GET_PREFERRED_NETWORK_MODE,
__anond46b825d0202() 218 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
219 return rilManager->GetPreferredNetwork(slotId, response);
220 } },
221 { RadioEvent::RADIO_GET_STATUS,
__anond46b825d0302() 222 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
223 return rilManager->GetRadioState(slotId, response);
224 } },
225 { RadioEvent::RADIO_GET_IMEI,
__anond46b825d0402() 226 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
227 return rilManager->GetImei(slotId, response);
228 } },
229 { RadioEvent::RADIO_GET_IMEISV,
__anond46b825d0502() 230 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
231 return rilManager->GetImeiSv(slotId, response);
232 } },
233 { RadioEvent::RADIO_GET_MEID,
__anond46b825d0602() 234 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
235 return rilManager->GetMeid(slotId, response);
236 } },
237 { RadioEvent::RADIO_NETWORK_SEARCH_RESULT,
__anond46b825d0702() 238 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &result) {
239 return rilManager->GetNetworkSearchInformation(slotId, result);
240 } },
241 { RadioEvent::RADIO_GET_VOICE_TECH,
__anond46b825d0802() 242 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
243 return rilManager->GetVoiceRadioTechnology(slotId, response);
244 } },
245 { RadioEvent::RADIO_OPERATOR,
__anond46b825d0902() 246 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
247 return rilManager->GetOperatorInfo(slotId, response);
248 } },
249 { RadioEvent::RADIO_GET_BASEBAND_VERSION,
__anond46b825d0a02() 250 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
251 return rilManager->GetBasebandVersion(slotId, response);
252 } },
253 { RadioEvent::RADIO_GET_NR_OPTION_MODE,
__anond46b825d0b02() 254 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
255 return rilManager->GetNrOptionMode(slotId, response);
256 } },
257 { RadioEvent::RADIO_GET_RRC_CONNECTION_STATE,
__anond46b825d0c02() 258 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
259 return rilManager->GetRrcConnectionState(slotId, response);
260 } },
261 { RadioEvent::RADIO_GET_NR_SSBID_INFO,
__anond46b825d0d02() 262 [](ITelRilManager *rilManager, int32_t slotId, const AppExecFwk::InnerEvent::Pointer &response) {
263 return rilManager->GetNrSsbId(slotId, response);
264 } },
265 };
266
267 const std::map<RadioEvent, RilFunc_Int_Event> EventSender::mapFunctionsInt_ = {
268 { RadioEvent::RADIO_SET_PREFERRED_NETWORK_MODE,
269 [](ITelRilManager *rilManager, int32_t slotId, int32_t preferredNetworkType,
__anond46b825d0e02() 270 const AppExecFwk::InnerEvent::Pointer &response) {
271 return rilManager->SetPreferredNetwork(slotId, preferredNetworkType, response);
272 } },
273 { RadioEvent::RADIO_SET_NR_OPTION_MODE,
__anond46b825d0f02() 274 [](ITelRilManager *rilManager, int32_t slotId, int32_t mode, const AppExecFwk::InnerEvent::Pointer &response) {
275 return rilManager->SetNrOptionMode(slotId, mode, response);
276 } },
277
278 };
279
280 const std::map<RadioEvent, RilFunc_Int_Int_Event> EventSender::mapFunctionsIntInt_ = {
281 { RadioEvent::RADIO_SET_STATUS,
282 [](ITelRilManager *rilManager, int32_t slotId, int32_t fun, int32_t rst,
__anond46b825d1002() 283 const AppExecFwk::InnerEvent::Pointer &response) {
284 return rilManager->SetRadioState(slotId, fun, rst, response);
285 } },
286 };
287
288 const std::map<RadioEvent, RilFunc_Int_String_Event> EventSender::mapFunctionsIntString_ = {
289 { RadioEvent::RADIO_SET_NETWORK_SELECTION_MODE,
290 [](ITelRilManager *rilManager, int32_t slotId, int32_t automaticFlag, std::string oper,
__anond46b825d1102() 291 const AppExecFwk::InnerEvent::Pointer &result) {
292 return rilManager->SetNetworkSelectionMode(slotId, automaticFlag, oper, result);
293 } },
294 };
295
GetEvent(int32_t slotId,RadioEvent radioEvent,int32_t param)296 AppExecFwk::InnerEvent::Pointer EventSender::GetEvent(int32_t slotId, RadioEvent radioEvent, int32_t param)
297 {
298 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
299 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
300 if (nsm == nullptr) {
301 TELEPHONY_LOGE("failed to get NetworkSearchManager");
302 return event;
303 }
304
305 auto inner = nsm->FindManagerInner(slotId);
306 if (inner != nullptr) {
307 event = AppExecFwk::InnerEvent::Get(static_cast<int32_t>(radioEvent), param);
308 if (event == nullptr) {
309 return event;
310 }
311 event->SetOwner(inner->networkSearchHandler_);
312 return event;
313 }
314 return event;
315 }
316
GetEvent(int32_t slotId,RadioEvent radioEvent)317 AppExecFwk::InnerEvent::Pointer EventSender::GetEvent(int32_t slotId, RadioEvent radioEvent)
318 {
319 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
320 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
321 if (nsm == nullptr) {
322 TELEPHONY_LOGE("failed to get NetworkSearchManager");
323 return event;
324 }
325
326 auto inner = nsm->FindManagerInner(slotId);
327 if (inner != nullptr) {
328 event = AppExecFwk::InnerEvent::Get(static_cast<int32_t>(radioEvent));
329 if (event == nullptr) {
330 return event;
331 }
332 event->SetOwner(inner->networkSearchHandler_);
333 return event;
334 }
335 return event;
336 }
337
GetEvent(int32_t slotId,RadioEvent radioEvent,int32_t param,const sptr<INetworkSearchCallback> & callback)338 AppExecFwk::InnerEvent::Pointer EventSender::GetEvent(
339 int32_t slotId, RadioEvent radioEvent, int32_t param, const sptr<INetworkSearchCallback> &callback)
340 {
341 AppExecFwk::InnerEvent::Pointer event(nullptr, nullptr);
342 std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
343 if (nsm == nullptr) {
344 TELEPHONY_LOGE("failed to get NetworkSearchManager");
345 return event;
346 }
347
348 auto inner = nsm->FindManagerInner(slotId);
349 if (inner != nullptr) {
350 int64_t index = NetworkUtils::GetCallbackIndex64bit();
351 std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo =
352 std::make_shared<NetworkSearchCallbackInfo>(param, callback);
353 if (callbackInfo == nullptr) {
354 TELEPHONY_LOGE("EventSender::GetEvent callbackInfo is null!! slotId:%{public}d", slotId);
355 return event;
356 }
357 if (!NetworkUtils::AddNetworkSearchCallBack(index, callbackInfo)) {
358 TELEPHONY_LOGE("EventSender::GetEvent AddNetworkSearchCallBack Error!! slotId:%{public}d", slotId);
359 return event;
360 }
361 event = AppExecFwk::InnerEvent::Get(static_cast<int32_t>(radioEvent), index);
362 if (event == nullptr) {
363 NetworkUtils::RemoveCallbackFromMap(index);
364 return event;
365 }
366 event->SetOwner(inner->networkSearchHandler_);
367 return event;
368 }
369 return event;
370 }
371
SendBase(int32_t slotId,RadioEvent radioEvent)372 bool EventSender::SendBase(int32_t slotId, RadioEvent radioEvent)
373 {
374 auto fun = GetFunctionOfEvent<RilFunc_Event>(mapFunctions_, radioEvent);
375 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Event> parameters(
376 slotId, radioEvent, 0, nullptr, fun);
377 return Send<EventGetMode::GET_EVENT_BY_HANDLERID, RilFunc_Event>(parameters);
378 }
379
SendBase(int32_t slotId,RadioEvent radioEvent,int32_t param)380 bool EventSender::SendBase(int32_t slotId, RadioEvent radioEvent, int32_t param)
381 {
382 auto fun = GetFunctionOfEvent<RilFunc_Int_Event>(mapFunctionsInt_, radioEvent);
383 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_Event> parameters(
384 slotId, radioEvent, param, nullptr, fun);
385 return Send<EventGetMode::GET_EVENT_BY_PARAM, RilFunc_Int_Event, int32_t>(parameters, param);
386 }
387
SendBase(int32_t slotId,RadioEvent radioEvent,int32_t firstParam,int32_t secondParam)388 bool EventSender::SendBase(int32_t slotId, RadioEvent radioEvent, int32_t firstParam, int32_t secondParam)
389 {
390 auto fun = GetFunctionOfEvent<RilFunc_Int_Int_Event>(mapFunctionsIntInt_, radioEvent);
391 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_Int_Event> parameters(
392 slotId, radioEvent, firstParam, nullptr, fun);
393 return Send<EventGetMode::GET_EVENT_BY_PARAM, RilFunc_Int_Int_Event, int32_t, int32_t>(
394 parameters, firstParam, secondParam);
395 }
396
SendBase(int32_t slotId,RadioEvent radioEvent,int32_t firstParam,std::string secondParam)397 bool EventSender::SendBase(int32_t slotId, RadioEvent radioEvent, int32_t firstParam, std::string secondParam)
398 {
399 auto fun = GetFunctionOfEvent<RilFunc_Int_String_Event>(mapFunctionsIntString_, radioEvent);
400 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_String_Event> parameters(
401 slotId, radioEvent, firstParam, nullptr, fun);
402 return Send<EventGetMode::GET_EVENT_BY_PARAM, RilFunc_Int_String_Event, int32_t, std::string>(
403 parameters, firstParam, secondParam);
404 }
405
SendCallback(int32_t slotId,RadioEvent radioEvent,const sptr<INetworkSearchCallback> * callback)406 bool EventSender::SendCallback(int32_t slotId, RadioEvent radioEvent, const sptr<INetworkSearchCallback> *callback)
407 {
408 auto fun = GetFunctionOfEvent<RilFunc_Event>(mapFunctions_, radioEvent);
409 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Event> parameters(
410 slotId, radioEvent, 0, callback, fun);
411 return Send<EventGetMode::GET_EVENT_BY_INDEX, RilFunc_Event>(parameters);
412 }
413
SendCallback(int32_t slotId,RadioEvent radioEvent,const sptr<INetworkSearchCallback> * callback,int32_t param)414 bool EventSender::SendCallback(
415 int32_t slotId, RadioEvent radioEvent, const sptr<INetworkSearchCallback> *callback, int32_t param)
416 {
417 auto fun = GetFunctionOfEvent<RilFunc_Event>(mapFunctions_, radioEvent);
418 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Event> parameters(
419 slotId, radioEvent, param, callback, fun);
420 return Send<EventGetMode::GET_EVENT_BY_PARAM, RilFunc_Event>(parameters);
421 }
422
SendCallbackEx(int32_t slotId,RadioEvent radioEvent,const sptr<INetworkSearchCallback> * callback,int32_t param)423 bool EventSender::SendCallbackEx(
424 int32_t slotId, RadioEvent radioEvent, const sptr<INetworkSearchCallback> *callback, int32_t param)
425 {
426 auto fun = GetFunctionOfEvent<RilFunc_Int_Event>(mapFunctionsInt_, radioEvent);
427 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_Event> parameters(
428 slotId, radioEvent, param, callback, fun);
429 return Send<EventGetMode::GET_EVENT_BY_INDEX, RilFunc_Int_Event, int32_t>(parameters, param);
430 }
431
SendCallback(int32_t slotId,RadioEvent radioEvent,const sptr<INetworkSearchCallback> * callback,int32_t firstParam,int32_t secondParam)432 bool EventSender::SendCallback(int32_t slotId, RadioEvent radioEvent, const sptr<INetworkSearchCallback> *callback,
433 int32_t firstParam, int32_t secondParam)
434 {
435 auto fun = GetFunctionOfEvent<RilFunc_Int_Int_Event>(mapFunctionsIntInt_, radioEvent);
436 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_Int_Event> parameters(
437 slotId, radioEvent, firstParam, callback, fun);
438 return Send<EventGetMode::GET_EVENT_BY_INDEX, RilFunc_Int_Int_Event, int32_t, int32_t>(
439 parameters, firstParam, secondParam);
440 }
441
SendCallback(int32_t slotId,RadioEvent radioEvent,const sptr<INetworkSearchCallback> * callback,int32_t firstParam,std::string secondParam)442 bool EventSender::SendCallback(int32_t slotId, RadioEvent radioEvent, const sptr<INetworkSearchCallback> *callback,
443 int32_t firstParam, std::string secondParam)
444 {
445 auto fun = GetFunctionOfEvent<RilFunc_Int_String_Event>(mapFunctionsIntString_, radioEvent);
446 std::tuple<int32_t, RadioEvent, int32_t, const sptr<INetworkSearchCallback> *, RilFunc_Int_String_Event> parameters(
447 slotId, radioEvent, firstParam, callback, fun);
448 return Send<EventGetMode::GET_EVENT_BY_INDEX, RilFunc_Int_String_Event, int32_t, std::string>(
449 parameters, firstParam, secondParam);
450 }
451 } // namespace Telephony
452 } // namespace OHOS
453