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 "radio_info.h"
17 
18 #include "core_service_hisysevent.h"
19 #include "network_search_manager.h"
20 #include "telephony_errors.h"
21 #include "telephony_log_wrapper.h"
22 
23 namespace OHOS {
24 namespace Telephony {
RadioInfo(std::weak_ptr<NetworkSearchManager> networkSearchManager,int32_t slotId)25 RadioInfo::RadioInfo(std::weak_ptr<NetworkSearchManager> networkSearchManager, int32_t slotId)
26     : networkSearchManager_(networkSearchManager), slotId_(slotId)
27 {}
28 
ProcessGetRadioState(const AppExecFwk::InnerEvent::Pointer & event) const29 void RadioInfo::ProcessGetRadioState(const AppExecFwk::InnerEvent::Pointer &event) const
30 {
31     if (event == nullptr) {
32         TELEPHONY_LOGE("RadioInfo::ProcessGetRadioState event is nullptr slotId:%{public}d", slotId_);
33         return;
34     }
35     std::unique_ptr<RadioStateInfo> object = event->GetUniqueObject<RadioStateInfo>();
36     std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
37     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
38     if ((responseInfo == nullptr && object == nullptr) || nsm == nullptr) {
39         TELEPHONY_LOGE("RadioInfo::ProcessGetRadioState object is nullptr slotId:%{public}d", slotId_);
40         return;
41     }
42     int64_t index = 0;
43     MessageParcel data;
44     data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor());
45     if (responseInfo != nullptr) {
46         TELEPHONY_LOGE("RadioInfo::ProcessGetRadioState false slotId:%{public}d", slotId_);
47         if (!WriteRadioStateResponseInfo(index, data, false, responseInfo)) {
48             return;
49         }
50     }
51     if (object != nullptr) {
52         TELEPHONY_LOGI("ProcessGetRadioState RadioState is:%{public}d slotId:%{public}d", object->state, slotId_);
53         bool state = (object->state == ModemPowerState::CORE_SERVICE_POWER_ON) ? true : false;
54         nsm->SetRadioStateValue(slotId_, static_cast<ModemPowerState>(object->state));
55         if (!WriteRadioStateObject(index, data, state, object)) {
56             return;
57         }
58     }
59     std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
60     if (callbackInfo != nullptr) {
61         sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
62         if (callback != nullptr && callback->OnNetworkSearchCallback(
63             INetworkSearchCallback::NetworkSearchCallback::GET_RADIO_STATUS_RESULT, data)) {
64             TELEPHONY_LOGE("RadioInfo::ProcessGetRadioState callback fail slotId:%{public}d", slotId_);
65         }
66         NetworkUtils::RemoveCallbackFromMap(index);
67     } else {
68         bool isAirplaneModeOn = false;
69         nsm->GetAirplaneMode(isAirplaneModeOn);
70         if (nsm->GetRadioState(slotId_) == ModemPowerState::CORE_SERVICE_POWER_OFF && !isAirplaneModeOn) {
71             nsm->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
72         }
73         if (nsm->GetRadioState(slotId_) == ModemPowerState::CORE_SERVICE_POWER_ON) {
74             nsm->TriggerSimRefresh(slotId_);
75         }
76     }
77 }
78 
ProcessSetRadioState(const AppExecFwk::InnerEvent::Pointer & event) const79 void RadioInfo::ProcessSetRadioState(const AppExecFwk::InnerEvent::Pointer &event) const
80 {
81     if (event == nullptr) {
82         TELEPHONY_LOGE("RadioInfo::ProcessSetRadioState event is nullptr slotId:%{public}d", slotId_);
83         return;
84     }
85     std::unique_ptr<RadioStateInfo> object = event->GetUniqueObject<RadioStateInfo>();
86     std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
87     if (responseInfo == nullptr && object == nullptr) {
88         TELEPHONY_LOGE("RadioInfo::ProcessSetRadioState object is nullptr slotId:%{public}d", slotId_);
89         return;
90     }
91     MessageParcel data;
92     int64_t index = 0;
93     bool result = true;
94     ModemPowerState radioState = ModemPowerState::CORE_SERVICE_POWER_NOT_AVAILABLE;
95     data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor());
96     if (responseInfo != nullptr) {
97         TELEPHONY_LOGE("RadioInfo::ProcessSetRadioState false slotId:%{public}d", slotId_);
98         int32_t error = static_cast<int32_t>(responseInfo->error);
99         int32_t status = static_cast<int32_t>(ErrType::ERR_REPEAT_STATUS);
100         result = (error == status) ? true : false;
101         if (!WriteRadioStateResponseInfo(index, data, result, responseInfo)) {
102             return;
103         }
104     }
105     if (object != nullptr) {
106         TELEPHONY_LOGI("RadioInfo::ProcessSetRadioState ok slotId:%{public}d", slotId_);
107         radioState = static_cast<ModemPowerState>(object->flag);
108         result = true;
109         if (!WriteRadioStateObject(index, data, result, object)) {
110             return;
111         }
112     }
113     UpdateInfoOfSetRadioState(radioState, result, data, index);
114 }
115 
RadioFirstPowerOn(std::shared_ptr<NetworkSearchManager> & nsm,ModemPowerState radioState) const116 void RadioInfo::RadioFirstPowerOn(std::shared_ptr<NetworkSearchManager> &nsm, ModemPowerState radioState) const
117 {
118     TELEPHONY_LOGI(
119         "RadioInfo::RadioFirstPowerOn radioState:%{public}d, slotId:%{public}d", static_cast<int>(radioState), slotId_);
120     if (radioState != ModemPowerState::CORE_SERVICE_POWER_ON) {
121         return;
122     }
123     if (!nsm->IsRadioFirstPowerOn(slotId_)) {
124         return;
125     }
126     nsm->SetRadioFirstPowerOn(slotId_, false);
127 }
128 
ProcessGetImei(const AppExecFwk::InnerEvent::Pointer & event) const129 void RadioInfo::ProcessGetImei(const AppExecFwk::InnerEvent::Pointer &event) const
130 {
131     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
132     TELEPHONY_LOGI("RadioInfo::ProcessGetImei slotId:%{public}d", slotId_);
133     if (event == nullptr) {
134         TELEPHONY_LOGE("RadioInfo::ProcessGetImei event is nullptr slotId:%{public}d", slotId_);
135         return;
136     }
137     if (nsm == nullptr) {
138         TELEPHONY_LOGE("RadioInfo::ProcessGetImei nsm is nullptr slotId:%{public}d", slotId_);
139         return;
140     }
141 
142     std::shared_ptr<StringParcel> imeiID = event->GetSharedObject<StringParcel>();
143     if (imeiID == nullptr) {
144         TELEPHONY_LOGE("RadioInfo::ProcessGetImei imei is nullptr slotId:%{public}d", slotId_);
145         nsm->SetImei(slotId_, u"");
146         return;
147     }
148     TELEPHONY_LOGI("RadioInfo::ProcessGetImei get imei success");
149     nsm->SetImei(slotId_, Str8ToStr16(imeiID->data));
150 }
151 
ProcessGetImeiSv(const AppExecFwk::InnerEvent::Pointer & event) const152 void RadioInfo::ProcessGetImeiSv(const AppExecFwk::InnerEvent::Pointer &event) const
153 {
154     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
155     TELEPHONY_LOGI("RadioInfo::ProcessGetImeiSv slotId:%{public}d", slotId_);
156     if (event == nullptr) {
157         TELEPHONY_LOGE("RadioInfo::ProcessGetImeiSv event is nullptr slotId:%{public}d", slotId_);
158         return;
159     }
160     if (nsm == nullptr) {
161         TELEPHONY_LOGE("RadioInfo::ProcessGetImeiSv nsm is nullptr slotId:%{public}d", slotId_);
162         return;
163     }
164 
165     std::shared_ptr<StringParcel> imeiSvID = event->GetSharedObject<StringParcel>();
166     if (imeiSvID == nullptr) {
167         TELEPHONY_LOGE("RadioInfo::ProcessGetImeiSv imeiSv is nullptr slotId:%{public}d", slotId_);
168         nsm->SetImeiSv(slotId_, u"");
169         return;
170     }
171     TELEPHONY_LOGI("RadioInfo::ProcessGetImeiSv get imeiSv success");
172     nsm->SetImeiSv(slotId_, Str8ToStr16(imeiSvID->data));
173 }
174 
ProcessGetMeid(const AppExecFwk::InnerEvent::Pointer & event) const175 void RadioInfo::ProcessGetMeid(const AppExecFwk::InnerEvent::Pointer &event) const
176 {
177     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
178     TELEPHONY_LOGI("RadioInfo::ProcessGetMeid slotId:%{public}d", slotId_);
179     if (event == nullptr) {
180         TELEPHONY_LOGE("RadioInfo::ProcessGetMeid event is nullptr slotId:%{public}d", slotId_);
181         return;
182     }
183     if (nsm == nullptr) {
184         TELEPHONY_LOGE("RadioInfo::ProcessGetMeid nsm is nullptr slotId:%{public}d", slotId_);
185         return;
186     }
187 
188     std::shared_ptr<StringParcel> meid = event->GetSharedObject<StringParcel>();
189     if (meid == nullptr) {
190         TELEPHONY_LOGE("RadioInfo::ProcessGetMeid meid is nullptr slotId:%{public}d", slotId_);
191         nsm->SetMeid(slotId_, u"");
192         return;
193     }
194     TELEPHONY_LOGI("RadioInfo::ProcessGetMeid success");
195     nsm->SetMeid(slotId_, Str8ToStr16(meid->data));
196 }
197 
SetPhoneType(PhoneType phoneType)198 void RadioInfo::SetPhoneType(PhoneType phoneType)
199 {
200     phoneType_ = phoneType;
201 }
202 
GetPhoneType() const203 PhoneType RadioInfo::GetPhoneType() const
204 {
205     return phoneType_;
206 }
207 
UpdatePhone(RadioTech csRadioTech,const RadioTech & psRadioTech)208 void RadioInfo::UpdatePhone(RadioTech csRadioTech, const RadioTech &psRadioTech)
209 {
210     TELEPHONY_LOGI("RadioInfo::UpdatePhone");
211     std::shared_ptr<NetworkSearchManager> networkSearchManager = networkSearchManager_.lock();
212     if (networkSearchManager == nullptr) {
213         TELEPHONY_LOGE("RadioInfo::UpdatePhone networkSearchManager is nullptr");
214         return;
215     }
216     PhoneType phoneType = RadioTechToPhoneType(csRadioTech, psRadioTech);
217     if (phoneType_ == phoneType) {
218         TELEPHONY_LOGI("RadioInfo::UpdatePhone No Change");
219         return;
220     }
221     if (phoneType == PhoneType::PHONE_TYPE_IS_NONE) {
222         TELEPHONY_LOGE("RadioInfo::UpdatePhone phoneType is UNKNOWN");
223         return;
224     }
225     TELEPHONY_LOGI("RadioInfo::UpdatePhone SetPhoneType is success %{public}d", phoneType);
226     SetPhoneType(phoneType);
227 
228     int radioState = networkSearchManager->GetRadioState(slotId_);
229     if (static_cast<ModemPowerState>(radioState) != CORE_SERVICE_POWER_NOT_AVAILABLE) {
230         networkSearchManager->InitSimRadioProtocol(slotId_);
231         std::u16string meid = u"";
232         std::u16string imei = u"";
233         std::u16string imeiSv = u"";
234         std::string basebandVersion = "";
235         networkSearchManager->GetImei(slotId_, imei);
236         networkSearchManager->GetImeiSv(slotId_, imeiSv);
237         networkSearchManager->GetMeid(slotId_, meid);
238         networkSearchManager->GetBasebandVersion(slotId_, basebandVersion);
239         if (static_cast<ModemPowerState>(radioState) == CORE_SERVICE_POWER_ON) {
240             networkSearchManager->GetVoiceTech(slotId_);
241         }
242     }
243 }
244 
ProcessVoiceTechChange(const AppExecFwk::InnerEvent::Pointer & event)245 void RadioInfo::ProcessVoiceTechChange(const AppExecFwk::InnerEvent::Pointer &event)
246 {
247     if (event == nullptr) {
248         TELEPHONY_LOGE("RadioInfo::ProcessVoiceTechChange event is nullptr");
249         return;
250     }
251     std::shared_ptr<VoiceRadioTechnology> csRadioTech = event->GetSharedObject<VoiceRadioTechnology>();
252     if (csRadioTech == nullptr) {
253         TELEPHONY_LOGE("RadioInfo::ProcessVoiceTechChange csRadioTech is nullptr");
254         return;
255     }
256     std::shared_ptr<NetworkSearchManager> networkSearchManager = networkSearchManager_.lock();
257     if (networkSearchManager == nullptr) {
258         TELEPHONY_LOGE("RadioInfo::ProcessVoiceTechChange networkSearchManager is nullptr");
259         return;
260     }
261     int32_t psRadioTech = 0;
262     networkSearchManager->GetPsRadioTech(slotId_, psRadioTech);
263     UpdatePhone(static_cast<RadioTech>(csRadioTech->actType), static_cast<RadioTech>(psRadioTech));
264 }
265 
RadioTechToPhoneType(RadioTech csRadioTech,const RadioTech & psRadioTech) const266 PhoneType RadioInfo::RadioTechToPhoneType(RadioTech csRadioTech, const RadioTech &psRadioTech) const
267 {
268     PhoneType phoneType = PhoneType::PHONE_TYPE_IS_NONE;
269     switch (csRadioTech) {
270         case RadioTech::RADIO_TECHNOLOGY_GSM:
271         case RadioTech::RADIO_TECHNOLOGY_WCDMA:
272         case RadioTech::RADIO_TECHNOLOGY_HSPA:
273         case RadioTech::RADIO_TECHNOLOGY_HSPAP:
274         case RadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
275         case RadioTech::RADIO_TECHNOLOGY_LTE:
276         case RadioTech::RADIO_TECHNOLOGY_LTE_CA:
277         case RadioTech::RADIO_TECHNOLOGY_NR:
278             phoneType = PhoneType::PHONE_TYPE_IS_GSM;
279             break;
280         case RadioTech::RADIO_TECHNOLOGY_1XRTT:
281         case RadioTech::RADIO_TECHNOLOGY_EVDO:
282         case RadioTech::RADIO_TECHNOLOGY_EHRPD:
283             phoneType = PhoneType::PHONE_TYPE_IS_CDMA;
284             break;
285         case RadioTech::RADIO_TECHNOLOGY_UNKNOWN:
286         default:
287             if (psRadioTech == RadioTech::RADIO_TECHNOLOGY_LTE || psRadioTech == RadioTech::RADIO_TECHNOLOGY_LTE_CA ||
288                 psRadioTech == RadioTech::RADIO_TECHNOLOGY_NR) {
289                 phoneType = PhoneType::PHONE_TYPE_IS_GSM;
290             }
291             break;
292     }
293     return phoneType;
294 }
295 
AirplaneModeChange()296 void RadioInfo::AirplaneModeChange()
297 {
298     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
299     if (nsm == nullptr) {
300         TELEPHONY_LOGE("networkSearchManager_ is nullptr slotId:%{public}d", slotId_);
301         return;
302     }
303     bool isAirplaneModeOn = false;
304     if (nsm->GetAirplaneMode(isAirplaneModeOn) != TELEPHONY_SUCCESS) {
305         TELEPHONY_LOGE("AirplaneModeChange GetAirplaneMode fail slotId:%{public}d", slotId_);
306     }
307     CoreServiceHiSysEvent::WriteAirplaneModeChangeEvent(isAirplaneModeOn);
308     bool lastAirplaneMode = false;
309     nsm->GetLocalAirplaneMode(slotId_, lastAirplaneMode);
310     if (isAirplaneModeOn == lastAirplaneMode) {
311         TELEPHONY_LOGE("airplaneMode is not change, slotId:%{public}d", slotId_);
312         return;
313     }
314     if (nsm->GetRadioState(slotId_) == ModemPowerState::CORE_SERVICE_POWER_OFF && isAirplaneModeOn == false) {
315         TELEPHONY_LOGI("radio is off, airplaneMode is closed, slotId:%{public}d", slotId_);
316         auto simManager = nsm->GetSimManager();
317         if (simManager == nullptr) {
318             TELEPHONY_LOGE("get simManager failed");
319             return;
320         }
321         if (simManager->IsSimActive(slotId_)) {
322             nsm->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_ON), 0);
323         }
324     }
325     if (nsm->GetRadioState(slotId_) == ModemPowerState::CORE_SERVICE_POWER_ON && isAirplaneModeOn == true) {
326         TELEPHONY_LOGI("radio is on, airplaneMode is opened, slotId:%{public}d", slotId_);
327         sptr<NetworkSearchCallBackBase> cellularData = nsm->GetCellularDataCallBack();
328         if (cellularData) {
329             cellularData->ClearCellularDataConnections(slotId_);
330         }
331         sptr<NetworkSearchCallBackBase> cellularCall = nsm->GetCellularCallCallBack();
332         if (cellularCall) {
333             cellularCall->ClearCellularCallList(slotId_);
334         }
335         nsm->SetRadioState(slotId_, static_cast<bool>(ModemPowerState::CORE_SERVICE_POWER_OFF), 0);
336     }
337     nsm->SetLocalAirplaneMode(slotId_, isAirplaneModeOn);
338     TELEPHONY_LOGI("airplaneMode:%{public}d, slotId:%{public}d", isAirplaneModeOn, slotId_);
339 }
340 
ProcessGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer & event) const341 int32_t RadioInfo::ProcessGetBasebandVersion(const AppExecFwk::InnerEvent::Pointer &event) const
342 {
343     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
344     TELEPHONY_LOGD("RadioInfo::ProcessGetBasebandVersion slotId:%{public}d", slotId_);
345     if (event == nullptr) {
346         TELEPHONY_LOGE("RadioInfo::ProcessGetBasebandVersion event is nullptr slotId:%{public}d", slotId_);
347         return TELEPHONY_ERR_LOCAL_PTR_NULL;
348     }
349     if (nsm == nullptr) {
350         TELEPHONY_LOGE("RadioInfo::ProcessGetBasebandVersion nsm is nullptr slotId:%{public}d", slotId_);
351         return TELEPHONY_ERR_LOCAL_PTR_NULL;
352     }
353 
354     std::shared_ptr<StringParcel> version = event->GetSharedObject<StringParcel>();
355     if (version == nullptr) {
356         TELEPHONY_LOGE("RadioInfo::ProcessGetBasebandVersion version is nullptr slotId:%{public}d", slotId_);
357         return TELEPHONY_ERR_LOCAL_PTR_NULL;
358     }
359     TELEPHONY_LOGD("RadioInfo::ProcessGetBasebandVersion success");
360     nsm->SetBasebandVersion(slotId_, version->data);
361     return TELEPHONY_ERR_SUCCESS;
362 }
363 
ProcessGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer & event) const364 int32_t RadioInfo::ProcessGetRrcConnectionState(const AppExecFwk::InnerEvent::Pointer &event) const
365 {
366     TELEPHONY_LOGI("start slotId:%{public}d", slotId_);
367     if (event == nullptr) {
368         TELEPHONY_LOGE("RadioInfo::ProcessGetRrcConnectionState event is nullptr slotId:%{public}d", slotId_);
369         return TELEPHONY_ERR_LOCAL_PTR_NULL;
370     }
371     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
372     if (nsm == nullptr) {
373         TELEPHONY_LOGE("RadioInfo::ProcessGetRrcConnectionState nsm is nullptr slotId:%{public}d", slotId_);
374         return TELEPHONY_ERR_LOCAL_PTR_NULL;
375     }
376 
377     auto object = event->GetSharedObject<Int32Parcel>();
378     if (object == nullptr) {
379         TELEPHONY_LOGE("RadioInfo::ProcessGetRrcConnectionState object is nullptr slotId:%{public}d", slotId_);
380         return TELEPHONY_ERR_LOCAL_PTR_NULL;
381     }
382     TELEPHONY_LOGI("rrc state[%{public}d] notify success, slotId:%{public}d", object->data, slotId_);
383     int32_t result = nsm->HandleRrcStateChanged(slotId_, object->data);
384     if (result != TELEPHONY_ERR_SUCCESS) {
385         TELEPHONY_LOGE("Do not need notify, result:%{public}d, slotId:%{public}d", result, slotId_);
386         return result;
387     }
388     nsm->ProcessNotifyStateChangeEvent(slotId_);
389     return TELEPHONY_ERR_SUCCESS;
390 }
391 
ProcessSetNrOptionMode(const AppExecFwk::InnerEvent::Pointer & event) const392 int32_t RadioInfo::ProcessSetNrOptionMode(const AppExecFwk::InnerEvent::Pointer &event) const
393 {
394     TELEPHONY_LOGI("start slotId:%{public}d", slotId_);
395     if (event == nullptr) {
396         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode event is nullptr slotId:%{public}d", slotId_);
397         return TELEPHONY_ERR_LOCAL_PTR_NULL;
398     }
399     std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
400     if (responseInfo == nullptr) {
401         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode responseInfo is nullptr");
402         return TELEPHONY_ERR_LOCAL_PTR_NULL;
403     }
404     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
405     if (nsm == nullptr) {
406         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode nsm is nullptr slotId:%{public}d", slotId_);
407         return TELEPHONY_ERR_LOCAL_PTR_NULL;
408     }
409     int64_t index = responseInfo->flag;
410     std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
411     if (callbackInfo == nullptr) {
412         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode callbackInfo is nullptr slotId:%{public}d", slotId_);
413         return TELEPHONY_ERR_LOCAL_PTR_NULL;
414     }
415     bool success = responseInfo->error == ErrType::NONE;
416     if (success) {
417         nsm->UpdateNrOptionMode(slotId_, static_cast<NrMode>(callbackInfo->param_));
418     }
419     sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
420     if (callback == nullptr) {
421         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode callback is nullptr slotId:%{public}d", slotId_);
422         return TELEPHONY_ERR_LOCAL_PTR_NULL;
423     }
424     MessageParcel data;
425     data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor());
426     if (!data.WriteBool(success) ||
427         !data.WriteInt32(success ? TELEPHONY_SUCCESS : static_cast<int32_t>(responseInfo->error))) {
428         TELEPHONY_LOGE("RadioInfo::ProcessSetNrOptionMode write date fail slotId:%{public}d", slotId_);
429         return TELEPHONY_ERR_WRITE_DATA_FAIL;
430     }
431     callback->OnNetworkSearchCallback(INetworkSearchCallback::NetworkSearchCallback::SET_NR_OPTION_MODE_RESULT, data);
432     NetworkUtils::RemoveCallbackFromMap(index);
433     return TELEPHONY_ERR_SUCCESS;
434 }
435 
ProcessGetNrOptionMode(const AppExecFwk::InnerEvent::Pointer & event) const436 int32_t RadioInfo::ProcessGetNrOptionMode(const AppExecFwk::InnerEvent::Pointer &event) const
437 {
438     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
439     if (event == nullptr || nsm == nullptr) {
440         TELEPHONY_LOGE("event or nsm is nullptr slotId:%{public}d", slotId_);
441         return TELEPHONY_ERR_LOCAL_PTR_NULL;
442     }
443     std::shared_ptr<NrModeInfo> nrModeInfo = event->GetSharedObject<NrModeInfo>();
444     if (TELEPHONY_EXT_WRAPPER.getNrOptionModeExt_ != nullptr && nrModeInfo != nullptr) {
445         TELEPHONY_EXT_WRAPPER.getNrOptionModeExt_(slotId_, nrModeInfo->nrMode);
446     }
447     std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
448     if (responseInfo == nullptr && nrModeInfo == nullptr) {
449         TELEPHONY_LOGE("responseInfo and mode is nullptr slotId:%{public}d", slotId_);
450         return TELEPHONY_ERR_LOCAL_PTR_NULL;
451     }
452     MessageParcel data;
453     data.WriteInterfaceToken(INetworkSearchCallback::GetDescriptor());
454     int64_t index = -1;
455     int32_t nrMode = static_cast<int32_t>(NrMode::NR_MODE_UNKNOWN);
456     if (nrModeInfo != nullptr) {
457         nrMode = nrModeInfo->nrMode;
458         index = nrModeInfo->flag;
459         nsm->UpdateNrOptionMode(slotId_, static_cast<NrMode>(nrMode));
460         if (!data.WriteInt32(nrMode) || !data.WriteInt32(TELEPHONY_SUCCESS)) {
461             TELEPHONY_LOGE("RadioInfo::ProcessGetNrOptionMode WriteInt32 nrMode is false");
462             return TELEPHONY_ERR_WRITE_DATA_FAIL;
463         }
464     } else if (responseInfo != nullptr) {
465         index = responseInfo->flag;
466         if (!data.WriteInt32(nrMode) || !data.WriteInt32(static_cast<int32_t>(responseInfo->error))) {
467             TELEPHONY_LOGE("RadioInfo::ProcessGetNrOptionMode WriteInt32 nrMode is false");
468             return TELEPHONY_ERR_WRITE_DATA_FAIL;
469         }
470     }
471     std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
472     if (callbackInfo == nullptr) {
473         TELEPHONY_LOGE("RadioInfo::ProcessGetNrOptionMode callbackInfo is nullptr slotId:%{public}d", slotId_);
474         return TELEPHONY_ERR_LOCAL_PTR_NULL;
475     }
476     sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
477     if (callback == nullptr) {
478         TELEPHONY_LOGE("RadioInfo::ProcessGetNrOptionMode callback is nullptr slotId:%{public}d", slotId_);
479         NetworkUtils::RemoveCallbackFromMap(index);
480         return TELEPHONY_ERR_LOCAL_PTR_NULL;
481     }
482     callback->OnNetworkSearchCallback(INetworkSearchCallback::NetworkSearchCallback::GET_NR_OPTION_MODE_RESULT, data);
483     NetworkUtils::RemoveCallbackFromMap(index);
484     return TELEPHONY_ERR_SUCCESS;
485 }
486 
WriteRadioStateResponseInfo(int64_t & index,MessageParcel & data,bool result,std::shared_ptr<RadioResponseInfo> & responseInfo) const487 bool RadioInfo::WriteRadioStateResponseInfo(
488     int64_t &index, MessageParcel &data, bool result, std::shared_ptr<RadioResponseInfo> &responseInfo) const
489 {
490     index = responseInfo->flag;
491     if (!data.WriteBool(result) || !data.WriteInt32(static_cast<int32_t>(responseInfo->error))) {
492         NetworkUtils::RemoveCallbackFromMap(index);
493         return false;
494     }
495     return true;
496 }
497 
WriteRadioStateObject(int64_t & index,MessageParcel & data,bool state,std::unique_ptr<RadioStateInfo> & object) const498 bool RadioInfo::WriteRadioStateObject(
499     int64_t &index, MessageParcel &data, bool state, std::unique_ptr<RadioStateInfo> &object) const
500 {
501     index = object->flag;
502     if (!data.WriteBool(state) || !data.WriteInt32(TELEPHONY_SUCCESS)) {
503         NetworkUtils::RemoveCallbackFromMap(index);
504         return false;
505     }
506     return true;
507 }
508 
UpdateInfoOfSetRadioState(ModemPowerState & radioState,bool result,MessageParcel & data,int64_t index) const509 void RadioInfo::UpdateInfoOfSetRadioState(
510     ModemPowerState &radioState, bool result, MessageParcel &data, int64_t index) const
511 {
512     std::shared_ptr<NetworkSearchManager> nsm = networkSearchManager_.lock();
513     if (nsm == nullptr) {
514         TELEPHONY_LOGE("RadioInfo::ProcessSetRadioState NetworkSearchManager is nullptr slotId:%{public}d", slotId_);
515         return;
516     }
517     std::shared_ptr<NetworkSearchCallbackInfo> callbackInfo = NetworkUtils::FindNetworkSearchCallback(index);
518     if (callbackInfo != nullptr) {
519         if (result) {
520             nsm->SetRadioStateValue(slotId_, static_cast<ModemPowerState>(callbackInfo->param_));
521             radioState = static_cast<ModemPowerState>(callbackInfo->param_);
522         }
523         sptr<INetworkSearchCallback> callback = callbackInfo->networkSearchItem_;
524         if (callback != nullptr && callback->OnNetworkSearchCallback(
525             INetworkSearchCallback::NetworkSearchCallback::SET_RADIO_STATUS_RESULT, data)) {
526             TELEPHONY_LOGE("RadioInfo::ProcessSetRadioState callback fail slotId:%{public}d", slotId_);
527         }
528         NetworkUtils::RemoveCallbackFromMap(index);
529     } else {
530         nsm->SetLocateUpdate(slotId_);
531     }
532     if (result) {
533         RadioFirstPowerOn(nsm, radioState);
534     }
535 }
536 } // namespace Telephony
537 } // namespace OHOS
538