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 #ifndef NETWORK_SEARCH_INCLUDE_NETWORK_SEARCH_MANAGER_H
17 #define NETWORK_SEARCH_INCLUDE_NETWORK_SEARCH_MANAGER_H
18 
19 #include <any>
20 #include <cinttypes>
21 #include <list>
22 #include <map>
23 #include <mutex>
24 #include <string>
25 #include <tuple>
26 
27 #include "device_state_handler.h"
28 #include "device_state_observer.h"
29 #include "i_network_search.h"
30 #include "i_sim_manager.h"
31 #include "i_tel_ril_manager.h"
32 #include "iremote_stub.h"
33 #include "network_search_handler.h"
34 #include "network_search_notify.h"
35 #include "network_search_result.h"
36 #include "network_search_state.h"
37 #include "network_utils.h"
38 #include "observer_handler.h"
39 #include "radio_event.h"
40 #include "setting_utils.h"
41 
42 namespace OHOS {
43 namespace Telephony {
44 enum class HandleRunningState { STATE_NOT_START, STATE_RUNNING };
45 /**
46  * @brief inner objects for network search manager
47  *
48  */
49 struct NetworkSearchManagerInner {
50     static const int32_t MSG_NUM = 3;
51     int32_t msgNum_ = MSG_NUM;
52     static const int32_t DEFAULT_RAF = 0xffff;
53     static const int64_t SERIAL_NUMBER_DEFAULT = -1;
54     static const int64_t SERIAL_NUMBER_THRESHOLD = 1000;
55     static const int64_t SERIAL_NUMBER_EXEMPT = 1100;
56     std::shared_ptr<NetworkSearchState> networkSearchState_ = nullptr;
57     std::shared_ptr<NetworkSearchHandler> networkSearchHandler_ = nullptr;
58     std::unique_ptr<ObserverHandler> observerHandler_ = nullptr;
59     std::shared_ptr<DeviceStateHandler> deviceStateHandler_ = nullptr;
60     std::shared_ptr<DeviceStateObserver> deviceStateObserver_ = nullptr;
61     sptr<AutoTimeObserver> settingAutoTimeObserver_ = nullptr;
62     sptr<AutoTimezoneObserver> settingAutoTimezoneObserver_ = nullptr;
63     sptr<AirplaneModeObserver> airplaneModeObserver_ = nullptr;
64     HandleRunningState state_ = HandleRunningState::STATE_NOT_START;
65     std::unique_ptr<NetworkSearchResult> networkSearchResult_ = nullptr;
66     SelectionMode selection_ = SelectionMode::MODE_TYPE_UNKNOWN;
67     ModemPowerState radioState_ = ModemPowerState::CORE_SERVICE_POWER_OFF;
68     std::u16string imei_ = u"";
69     std::u16string imeiSv_ = u"";
70     std::u16string meid_ = u"";
71     std::string residentNetworkNumeric_ = "";
72     std::string basebandVersion_ = "";
73     NrMode nrMode_ = NrMode::NR_MODE_UNKNOWN;
74     int32_t rrcConnectionStatus_ = 0;
75     FrequencyType freqType_ = FrequencyType::FREQ_TYPE_UNKNOWN;
76     std::mutex mutex_;
77     bool isRadioFirstPowerOn_ = true;
78     bool airplaneMode_ = false;
79     int32_t preferredNetworkValue_ = PREFERRED_NETWORK_TYPE;
80     int64_t serialNum_ = SERIAL_NUMBER_DEFAULT;
81     std::mutex msgNumMutex_;
82     std::mutex serialNumMutex_;
83     bool hasCall_ = false;
84 
85     bool RegisterSetting();
86     bool UnRegisterSetting();
87     bool RegisterDeviceStateObserver();
88     bool UnRegisterDeviceStateObserver();
InitNetworkSearchManagerInner89     bool Init()
90     {
91         if (networkSearchState_ != nullptr) {
92             if (!networkSearchState_->Init()) {
93                 return false;
94             }
95         }
96         if (networkSearchHandler_ != nullptr) {
97             if (!networkSearchHandler_->Init()) {
98                 return false;
99             }
100             if (!RegisterSetting()) {
101                 return false;
102             }
103         }
104         if (deviceStateHandler_ != nullptr) {
105             if (!RegisterDeviceStateObserver()) {
106                 return false;
107             }
108         }
109         state_ = HandleRunningState::STATE_RUNNING;
110         return true;
111     }
InitMsgNumNetworkSearchManagerInner112     inline void InitMsgNum()
113     {
114         std::lock_guard<std::mutex> lock(msgNumMutex_);
115         msgNum_ = MSG_NUM;
116     }
CheckIsNeedNotifyNetworkSearchManagerInner117     inline bool CheckIsNeedNotify()
118     {
119         std::lock_guard<std::mutex> lock(msgNumMutex_);
120         return msgNum_ == 0 ? true : false;
121     }
decMsgNumNetworkSearchManagerInner122     inline void decMsgNum()
123     {
124         std::lock_guard<std::mutex> lock(msgNumMutex_);
125         msgNum_--;
126     }
IncreaseSerialNumNetworkSearchManagerInner127     inline int64_t IncreaseSerialNum()
128     {
129         std::lock_guard<std::mutex> lock(serialNumMutex_);
130         if (serialNum_ >= SERIAL_NUMBER_THRESHOLD) {
131             // recycle the serial number.
132             serialNum_ = SERIAL_NUMBER_DEFAULT;
133         }
134         return ++serialNum_;
135     }
GetSerialNumNetworkSearchManagerInner136     inline int64_t GetSerialNum()
137     {
138         std::lock_guard<std::mutex> lock(serialNumMutex_);
139         return serialNum_;
140     }
141 };
142 
143 /**
144  * @brief manager class of network search module .The main entrance to the module.
145  *
146  */
147 class NetworkSearchManager : public INetworkSearch, public std::enable_shared_from_this<NetworkSearchManager> {
148 public:
149     NetworkSearchManager(std::shared_ptr<ITelRilManager> telRilManager, std::shared_ptr<ISimManager> simManager);
150     virtual ~NetworkSearchManager();
151 
152     bool OnInit() override;
153     int32_t InitTelExtraModule(int32_t slotId) override;
154     void SetRadioState(int32_t slotId, bool isOn, int32_t rst) override;
155     int32_t SetRadioState(int32_t slotId, bool isOn, int32_t rst, NSCALLBACK &callback) override;
156     int32_t GetRadioState(int32_t slotId) override;
157     int32_t GetRadioState(int32_t slotId, NSCALLBACK &callback) override;
158     int32_t GetPsRadioTech(int32_t slotId, int32_t &psRadioTech) override;
159     int32_t GetCsRadioTech(int32_t slotId, int32_t &csRadioTech) override;
160     std::u16string GetOperatorNumeric(int32_t slotId) override;
161     int32_t GetOperatorName(int32_t slotId, std::u16string &operatorName) override;
162     int32_t GetNetworkStatus(int32_t slotId, sptr<NetworkState> &networkState) override;
163     int32_t GetSignalInfoList(int32_t slotId, std::vector<sptr<SignalInformation>> &signals) override;
164     void RegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what) override;
165     void UnRegisterCoreNotify(int32_t slotId, HANDLE &handler, int32_t what) override;
166     void RegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> &callback) override;
167     void UnRegisterCellularDataObject(const sptr<NetworkSearchCallBackBase> &callback) override;
168     void RegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> &callback) override;
169     void UnRegisterCellularCallObject(const sptr<NetworkSearchCallBackBase> &callback) override;
170     int32_t GetNetworkSearchInformation(int32_t slotId, NSCALLBACK &callback) override;
171     int32_t GetNetworkSelectionMode(int32_t slotId, NSCALLBACK &callback) override;
172     int32_t SetNetworkSelectionMode(int32_t slotId, int32_t selectMode,
173         const sptr<NetworkInformation> &networkInformation, bool resumeSelection, NSCALLBACK &callback) override;
174     int32_t GetPreferredNetwork(int32_t slotId, NSCALLBACK &callback) override;
175     int32_t SetPreferredNetwork(int32_t slotId, int32_t networkMode, NSCALLBACK &callback) override;
176     int32_t GetIsoCountryCodeForNetwork(int32_t slotId, std::u16string &countryCode) override;
177     int32_t GetImei(int32_t slotId, std::u16string &imei) override;
178     int32_t GetImeiSv(int32_t slotId, std::u16string &imeiSv) override;
179     int32_t GetPsRegState(int32_t slotId) override;
180     int32_t GetCsRegState(int32_t slotId) override;
181     int32_t GetPsRoamingState(int32_t slotId) override;
182     int32_t GetCellInfoList(int32_t slotId, std::vector<sptr<CellInformation>> &cellInfo) override;
183     int32_t SendUpdateCellLocationRequest(int32_t slotId) override;
184     sptr<CellLocation> GetCellLocation(int32_t slotId) override;
185     int32_t GetImsRegStatus(int32_t slotId, ImsServiceType imsSrvType, ImsRegInfo &info) override;
186     PhoneType GetPhoneType(int32_t slotId) override;
187     int32_t GetMeid(int32_t slotId, std::u16string &meid) override;
188     int32_t GetUniqueDeviceId(int32_t slotId, std::u16string &deviceId) override;
189     bool IsNrSupported(int32_t slotId) override;
190     bool IsSatelliteEnabled() override;
191     FrequencyType GetFrequencyType(int32_t slotId) override;
192     NrState GetNrState(int32_t slotId) override;
193     void DcPhysicalLinkActiveUpdate(int32_t slotId, bool isActive) override;
194     int32_t NotifyCallStatusToNetworkSearch(int32_t slotId, int32_t callStatus) override;
195     int32_t HandleNotifyStateChangeWithDelay(int32_t slotId, bool isNeedDelay) override;
196     bool IsNeedDelayNotify(int32_t slotId);
197     int32_t SetNrOptionMode(int32_t slotId, int32_t mode);
198     int32_t SetNrOptionMode(int32_t slotId, int32_t mode, NSCALLBACK &callback) override;
199     int32_t GetNrOptionMode(int32_t slotId, NrMode &mode) override;
200     int32_t GetNrOptionMode(int32_t slotId, NSCALLBACK &callback) override;
201     int32_t RegisterImsRegInfoCallback(int32_t slotId, ImsServiceType imsSrvType, const int32_t tokenId,
202         const sptr<ImsRegInfoCallback> &callback) override;
203     int32_t UnregisterImsRegInfoCallback(
204         int32_t slotId, ImsServiceType imsSrvType, const int32_t tokenId) override;
205     int32_t GetNetworkCapability(
206         int32_t slotId, int32_t networkCapabilityType, int32_t &networkCapabilityState) override;
207     int32_t SetNetworkCapability(
208         int32_t slotId, int32_t networkCapabilityType, int32_t networkCapabilityState) override;
209     int32_t FactoryReset(int32_t slotId) override;
210 
211     void NotifyPsRoamingOpenChanged(int32_t slotId);
212     void NotifyPsRoamingCloseChanged(int32_t slotId);
213     void NotifyPsConnectionAttachedChanged(int32_t slotId);
214     void NotifyPsConnectionDetachedChanged(int32_t slotId);
215     void NotifyPsRatChanged(int32_t slotId);
216     void NotifyEmergencyOpenChanged(int32_t slotId);
217     void NotifyEmergencyCloseChanged(int32_t slotId);
218     void NotifyNrStateChanged(int32_t slotId);
219     void NotifyNrFrequencyChanged(int32_t slotId);
220     void NotifyFactoryReset(int32_t slotId);
221     std::shared_ptr<NetworkSearchState> GetNetworkSearchState(int32_t slotId);
222     void TriggerSimRefresh(int32_t slotId);
223     void TriggerTimezoneRefresh(int32_t slotId);
224     void SetNetworkSearchResultValue(
225         int32_t slotId, int32_t listSize, const std::vector<NetworkInformation> &operatorInfo);
226     sptr<NetworkSearchResult> GetNetworkSearchInformationValue(int32_t slotId);
227     int32_t GetNetworkSelectionMode(int32_t slotId);
228     bool SetNetworkSelectionMode(
229         int32_t slotId, int32_t selectMode, const sptr<NetworkInformation> &networkInformation, bool resumeSelection);
230     void SetRadioStateValue(int32_t slotId, ModemPowerState radioState);
231     void SetNetworkSelectionValue(int32_t slotId, SelectionMode selection);
232     int32_t GetPreferredNetwork(int32_t slotId);
233     int32_t SetCachePreferredNetworkValue(int32_t slotId, int32_t networkMode);
234     int32_t GetCachePreferredNetworkValue(int32_t slotId, int32_t &networkMode);
235     bool SetPreferredNetwork(int32_t slotId, int32_t networkMode);
236     void SavePreferredNetworkValue(int32_t slotId, int32_t networkMode);
237     int32_t GetPreferredNetworkValue(int32_t slotId) const;
238     void UpdatePhone(int32_t slotId, RadioTech csRadioTech, const RadioTech &psRadioTech);
239     void SetImei(int32_t slotId, std::u16string imei);
240     void SetImeiSv(int32_t slotId, std::u16string imeiSv);
241     void UpdateCellLocation(int32_t slotId, int32_t techType, int32_t cellId, int32_t lac);
242     void SetMeid(int32_t slotId, std::u16string meid);
243     void SetFrequencyType(int32_t slotId, FrequencyType type);
244     void GetVoiceTech(int32_t slotId);
245     std::shared_ptr<NetworkSearchManagerInner> FindManagerInner(int32_t slotId);
246     void SetLocateUpdate(int32_t slotId);
247     int32_t GetAirplaneMode(bool &airplaneMode) override;
248     void InitAirplaneMode(int32_t slotId) override;
249     int32_t ProcessNotifyStateChangeEvent(int32_t slotId);
250     bool IsRadioFirstPowerOn(int32_t slotId);
251     void SetRadioFirstPowerOn(int32_t slotId, bool isFirstPowerOn);
252     void NotifyImsRegInfoChanged(int32_t slotId, ImsServiceType imsSrvType, const ImsRegInfo &info);
253     void InitSimRadioProtocol(int32_t slotId);
254     int32_t SetLocalAirplaneMode(int32_t slotId, bool state);
255     int32_t GetLocalAirplaneMode(int32_t slotId, bool &state);
256     void SetBasebandVersion(int32_t slotId, std::string version);
257     int32_t GetBasebandVersion(int32_t slotId, std::string &version) override;
258     int32_t UpdateNrOptionMode(int32_t slotId, NrMode mode);
259     int32_t UpdateRadioOn(int32_t slotId) override;
260     int32_t HandleRrcStateChanged(int32_t slotId, int32_t status);
261     int32_t GetRrcConnectionState(int32_t slotId, int32_t &status) override;
262     int32_t UpdateRrcConnectionState(int32_t slotId, int32_t &status);
263     int32_t GetNrSsbId(int32_t slotId, const std::shared_ptr<NrSsbInformation> &nrSsbInformation) override;
264     int32_t IsGsm(int32_t slotId, bool &isGsm) override;
265     int32_t IsCdma(int32_t slotId, bool &isCdma) override;
266     std::string GetResidentNetworkNumeric(int32_t slotId) override;
267     void SetResidentNetworkNumeric(int32_t slotId, std::string operatorNumeric);
268     int32_t ProcessSignalIntensity(int32_t slotId, const Rssi &signalIntensity) override;
269     int32_t StartRadioOnState(int32_t slotId) override;
270     int32_t StartGetRilSignalIntensity(int32_t slotId) override;
271 
InitMsgNum(int32_t slotId)272     inline void InitMsgNum(int32_t slotId)
273     {
274         auto inner = FindManagerInner(slotId);
275         if (inner != nullptr) {
276             inner->InitMsgNum();
277         }
278     }
CheckIsNeedNotify(int32_t slotId)279     inline bool CheckIsNeedNotify(int32_t slotId)
280     {
281         auto inner = FindManagerInner(slotId);
282         if (inner != nullptr) {
283             return inner->CheckIsNeedNotify();
284         }
285         return false;
286     }
decMsgNum(int32_t slotId)287     inline void decMsgNum(int32_t slotId)
288     {
289         auto inner = FindManagerInner(slotId);
290         if (inner != nullptr) {
291             inner->decMsgNum();
292         }
293     }
IncreaseSerialNum(int32_t slotId)294     inline int64_t IncreaseSerialNum(int32_t slotId)
295     {
296         auto inner = FindManagerInner(slotId);
297         if (inner != nullptr) {
298             return inner->IncreaseSerialNum();
299         }
300         return NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT;
301     }
GetSerialNum(int32_t slotId)302     inline int64_t GetSerialNum(int32_t slotId)
303     {
304         auto inner = FindManagerInner(slotId);
305         if (inner != nullptr) {
306             return inner->GetSerialNum();
307         }
308         return NetworkSearchManagerInner::SERIAL_NUMBER_DEFAULT;
309     }
GetCellularDataCallBack()310     inline sptr<NetworkSearchCallBackBase> GetCellularDataCallBack()
311     {
312         return cellularDataCallBack_;
313     }
GetCellularCallCallBack()314     inline sptr<NetworkSearchCallBackBase> GetCellularCallCallBack()
315     {
316         return cellularCallCallBack_;
317     }
GetSimManager()318     inline std::shared_ptr<ISimManager> GetSimManager() const
319     {
320         return simManager_;
321     }
322 
323 public:
324     static std::mutex ctx_;
325     static bool ssbResponseReady_;
326     static std::condition_variable cv_;
327 
328 private:
329     bool InitPointer(std::shared_ptr<NetworkSearchManagerInner> &inner, int32_t slotId);
330     void ClearManagerInner();
331     void AddManagerInner(int32_t slotId, const std::shared_ptr<NetworkSearchManagerInner> &inner);
332     bool RemoveManagerInner(int32_t slotId);
333     int32_t InitModuleBySlotId(int32_t slotId);
334     int32_t GetDelayNotifyTime();
335     int32_t RevertLastTechnology(int32_t slotId);
336     int32_t ConvertNetworkModeToCapabilityType(int32_t preferredNetwork);
337 
338 private:
339     struct ImsRegInfoCallbackRecord {
340         int32_t slotId;
341         ImsServiceType imsSrvType;
342         int32_t tokenId = 0;
343         sptr<ImsRegInfoCallback> imsCallback;
344     };
345 
346     sptr<NetworkSearchCallBackBase> cellularDataCallBack_ = nullptr;
347     sptr<NetworkSearchCallBackBase> cellularCallCallBack_ = nullptr;
348     std::shared_ptr<ITelRilManager> telRilManager_ = nullptr;
349     std::shared_ptr<ISimManager> simManager_ = nullptr;
350     std::unique_ptr<EventSender> eventSender_ = nullptr;
351     std::map<int32_t, std::shared_ptr<NetworkSearchManagerInner>> mapManagerInner_;
352     std::list<ImsRegInfoCallbackRecord> listImsRegInfoCallbackRecord_;
353     std::mutex mutexInner_;
354     std::mutex mutexIms_;
355     int32_t delayTime_ = 0;
356 };
357 } // namespace Telephony
358 } // namespace OHOS
359 #endif // NETWORK_SEARCH_INCLUDE_NETWORK_SEARCH_MANAGER_H
360