1 /*
2 * Copyright (C) 2023 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 #include "locator_required_data_manager.h"
16 #include "location_log.h"
17 #ifdef WIFI_ENABLE
18 #include "wifi_errcode.h"
19 #include "wifi_device.h"
20 #endif
21 #include "iservice_registry.h"
22 #include "common_utils.h"
23 #include "permission_manager.h"
24
25 namespace OHOS {
26 namespace Location {
27 const uint32_t EVENT_START_SCAN = 0x0100;
28 const uint32_t EVENT_STOP_SCAN = 0x0200;
29 const uint32_t EVENT_GET_WIFI_LIST = 0x0300;
30 const uint32_t EVENT_REGISTER_WIFI_CALLBACK = 0x0400;
31 const uint32_t EVENT_UNREGISTER_WIFI_CALLBACK = 0x0500;
32 const int32_t DEFAULT_TIMEOUT_4S = 4000;
33 const int64_t DEFAULT_TIMEOUT_30_MIN = 30 * 60 * MILLI_PER_SEC * MICRO_PER_MILLI; // 1800000000μs
34
LocatorRequiredDataManager()35 LocatorRequiredDataManager::LocatorRequiredDataManager()
36 {
37 scanHandler_ = std::make_shared<ScanHandler>(AppExecFwk::EventRunner::Create(true, AppExecFwk::ThreadMode::FFRT));
38 wifiSdkHandler_ =
39 std::make_shared<WifiSdkHandler>(AppExecFwk::EventRunner::Create(true, AppExecFwk::ThreadMode::FFRT));
40 if (wifiSdkHandler_ != nullptr) {
41 wifiSdkHandler_->SendEvent(EVENT_REGISTER_WIFI_CALLBACK, 0, 0);
42 }
43 }
44
GetInstance()45 LocatorRequiredDataManager* LocatorRequiredDataManager::GetInstance()
46 {
47 static LocatorRequiredDataManager data;
48 return &data;
49 }
50
~LocatorRequiredDataManager()51 LocatorRequiredDataManager::~LocatorRequiredDataManager()
52 {
53 if (wifiSdkHandler_ != nullptr) {
54 wifiSdkHandler_->SendEvent(EVENT_UNREGISTER_WIFI_CALLBACK, 0, 0);
55 }
56 }
57
SyncStillMovementState(bool state)58 void LocatorRequiredDataManager::SyncStillMovementState(bool state)
59 {
60 std::unique_lock<std::mutex> lock(lastStillTimeMutex_);
61 if (state) {
62 lastStillTime_ = CommonUtils::GetSinceBootTime();
63 } else {
64 lastStillTime_ = 0;
65 }
66 }
67
GetlastStillTime()68 int64_t LocatorRequiredDataManager::GetlastStillTime()
69 {
70 std::unique_lock<std::mutex> lock(lastStillTimeMutex_);
71 return lastStillTime_;
72 }
73
IsStill()74 bool LocatorRequiredDataManager::IsStill()
75 {
76 std::unique_lock<std::mutex> lock(lastStillTimeMutex_);
77 return lastStillTime_ > 0;
78 }
79
SendWifiScanEvent()80 void LocatorRequiredDataManager::SendWifiScanEvent()
81 {
82 if (scanHandler_ != nullptr) {
83 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(
84 EVENT_START_SCAN, 1);
85 scanHandler_->SendEvent(event);
86 }
87 }
88
SendGetWifiListEvent(int timeout)89 void LocatorRequiredDataManager::SendGetWifiListEvent(int timeout)
90 {
91 if (timeout > 0 && wifiSdkHandler_->HasInnerEvent(EVENT_GET_WIFI_LIST)) {
92 return;
93 }
94 if (wifiSdkHandler_ != nullptr) {
95 wifiSdkHandler_->SendHighPriorityEvent(EVENT_GET_WIFI_LIST, 0, timeout);
96 }
97 }
98
RegisterCallback(AppIdentity & identity,std::shared_ptr<LocatingRequiredDataConfig> & config,const sptr<IRemoteObject> & callback)99 __attribute__((no_sanitize("cfi"))) LocationErrCode LocatorRequiredDataManager::RegisterCallback(
100 AppIdentity &identity, std::shared_ptr<LocatingRequiredDataConfig>& config, const sptr<IRemoteObject>& callback)
101 {
102 if (config->GetType() == LocatingRequiredDataType::WIFI) {
103 #ifdef WIFI_ENABLE
104 std::unique_lock<std::mutex> lock(mutex_, std::defer_lock);
105 lock.lock();
106 callbacksMap_[callback] = identity;
107 LBSLOGD(LOCATOR, "after RegisterCallback, callback size:%{public}s",
108 std::to_string(callbacksMap_.size()).c_str());
109 if (!IsWifiCallbackRegistered() && wifiSdkHandler_ != nullptr) {
110 wifiSdkHandler_->SendEvent(EVENT_REGISTER_WIFI_CALLBACK, 0, 0);
111 }
112 bool needScan = false;
113 if (config->GetNeedStartScan()) {
114 needScan = true;
115 }
116 lock.unlock();
117 if (needScan) {
118 SendWifiScanEvent();
119 SendGetWifiListEvent(DEFAULT_TIMEOUT_4S >= config->GetScanTimeoutMs() ?
120 config->GetScanTimeoutMs() : DEFAULT_TIMEOUT_4S);
121 } else {
122 SendGetWifiListEvent(0);
123 }
124 #endif
125 } else if (config->GetType() == LocatingRequiredDataType::BLUE_TOOTH) {
126 return ERRCODE_NOT_SUPPORTED;
127 }
128 return ERRCODE_SUCCESS;
129 }
130
UnregisterCallback(const sptr<IRemoteObject> & callback)131 LocationErrCode LocatorRequiredDataManager::UnregisterCallback(const sptr<IRemoteObject>& callback)
132 {
133 #ifdef WIFI_ENABLE
134 std::unique_lock<std::mutex> lock(mutex_);
135 auto iter = callbacksMap_.find(callback);
136 if (iter != callbacksMap_.end()) {
137 callbacksMap_.erase(iter);
138 }
139 LBSLOGD(LOCATOR, "after UnregisterCallback, callback size:%{public}s",
140 std::to_string(callbacksMap_.size()).c_str());
141 #endif
142 return ERRCODE_SUCCESS;
143 }
144
145 #ifdef BLUETOOTH_ENABLE
146
GetLocatingRequiredDataByBtHost(const Bluetooth::BluetoothRemoteDevice & device)147 std::vector<std::shared_ptr<LocatingRequiredData>> LocatorBluetoothHost::GetLocatingRequiredDataByBtHost(
148 const Bluetooth::BluetoothRemoteDevice &device)
149 {
150 std::vector<std::shared_ptr<LocatingRequiredData>> result;
151 std::shared_ptr<LocatingRequiredData> info = std::make_shared<LocatingRequiredData>();
152 std::shared_ptr<BluetoothScanInfo> btData = std::make_shared<BluetoothScanInfo>();
153 btData->SetMac(device.GetDeviceAddr());
154 btData->SetDeviceName(device.GetDeviceName());
155 info->SetType(LocatingRequiredDataType::BLUE_TOOTH);
156 info->SetBluetoothScanInfo(btData);
157 result.push_back(info);
158 return result;
159 }
160
GetLocatingRequiredDataByBle(const Bluetooth::BleScanResult & result)161 std::vector<std::shared_ptr<LocatingRequiredData>> LocatorBleCallbackWapper::GetLocatingRequiredDataByBle(
162 const Bluetooth::BleScanResult &result)
163 {
164 std::vector<std::shared_ptr<LocatingRequiredData>> res;
165 std::shared_ptr<LocatingRequiredData> info = std::make_shared<LocatingRequiredData>();
166 std::shared_ptr<BluetoothScanInfo> btData = std::make_shared<BluetoothScanInfo>();
167 btData->SetMac(result.GetPeripheralDevice().GetDeviceAddr());
168 btData->SetDeviceName(result.GetPeripheralDevice().GetDeviceName());
169 btData->SetRssi(result.GetRssi());
170 info->SetType(LocatingRequiredDataType::BLUE_TOOTH);
171 info->SetBluetoothScanInfo(btData);
172 res.push_back(info);
173 return res;
174 }
175
OnStateChanged(const int transport,const int status)176 void LocatorBluetoothHost::OnStateChanged(const int transport, const int status) {}
177
OnDiscoveryStateChanged(int status)178 void LocatorBluetoothHost::OnDiscoveryStateChanged(int status) {}
179
OnDiscoveryResult(const Bluetooth::BluetoothRemoteDevice & device,int rssi,const std::string deviceName,int deviceClass)180 void LocatorBluetoothHost::OnDiscoveryResult(const Bluetooth::BluetoothRemoteDevice &device, int rssi,
181 const std::string deviceName, int deviceClass)
182 {
183 std::vector<std::shared_ptr<LocatingRequiredData>> result = GetLocatingRequiredDataByBtHost(device);
184 auto dataManager = LocatorRequiredDataManager::GetInstance();
185 dataManager->ReportData(result);
186 }
187
OnPairRequested(const Bluetooth::BluetoothRemoteDevice & device)188 void LocatorBluetoothHost::OnPairRequested(const Bluetooth::BluetoothRemoteDevice &device) {}
189
OnPairConfirmed(const Bluetooth::BluetoothRemoteDevice & device,int reqType,int number)190 void LocatorBluetoothHost::OnPairConfirmed(const Bluetooth::BluetoothRemoteDevice &device, int reqType, int number) {}
191
OnScanModeChanged(int mode)192 void LocatorBluetoothHost::OnScanModeChanged(int mode) {}
193
OnDeviceNameChanged(const std::string & deviceName)194 void LocatorBluetoothHost::OnDeviceNameChanged(const std::string &deviceName) {}
195
OnDeviceAddrChanged(const std::string & address)196 void LocatorBluetoothHost::OnDeviceAddrChanged(const std::string &address) {}
197
OnScanCallback(const Bluetooth::BleScanResult & result)198 void LocatorBleCallbackWapper::OnScanCallback(const Bluetooth::BleScanResult &result)
199 {
200 std::vector<std::shared_ptr<LocatingRequiredData>> res = GetLocatingRequiredDataByBle(result);
201 auto dataManager = LocatorRequiredDataManager::GetInstance();
202 dataManager->ReportData(res);
203 }
204
OnFoundOrLostCallback(const Bluetooth::BleScanResult & result,uint8_t callbackType)205 void LocatorBleCallbackWapper::OnFoundOrLostCallback(const Bluetooth::BleScanResult &result, uint8_t callbackType) {}
206
OnBleBatchScanResultsEvent(const std::vector<Bluetooth::BleScanResult> & results)207 void LocatorBleCallbackWapper::OnBleBatchScanResultsEvent(const std::vector<Bluetooth::BleScanResult> &results) {}
208
OnStartOrStopScanEvent(int32_t resultCode,bool isStartScan)209 void LocatorBleCallbackWapper::OnStartOrStopScanEvent(int32_t resultCode, bool isStartScan) {}
210
OnNotifyMsgReportFromLpDevice(const Bluetooth::UUID & btUuid,int msgType,const std::vector<uint8_t> & value)211 void LocatorBleCallbackWapper::OnNotifyMsgReportFromLpDevice(const Bluetooth::UUID &btUuid, int msgType,
212 const std::vector<uint8_t> &value) {}
213 #endif
214
215 #ifdef WIFI_ENABLE
WifiInfoInit()216 void LocatorRequiredDataManager::WifiInfoInit()
217 {
218 wifiScanPtr_ = Wifi::WifiScan::GetInstance(WIFI_SCAN_ABILITY_ID);
219 }
220
IsWifiCallbackRegistered()221 bool LocatorRequiredDataManager::IsWifiCallbackRegistered()
222 {
223 std::unique_lock<std::mutex> lock(wifiRegisteredMutex_);
224 return isWifiCallbackRegistered_;
225 }
226
SetIsWifiCallbackRegistered(bool isWifiCallbackRegistered)227 void LocatorRequiredDataManager::SetIsWifiCallbackRegistered(bool isWifiCallbackRegistered)
228 {
229 std::unique_lock<std::mutex> lock(wifiRegisteredMutex_);
230 isWifiCallbackRegistered_ = isWifiCallbackRegistered;
231 }
232
RegisterWifiCallBack()233 __attribute__((no_sanitize("cfi"))) bool LocatorRequiredDataManager::RegisterWifiCallBack()
234 {
235 LBSLOGD(LOCATOR, "%{public}s enter", __func__);
236 wifiScanEventCallback_.OnWifiScanStateChanged = LocatorWifiScanEventCallback::OnWifiScanStateChanged;
237 int32_t ret = RegisterWifiEvent(&wifiScanEventCallback_);
238 if (ret != Wifi::WIFI_OPT_SUCCESS) {
239 LBSLOGE(LOCATOR, "%{public}s WifiScan RegisterCallBack failed!", __func__);
240 SetIsWifiCallbackRegistered(false);
241 return false;
242 }
243 SetIsWifiCallbackRegistered(true);
244 return true;
245 }
246
UnregisterWifiCallBack()247 __attribute__((no_sanitize("cfi"))) bool LocatorRequiredDataManager::UnregisterWifiCallBack()
248 {
249 LBSLOGD(LOCATOR, "%{public}s enter", __func__);
250 int ret = UnRegisterWifiEvent(&wifiScanEventCallback_);
251 if (ret != Wifi::WIFI_OPT_SUCCESS) {
252 LBSLOGE(LOCATOR, "%{public}s WifiScan RegisterCallBack failed!", __func__);
253 return false;
254 }
255 SetIsWifiCallbackRegistered(false);
256 return true;
257 }
258
GetWifiScanList(std::vector<Wifi::WifiScanInfo> & wifiScanInfo)259 __attribute__((no_sanitize("cfi"))) void LocatorRequiredDataManager::GetWifiScanList(
260 std::vector<Wifi::WifiScanInfo>& wifiScanInfo)
261 {
262 std::shared_ptr<Wifi::WifiScan> ptrWifiScan = Wifi::WifiScan::GetInstance(WIFI_SCAN_ABILITY_ID);
263 if (ptrWifiScan == nullptr) {
264 LBSLOGE(LOCATOR, "%{public}s WifiScan get instance failed", __func__);
265 return;
266 }
267 int ret = ptrWifiScan->GetScanInfoList(wifiScanInfo);
268 if (ret != Wifi::WIFI_OPT_SUCCESS) {
269 LBSLOGE(LOCATOR, "GetScanInfoList failed");
270 return;
271 }
272 if (wifiSdkHandler_ != nullptr) {
273 wifiSdkHandler_->RemoveEvent(EVENT_GET_WIFI_LIST);
274 }
275 }
276
GetLocatingRequiredDataByWifi(const std::vector<Wifi::WifiScanInfo> & wifiScanInfo)277 std::vector<std::shared_ptr<LocatingRequiredData>> LocatorRequiredDataManager::GetLocatingRequiredDataByWifi(
278 const std::vector<Wifi::WifiScanInfo>& wifiScanInfo)
279 {
280 auto deltaMis = (CommonUtils::GetSinceBootTime() - GetWifiScanCompleteTimestamp()) / NANOS_PER_MICRO;
281 std::vector<std::shared_ptr<LocatingRequiredData>> res;
282 for (size_t i = 0; i < wifiScanInfo.size(); i++) {
283 std::shared_ptr<LocatingRequiredData> info = std::make_shared<LocatingRequiredData>();
284 std::shared_ptr<WifiScanInfo> wifiData = std::make_shared<WifiScanInfo>();
285 wifiData->SetSsid(wifiScanInfo[i].ssid);
286 wifiData->SetBssid(wifiScanInfo[i].bssid);
287 wifiData->SetRssi(wifiScanInfo[i].rssi);
288 wifiData->SetFrequency(wifiScanInfo[i].frequency);
289 if (!IsStill()) {
290 wifiData->SetTimestamp(wifiScanInfo[i].timestamp);
291 } else {
292 wifiData->SetTimestamp(wifiScanInfo[i].timestamp + deltaMis);
293 }
294 info->SetType(LocatingRequiredDataType::WIFI);
295 info->SetWifiScanInfo(wifiData);
296 res.push_back(info);
297 }
298 return res;
299 }
300
UpdateWifiScanCompleteTimestamp()301 void LocatorRequiredDataManager::UpdateWifiScanCompleteTimestamp()
302 {
303 std::unique_lock<std::mutex> lock(wifiScanCompleteTimestampMutex_);
304 wifiScanCompleteTimestamp_ = CommonUtils::GetSinceBootTime();
305 }
306
GetWifiScanCompleteTimestamp()307 int64_t LocatorRequiredDataManager::GetWifiScanCompleteTimestamp()
308 {
309 std::unique_lock<std::mutex> lock(wifiScanCompleteTimestampMutex_);
310 return wifiScanCompleteTimestamp_;
311 }
312
OnWifiScanStateChanged(int state,int size)313 void LocatorWifiScanEventCallback::OnWifiScanStateChanged(int state, int size)
314 {
315 LBSLOGD(LOCATOR, "OnWifiScanStateChanged state=%{public}d", state);
316 auto dataManager = LocatorRequiredDataManager::GetInstance();
317 if (state == 0) {
318 LBSLOGE(LOCATOR, "OnWifiScanStateChanged false");
319 } else {
320 dataManager->UpdateWifiScanCompleteTimestamp();
321 }
322 if (!dataManager->IsConnecting()) {
323 LBSLOGE(LOCATOR, "%{public}s no valid callback, return", __func__);
324 return;
325 }
326 std::vector<Wifi::WifiScanInfo> wifiScanInfo;
327 dataManager->GetWifiScanList(wifiScanInfo);
328 std::vector<std::shared_ptr<LocatingRequiredData>> result =
329 dataManager->GetLocatingRequiredDataByWifi(wifiScanInfo);
330 dataManager->ReportData(result);
331 return;
332 }
333 #endif
334
ReportData(const std::vector<std::shared_ptr<LocatingRequiredData>> & result)335 void LocatorRequiredDataManager::ReportData(const std::vector<std::shared_ptr<LocatingRequiredData>>& result)
336 {
337 std::unique_lock<std::mutex> lock(mutex_);
338 for (const auto& pair : callbacksMap_) {
339 auto callback = pair.first;
340 sptr<ILocatingRequiredDataCallback> locatingRequiredDataCallback =
341 iface_cast<ILocatingRequiredDataCallback>(callback);
342 AppIdentity identity = pair.second;
343 if (CommonUtils::IsAppBelongCurrentAccount(identity)) {
344 locatingRequiredDataCallback->OnLocatingDataChange(result);
345 }
346 }
347 }
348
StartWifiScan(int fixNumber,bool flag)349 __attribute__((no_sanitize("cfi"))) void LocatorRequiredDataManager::StartWifiScan(int fixNumber, bool flag)
350 {
351 if (!flag) {
352 if (scanHandler_ != nullptr) {
353 scanHandler_->RemoveEvent(EVENT_START_SCAN);
354 }
355 if (wifiSdkHandler_ != nullptr) {
356 wifiSdkHandler_->RemoveEvent(EVENT_GET_WIFI_LIST);
357 }
358 LBSLOGE(LOCATOR, "%{public}s no valid callback, return", __func__);
359 return;
360 }
361 #ifdef WIFI_ENABLE
362 int64_t currentTime = CommonUtils::GetSinceBootTime();
363 if (IsStill() && GetWifiScanCompleteTimestamp() > GetlastStillTime() &&
364 (currentTime - GetWifiScanCompleteTimestamp()) / NANOS_PER_MICRO < DEFAULT_TIMEOUT_30_MIN) {
365 LBSLOGI(LOCATOR, "current state is still, no need to scan, report cache scaninfo");
366 SendGetWifiListEvent(0);
367 return;
368 }
369 int ret = Wifi::WifiScan::GetInstance(WIFI_SCAN_ABILITY_ID)->Scan();
370 if (ret != Wifi::WIFI_OPT_SUCCESS) {
371 LBSLOGE(LOCATOR, "%{public}s WifiScan failed, ret=%{public}d", __func__, ret);
372 SendGetWifiListEvent(0);
373 }
374 #endif
375 if (fixNumber) {
376 return;
377 }
378 LBSLOGD(LOCATOR, "StartWifiScan timeInterval_=%{public}d", timeInterval_);
379 if (scanHandler_ != nullptr) {
380 scanHandler_->SendHighPriorityEvent(EVENT_START_SCAN, 0, timeInterval_);
381 }
382 }
383
IsConnecting()384 bool LocatorRequiredDataManager::IsConnecting()
385 {
386 std::unique_lock<std::mutex> lock(mutex_);
387 if (callbacksMap_.size() > 0) {
388 return true;
389 }
390 return false;
391 }
392
GetCurrentWifiBssidForLocating(std::string & bssid)393 LocationErrCode LocatorRequiredDataManager::GetCurrentWifiBssidForLocating(std::string& bssid)
394 {
395 #ifdef WIFI_ENABLE
396 auto wifiDeviceSharedPtr = Wifi::WifiDevice::GetInstance(WIFI_DEVICE_ABILITY_ID);
397 Wifi::WifiDevice* wifiDevicePtr = wifiDeviceSharedPtr.get();
398 if (wifiDevicePtr == nullptr) {
399 LBSLOGE(LOCATOR, "Enter WifiEnhanceNewUtils:: wifiDevicePtr is null");
400 return ERRCODE_SERVICE_UNAVAILABLE;
401 }
402 OHOS::Wifi::WifiLinkedInfo linkedInfo;
403 ErrCode ret = wifiDevicePtr->GetLinkedInfo(linkedInfo);
404 if (ret == Wifi::WIFI_OPT_STA_NOT_OPENED) {
405 LBSLOGE(LOCATOR, "Enter WifiEnhanceNewUtils::GetLinkedInfo fail: %{public}d", ret);
406 return ERRCODE_WIFI_IS_NOT_CONNECTED;
407 }
408 if (ret != Wifi::WIFI_OPT_SUCCESS) {
409 LBSLOGE(LOCATOR, "Enter WifiEnhanceNewUtils::GetLinkedInfo fail: %{public}d", ret);
410 return ERRCODE_SERVICE_UNAVAILABLE;
411 }
412 if (linkedInfo.bssid.size() == 0) {
413 LBSLOGE(LOCATOR, "linkedInfo.bssid.size() is 0");
414 return ERRCODE_WIFI_IS_NOT_CONNECTED;
415 }
416 bssid = linkedInfo.bssid;
417 return ERRCODE_SUCCESS;
418 #else
419 return ERRCODE_NOT_SUPPORTED;
420 #endif
421 }
422
ScanHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner)423 ScanHandler::ScanHandler(const std::shared_ptr<AppExecFwk::EventRunner>& runner) : EventHandler(runner) {}
424
~ScanHandler()425 ScanHandler::~ScanHandler() {}
426
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)427 void ScanHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer& event)
428 {
429 auto dataManager = LocatorRequiredDataManager::GetInstance();
430 uint32_t eventId = event->GetInnerEventId();
431 int fixNumber = event->GetParam();
432 LBSLOGD(LOCATOR, "ScanHandler ProcessEvent event:%{public}d", eventId);
433 switch (eventId) {
434 case EVENT_START_SCAN: {
435 dataManager->StartWifiScan(fixNumber, true);
436 break;
437 }
438 case EVENT_STOP_SCAN: {
439 dataManager->StartWifiScan(fixNumber, false);
440 break;
441 }
442 default:
443 break;
444 }
445 }
446
WifiSdkHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner)447 WifiSdkHandler::WifiSdkHandler(const std::shared_ptr<AppExecFwk::EventRunner>& runner) : EventHandler(runner) {}
448
~WifiSdkHandler()449 WifiSdkHandler::~WifiSdkHandler() {}
450
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)451 void WifiSdkHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer& event)
452 {
453 auto dataManager = LocatorRequiredDataManager::GetInstance();
454 uint32_t eventId = event->GetInnerEventId();
455 LBSLOGD(LOCATOR, "WifiSdkHandler ProcessEvent event:%{public}d", eventId);
456 switch (eventId) {
457 case EVENT_GET_WIFI_LIST: {
458 if (!dataManager->IsConnecting()) {
459 LBSLOGE(LOCATOR, "%{public}s no valid callback, return", __func__);
460 return;
461 }
462 std::vector<Wifi::WifiScanInfo> wifiScanInfo;
463 dataManager->GetWifiScanList(wifiScanInfo);
464 std::vector<std::shared_ptr<LocatingRequiredData>> result =
465 dataManager->GetLocatingRequiredDataByWifi(wifiScanInfo);
466 dataManager->ReportData(result);
467 break;
468 }
469 case EVENT_REGISTER_WIFI_CALLBACK: {
470 dataManager->RegisterWifiCallBack();
471 break;
472 }
473 case EVENT_UNREGISTER_WIFI_CALLBACK: {
474 dataManager->UnregisterWifiCallBack();
475 break;
476 }
477 default:
478 break;
479 }
480 }
481 } // namespace Location
482 } // namespace OHOS
483