1 /*
2 * Copyright (C) 2022 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 "locator_ability.h"
17
18 #include "accesstoken_kit.h"
19 #include "event_runner.h"
20 #include "privacy_kit.h"
21 #include "privacy_error.h"
22 #include "system_ability_definition.h"
23 #include "uri.h"
24
25 #include "common_event_manager.h"
26 #include "common_hisysevent.h"
27 #include "location_log_event_ids.h"
28 #include "common_utils.h"
29 #include "constant_definition.h"
30 #ifdef FEATURE_GEOCODE_SUPPORT
31 #include "geo_convert_proxy.h"
32 #endif
33 #ifdef FEATURE_GNSS_SUPPORT
34 #include "gnss_ability_proxy.h"
35 #endif
36 #include "hook_utils.h"
37 #include "locator_background_proxy.h"
38 #include "location_config_manager.h"
39 #include "location_data_rdb_helper.h"
40 #include "location_log.h"
41 #include "location_sa_load_manager.h"
42 #include "locationhub_ipc_interface_code.h"
43 #include "locator_required_data_manager.h"
44 #include "location_data_rdb_manager.h"
45 #ifdef FEATURE_NETWORK_SUPPORT
46 #include "network_ability_proxy.h"
47 #endif
48 #ifdef FEATURE_PASSIVE_SUPPORT
49 #include "passive_ability_proxy.h"
50 #endif
51 #include "permission_status_change_cb.h"
52 #include "work_record_statistic.h"
53 #include "permission_manager.h"
54 #ifdef RES_SCHED_SUPPROT
55 #include "res_type.h"
56 #include "res_sched_client.h"
57 #endif
58 #include "app_mgr_interface.h"
59 #include "app_state_data.h"
60 #include "if_system_ability_manager.h"
61 #include "iservice_registry.h"
62 #include "geo_convert_request.h"
63 #include "parameter.h"
64 #include "self_request_manager.h"
65 #ifdef LOCATION_HICOLLIE_ENABLE
66 #include "xcollie/xcollie.h"
67 #include "xcollie/xcollie_define.h"
68 #endif
69
70 namespace OHOS {
71 namespace Location {
72 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
73 LocatorAbility::GetInstance());
74
75 const uint32_t EVENT_UPDATE_SA = 0x0001;
76 const uint32_t EVENT_INIT_REQUEST_MANAGER = 0x0002;
77 const uint32_t EVENT_APPLY_REQUIREMENTS = 0x0003;
78 const uint32_t EVENT_RETRY_REGISTER_ACTION = 0x0004;
79 const uint32_t EVENT_REPORT_LOCATION_MESSAGE = 0x0005;
80 const uint32_t EVENT_SEND_SWITCHSTATE_TO_HIFENCE = 0x0006;
81 const uint32_t EVENT_START_LOCATING = 0x0007;
82 const uint32_t EVENT_STOP_LOCATING = 0x0008;
83 const uint32_t EVENT_UPDATE_LASTLOCATION_REQUESTNUM = 0x0009;
84 const uint32_t EVENT_UNLOAD_SA = 0x0010;
85 const uint32_t EVENT_GET_CACHED_LOCATION_SUCCESS = 0x0014;
86 const uint32_t EVENT_GET_CACHED_LOCATION_FAILED = 0x0015;
87 const uint32_t EVENT_REG_LOCATION_ERROR = 0x0011;
88 const uint32_t EVENT_UNREG_LOCATION_ERROR = 0x0012;
89 const uint32_t EVENT_REPORT_LOCATION_ERROR = 0x0013;
90 const uint32_t EVENT_PERIODIC_CHECK = 0x0016;
91 const uint32_t EVENT_SYNC_LOCATION_STATUS = 0x0017;
92 const uint32_t EVENT_SYNC_STILL_MOVEMENT_STATE = 0x0018;
93 const uint32_t EVENT_SYNC_IDLE_STATE = 0x0019;
94 const uint32_t EVENT_INIT_MSDP_MONITOR_MANAGER = 0x0020;
95 const uint32_t EVENT_IS_STAND_BY = 0x0021;
96 const uint32_t EVENT_SET_LOCATION_WORKING_STATE = 0x0022;
97 const uint32_t EVENT_SEND_GEOREQUEST = 0x0023;
98 const uint32_t EVENT_SET_SWITCH_STATE_TO_DB = 0x0024;
99 const uint32_t EVENT_WATCH_SWITCH_PARAMETER = 0x0025;
100 const uint32_t EVENT_SET_SWITCH_STATE_TO_DB_BY_USERID = 0x0026;
101
102 const uint32_t RETRY_INTERVAL_UNITE = 1000;
103 const uint32_t RETRY_INTERVAL_OF_INIT_REQUEST_MANAGER = 5 * RETRY_INTERVAL_UNITE;
104 const uint32_t RETRY_INTERVAL_OF_UNLOAD_SA = 30 * 60 * RETRY_INTERVAL_UNITE;
105 const float_t PRECISION = 0.000001;
106 const int COMMON_SA_ID = 4353;
107 const int COMMON_SWITCH_STATE_ID = 30;
108 const std::u16string COMMON_DESCRIPTION = u"location.IHifenceAbility";
109 const std::string UNLOAD_TASK = "locatior_sa_unload";
110 const std::string WIFI_SCAN_STATE_CHANGE = "wifiScanStateChange";
111 const uint32_t SET_ENABLE = 3;
112 const uint32_t EVENT_PERIODIC_INTERVAL = 3 * 60 * 1000;
113 const uint32_t REQUEST_DEFAULT_TIMEOUT_SECOUND = 5 * 60;
114 const int LOCATIONHUB_STATE_UNLOAD = 0;
115 const int LOCATIONHUB_STATE_LOAD = 1;
116 const int MAX_SIZE = 100;
117 const int INVALID_REQUESTS_SIZE = 20;
118 const int TIMEOUT_WATCHDOG = 60; // s
119
GetInstance()120 LocatorAbility* LocatorAbility::GetInstance()
121 {
122 static LocatorAbility data;
123 return &data;
124 }
125
LocatorAbility()126 LocatorAbility::LocatorAbility() : SystemAbility(LOCATION_LOCATOR_SA_ID, true)
127 {
128 locatorHandler_ = std::make_shared<LocatorHandler>(AppExecFwk::EventRunner::Create(true,
129 AppExecFwk::ThreadMode::FFRT));
130 switchCallbacks_ = std::make_unique<std::map<pid_t, sptr<ISwitchCallback>>>();
131 requests_ = std::make_shared<std::map<std::string, std::list<std::shared_ptr<Request>>>>();
132 receivers_ = std::make_shared<std::map<sptr<IRemoteObject>, std::list<std::shared_ptr<Request>>>>();
133 proxyMap_ = std::make_shared<std::map<std::string, sptr<IRemoteObject>>>();
134 loadedSaMap_ = std::make_shared<std::map<std::string, sptr<IRemoteObject>>>();
135 permissionMap_ = std::make_shared<std::map<uint32_t, std::shared_ptr<PermissionStatusChangeCb>>>();
136 InitRequestManagerMap();
137 reportManager_ = ReportManager::GetInstance();
138 deviceId_ = CommonUtils::InitDeviceId();
139 #ifdef MOVEMENT_CLIENT_ENABLE
140 if (locatorHandler_ != nullptr) {
141 locatorHandler_->SendHighPriorityEvent(EVENT_INIT_MSDP_MONITOR_MANAGER, 0, 0);
142 }
143 #endif
144 requestManager_ = RequestManager::GetInstance();
145 if (locatorHandler_ != nullptr) {
146 locatorHandler_->SendHighPriorityEvent(EVENT_IS_STAND_BY, 0, 0);
147 }
148 LBSLOGI(LOCATOR, "LocatorAbility constructed.");
149 }
150
~LocatorAbility()151 LocatorAbility::~LocatorAbility() {}
152
OnStart()153 void LocatorAbility::OnStart()
154 {
155 if (state_ == ServiceRunningState::STATE_RUNNING) {
156 LBSLOGI(LOCATOR, "LocatorAbility has already started.");
157 return;
158 }
159 if (!Init()) {
160 LBSLOGE(LOCATOR, "failed to init LocatorAbility");
161 OnStop();
162 return;
163 }
164 state_ = ServiceRunningState::STATE_RUNNING;
165 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
166 if (locatorHandler_ != nullptr) {
167 locatorHandler_->SendHighPriorityEvent(EVENT_SET_LOCATION_WORKING_STATE, 0, 0);
168 locatorHandler_->SendHighPriorityEvent(EVENT_SYNC_LOCATION_STATUS, 0, 0);
169 locatorHandler_->SendHighPriorityEvent(EVENT_WATCH_SWITCH_PARAMETER, 0, 0);
170 }
171 LBSLOGI(LOCATOR, "LocatorAbility::OnStart start ability success.");
172 }
173
OnStop()174 void LocatorAbility::OnStop()
175 {
176 state_ = ServiceRunningState::STATE_NOT_START;
177 registerToAbility_ = false;
178 if (!LocationDataRdbManager::SetLocationWorkingState(0)) {
179 LBSLOGD(LOCATOR, "LocatorAbility::reset LocationWorkingState failed.");
180 }
181 SetLocationhubStateToSyspara(LOCATIONHUB_STATE_UNLOAD);
182 LocatorRequiredDataManager::GetInstance()->UnregisterWifiCallBack();
183 LBSLOGI(LOCATOR, "LocatorAbility::OnStop ability stopped.");
184 }
185
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)186 void LocatorAbility::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
187 {
188 if (systemAbilityId == COMMON_EVENT_SERVICE_ID) {
189 RegisterAction();
190 RegisterLocationPrivacyAction();
191 }
192 }
193
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)194 void LocatorAbility::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
195 {
196 if (systemAbilityId != COMMON_EVENT_SERVICE_ID) {
197 LBSLOGE(LOCATOR, "systemAbilityId is not COMMON_EVENT_SERVICE_ID");
198 return;
199 }
200
201 if (locationPrivacyEventSubscriber_ != nullptr) {
202 bool ret = OHOS::EventFwk::CommonEventManager::UnSubscribeCommonEvent(locationPrivacyEventSubscriber_);
203 locationPrivacyEventSubscriber_ = nullptr;
204 isLocationPrivacyActionRegistered_ = false;
205 LBSLOGI(LOCATOR, "UnSubscribeCommonEvent locationPrivacyEventSubscriber_ result = %{public}d", ret);
206 return;
207 }
208
209 if (locatorEventSubscriber_ == nullptr) {
210 LBSLOGE(LOCATOR, "OnRemoveSystemAbility subscribeer is nullptr");
211 return;
212 }
213 bool result = OHOS::EventFwk::CommonEventManager::UnSubscribeCommonEvent(locatorEventSubscriber_);
214 isActionRegistered = false;
215 LBSLOGI(LOCATOR, "UnSubscribeCommonEvent locatorEventSubscriber_ result = %{public}d", result);
216 }
217
Init()218 bool LocatorAbility::Init()
219 {
220 if (registerToAbility_) {
221 return true;
222 }
223 LBSLOGI(LOCATOR, "LocatorAbility Init.");
224 bool ret = Publish(AsObject());
225 if (!ret) {
226 LBSLOGE(LOCATOR, "Init add system ability failed!");
227 return false;
228 }
229 UpdateSaAbility();
230 if (locatorHandler_ != nullptr) {
231 locatorHandler_->SendHighPriorityEvent(EVENT_INIT_REQUEST_MANAGER, 0, RETRY_INTERVAL_OF_INIT_REQUEST_MANAGER);
232 locatorHandler_->SendHighPriorityEvent(EVENT_PERIODIC_CHECK, 0, EVENT_PERIODIC_INTERVAL);
233 }
234 SetLocationhubStateToSyspara(LOCATIONHUB_STATE_LOAD);
235 registerToAbility_ = true;
236 return registerToAbility_;
237 }
238
InitRequestManagerMap()239 void LocatorAbility::InitRequestManagerMap()
240 {
241 std::unique_lock<ffrt::mutex> lock(requestsMutex_);
242 if (requests_ != nullptr) {
243 #ifdef FEATURE_GNSS_SUPPORT
244 std::list<std::shared_ptr<Request>> gnssList;
245 requests_->insert(make_pair(GNSS_ABILITY, gnssList));
246 #endif
247 #ifdef FEATURE_NETWORK_SUPPORT
248 std::list<std::shared_ptr<Request>> networkList;
249 requests_->insert(make_pair(NETWORK_ABILITY, networkList));
250 #endif
251 #ifdef FEATURE_PASSIVE_SUPPORT
252 std::list<std::shared_ptr<Request>> passiveList;
253 requests_->insert(make_pair(PASSIVE_ABILITY, passiveList));
254 #endif
255 }
256 }
257
GetRequests()258 std::shared_ptr<std::map<std::string, std::list<std::shared_ptr<Request>>>> LocatorAbility::GetRequests()
259 {
260 std::unique_lock<ffrt::mutex> lock(requestsMutex_);
261 return requests_;
262 }
263
GetActiveRequestNum()264 int LocatorAbility::GetActiveRequestNum()
265 {
266 std::unique_lock<ffrt::mutex> lock(requestsMutex_);
267 int num = 0;
268 #ifdef FEATURE_GNSS_SUPPORT
269 auto gpsListIter = requests_->find(GNSS_ABILITY);
270 if (gpsListIter != requests_->end()) {
271 auto list = &(gpsListIter->second);
272 num += static_cast<int>(list->size());
273 }
274 #endif
275 #ifdef FEATURE_NETWORK_SUPPORT
276 auto networkListIter = requests_->find(NETWORK_ABILITY);
277 if (networkListIter != requests_->end()) {
278 auto list = &(networkListIter->second);
279 num += static_cast<int>(list->size());
280 }
281 #endif
282 return num;
283 }
284
GetReceivers()285 std::shared_ptr<std::map<sptr<IRemoteObject>, std::list<std::shared_ptr<Request>>>> LocatorAbility::GetReceivers()
286 {
287 std::unique_lock<ffrt::mutex> lock(receiversMutex_);
288 return receivers_;
289 }
290
GetProxyMap()291 std::shared_ptr<std::map<std::string, sptr<IRemoteObject>>> LocatorAbility::GetProxyMap()
292 {
293 std::unique_lock<std::mutex> lock(proxyMapMutex_);
294 return proxyMap_;
295 }
296
ApplyRequests(int delay)297 void LocatorAbility::ApplyRequests(int delay)
298 {
299 if (locatorHandler_ != nullptr) {
300 locatorHandler_->SendHighPriorityEvent(EVENT_APPLY_REQUIREMENTS, 0, delay * RETRY_INTERVAL_UNITE);
301 }
302 }
303
InitSaAbility()304 void LocatorAbility::InitSaAbility()
305 {
306 LBSLOGI(LOCATOR, "initSaAbility start");
307 if (proxyMap_ == nullptr) {
308 return;
309 }
310 UpdateSaAbilityHandler();
311 }
312
CheckSaValid()313 bool LocatorAbility::CheckSaValid()
314 {
315 std::unique_lock<std::mutex> lock(proxyMapMutex_);
316 #ifdef FEATURE_GNSS_SUPPORT
317 auto objectGnss = proxyMap_->find(GNSS_ABILITY);
318 if (objectGnss == proxyMap_->end()) {
319 LBSLOGI(LOCATOR, "gnss sa is null");
320 return false;
321 }
322 #endif
323 #ifdef FEATURE_NETWORK_SUPPORT
324 auto objectNetwork = proxyMap_->find(NETWORK_ABILITY);
325 if (objectNetwork == proxyMap_->end()) {
326 LBSLOGI(LOCATOR, "network sa is null");
327 return false;
328 }
329 #endif
330 #ifdef FEATURE_PASSIVE_SUPPORT
331 auto objectPassive = proxyMap_->find(PASSIVE_ABILITY);
332 if (objectPassive == proxyMap_->end()) {
333 LBSLOGI(LOCATOR, "passive sa is null");
334 return false;
335 }
336 #endif
337 return true;
338 }
339
SetLocationhubStateToSyspara(int value)340 bool LocatorAbility::SetLocationhubStateToSyspara(int value)
341 {
342 char valueArray[MAX_SIZE] = {0};
343 (void)sprintf_s(valueArray, sizeof(valueArray), "%d", value);
344 int res = SetParameter(LOCATION_LOCATIONHUB_STATE, valueArray);
345 if (res != 0) {
346 LBSLOGE(LOCATOR, "%{public}s failed, res: %{public}d", __func__, res);
347 return false;
348 }
349 return true;
350 }
351
UpdateSaAbility()352 LocationErrCode LocatorAbility::UpdateSaAbility()
353 {
354 auto event = AppExecFwk::InnerEvent::Get(EVENT_UPDATE_SA, 0);
355 if (locatorHandler_ != nullptr) {
356 locatorHandler_->SendHighPriorityEvent(event);
357 }
358 return ERRCODE_SUCCESS;
359 }
360
UpdateSaAbilityHandler()361 void LocatorAbility::UpdateSaAbilityHandler()
362 {
363 int state = LocationDataRdbManager::QuerySwitchState();
364 LBSLOGI(LOCATOR, "update location subability enable state, switch state=%{public}d, action registered=%{public}d",
365 state, isActionRegistered);
366 if (state == DEFAULT_SWITCH_STATE) {
367 return;
368 }
369 bool isEnabled = (state == ENABLED);
370 auto locatorBackgroundProxy = LocatorBackgroundProxy::GetInstance();
371 if (locatorBackgroundProxy == nullptr) {
372 LBSLOGE(LOCATOR, "UpdateSaAbilityHandler: LocatorBackgroundProxy is nullptr");
373 return;
374 }
375 locatorBackgroundProxy->OnSaStateChange(isEnabled);
376 UpdateLoadedSaMap();
377 std::unique_lock<ffrt::mutex> lock(loadedSaMapMutex_);
378 for (auto iter = loadedSaMap_->begin(); iter != loadedSaMap_->end(); iter++) {
379 sptr<IRemoteObject> remoteObject = iter->second;
380 MessageParcel data;
381 if (iter->first == GNSS_ABILITY) {
382 #ifdef FEATURE_GNSS_SUPPORT
383 data.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
384 #endif
385 } else if (iter->first == NETWORK_ABILITY) {
386 #ifdef FEATURE_NETWORK_SUPPORT
387 data.WriteInterfaceToken(NetworkAbilityProxy::GetDescriptor());
388 #endif
389 } else if (iter->first == PASSIVE_ABILITY) {
390 #ifdef FEATURE_PASSIVE_SUPPORT
391 data.WriteInterfaceToken(PassiveAbilityProxy::GetDescriptor());
392 #endif
393 }
394 data.WriteBool(isEnabled);
395
396 MessageParcel reply;
397 MessageOption option;
398 int error = remoteObject->SendRequest(SET_ENABLE, data, reply, option);
399 if (error != ERR_OK) {
400 LBSLOGI(LOCATOR, "enable %{public}s ability, remote result %{public}d", (iter->first).c_str(), error);
401 }
402 }
403 SendSwitchState(isEnabled ? 1 : 0);
404 }
405
CancelIdleState()406 bool LocatorAbility::CancelIdleState()
407 {
408 bool ret = CancelIdle();
409 if (!ret) {
410 LBSLOGE(LOCATOR, "%{public}s cancel idle failed!", __func__);
411 return false;
412 }
413 return true;
414 }
415
RemoveUnloadTask(uint32_t code)416 void LocatorAbility::RemoveUnloadTask(uint32_t code)
417 {
418 if (locatorHandler_ == nullptr) {
419 LBSLOGE(LOCATOR, "%{public}s locatorHandler is nullptr", __func__);
420 return;
421 }
422 if (code == static_cast<uint16_t>(LocatorInterfaceCode::PROXY_PID_FOR_FREEZE) ||
423 code == static_cast<uint16_t>(LocatorInterfaceCode::RESET_ALL_PROXY)) {
424 return;
425 }
426 locatorHandler_->RemoveTask(UNLOAD_TASK);
427 }
428
PostUnloadTask(uint32_t code)429 void LocatorAbility::PostUnloadTask(uint32_t code)
430 {
431 if (code == static_cast<uint16_t>(LocatorInterfaceCode::PROXY_PID_FOR_FREEZE) ||
432 code == static_cast<uint16_t>(LocatorInterfaceCode::RESET_ALL_PROXY)) {
433 return;
434 }
435 if (CheckIfLocatorConnecting()) {
436 return;
437 }
438 auto task = [this]() {
439 SaLoadWithStatistic::UnInitLocationSa(LOCATION_LOCATOR_SA_ID);
440 };
441 if (locatorHandler_ != nullptr) {
442 locatorHandler_->PostTask(task, UNLOAD_TASK, RETRY_INTERVAL_OF_UNLOAD_SA);
443 }
444 }
445
SendSwitchState(const int state)446 void LocatorAbility::SendSwitchState(const int state)
447 {
448 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
449 Get(EVENT_SEND_SWITCHSTATE_TO_HIFENCE, state);
450 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
451 LBSLOGD(LOCATOR, "%{public}s: EVENT_SEND_SWITCHSTATE_TO_HIFENCE Send Success", __func__);
452 }
453 }
454
CheckIfLocatorConnecting()455 bool LocatorAbility::CheckIfLocatorConnecting()
456 {
457 return LocatorRequiredDataManager::GetInstance()->IsConnecting() || GetActiveRequestNum() > 0;
458 }
459
EnableAbility(bool isEnabled)460 LocationErrCode LocatorAbility::EnableAbility(bool isEnabled)
461 {
462 LBSLOGI(LOCATOR, "EnableAbility %{public}d", isEnabled);
463 int modeValue = isEnabled ? ENABLED : DISABLED;
464 int currentSwitchState = LocationDataRdbManager::QuerySwitchState();
465 if (modeValue == currentSwitchState) {
466 LBSLOGD(LOCATOR, "no need to set location ability, enable:%{public}d", modeValue);
467 return ERRCODE_SUCCESS;
468 }
469 // update param
470 LocationDataRdbManager::SetSwitchStateToSysparaForCurrentUser(isEnabled ? ENABLED : DISABLED);
471 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
472 Get(EVENT_SET_SWITCH_STATE_TO_DB, modeValue);
473 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
474 LBSLOGD(LOCATOR, "%{public}s: EVENT_SET_SWITCH_STATE_TO_DB Send Success", __func__);
475 }
476 return ERRCODE_SUCCESS;
477 }
478
EnableAbilityForUser(bool isEnabled,int32_t userId)479 LocationErrCode LocatorAbility::EnableAbilityForUser(bool isEnabled, int32_t userId)
480 {
481 LBSLOGI(LOCATOR, "EnableAbilityForUser %{public}d, UserId %{public}d", isEnabled, userId);
482 // update param
483 int modeValue = isEnabled ? ENABLED : DISABLED;
484 std::unique_ptr<LocatorSwitchMessage> locatorSwitchMessage = std::make_unique<LocatorSwitchMessage>();
485 locatorSwitchMessage->SetModeValue(modeValue);
486 locatorSwitchMessage->SetUserId(userId);
487 LocationDataRdbManager::SetSwitchStateToSysparaForUser(isEnabled ? ENABLED : DISABLED, userId);
488 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
489 Get(EVENT_SET_SWITCH_STATE_TO_DB_BY_USERID, locatorSwitchMessage);
490 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
491 LBSLOGD(LOCATOR, "%{public}s: EVENT_SET_SWITCH_STATE_TO_DB_BY_USERID Send Success", __func__);
492 }
493 return ERRCODE_SUCCESS;
494 }
495
GetSwitchState(int & state)496 LocationErrCode LocatorAbility::GetSwitchState(int& state)
497 {
498 state = LocationDataRdbManager::QuerySwitchState();
499 return ERRCODE_SUCCESS;
500 }
501
IsLocationPrivacyConfirmed(const int type,bool & isConfirmed)502 LocationErrCode LocatorAbility::IsLocationPrivacyConfirmed(const int type, bool& isConfirmed)
503 {
504 return LocationConfigManager::GetInstance()->GetPrivacyTypeState(type, isConfirmed);
505 }
506
SetLocationPrivacyConfirmStatus(const int type,bool isConfirmed)507 LocationErrCode LocatorAbility::SetLocationPrivacyConfirmStatus(const int type, bool isConfirmed)
508 {
509 return LocationConfigManager::GetInstance()->SetPrivacyTypeState(type, isConfirmed);
510 }
511
RegisterSwitchCallback(const sptr<IRemoteObject> & callback,pid_t uid)512 LocationErrCode LocatorAbility::RegisterSwitchCallback(const sptr<IRemoteObject>& callback, pid_t uid)
513 {
514 if (callback == nullptr) {
515 LBSLOGE(LOCATOR, "register an invalid switch callback");
516 return ERRCODE_INVALID_PARAM;
517 }
518 sptr<IRemoteObject::DeathRecipient> death(new (std::nothrow) SwitchCallbackDeathRecipient());
519 callback->AddDeathRecipient(death);
520 sptr<ISwitchCallback> switchCallback = iface_cast<ISwitchCallback>(callback);
521 if (switchCallback == nullptr) {
522 LBSLOGE(LOCATOR, "cast switch callback fail!");
523 return ERRCODE_INVALID_PARAM;
524 }
525 std::unique_lock<std::mutex> lock(switchMutex_);
526 switchCallbacks_->erase(uid);
527 switchCallbacks_->insert(std::make_pair(uid, switchCallback));
528 LBSLOGD(LOCATOR, "after uid:%{public}d register, switch callback size:%{public}s",
529 uid, std::to_string(switchCallbacks_->size()).c_str());
530 return ERRCODE_SUCCESS;
531 }
532
UnregisterSwitchCallback(const sptr<IRemoteObject> & callback)533 LocationErrCode LocatorAbility::UnregisterSwitchCallback(const sptr<IRemoteObject>& callback)
534 {
535 if (callback == nullptr) {
536 LBSLOGE(LOCATOR, "unregister an invalid switch callback");
537 return ERRCODE_INVALID_PARAM;
538 }
539 sptr<ISwitchCallback> switchCallback = iface_cast<ISwitchCallback>(callback);
540 if (switchCallback == nullptr) {
541 LBSLOGE(LOCATOR, "cast switch callback fail!");
542 return ERRCODE_INVALID_PARAM;
543 }
544
545 std::unique_lock<std::mutex> lock(switchMutex_);
546 pid_t uid = -1;
547 for (auto iter = switchCallbacks_->begin(); iter != switchCallbacks_->end(); iter++) {
548 sptr<IRemoteObject> remoteObject = (iter->second)->AsObject();
549 if (remoteObject == callback) {
550 uid = iter->first;
551 break;
552 }
553 }
554 switchCallbacks_->erase(uid);
555 LBSLOGD(LOCATOR, "after uid:%{public}d unregister, switch callback size:%{public}s",
556 uid, std::to_string(switchCallbacks_->size()).c_str());
557 return ERRCODE_SUCCESS;
558 }
559
560 #ifdef FEATURE_GNSS_SUPPORT
SendGnssRequest(int type,MessageParcel & data,MessageParcel & reply)561 LocationErrCode LocatorAbility::SendGnssRequest(int type, MessageParcel &data, MessageParcel &reply)
562 {
563 if (!SaLoadWithStatistic::InitLocationSa(LOCATION_GNSS_SA_ID)) {
564 return ERRCODE_SERVICE_UNAVAILABLE;
565 }
566 sptr<IRemoteObject> objectGnss =
567 CommonUtils::GetRemoteObject(LOCATION_GNSS_SA_ID, CommonUtils::InitDeviceId());
568 if (objectGnss == nullptr) {
569 return ERRCODE_SERVICE_UNAVAILABLE;
570 }
571 MessageOption option;
572 objectGnss->SendRequest(type, data, reply, option);
573 return LocationErrCode(reply.ReadInt32());
574 }
575 #endif
576
577 #ifdef FEATURE_GNSS_SUPPORT
RegisterGnssStatusCallback(const sptr<IRemoteObject> & callback,AppIdentity & identity)578 LocationErrCode LocatorAbility::RegisterGnssStatusCallback(const sptr<IRemoteObject>& callback,
579 AppIdentity &identity)
580 {
581 LBSLOGD(LOCATOR, "uid is: %{public}d", identity.GetUid());
582 MessageParcel dataToStub;
583 MessageParcel replyToStub;
584 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
585 return ERRCODE_SERVICE_UNAVAILABLE;
586 }
587 identity.Marshalling(dataToStub);
588 dataToStub.WriteRemoteObject(callback);
589 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::REG_GNSS_STATUS), dataToStub, replyToStub);
590 }
591 #endif
592
593 #ifdef FEATURE_GNSS_SUPPORT
UnregisterGnssStatusCallback(const sptr<IRemoteObject> & callback)594 LocationErrCode LocatorAbility::UnregisterGnssStatusCallback(const sptr<IRemoteObject>& callback)
595 {
596 MessageParcel dataToStub;
597 MessageParcel replyToStub;
598 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
599 return ERRCODE_SERVICE_UNAVAILABLE;
600 }
601 dataToStub.WriteRemoteObject(callback);
602 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::UNREG_GNSS_STATUS), dataToStub, replyToStub);
603 }
604 #endif
605
606 #ifdef FEATURE_GNSS_SUPPORT
RegisterNmeaMessageCallback(const sptr<IRemoteObject> & callback,AppIdentity & identity)607 LocationErrCode LocatorAbility::RegisterNmeaMessageCallback(const sptr<IRemoteObject>& callback,
608 AppIdentity &identity)
609 {
610 MessageParcel dataToStub;
611 MessageParcel replyToStub;
612 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
613 return ERRCODE_SERVICE_UNAVAILABLE;
614 }
615 identity.Marshalling(dataToStub);
616 dataToStub.WriteRemoteObject(callback);
617 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::REG_NMEA), dataToStub, replyToStub);
618 }
619 #endif
620
621 #ifdef FEATURE_GNSS_SUPPORT
UnregisterNmeaMessageCallback(const sptr<IRemoteObject> & callback)622 LocationErrCode LocatorAbility::UnregisterNmeaMessageCallback(const sptr<IRemoteObject>& callback)
623 {
624 MessageParcel dataToStub;
625 MessageParcel replyToStub;
626 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
627 return ERRCODE_SERVICE_UNAVAILABLE;
628 }
629 dataToStub.WriteRemoteObject(callback);
630 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::UNREG_NMEA), dataToStub, replyToStub);
631 }
632 #endif
633
634 #ifdef FEATURE_GNSS_SUPPORT
RegisterCachedLocationCallback(std::unique_ptr<CachedGnssLocationsRequest> & request,sptr<ICachedLocationsCallback> & callback,std::string bundleName)635 LocationErrCode LocatorAbility::RegisterCachedLocationCallback(std::unique_ptr<CachedGnssLocationsRequest>& request,
636 sptr<ICachedLocationsCallback>& callback, std::string bundleName)
637 {
638 MessageParcel dataToStub;
639 MessageParcel replyToStub;
640 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
641 return ERRCODE_SERVICE_UNAVAILABLE;
642 }
643 dataToStub.WriteInt32(request->reportingPeriodSec);
644 dataToStub.WriteBool(request->wakeUpCacheQueueFull);
645 dataToStub.WriteRemoteObject(callback->AsObject());
646 dataToStub.WriteString16(Str8ToStr16(bundleName));
647 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::REG_CACHED), dataToStub, replyToStub);
648 }
649 #endif
650
651 #ifdef FEATURE_GNSS_SUPPORT
UnregisterCachedLocationCallback(sptr<ICachedLocationsCallback> & callback)652 LocationErrCode LocatorAbility::UnregisterCachedLocationCallback(sptr<ICachedLocationsCallback>& callback)
653 {
654 MessageParcel dataToStub;
655 MessageParcel replyToStub;
656 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
657 return ERRCODE_SERVICE_UNAVAILABLE;
658 }
659 dataToStub.WriteRemoteObject(callback->AsObject());
660 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::UNREG_CACHED), dataToStub, replyToStub);
661 }
662 #endif
663
664 #ifdef FEATURE_GNSS_SUPPORT
GetCachedGnssLocationsSize(int & size)665 LocationErrCode LocatorAbility::GetCachedGnssLocationsSize(int& size)
666 {
667 MessageParcel dataToStub;
668 MessageParcel replyToStub;
669 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
670 return ERRCODE_SERVICE_UNAVAILABLE;
671 }
672 LocationErrCode errorCode =
673 SendGnssRequest(static_cast<int>(GnssInterfaceCode::GET_CACHED_SIZE), dataToStub, replyToStub);
674 if (errorCode == ERRCODE_SUCCESS) {
675 size = replyToStub.ReadInt32();
676 }
677 return errorCode;
678 }
679 #endif
680
681 #ifdef FEATURE_GNSS_SUPPORT
FlushCachedGnssLocations()682 LocationErrCode LocatorAbility::FlushCachedGnssLocations()
683 {
684 MessageParcel dataToStub;
685 MessageParcel replyToStub;
686 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
687 return ERRCODE_SERVICE_UNAVAILABLE;
688 }
689 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::FLUSH_CACHED), dataToStub, replyToStub);
690 }
691 #endif
692
693 #ifdef FEATURE_GNSS_SUPPORT
SendCommand(std::unique_ptr<LocationCommand> & commands)694 LocationErrCode LocatorAbility::SendCommand(std::unique_ptr<LocationCommand>& commands)
695 {
696 MessageParcel dataToStub;
697 MessageParcel replyToStub;
698 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
699 return ERRCODE_SERVICE_UNAVAILABLE;
700 }
701 dataToStub.WriteInt32(commands->scenario);
702 dataToStub.WriteString16(Str8ToStr16(commands->command));
703 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::SEND_COMMANDS), dataToStub, replyToStub);
704 }
705 #endif
706
707 #ifdef FEATURE_GNSS_SUPPORT
AddFence(std::shared_ptr<GeofenceRequest> & request)708 LocationErrCode LocatorAbility::AddFence(std::shared_ptr<GeofenceRequest>& request)
709 {
710 MessageParcel dataToStub;
711 MessageParcel replyToStub;
712 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
713 return ERRCODE_SERVICE_UNAVAILABLE;
714 }
715 request->Marshalling(dataToStub);
716 return SendGnssRequest(
717 static_cast<int>(GnssInterfaceCode::ADD_FENCE_INFO), dataToStub, replyToStub);
718 }
719 #endif
720
721 #ifdef FEATURE_GNSS_SUPPORT
RemoveFence(std::shared_ptr<GeofenceRequest> & request)722 LocationErrCode LocatorAbility::RemoveFence(std::shared_ptr<GeofenceRequest>& request)
723 {
724 MessageParcel dataToStub;
725 MessageParcel replyToStub;
726 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
727 return ERRCODE_SERVICE_UNAVAILABLE;
728 }
729 request->Marshalling(dataToStub);
730 return SendGnssRequest(
731 static_cast<int>(GnssInterfaceCode::REMOVE_FENCE_INFO), dataToStub, replyToStub);
732 }
733 #endif
734
735 #ifdef FEATURE_GNSS_SUPPORT
AddGnssGeofence(std::shared_ptr<GeofenceRequest> & request)736 LocationErrCode LocatorAbility::AddGnssGeofence(std::shared_ptr<GeofenceRequest>& request)
737 {
738 MessageParcel dataToStub;
739 MessageParcel replyToStub;
740 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
741 return ERRCODE_SERVICE_UNAVAILABLE;
742 }
743 request->Marshalling(dataToStub);
744 return SendGnssRequest(
745 static_cast<int>(GnssInterfaceCode::ADD_GNSS_GEOFENCE), dataToStub, replyToStub);
746 }
747 #endif
748
749 #ifdef FEATURE_GNSS_SUPPORT
RemoveGnssGeofence(std::shared_ptr<GeofenceRequest> & request)750 LocationErrCode LocatorAbility::RemoveGnssGeofence(std::shared_ptr<GeofenceRequest>& request)
751 {
752 MessageParcel dataToStub;
753 MessageParcel replyToStub;
754 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
755 return ERRCODE_SERVICE_UNAVAILABLE;
756 }
757 dataToStub.WriteInt32(request->GetFenceId());
758 dataToStub.WriteString(request->GetBundleName());
759 return SendGnssRequest(
760 static_cast<int>(GnssInterfaceCode::REMOVE_GNSS_GEOFENCE), dataToStub, replyToStub);
761 }
762 #endif
763
764 #ifdef FEATURE_GNSS_SUPPORT
SendLocationMockMsgToGnssSa(const sptr<IRemoteObject> obj,const int timeInterval,const std::vector<std::shared_ptr<Location>> & location,int msgId)765 LocationErrCode LocatorAbility::SendLocationMockMsgToGnssSa(const sptr<IRemoteObject> obj,
766 const int timeInterval, const std::vector<std::shared_ptr<Location>> &location, int msgId)
767 {
768 if (obj == nullptr) {
769 LBSLOGE(LOCATOR, "SendLocationMockMsgToGnssSa obj is nullptr");
770 return ERRCODE_SERVICE_UNAVAILABLE;
771 }
772 std::unique_ptr<GnssAbilityProxy> gnssProxy = std::make_unique<GnssAbilityProxy>(obj);
773 LocationErrCode errorCode = ERRCODE_NOT_SUPPORTED;
774 if (msgId == static_cast<int>(LocatorInterfaceCode::ENABLE_LOCATION_MOCK)) {
775 errorCode = gnssProxy->EnableMock();
776 } else if (msgId == static_cast<int>(LocatorInterfaceCode::DISABLE_LOCATION_MOCK)) {
777 errorCode = gnssProxy->DisableMock();
778 } else if (msgId == static_cast<int>(LocatorInterfaceCode::SET_MOCKED_LOCATIONS)) {
779 errorCode = gnssProxy->SetMocked(timeInterval, location);
780 }
781 return errorCode;
782 }
783 #endif
784
785 #ifdef FEATURE_NETWORK_SUPPORT
SendLocationMockMsgToNetworkSa(const sptr<IRemoteObject> obj,const int timeInterval,const std::vector<std::shared_ptr<Location>> & location,int msgId)786 LocationErrCode LocatorAbility::SendLocationMockMsgToNetworkSa(const sptr<IRemoteObject> obj,
787 const int timeInterval, const std::vector<std::shared_ptr<Location>> &location, int msgId)
788 {
789 if (obj == nullptr) {
790 LBSLOGE(LOCATOR, "SendLocationMockMsgToNetworkSa obj is nullptr");
791 return ERRCODE_SERVICE_UNAVAILABLE;
792 }
793 std::unique_ptr<NetworkAbilityProxy> networkProxy =
794 std::make_unique<NetworkAbilityProxy>(obj);
795 LocationErrCode errorCode = ERRCODE_NOT_SUPPORTED;
796 if (msgId == static_cast<int>(LocatorInterfaceCode::ENABLE_LOCATION_MOCK)) {
797 errorCode = networkProxy->EnableMock();
798 } else if (msgId == static_cast<int>(LocatorInterfaceCode::DISABLE_LOCATION_MOCK)) {
799 errorCode = networkProxy->DisableMock();
800 } else if (msgId == static_cast<int>(LocatorInterfaceCode::SET_MOCKED_LOCATIONS)) {
801 errorCode = networkProxy->SetMocked(timeInterval, location);
802 }
803 return errorCode;
804 }
805 #endif
806
807 #ifdef FEATURE_PASSIVE_SUPPORT
SendLocationMockMsgToPassiveSa(const sptr<IRemoteObject> obj,const int timeInterval,const std::vector<std::shared_ptr<Location>> & location,int msgId)808 LocationErrCode LocatorAbility::SendLocationMockMsgToPassiveSa(const sptr<IRemoteObject> obj,
809 const int timeInterval, const std::vector<std::shared_ptr<Location>> &location, int msgId)
810 {
811 if (obj == nullptr) {
812 LBSLOGE(LOCATOR, "SendLocationMockMsgToNetworkSa obj is nullptr");
813 return ERRCODE_SERVICE_UNAVAILABLE;
814 }
815 std::unique_ptr<PassiveAbilityProxy> passiveProxy =
816 std::make_unique<PassiveAbilityProxy>(obj);
817 LocationErrCode errorCode = ERRCODE_NOT_SUPPORTED;
818 if (msgId == static_cast<int>(LocatorInterfaceCode::ENABLE_LOCATION_MOCK)) {
819 errorCode = passiveProxy->EnableMock();
820 } else if (msgId == static_cast<int>(LocatorInterfaceCode::DISABLE_LOCATION_MOCK)) {
821 errorCode = passiveProxy->DisableMock();
822 } else if (msgId == static_cast<int>(LocatorInterfaceCode::SET_MOCKED_LOCATIONS)) {
823 errorCode = passiveProxy->SetMocked(timeInterval, location);
824 }
825 return errorCode;
826 }
827 #endif
828
ProcessLocationMockMsg(const int timeInterval,const std::vector<std::shared_ptr<Location>> & location,int msgId)829 LocationErrCode LocatorAbility::ProcessLocationMockMsg(
830 const int timeInterval, const std::vector<std::shared_ptr<Location>> &location, int msgId)
831 {
832 #if !defined(FEATURE_GNSS_SUPPORT) && !defined(FEATURE_NETWORK_SUPPORT) && !defined(FEATURE_PASSIVE_SUPPORT)
833 LBSLOGE(LOCATOR, "%{public}s: mock service unavailable", __func__);
834 return ERRCODE_NOT_SUPPORTED;
835 #endif
836 if (!CheckSaValid()) {
837 UpdateProxyMap();
838 }
839
840 std::unique_lock<std::mutex> lock(proxyMapMutex_);
841 for (auto iter = proxyMap_->begin(); iter != proxyMap_->end(); iter++) {
842 auto obj = iter->second;
843 if (iter->first == GNSS_ABILITY) {
844 #ifdef FEATURE_GNSS_SUPPORT
845 SendLocationMockMsgToGnssSa(obj, timeInterval, location, msgId);
846 #endif
847 } else if (iter->first == NETWORK_ABILITY) {
848 #ifdef FEATURE_NETWORK_SUPPORT
849 SendLocationMockMsgToNetworkSa(obj, timeInterval, location, msgId);
850 #endif
851 } else if (iter->first == PASSIVE_ABILITY) {
852 #ifdef FEATURE_PASSIVE_SUPPORT
853 SendLocationMockMsgToPassiveSa(obj, timeInterval, location, msgId);
854 #endif
855 }
856 }
857 return ERRCODE_SUCCESS;
858 }
859
UpdateLoadedSaMap()860 void LocatorAbility::UpdateLoadedSaMap()
861 {
862 std::unique_lock<ffrt::mutex> lock(loadedSaMapMutex_);
863 loadedSaMap_->clear();
864 if (LocationSaLoadManager::CheckIfSystemAbilityAvailable(LOCATION_GNSS_SA_ID)) {
865 sptr<IRemoteObject> objectGnss =
866 CommonUtils::GetRemoteObject(LOCATION_GNSS_SA_ID, CommonUtils::InitDeviceId());
867 loadedSaMap_->insert(make_pair(GNSS_ABILITY, objectGnss));
868 }
869 if (LocationSaLoadManager::CheckIfSystemAbilityAvailable(LOCATION_NETWORK_LOCATING_SA_ID)) {
870 sptr<IRemoteObject> objectNetwork =
871 CommonUtils::GetRemoteObject(LOCATION_NETWORK_LOCATING_SA_ID, CommonUtils::InitDeviceId());
872 loadedSaMap_->insert(make_pair(NETWORK_ABILITY, objectNetwork));
873 }
874 if (LocationSaLoadManager::CheckIfSystemAbilityAvailable(LOCATION_NOPOWER_LOCATING_SA_ID)) {
875 sptr<IRemoteObject> objectPassive =
876 CommonUtils::GetRemoteObject(LOCATION_NOPOWER_LOCATING_SA_ID, CommonUtils::InitDeviceId());
877 loadedSaMap_->insert(make_pair(PASSIVE_ABILITY, objectPassive));
878 }
879 }
880
UpdateProxyMap()881 void LocatorAbility::UpdateProxyMap()
882 {
883 std::unique_lock<std::mutex> lock(proxyMapMutex_);
884 #ifdef FEATURE_GNSS_SUPPORT
885 // init gnss ability sa
886 if (!SaLoadWithStatistic::InitLocationSa(LOCATION_GNSS_SA_ID)) {
887 return;
888 }
889 sptr<IRemoteObject> objectGnss = CommonUtils::GetRemoteObject(LOCATION_GNSS_SA_ID, CommonUtils::InitDeviceId());
890 if (objectGnss != nullptr) {
891 proxyMap_->insert(make_pair(GNSS_ABILITY, objectGnss));
892 } else {
893 LBSLOGE(LOCATOR, "GetRemoteObject gnss sa is null");
894 }
895 #endif
896 #ifdef FEATURE_NETWORK_SUPPORT
897 // init network ability sa
898 if (!SaLoadWithStatistic::InitLocationSa(LOCATION_NETWORK_LOCATING_SA_ID)) {
899 return;
900 }
901 sptr<IRemoteObject> objectNetwork = CommonUtils::GetRemoteObject(LOCATION_NETWORK_LOCATING_SA_ID,
902 CommonUtils::InitDeviceId());
903 if (objectNetwork != nullptr) {
904 proxyMap_->insert(make_pair(NETWORK_ABILITY, objectNetwork));
905 } else {
906 LBSLOGE(LOCATOR, "GetRemoteObject network sa is null");
907 }
908 #endif
909 #ifdef FEATURE_PASSIVE_SUPPORT
910 // init passive ability sa
911 if (!SaLoadWithStatistic::InitLocationSa(LOCATION_NOPOWER_LOCATING_SA_ID)) {
912 return;
913 }
914 sptr<IRemoteObject> objectPassive = CommonUtils::GetRemoteObject(LOCATION_NOPOWER_LOCATING_SA_ID,
915 CommonUtils::InitDeviceId());
916 if (objectPassive != nullptr) {
917 proxyMap_->insert(make_pair(PASSIVE_ABILITY, objectPassive));
918 } else {
919 LBSLOGE(LOCATOR, "GetRemoteObject passive sa is null");
920 }
921 #endif
922 }
923
EnableLocationMock()924 LocationErrCode LocatorAbility::EnableLocationMock()
925 {
926 int timeInterval = 0;
927 std::vector<std::shared_ptr<Location>> location;
928 return ProcessLocationMockMsg(timeInterval, location,
929 static_cast<int>(LocatorInterfaceCode::ENABLE_LOCATION_MOCK));
930 }
931
DisableLocationMock()932 LocationErrCode LocatorAbility::DisableLocationMock()
933 {
934 int timeInterval = 0;
935 std::vector<std::shared_ptr<Location>> location;
936 return ProcessLocationMockMsg(timeInterval, location,
937 static_cast<int>(LocatorInterfaceCode::DISABLE_LOCATION_MOCK));
938 }
939
SetMockedLocations(const int timeInterval,const std::vector<std::shared_ptr<Location>> & location)940 LocationErrCode LocatorAbility::SetMockedLocations(
941 const int timeInterval, const std::vector<std::shared_ptr<Location>> &location)
942 {
943 return ProcessLocationMockMsg(timeInterval, location,
944 static_cast<int>(LocatorInterfaceCode::SET_MOCKED_LOCATIONS));
945 }
946
StartLocating(std::unique_ptr<RequestConfig> & requestConfig,sptr<ILocatorCallback> & callback,AppIdentity & identity)947 LocationErrCode LocatorAbility::StartLocating(std::unique_ptr<RequestConfig>& requestConfig,
948 sptr<ILocatorCallback>& callback, AppIdentity &identity)
949 {
950 #if !defined(FEATURE_GNSS_SUPPORT) && !defined(FEATURE_NETWORK_SUPPORT) && !defined(FEATURE_PASSIVE_SUPPORT)
951 LBSLOGE(LOCATOR, "%{public}s: service unavailable", __func__);
952 return ERRCODE_NOT_SUPPORTED;
953 #endif
954 if (LocationDataRdbManager::QuerySwitchState() != ENABLED) {
955 ReportErrorStatus(callback, ERROR_SWITCH_UNOPEN);
956 }
957 // update offset before add request
958 if (reportManager_ == nullptr || requestManager_ == nullptr) {
959 return ERRCODE_SERVICE_UNAVAILABLE;
960 }
961 reportManager_->UpdateRandom();
962 std::shared_ptr<Request> request = std::make_shared<Request>(requestConfig, callback, identity);
963 sptr<IRemoteObject::DeathRecipient> death(new (std::nothrow) LocatorCallbackDeathRecipient(identity.GetTokenId()));
964 callback->AsObject()->AddDeathRecipient(death);
965 request->SetLocatorCallbackRecipient(death);
966 OHOS::Security::AccessToken::PermUsedTypeEnum type =
967 Security::AccessToken::AccessTokenKit::GetUserGrantedPermissionUsedType(request->GetTokenId(),
968 ACCESS_APPROXIMATELY_LOCATION);
969 request->SetPermUsedType(static_cast<int>(type));
970 if (requestConfig->GetScenario() != SCENE_NO_POWER &&
971 requestConfig->GetScenario() != LOCATION_SCENE_NO_POWER_CONSUMPTION &&
972 !reportManager_->IsCacheGnssLocationValid()) {
973 LocatorRequiredDataManager::GetInstance()->SendWifiScanEvent();
974 }
975 #ifdef EMULATOR_ENABLED
976 // for emulator, report cache location is unnecessary
977 HandleStartLocating(request, callback);
978 #else
979 if (NeedReportCacheLocation(request, callback)) {
980 LBSLOGI(LOCATOR, "report cache location to %{public}s", identity.GetBundleName().c_str());
981 SelfRequestManager::GetInstance()->StartSelfRequest();
982 callback->AsObject()->RemoveDeathRecipient(death);
983 } else {
984 HandleStartLocating(request, callback);
985 }
986 #endif
987 return ERRCODE_SUCCESS;
988 }
989
IsCacheVaildScenario(const sptr<RequestConfig> & requestConfig)990 bool LocatorAbility::IsCacheVaildScenario(const sptr<RequestConfig>& requestConfig)
991 {
992 if ((requestConfig->GetPriority() == LOCATION_PRIORITY_LOCATING_SPEED) ||
993 (requestConfig->GetScenario() == SCENE_DAILY_LIFE_SERVICE) ||
994 (requestConfig->GetScenario() == LOCATION_SCENE_DAILY_LIFE_SERVICE) ||
995 (requestConfig->GetScenario() == LOCATION_SCENE_LOW_POWER_CONSUMPTION) ||
996 ((requestConfig->GetScenario() == SCENE_UNSET) && (requestConfig->GetPriority() == PRIORITY_FAST_FIRST_FIX)) ||
997 ((requestConfig->GetScenario() == SCENE_UNSET) && (requestConfig->GetPriority() == PRIORITY_LOW_POWER))) {
998 return true;
999 }
1000 return false;
1001 }
1002
IsSingleRequest(const sptr<RequestConfig> & requestConfig)1003 bool LocatorAbility::IsSingleRequest(const sptr<RequestConfig>& requestConfig)
1004 {
1005 if (requestConfig->GetFixNumber() == 1) {
1006 return true;
1007 }
1008 return false;
1009 }
1010
UpdatePermissionUsedRecord(uint32_t tokenId,std::string permissionName,int permUsedType,int succCnt,int failCnt)1011 int LocatorAbility::UpdatePermissionUsedRecord(uint32_t tokenId, std::string permissionName,
1012 int permUsedType, int succCnt, int failCnt)
1013 {
1014 Security::AccessToken::AddPermParamInfo info;
1015 info.tokenId = tokenId;
1016 info.permissionName = permissionName;
1017 info.successCount = succCnt;
1018 info.failCount = failCnt;
1019 info.type = static_cast<OHOS::Security::AccessToken::PermissionUsedType>(permUsedType);
1020 int ret = Security::AccessToken::PrivacyKit::AddPermissionUsedRecord(info);
1021 return ret;
1022 }
1023
NeedReportCacheLocation(const std::shared_ptr<Request> & request,sptr<ILocatorCallback> & callback)1024 bool LocatorAbility::NeedReportCacheLocation(const std::shared_ptr<Request>& request, sptr<ILocatorCallback>& callback)
1025 {
1026 if (reportManager_ == nullptr || requestManager_ == nullptr || request == nullptr || callback == nullptr ||
1027 !IsCacheVaildScenario(request->GetRequestConfig())) {
1028 return false;
1029 }
1030 uint32_t tokenId = request->GetTokenId();
1031 uint32_t firstTokenId = request->GetFirstTokenId();
1032 if (!PermissionManager::CheckLocationPermission(tokenId, firstTokenId) &&
1033 !PermissionManager::CheckApproximatelyPermission(tokenId, firstTokenId)) {
1034 RequestManager::GetInstance()->ReportLocationError(LOCATING_FAILED_LOCATION_PERMISSION_DENIED, request);
1035 LBSLOGI(LOCATOR, "CheckLocationPermission return false, tokenId=%{public}d", tokenId);
1036 return false;
1037 }
1038 std::string bundleName = request->GetPackageName();
1039 pid_t uid = request->GetUid();
1040 pid_t pid = request->GetPid();
1041 auto reportManager = ReportManager::GetInstance();
1042 if (reportManager != nullptr) {
1043 if (reportManager->IsAppBackground(bundleName, tokenId, request->GetTokenIdEx(), uid, pid) &&
1044 !PermissionManager::CheckBackgroundPermission(tokenId, firstTokenId)) {
1045 RequestManager::GetInstance()->ReportLocationError(LOCATING_FAILED_BACKGROUND_PERMISSION_DENIED, request);
1046 LBSLOGE(REPORT_MANAGER, "CheckBackgroundPermission return false, tokenId=%{public}d", tokenId);
1047 return false;
1048 }
1049 }
1050 // report cache location
1051 auto cacheLocation = reportManager_->GetCacheLocation(request);
1052 if (cacheLocation == nullptr) {
1053 return false;
1054 }
1055 auto workRecordStatistic = WorkRecordStatistic::GetInstance();
1056 if (!workRecordStatistic->Update("CacheLocation", 1)) {
1057 LBSLOGE(LOCATOR, "%{public}s line:%{public}d workRecordStatistic::Update failed", __func__, __LINE__);
1058 }
1059 if (IsSingleRequest(request->GetRequestConfig())) {
1060 return ReportSingleCacheLocation(request, callback, cacheLocation);
1061 } else {
1062 return ReportCacheLocation(request, callback, cacheLocation);
1063 }
1064 }
1065
ReportSingleCacheLocation(const std::shared_ptr<Request> & request,sptr<ILocatorCallback> & callback,std::unique_ptr<Location> & cacheLocation)1066 bool LocatorAbility::ReportSingleCacheLocation(
1067 const std::shared_ptr<Request>& request, sptr<ILocatorCallback>& callback, std::unique_ptr<Location>& cacheLocation)
1068 {
1069 requestManager_->IncreaseWorkingPidsCount(request->GetPid());
1070 if (requestManager_->IsNeedStartUsingPermission(request->GetPid())) {
1071 int ret = PrivacyKit::StartUsingPermission(
1072 request->GetTokenId(), ACCESS_APPROXIMATELY_LOCATION, request->GetPid());
1073 if (ret != ERRCODE_SUCCESS && ret != Security::AccessToken::ERR_PERMISSION_ALREADY_START_USING &&
1074 IsHapCaller(request->GetTokenId())) {
1075 requestManager_->DecreaseWorkingPidsCount(request->GetPid());
1076 LBSLOGE(LOCATOR, "StartUsingPermission failed ret=%{public}d", ret);
1077 return false;
1078 }
1079 }
1080 // add location permission using record
1081 int recordResult = UpdatePermissionUsedRecord(request->GetTokenId(), ACCESS_APPROXIMATELY_LOCATION,
1082 request->GetPermUsedType(), 1, 0);
1083 if (recordResult != ERRCODE_SUCCESS && IsHapCaller(request->GetTokenId())) {
1084 requestManager_->DecreaseWorkingPidsCount(request->GetPid());
1085 LBSLOGE(LOCATOR, "UpdatePermissionUsedRecord failed ret=%{public}d", recordResult);
1086 return false;
1087 }
1088 callback->OnLocationReport(cacheLocation);
1089 requestManager_->DecreaseWorkingPidsCount(request->GetPid());
1090 if (requestManager_->IsNeedStopUsingPermission(request->GetPid())) {
1091 PrivacyKit::StopUsingPermission(request->GetTokenId(), ACCESS_APPROXIMATELY_LOCATION, request->GetPid());
1092 }
1093 if (locatorHandler_ != nullptr &&
1094 locatorHandler_->SendHighPriorityEvent(EVENT_UPDATE_LASTLOCATION_REQUESTNUM, 0, 1)) {
1095 LBSLOGD(LOCATOR, "%{public}s: EVENT_UPDATE_LASTLOCATION_REQUESTNUM Send Success", __func__);
1096 }
1097 return true;
1098 }
1099
ReportCacheLocation(const std::shared_ptr<Request> & request,sptr<ILocatorCallback> & callback,std::unique_ptr<Location> & cacheLocation)1100 bool LocatorAbility::ReportCacheLocation(
1101 const std::shared_ptr<Request>& request, sptr<ILocatorCallback>& callback, std::unique_ptr<Location>& cacheLocation)
1102 {
1103 // add location permission using record
1104 int ret = UpdatePermissionUsedRecord(request->GetTokenId(), ACCESS_APPROXIMATELY_LOCATION,
1105 request->GetPermUsedType(), 1, 0);
1106 if (ret != ERRCODE_SUCCESS && IsHapCaller(request->GetTokenId())) {
1107 LBSLOGE(LOCATOR, "UpdatePermissionUsedRecord failed ret=%{public}d", ret);
1108 return false;
1109 }
1110 callback->OnLocationReport(cacheLocation);
1111 return false;
1112 }
1113
HandleStartLocating(const std::shared_ptr<Request> & request,sptr<ILocatorCallback> & callback)1114 void LocatorAbility::HandleStartLocating(const std::shared_ptr<Request>& request, sptr<ILocatorCallback>& callback)
1115 {
1116 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1117 Get(EVENT_START_LOCATING, request);
1118 if (locatorHandler_ != nullptr) {
1119 locatorHandler_->SendEvent(event);
1120 }
1121 if (callback != nullptr) {
1122 ReportLocationStatus(callback, SESSION_START);
1123 }
1124 }
1125
StopLocating(sptr<ILocatorCallback> & callback)1126 LocationErrCode LocatorAbility::StopLocating(sptr<ILocatorCallback>& callback)
1127 {
1128 #if !defined(FEATURE_GNSS_SUPPORT) && !defined(FEATURE_NETWORK_SUPPORT) && !defined(FEATURE_PASSIVE_SUPPORT)
1129 LBSLOGE(LOCATOR, "%{public}s: service unavailable", __func__);
1130 return ERRCODE_NOT_SUPPORTED;
1131 #endif
1132 if (requestManager_ == nullptr) {
1133 return ERRCODE_SERVICE_UNAVAILABLE;
1134 }
1135 std::unique_ptr<LocatorCallbackMessage> callbackMessage = std::make_unique<LocatorCallbackMessage>();
1136 callbackMessage->SetCallback(callback);
1137 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1138 Get(EVENT_STOP_LOCATING, callbackMessage);
1139 if (locatorHandler_ != nullptr) {
1140 locatorHandler_->SendEvent(event);
1141 }
1142 if (callback != nullptr) {
1143 ReportLocationStatus(callback, SESSION_STOP);
1144 }
1145 return ERRCODE_SUCCESS;
1146 }
1147
GetCacheLocation(std::unique_ptr<Location> & loc,AppIdentity & identity)1148 LocationErrCode LocatorAbility::GetCacheLocation(std::unique_ptr<Location>& loc, AppIdentity &identity)
1149 {
1150 if (locatorHandler_ == nullptr) {
1151 return ERRCODE_SERVICE_UNAVAILABLE;
1152 }
1153 auto lastLocation = reportManager_->GetLastLocation();
1154 if (locatorHandler_ != nullptr &&
1155 locatorHandler_->SendHighPriorityEvent(EVENT_UPDATE_LASTLOCATION_REQUESTNUM, 0, 1)) {
1156 LBSLOGD(LOCATOR, "%{public}s: EVENT_UPDATE_LASTLOCATION_REQUESTNUM Send Success", __func__);
1157 }
1158 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
1159 sptr<ILocatorCallback> callback;
1160 std::shared_ptr<Request> request = std::make_shared<Request>(requestConfig, callback, identity);
1161 loc = reportManager_->GetPermittedLocation(request, lastLocation);
1162 std::shared_ptr<AppIdentity> identityInfo = std::make_shared<AppIdentity>(identity);
1163 if (loc == nullptr) {
1164 locatorHandler_->SendHighPriorityEvent(EVENT_GET_CACHED_LOCATION_FAILED, identityInfo, 0);
1165 return ERRCODE_LOCATING_FAIL;
1166 }
1167 reportManager_->UpdateLocationByRequest(identity.GetTokenId(), identity.GetTokenIdEx(), loc);
1168 requestManager_->IncreaseWorkingPidsCount(identity.GetPid());
1169 if (requestManager_->IsNeedStartUsingPermission(identity.GetPid())) {
1170 int ret = PrivacyKit::StartUsingPermission(
1171 identity.GetTokenId(), ACCESS_APPROXIMATELY_LOCATION, identity.GetPid());
1172 if (ret != ERRCODE_SUCCESS && ret != Security::AccessToken::ERR_PERMISSION_ALREADY_START_USING &&
1173 IsHapCaller(request->GetTokenId())) {
1174 LBSLOGE(LOCATOR, "StartUsingPermission failed ret=%{public}d", ret);
1175 locatorHandler_->SendHighPriorityEvent(EVENT_GET_CACHED_LOCATION_FAILED, identityInfo, 0);
1176 return ERRCODE_LOCATING_FAIL;
1177 }
1178 }
1179 if (fabs(loc->GetLatitude() - 0.0) > PRECISION
1180 && fabs(loc->GetLongitude() - 0.0) > PRECISION) {
1181 // add location permission using record
1182 locatorHandler_->SendHighPriorityEvent(EVENT_GET_CACHED_LOCATION_SUCCESS, identityInfo, 0);
1183 return ERRCODE_SUCCESS;
1184 }
1185 locatorHandler_->SendHighPriorityEvent(EVENT_GET_CACHED_LOCATION_FAILED, identityInfo, 0);
1186 return ERRCODE_LOCATING_FAIL;
1187 }
1188
ReportLocation(const std::unique_ptr<Location> & location,std::string abilityName,AppIdentity & identity)1189 LocationErrCode LocatorAbility::ReportLocation(
1190 const std::unique_ptr<Location>& location, std::string abilityName, AppIdentity &identity)
1191 {
1192 if (requests_ == nullptr) {
1193 return ERRCODE_SERVICE_UNAVAILABLE;
1194 }
1195 std::unique_ptr<LocationMessage> locationMessage = std::make_unique<LocationMessage>();
1196 locationMessage->SetAbilityName(abilityName);
1197 locationMessage->SetLocation(location);
1198 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1199 Get(EVENT_REPORT_LOCATION_MESSAGE, locationMessage);
1200 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
1201 return ERRCODE_SUCCESS;
1202 }
1203 return ERRCODE_SERVICE_UNAVAILABLE;
1204 }
1205
ReportLocationStatus(sptr<ILocatorCallback> & callback,int result)1206 LocationErrCode LocatorAbility::ReportLocationStatus(sptr<ILocatorCallback>& callback, int result)
1207 {
1208 int state = DISABLED;
1209 LocationErrCode errorCode = GetSwitchState(state);
1210 if (errorCode != ERRCODE_SUCCESS) {
1211 return errorCode;
1212 }
1213 if (state == DISABLED) {
1214 LBSLOGE(LOCATOR, "%{public}s line:%{public}d location switch is off",
1215 __func__, __LINE__);
1216 return ERRCODE_SWITCH_OFF;
1217 }
1218 if (reportManager_->ReportRemoteCallback(callback, ILocatorCallback::RECEIVE_LOCATION_STATUS_EVENT, result)) {
1219 return ERRCODE_SUCCESS;
1220 }
1221 return ERRCODE_SERVICE_UNAVAILABLE;
1222 }
1223
ReportErrorStatus(sptr<ILocatorCallback> & callback,int result)1224 LocationErrCode LocatorAbility::ReportErrorStatus(sptr<ILocatorCallback>& callback, int result)
1225 {
1226 int state = DISABLED;
1227 LocationErrCode errorCode = GetSwitchState(state);
1228 if (errorCode != ERRCODE_SUCCESS) {
1229 return errorCode;
1230 }
1231 if (state == DISABLED) {
1232 LBSLOGE(LOCATOR, "%{public}s line:%{public}d location switch is off",
1233 __func__, __LINE__);
1234 return ERRCODE_SWITCH_OFF;
1235 }
1236 if (reportManager_->ReportRemoteCallback(callback, ILocatorCallback::RECEIVE_ERROR_INFO_EVENT, result)) {
1237 return ERRCODE_SUCCESS;
1238 }
1239 return ERRCODE_SERVICE_UNAVAILABLE;
1240 }
1241
RegisterAction()1242 void LocatorAbility::RegisterAction()
1243 {
1244 if (isActionRegistered) {
1245 LBSLOGI(LOCATOR, "action has already registered");
1246 return;
1247 }
1248 OHOS::EventFwk::MatchingSkills matchingSkills;
1249 matchingSkills.AddEvent(MODE_CHANGED_EVENT);
1250 matchingSkills.AddEvent(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_DEVICE_IDLE_MODE_CHANGED);
1251 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1252 locatorEventSubscriber_ = std::make_shared<LocatorEventSubscriber>(subscriberInfo);
1253
1254 bool result = OHOS::EventFwk::CommonEventManager::SubscribeCommonEvent(locatorEventSubscriber_);
1255 if (!result) {
1256 LBSLOGE(LOCATOR, "Failed to subscriber locator event, result = %{public}d", result);
1257 isActionRegistered = false;
1258 } else {
1259 LBSLOGI(LOCATOR, "success to subscriber locator event, result = %{public}d", result);
1260 isActionRegistered = true;
1261 }
1262 }
1263
RegisterLocationPrivacyAction()1264 void LocatorAbility::RegisterLocationPrivacyAction()
1265 {
1266 if (isLocationPrivacyActionRegistered_) {
1267 LBSLOGI(LOCATOR, "location privacy action has already registered");
1268 return;
1269 }
1270 OHOS::EventFwk::MatchingSkills matchingSkills;
1271 matchingSkills.AddEvent(LOCATION_PRIVACY_ACCEPT_EVENT);
1272 matchingSkills.AddEvent(LOCATION_PRIVACY_REJECT_EVENT);
1273 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1274 subscriberInfo.SetPermission("ohos.permission.PUBLISH_LOCATION_EVENT");
1275 locationPrivacyEventSubscriber_ = std::make_shared<LocatorEventSubscriber>(subscriberInfo);
1276
1277 bool result = OHOS::EventFwk::CommonEventManager::SubscribeCommonEvent(locationPrivacyEventSubscriber_);
1278 if (!result) {
1279 LBSLOGE(LOCATOR, "Failed to subscriber location privacy event, result = %{public}d", result);
1280 isLocationPrivacyActionRegistered_ = false;
1281 } else {
1282 LBSLOGI(LOCATOR, "success to subscriber location privacy event, result = %{public}d", result);
1283 isLocationPrivacyActionRegistered_ = true;
1284 }
1285 }
1286
1287 #ifdef FEATURE_GEOCODE_SUPPORT
IsGeoConvertAvailable(bool & isAvailable)1288 LocationErrCode LocatorAbility::IsGeoConvertAvailable(bool &isAvailable)
1289 {
1290 MessageParcel dataParcel;
1291 MessageParcel replyParcel;
1292 if (!dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor())) {
1293 isAvailable = false;
1294 return ERRCODE_SERVICE_UNAVAILABLE;
1295 }
1296 SendGeoRequest(static_cast<int>(LocatorInterfaceCode::GEO_IS_AVAILABLE), dataParcel, replyParcel);
1297 LocationErrCode errorCode = LocationErrCode(replyParcel.ReadInt32());
1298 if (errorCode == ERRCODE_SUCCESS) {
1299 isAvailable = replyParcel.ReadBool();
1300 } else {
1301 isAvailable = false;
1302 }
1303 return errorCode;
1304 }
1305 #endif
1306
1307 #ifdef FEATURE_GEOCODE_SUPPORT
GetAddressByCoordinate(MessageParcel & data,MessageParcel & reply,std::string bundleName)1308 void LocatorAbility::GetAddressByCoordinate(MessageParcel &data, MessageParcel &reply, std::string bundleName)
1309 {
1310 MessageParcel dataParcel;
1311 auto requestTime = CommonUtils::GetCurrentTimeStamp();
1312 GeoCodeType requestType = GeoCodeType::REQUEST_REVERSE_GEOCODE;
1313 GeoConvertRequest::OrderParcel(data, dataParcel, requestType, bundleName);
1314 auto geoConvertRequest = GeoConvertRequest::Unmarshalling(dataParcel, requestType);
1315 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1316 Get(EVENT_SEND_GEOREQUEST, geoConvertRequest);
1317 if (locatorHandler_ != nullptr) {
1318 locatorHandler_->SendEvent(event);
1319 }
1320 int errorCode = reply.ReadInt32();
1321 WriteLocationInnerEvent(GEOCODE_REQUEST, {
1322 "type", "ReverseGeocode",
1323 "appName", bundleName,
1324 "subCode", std::to_string(errorCode),
1325 "requestTime", std::to_string(requestTime),
1326 "receiveTime", std::to_string(CommonUtils::GetCurrentTimeStamp()),
1327 });
1328 HookUtils::ExecuteHookWhenGetAddressFromLocation(bundleName);
1329 reply.RewindRead(0);
1330 }
1331 #endif
1332
1333 #ifdef FEATURE_GEOCODE_SUPPORT
GetAddressByLocationName(MessageParcel & data,MessageParcel & reply,std::string bundleName)1334 void LocatorAbility::GetAddressByLocationName(MessageParcel &data, MessageParcel &reply, std::string bundleName)
1335 {
1336 MessageParcel dataParcel;
1337 auto requestTime = CommonUtils::GetCurrentTimeStamp();
1338 GeoCodeType requestType = GeoCodeType::REQUEST_GEOCODE;
1339 GeoConvertRequest::OrderParcel(data, dataParcel, requestType, bundleName);
1340 auto geoConvertRequest = GeoConvertRequest::Unmarshalling(dataParcel, requestType);
1341 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1342 Get(EVENT_SEND_GEOREQUEST, geoConvertRequest);
1343 if (locatorHandler_ != nullptr) {
1344 locatorHandler_->SendEvent(event);
1345 }
1346 int errorCode = reply.ReadInt32();
1347 WriteLocationInnerEvent(GEOCODE_REQUEST, {
1348 "type", "Geocode",
1349 "appName", bundleName,
1350 "subCode", std::to_string(errorCode),
1351 "requestTime", std::to_string(requestTime),
1352 "receiveTime", std::to_string(CommonUtils::GetCurrentTimeStamp()),
1353 });
1354 HookUtils::ExecuteHookWhenGetAddressFromLocationName(bundleName);
1355 reply.RewindRead(0);
1356 }
1357 #endif
1358
1359 #ifdef FEATURE_GEOCODE_SUPPORT
SendGeoRequest(int type,MessageParcel & data,MessageParcel & reply)1360 LocationErrCode LocatorAbility::SendGeoRequest(int type, MessageParcel &data, MessageParcel &reply)
1361 {
1362 if (!SaLoadWithStatistic::InitLocationSa(LOCATION_GEO_CONVERT_SA_ID)) {
1363 reply.WriteInt32(ERRCODE_SERVICE_UNAVAILABLE);
1364 return ERRCODE_SERVICE_UNAVAILABLE;
1365 }
1366 sptr<IRemoteObject> remoteObject = CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID,
1367 CommonUtils::InitDeviceId());
1368 if (remoteObject == nullptr) {
1369 reply.WriteInt32(ERRCODE_SERVICE_UNAVAILABLE);
1370 return ERRCODE_SERVICE_UNAVAILABLE;
1371 }
1372 MessageOption option;
1373 remoteObject->SendRequest(type, data, reply, option);
1374 return ERRCODE_SUCCESS;
1375 }
1376 #endif
1377
1378 #ifdef FEATURE_GEOCODE_SUPPORT
EnableReverseGeocodingMock()1379 LocationErrCode LocatorAbility::EnableReverseGeocodingMock()
1380 {
1381 MessageParcel dataParcel;
1382 MessageParcel replyParcel;
1383 if (!dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor())) {
1384 return ERRCODE_SERVICE_UNAVAILABLE;
1385 }
1386 SendGeoRequest(static_cast<int>(LocatorInterfaceCode::ENABLE_REVERSE_GEOCODE_MOCK), dataParcel, replyParcel);
1387 return LocationErrCode(replyParcel.ReadInt32());
1388 }
1389 #endif
1390
1391 #ifdef FEATURE_GEOCODE_SUPPORT
DisableReverseGeocodingMock()1392 LocationErrCode LocatorAbility::DisableReverseGeocodingMock()
1393 {
1394 MessageParcel dataParcel;
1395 MessageParcel replyParcel;
1396 if (!dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor())) {
1397 return ERRCODE_SERVICE_UNAVAILABLE;
1398 }
1399 SendGeoRequest(static_cast<int>(LocatorInterfaceCode::DISABLE_REVERSE_GEOCODE_MOCK), dataParcel, replyParcel);
1400 return LocationErrCode(replyParcel.ReadInt32());
1401 }
1402 #endif
1403
1404 #ifdef FEATURE_GEOCODE_SUPPORT
SetReverseGeocodingMockInfo(std::vector<std::shared_ptr<GeocodingMockInfo>> & mockInfo)1405 LocationErrCode LocatorAbility::SetReverseGeocodingMockInfo(std::vector<std::shared_ptr<GeocodingMockInfo>>& mockInfo)
1406 {
1407 MessageParcel dataParcel;
1408 MessageParcel replyParcel;
1409 if (!dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor())) {
1410 return ERRCODE_SERVICE_UNAVAILABLE;
1411 }
1412 dataParcel.WriteInt32(mockInfo.size());
1413 for (size_t i = 0; i < mockInfo.size(); i++) {
1414 mockInfo[i]->Marshalling(dataParcel);
1415 }
1416 SendGeoRequest(static_cast<int>(LocatorInterfaceCode::SET_REVERSE_GEOCODE_MOCKINFO), dataParcel, replyParcel);
1417 return LocationErrCode(replyParcel.ReadInt32());
1418 }
1419 #endif
1420
ProxyForFreeze(std::set<int> pidList,bool isProxy)1421 LocationErrCode LocatorAbility::ProxyForFreeze(std::set<int> pidList, bool isProxy)
1422 {
1423 std::unique_lock<std::mutex> lock(proxyPidsMutex_, std::defer_lock);
1424 lock.lock();
1425 if (isProxy) {
1426 for (auto it = pidList.begin(); it != pidList.end(); it++) {
1427 proxyPids_.insert(*it);
1428 LBSLOGI(LOCATOR, "Start locator proxy, pid: %{public}d, isProxy: %{public}d, timestamp = %{public}s",
1429 *it, isProxy, std::to_string(CommonUtils::GetCurrentTimeStamp()).c_str());
1430 }
1431 } else {
1432 for (auto it = pidList.begin(); it != pidList.end(); it++) {
1433 proxyPids_.erase(*it);
1434 LBSLOGI(LOCATOR, "Start locator proxy, pid: %{public}d, isProxy: %{public}d, timestamp = %{public}s",
1435 *it, isProxy, std::to_string(CommonUtils::GetCurrentTimeStamp()).c_str());
1436 }
1437 }
1438 lock.unlock();
1439 if (GetActiveRequestNum() <= 0) {
1440 LBSLOGD(LOCATOR, "no active request, do not refresh.");
1441 return ERRCODE_SUCCESS;
1442 }
1443 // for proxy uid update, should send message to refresh requests
1444 ApplyRequests(0);
1445 return ERRCODE_SUCCESS;
1446 }
1447
ResetAllProxy()1448 LocationErrCode LocatorAbility::ResetAllProxy()
1449 {
1450 LBSLOGI(LOCATOR, "Start locator ResetAllProxy");
1451 std::unique_lock<std::mutex> lock(proxyPidsMutex_, std::defer_lock);
1452 lock.lock();
1453 proxyPids_.clear();
1454 lock.unlock();
1455 if (GetActiveRequestNum() <= 0) {
1456 LBSLOGD(LOCATOR, "no active request, do not refresh.");
1457 return ERRCODE_SUCCESS;
1458 }
1459 // for proxy uid update, should send message to refresh requests
1460 ApplyRequests(0);
1461 return ERRCODE_SUCCESS;
1462 }
1463
IsProxyPid(int32_t pid)1464 bool LocatorAbility::IsProxyPid(int32_t pid)
1465 {
1466 std::unique_lock<std::mutex> lock(proxyPidsMutex_);
1467 return proxyPids_.find(pid) != proxyPids_.end();
1468 }
1469
RegisterPermissionCallback(const uint32_t callingTokenId,const std::vector<std::string> & permissionNameList)1470 void LocatorAbility::RegisterPermissionCallback(const uint32_t callingTokenId,
1471 const std::vector<std::string>& permissionNameList)
1472 {
1473 std::unique_lock<ffrt::mutex> lock(permissionMapMutex_);
1474 if (permissionMap_ == nullptr) {
1475 LBSLOGE(LOCATOR, "permissionMap is null.");
1476 return;
1477 }
1478 PermStateChangeScope scopeInfo;
1479 scopeInfo.permList = permissionNameList;
1480 scopeInfo.tokenIDs = {callingTokenId};
1481 auto callbackPtr = std::make_shared<PermissionStatusChangeCb>(scopeInfo);
1482 permissionMap_->erase(callingTokenId);
1483 permissionMap_->insert(std::make_pair(callingTokenId, callbackPtr));
1484 LBSLOGD(LOCATOR, "after tokenId:%{public}d register, permission callback size:%{public}s",
1485 callingTokenId, std::to_string(permissionMap_->size()).c_str());
1486 int32_t res = AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
1487 if (res != SUCCESS) {
1488 LBSLOGE(LOCATOR, "RegisterPermStateChangeCallback failed.");
1489 }
1490 }
1491
UnregisterPermissionCallback(const uint32_t callingTokenId)1492 void LocatorAbility::UnregisterPermissionCallback(const uint32_t callingTokenId)
1493 {
1494 std::unique_lock<ffrt::mutex> lock(permissionMapMutex_);
1495 if (permissionMap_ == nullptr) {
1496 LBSLOGE(LOCATOR, "permissionMap is null.");
1497 return;
1498 }
1499 auto iter = permissionMap_->find(callingTokenId);
1500 if (iter != permissionMap_->end()) {
1501 auto callbackPtr = iter->second;
1502 int32_t res = AccessTokenKit::UnRegisterPermStateChangeCallback(callbackPtr);
1503 if (res != SUCCESS) {
1504 LBSLOGE(LOCATOR, "UnRegisterPermStateChangeCallback failed.");
1505 }
1506 }
1507 permissionMap_->erase(callingTokenId);
1508 LBSLOGD(LOCATOR, "after tokenId:%{public}d unregister, permission callback size:%{public}s",
1509 callingTokenId, std::to_string(permissionMap_->size()).c_str());
1510 }
1511
ReportDataToResSched(std::string state)1512 void LocatorAbility::ReportDataToResSched(std::string state)
1513 {
1514 #ifdef RES_SCHED_SUPPROT
1515 std::unordered_map<std::string, std::string> payload;
1516 payload["state"] = state;
1517 uint32_t type = ResourceSchedule::ResType::RES_TYPE_LOCATION_STATUS_CHANGE;
1518 int64_t value = ResourceSchedule::ResType::LocationStatus::LOCATION_SWTICH_CHANGE;
1519 ResourceSchedule::ResSchedClient::GetInstance().ReportData(type, value, payload);
1520 #endif
1521 }
1522
UpdateLastLocationRequestNum()1523 void LocatorAbility::UpdateLastLocationRequestNum()
1524 {
1525 if (locatorHandler_ != nullptr &&
1526 locatorHandler_->SendHighPriorityEvent(EVENT_UPDATE_LASTLOCATION_REQUESTNUM, 0, RETRY_INTERVAL_UNITE)) {
1527 LBSLOGD(LOCATOR, "%{public}s: EVENT_UPDATE_LASTLOCATION_REQUESTNUM Send Success", __func__);
1528 }
1529 }
1530
1531 #ifdef FEATURE_GNSS_SUPPORT
QuerySupportCoordinateSystemType(std::vector<CoordinateSystemType> & coordinateSystemTypes)1532 LocationErrCode LocatorAbility::QuerySupportCoordinateSystemType(
1533 std::vector<CoordinateSystemType>& coordinateSystemTypes)
1534 {
1535 MessageParcel dataToStub;
1536 MessageParcel replyToStub;
1537 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
1538 return ERRCODE_SERVICE_UNAVAILABLE;
1539 }
1540 auto errCode = SendGnssRequest(
1541 static_cast<int>(GnssInterfaceCode::GET_GEOFENCE_SUPPORT_COORDINATE_SYSTEM_TYPE),
1542 dataToStub, replyToStub);
1543 if (errCode == ERRCODE_SUCCESS) {
1544 int size = replyToStub.ReadInt32();
1545 size = size > COORDINATE_SYSTEM_TYPE_SIZE ? COORDINATE_SYSTEM_TYPE_SIZE : size;
1546 for (int i = 0; i < size; i++) {
1547 int coordinateSystemType = replyToStub.ReadInt32();
1548 coordinateSystemTypes.push_back(static_cast<CoordinateSystemType>(coordinateSystemType));
1549 }
1550 }
1551 return errCode;
1552 }
1553
SendNetworkLocation(const std::unique_ptr<Location> & location)1554 LocationErrCode LocatorAbility::SendNetworkLocation(const std::unique_ptr<Location>& location)
1555 {
1556 LBSLOGI(LOCATOR, "%{public}s: send network location", __func__);
1557 int64_t time = location->GetTimeStamp();
1558 int64_t timeSinceBoot = location->GetTimeSinceBoot();
1559 double acc = location->GetAccuracy();
1560 LBSLOGI(LOCATOR,
1561 "receive network location: [ time=%{public}s timeSinceBoot=%{public}s acc=%{public}f]",
1562 std::to_string(time).c_str(), std::to_string(timeSinceBoot).c_str(), acc);
1563 MessageParcel dataToStub;
1564 MessageParcel replyToStub;
1565 if (!dataToStub.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor())) {
1566 return ERRCODE_SERVICE_UNAVAILABLE;
1567 }
1568 location->Marshalling(dataToStub);
1569 return SendGnssRequest(static_cast<int>(GnssInterfaceCode::SEND_NETWORK_LOCATION), dataToStub, replyToStub);
1570 }
1571 #endif
1572
RegisterLocationError(sptr<ILocatorCallback> & callback,AppIdentity & identity)1573 LocationErrCode LocatorAbility::RegisterLocationError(sptr<ILocatorCallback>& callback, AppIdentity &identity)
1574 {
1575 std::unique_ptr<LocatorCallbackMessage> callbackMessage = std::make_unique<LocatorCallbackMessage>();
1576 callbackMessage->SetCallback(callback);
1577 callbackMessage->SetAppIdentity(identity);
1578 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1579 Get(EVENT_REG_LOCATION_ERROR, callbackMessage);
1580 if (locatorHandler_ != nullptr) {
1581 locatorHandler_->SendEvent(event);
1582 }
1583 return ERRCODE_SUCCESS;
1584 }
1585
UnregisterLocationError(sptr<ILocatorCallback> & callback,AppIdentity & identity)1586 LocationErrCode LocatorAbility::UnregisterLocationError(sptr<ILocatorCallback>& callback, AppIdentity &identity)
1587 {
1588 std::unique_ptr<LocatorCallbackMessage> callbackMessage = std::make_unique<LocatorCallbackMessage>();
1589 callbackMessage->SetCallback(callback);
1590 callbackMessage->SetAppIdentity(identity);
1591 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1592 Get(EVENT_UNREG_LOCATION_ERROR, callbackMessage);
1593 if (locatorHandler_ != nullptr) {
1594 locatorHandler_->SendEvent(event);
1595 }
1596 return ERRCODE_SUCCESS;
1597 }
1598
ReportLocationError(std::string uuid,int32_t errCode)1599 void LocatorAbility::ReportLocationError(std::string uuid, int32_t errCode)
1600 {
1601 std::unique_ptr<LocatorErrorMessage> locatorErrorMessage = std::make_unique<LocatorErrorMessage>();
1602 locatorErrorMessage->SetUuid(uuid);
1603 locatorErrorMessage->SetErrCode(errCode);
1604 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1605 Get(EVENT_REPORT_LOCATION_ERROR, locatorErrorMessage);
1606 if (locatorHandler_ != nullptr) {
1607 locatorHandler_->SendEvent(event);
1608 }
1609 }
1610
RemoveInvalidRequests()1611 LocationErrCode LocatorAbility::RemoveInvalidRequests()
1612 {
1613 std::list<std::shared_ptr<Request>> invalidRequestList;
1614 int32_t requestNum = 0;
1615 int32_t invalidRequestNum = 0;
1616 {
1617 std::unique_lock<ffrt::mutex> lock(requestsMutex_);
1618 #ifdef FEATURE_GNSS_SUPPORT
1619 auto gpsListIter = requests_->find(GNSS_ABILITY);
1620 if (gpsListIter != requests_->end()) {
1621 auto list = &(gpsListIter->second);
1622 requestNum += static_cast<int>(list->size());
1623 for (auto& item : *list) {
1624 if (IsInvalidRequest(item)) {
1625 invalidRequestList.push_back(item);
1626 invalidRequestNum++;
1627 }
1628 }
1629 }
1630 #endif
1631 #ifdef FEATURE_NETWORK_SUPPORT
1632 auto networkListIter = requests_->find(NETWORK_ABILITY);
1633 if (networkListIter != requests_->end()) {
1634 auto list = &(networkListIter->second);
1635 requestNum += static_cast<int>(list->size());
1636 for (auto& item : *list) {
1637 if (IsInvalidRequest(item)) {
1638 invalidRequestList.push_back(item);
1639 invalidRequestNum++;
1640 }
1641 }
1642 }
1643 #endif
1644 }
1645 LBSLOGI(LOCATOR, "request num : %{public}d, invalid request num: %{public}d", requestNum, invalidRequestNum);
1646 if (invalidRequestList.size() > INVALID_REQUESTS_SIZE) {
1647 return ERRCODE_SUCCESS;
1648 }
1649 for (auto& item : invalidRequestList) {
1650 sptr<ILocatorCallback> callback = item->GetLocatorCallBack();
1651 StopLocating(callback);
1652 }
1653 return ERRCODE_SUCCESS;
1654 }
1655
IsInvalidRequest(std::shared_ptr<Request> & request)1656 bool LocatorAbility::IsInvalidRequest(std::shared_ptr<Request>& request)
1657 {
1658 LBSLOGI(LOCATOR, "request : %{public}s %{public}s", request->GetPackageName().c_str(),
1659 request->GetRequestConfig()->ToString().c_str());
1660 int64_t timeDiff = fabs(CommonUtils::GetCurrentTime() - request->GetRequestConfig()->GetTimeStamp());
1661 if (request->GetRequestConfig()->GetFixNumber() == 1 &&
1662 timeDiff > (request->GetRequestConfig()->GetTimeOut() / MILLI_PER_SEC)) {
1663 LBSLOGI(LOCATOR, "once request is timeout");
1664 return true;
1665 }
1666
1667 if (timeDiff > REQUEST_DEFAULT_TIMEOUT_SECOUND && !IsProcessRunning(request->GetPid(), request->GetTokenId())) {
1668 LBSLOGI(LOCATOR, "request process is not running");
1669 return true;
1670 }
1671 return false;
1672 }
1673
IsProcessRunning(pid_t pid,const uint32_t tokenId)1674 bool LocatorAbility::IsProcessRunning(pid_t pid, const uint32_t tokenId)
1675 {
1676 auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
1677 if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE) {
1678 return true;
1679 }
1680 sptr<ISystemAbilityManager> samgrClient = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1681 if (samgrClient == nullptr) {
1682 LBSLOGE(LOCATOR, "Get system ability manager failed.");
1683 return true;
1684 }
1685 sptr<AppExecFwk::IAppMgr> iAppManager =
1686 iface_cast<AppExecFwk::IAppMgr>(samgrClient->GetSystemAbility(APP_MGR_SERVICE_ID));
1687 if (iAppManager == nullptr) {
1688 LBSLOGE(LOCATOR, "Failed to get ability manager service.");
1689 return true;
1690 }
1691 std::vector<AppExecFwk::RunningProcessInfo> runningProcessList;
1692 int32_t res = iAppManager->GetAllRunningProcesses(runningProcessList);
1693 if (res != ERR_OK) {
1694 LBSLOGE(LOCATOR, "Failed to get all running process.");
1695 return true;
1696 }
1697 auto it = std::find_if(runningProcessList.begin(), runningProcessList.end(), [pid] (auto runningProcessInfo) {
1698 return pid == runningProcessInfo.pid_;
1699 });
1700 if (it != runningProcessList.end()) {
1701 LBSLOGD(LOCATOR, "process : %{public}d is found.", pid);
1702 return true;
1703 }
1704 return false;
1705 }
1706
SyncStillMovementState(bool state)1707 void LocatorAbility::SyncStillMovementState(bool state)
1708 {
1709 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1710 Get(EVENT_SYNC_STILL_MOVEMENT_STATE, state);
1711 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
1712 LBSLOGD(LOCATOR, "%{public}s: EVENT_SYNC_MOVEMENT_STATE Send Success", __func__);
1713 }
1714 }
1715
IsHapCaller(const uint32_t tokenId)1716 bool LocatorAbility::IsHapCaller(const uint32_t tokenId)
1717 {
1718 auto tokenType = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
1719 if (tokenType == Security::AccessToken::ATokenTypeEnum::TOKEN_HAP) {
1720 return true;
1721 }
1722 return false;
1723 }
1724
SyncIdleState(bool state)1725 void LocatorAbility::SyncIdleState(bool state)
1726 {
1727 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::
1728 Get(EVENT_SYNC_IDLE_STATE, state);
1729 if (locatorHandler_ != nullptr && locatorHandler_->SendEvent(event)) {
1730 LBSLOGD(LOCATOR, "%{public}s: EVENT_SYNC_IDLE_STATE Send Success", __func__);
1731 }
1732 }
1733
SetAbilityName(std::string abilityName)1734 void LocationMessage::SetAbilityName(std::string abilityName)
1735 {
1736 abilityName_ = abilityName;
1737 }
1738
GetAbilityName()1739 std::string LocationMessage::GetAbilityName()
1740 {
1741 return abilityName_;
1742 }
1743
SetLocation(const std::unique_ptr<Location> & location)1744 void LocationMessage::SetLocation(const std::unique_ptr<Location>& location)
1745 {
1746 if (location != nullptr) {
1747 location_ = std::make_unique<Location>(*location);
1748 }
1749 }
1750
GetLocation()1751 std::unique_ptr<Location> LocationMessage::GetLocation()
1752 {
1753 if (location_ != nullptr) {
1754 return std::make_unique<Location>(*location_);
1755 } else {
1756 return nullptr;
1757 }
1758 }
1759
SetCallback(const sptr<ILocatorCallback> & callback)1760 void LocatorCallbackMessage::SetCallback(const sptr<ILocatorCallback>& callback)
1761 {
1762 callback_ = callback;
1763 }
1764
GetCallback()1765 sptr<ILocatorCallback> LocatorCallbackMessage::GetCallback()
1766 {
1767 return callback_;
1768 }
1769
SetAppIdentity(AppIdentity & appIdentity)1770 void LocatorCallbackMessage::SetAppIdentity(AppIdentity& appIdentity)
1771 {
1772 appIdentity_ = appIdentity;
1773 }
1774
GetAppIdentity()1775 AppIdentity LocatorCallbackMessage::GetAppIdentity()
1776 {
1777 return appIdentity_;
1778 }
1779
SetUuid(std::string uuid)1780 void LocatorErrorMessage::SetUuid(std::string uuid)
1781 {
1782 uuid_ = uuid;
1783 }
1784
GetUuid()1785 std::string LocatorErrorMessage::GetUuid()
1786 {
1787 return uuid_;
1788 }
1789
SetErrCode(int32_t errCode)1790 void LocatorErrorMessage::SetErrCode(int32_t errCode)
1791 {
1792 errCode_ = errCode;
1793 }
1794
GetErrCode()1795 int32_t LocatorErrorMessage::GetErrCode()
1796 {
1797 return errCode_;
1798 }
1799
SetUserId(int32_t userId)1800 void LocatorSwitchMessage::SetUserId(int32_t userId)
1801 {
1802 userId_ = userId;
1803 }
1804
GetUserId()1805 int32_t LocatorSwitchMessage::GetUserId()
1806 {
1807 return userId_;
1808 }
1809
SetModeValue(int32_t modeValue)1810 void LocatorSwitchMessage::SetModeValue(int32_t modeValue)
1811 {
1812 modeValue_ = modeValue;
1813 }
1814
GetModeValue()1815 int32_t LocatorSwitchMessage::GetModeValue()
1816 {
1817 return modeValue_;
1818 }
1819
LocatorHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner)1820 LocatorHandler::LocatorHandler(const std::shared_ptr<AppExecFwk::EventRunner>& runner) : EventHandler(runner)
1821 {
1822 InitLocatorHandlerEventMap();
1823 }
1824
~LocatorHandler()1825 LocatorHandler::~LocatorHandler() {}
1826
InitLocatorHandlerEventMap()1827 void LocatorHandler::InitLocatorHandlerEventMap()
1828 {
1829 if (locatorHandlerEventMap_.size() != 0) {
1830 return;
1831 }
1832 locatorHandlerEventMap_[EVENT_UPDATE_SA] =
1833 [this](const AppExecFwk::InnerEvent::Pointer& event) { UpdateSaEvent(event); };
1834 locatorHandlerEventMap_[EVENT_INIT_REQUEST_MANAGER] =
1835 [this](const AppExecFwk::InnerEvent::Pointer& event) { InitRequestManagerEvent(event); };
1836 locatorHandlerEventMap_[EVENT_APPLY_REQUIREMENTS] =
1837 [this](const AppExecFwk::InnerEvent::Pointer& event) { ApplyRequirementsEvent(event); };
1838 locatorHandlerEventMap_[EVENT_RETRY_REGISTER_ACTION] =
1839 [this](const AppExecFwk::InnerEvent::Pointer& event) { RetryRegisterActionEvent(event); };
1840 locatorHandlerEventMap_[EVENT_REPORT_LOCATION_MESSAGE] =
1841 [this](const AppExecFwk::InnerEvent::Pointer& event) { ReportLocationMessageEvent(event); };
1842 locatorHandlerEventMap_[EVENT_SEND_SWITCHSTATE_TO_HIFENCE] =
1843 [this](const AppExecFwk::InnerEvent::Pointer& event) { SendSwitchStateToHifenceEvent(event); };
1844 locatorHandlerEventMap_[EVENT_START_LOCATING] =
1845 [this](const AppExecFwk::InnerEvent::Pointer& event) { StartLocatingEvent(event); };
1846 locatorHandlerEventMap_[EVENT_STOP_LOCATING] =
1847 [this](const AppExecFwk::InnerEvent::Pointer& event) { StopLocatingEvent(event); };
1848 locatorHandlerEventMap_[EVENT_UPDATE_LASTLOCATION_REQUESTNUM] =
1849 [this](const AppExecFwk::InnerEvent::Pointer& event) { UpdateLastLocationRequestNum(event); };
1850 locatorHandlerEventMap_[EVENT_UNLOAD_SA] =
1851 [this](const AppExecFwk::InnerEvent::Pointer& event) { UnloadSaEvent(event); };
1852 locatorHandlerEventMap_[EVENT_GET_CACHED_LOCATION_SUCCESS] =
1853 [this](const AppExecFwk::InnerEvent::Pointer& event) { GetCachedLocationSuccess(event); };
1854 locatorHandlerEventMap_[EVENT_GET_CACHED_LOCATION_FAILED] =
1855 [this](const AppExecFwk::InnerEvent::Pointer& event) { GetCachedLocationFailed(event); };
1856 locatorHandlerEventMap_[EVENT_REG_LOCATION_ERROR] =
1857 [this](const AppExecFwk::InnerEvent::Pointer& event) { RegLocationErrorEvent(event); };
1858 locatorHandlerEventMap_[EVENT_UNREG_LOCATION_ERROR] =
1859 [this](const AppExecFwk::InnerEvent::Pointer& event) { UnRegLocationErrorEvent(event); };
1860 locatorHandlerEventMap_[EVENT_REPORT_LOCATION_ERROR] =
1861 [this](const AppExecFwk::InnerEvent::Pointer& event) { ReportNetworkLocatingErrorEvent(event); };
1862 locatorHandlerEventMap_[EVENT_PERIODIC_CHECK] =
1863 [this](const AppExecFwk::InnerEvent::Pointer& event) { RequestCheckEvent(event); };
1864 locatorHandlerEventMap_[EVENT_SYNC_LOCATION_STATUS] =
1865 [this](const AppExecFwk::InnerEvent::Pointer& event) { SyncSwitchStatus(event); };
1866 locatorHandlerEventMap_[EVENT_SYNC_STILL_MOVEMENT_STATE] =
1867 [this](const AppExecFwk::InnerEvent::Pointer& event) { SyncStillMovementState(event); };
1868 locatorHandlerEventMap_[EVENT_SYNC_IDLE_STATE] =
1869 [this](const AppExecFwk::InnerEvent::Pointer& event) { SyncIdleState(event); };
1870 locatorHandlerEventMap_[EVENT_INIT_MSDP_MONITOR_MANAGER] =
1871 [this](const AppExecFwk::InnerEvent::Pointer& event) { InitMonitorManagerEvent(event); };
1872 locatorHandlerEventMap_[EVENT_IS_STAND_BY] =
1873 [this](const AppExecFwk::InnerEvent::Pointer& event) { IsStandByEvent(event); };
1874 ConstructDbHandleMap();
1875 ConstructGeocodeHandleMap();
1876 }
1877
ConstructGeocodeHandleMap()1878 void LocatorHandler::ConstructGeocodeHandleMap()
1879 {
1880 locatorHandlerEventMap_[EVENT_SEND_GEOREQUEST] =
1881 [this](const AppExecFwk::InnerEvent::Pointer& event) { SendGeoRequestEvent(event); };
1882 }
1883
ConstructDbHandleMap()1884 void LocatorHandler::ConstructDbHandleMap()
1885 {
1886 locatorHandlerEventMap_[EVENT_SET_LOCATION_WORKING_STATE] =
1887 [this](const AppExecFwk::InnerEvent::Pointer& event) { SetLocationWorkingStateEvent(event); };
1888 locatorHandlerEventMap_[EVENT_SET_SWITCH_STATE_TO_DB] =
1889 [this](const AppExecFwk::InnerEvent::Pointer& event) { SetSwitchStateToDbEvent(event); };
1890 locatorHandlerEventMap_[EVENT_SET_SWITCH_STATE_TO_DB_BY_USERID] =
1891 [this](const AppExecFwk::InnerEvent::Pointer& event) { SetSwitchStateToDbForUserEvent(event); };
1892 locatorHandlerEventMap_[EVENT_WATCH_SWITCH_PARAMETER] =
1893 [this](const AppExecFwk::InnerEvent::Pointer& event) { WatchSwitchParameter(event); };
1894 }
1895
GetCachedLocationSuccess(const AppExecFwk::InnerEvent::Pointer & event)1896 void LocatorHandler::GetCachedLocationSuccess(const AppExecFwk::InnerEvent::Pointer& event)
1897 {
1898 auto workRecordStatistic = WorkRecordStatistic::GetInstance();
1899 if (!workRecordStatistic->Update("CacheLocation", 1)) {
1900 LBSLOGE(LOCATOR, "%{public}s line:%{public}d workRecordStatistic::Update failed", __func__, __LINE__);
1901 }
1902 std::shared_ptr<AppIdentity> identity = event->GetSharedObject<AppIdentity>();
1903 int64_t tokenId = identity->GetTokenId();
1904 OHOS::Security::AccessToken::PermUsedTypeEnum type =
1905 Security::AccessToken::AccessTokenKit::GetUserGrantedPermissionUsedType(tokenId, ACCESS_APPROXIMATELY_LOCATION);
1906 auto locatorAbility = LocatorAbility::GetInstance();
1907 int ret;
1908 if (locatorAbility != nullptr) {
1909 locatorAbility->UpdateLastLocationRequestNum();
1910 ret = locatorAbility->UpdatePermissionUsedRecord(tokenId, ACCESS_APPROXIMATELY_LOCATION,
1911 static_cast<int>(type), 1, 0);
1912 LBSLOGD(LOCATOR, "UpdatePermissionUsedRecord, ret=%{public}d", ret);
1913 }
1914 auto requestManager = RequestManager::GetInstance();
1915 requestManager->DecreaseWorkingPidsCount(identity->GetPid());
1916 if (requestManager->IsNeedStopUsingPermission(identity->GetPid())) {
1917 ret = PrivacyKit::StopUsingPermission(tokenId, ACCESS_APPROXIMATELY_LOCATION, identity->GetPid());
1918 LBSLOGD(LOCATOR, "StopUsingPermission, ret=%{public}d", ret);
1919 }
1920 }
1921
GetCachedLocationFailed(const AppExecFwk::InnerEvent::Pointer & event)1922 void LocatorHandler::GetCachedLocationFailed(const AppExecFwk::InnerEvent::Pointer& event)
1923 {
1924 auto workRecordStatistic = WorkRecordStatistic::GetInstance();
1925 if (!workRecordStatistic->Update("CacheLocation", 1)) {
1926 LBSLOGE(LOCATOR, "%{public}s line:%{public}d workRecordStatistic::Update failed", __func__, __LINE__);
1927 }
1928 std::shared_ptr<AppIdentity> identity = event->GetSharedObject<AppIdentity>();
1929 int64_t tokenId = identity->GetTokenId();
1930 OHOS::Security::AccessToken::PermUsedTypeEnum type =
1931 Security::AccessToken::AccessTokenKit::GetUserGrantedPermissionUsedType(tokenId, ACCESS_APPROXIMATELY_LOCATION);
1932 auto locatorAbility = LocatorAbility::GetInstance();
1933 int ret;
1934 if (locatorAbility != nullptr) {
1935 locatorAbility->UpdateLastLocationRequestNum();
1936 ret = locatorAbility->UpdatePermissionUsedRecord(tokenId, ACCESS_APPROXIMATELY_LOCATION,
1937 static_cast<int>(type), 0, 1);
1938 LBSLOGD(LOCATOR, "UpdatePermissionUsedRecord, ret=%{public}d", ret);
1939 }
1940 auto requestManager = RequestManager::GetInstance();
1941 requestManager->DecreaseWorkingPidsCount(identity->GetPid());
1942 if (requestManager->IsNeedStopUsingPermission(identity->GetPid())) {
1943 ret = PrivacyKit::StopUsingPermission(tokenId, ACCESS_APPROXIMATELY_LOCATION, identity->GetPid());
1944 LBSLOGD(LOCATOR, "StopUsingPermission, ret=%{public}d", ret);
1945 }
1946 }
1947
UpdateSaEvent(const AppExecFwk::InnerEvent::Pointer & event)1948 void LocatorHandler::UpdateSaEvent(const AppExecFwk::InnerEvent::Pointer& event)
1949 {
1950 auto locatorAbility = LocatorAbility::GetInstance();
1951 if (locatorAbility != nullptr) {
1952 locatorAbility->UpdateSaAbilityHandler();
1953 }
1954 }
1955
InitRequestManagerEvent(const AppExecFwk::InnerEvent::Pointer & event)1956 void LocatorHandler::InitRequestManagerEvent(const AppExecFwk::InnerEvent::Pointer& event)
1957 {
1958 auto requestManager = RequestManager::GetInstance();
1959 if (requestManager == nullptr || !requestManager->InitSystemListeners()) {
1960 LBSLOGE(LOCATOR, "InitSystemListeners failed");
1961 }
1962 }
1963
ApplyRequirementsEvent(const AppExecFwk::InnerEvent::Pointer & event)1964 void LocatorHandler::ApplyRequirementsEvent(const AppExecFwk::InnerEvent::Pointer& event)
1965 {
1966 auto requestManager = RequestManager::GetInstance();
1967 if (requestManager != nullptr) {
1968 requestManager->HandleRequest();
1969 }
1970 }
1971
RetryRegisterActionEvent(const AppExecFwk::InnerEvent::Pointer & event)1972 void LocatorHandler::RetryRegisterActionEvent(const AppExecFwk::InnerEvent::Pointer& event)
1973 {
1974 auto locatorAbility = LocatorAbility::GetInstance();
1975 if (locatorAbility != nullptr) {
1976 locatorAbility->RegisterAction();
1977 locatorAbility->RegisterLocationPrivacyAction();
1978 }
1979 }
1980
ReportLocationMessageEvent(const AppExecFwk::InnerEvent::Pointer & event)1981 void LocatorHandler::ReportLocationMessageEvent(const AppExecFwk::InnerEvent::Pointer& event)
1982 {
1983 auto reportManager = ReportManager::GetInstance();
1984 if (reportManager != nullptr) {
1985 std::unique_ptr<LocationMessage> locationMessage = event->GetUniqueObject<LocationMessage>();
1986 if (locationMessage == nullptr) {
1987 return;
1988 }
1989 std::unique_ptr<Location> location = locationMessage->GetLocation();
1990 std::string abilityName = locationMessage->GetAbilityName();
1991 int64_t time = location->GetTimeStamp();
1992 int64_t timeSinceBoot = location->GetTimeSinceBoot();
1993 double acc = location->GetAccuracy();
1994 LBSLOGI(LOCATOR,
1995 "receive location: [%{public}s time=%{public}s timeSinceBoot=%{public}s acc=%{public}f]",
1996 abilityName.c_str(), std::to_string(time).c_str(), std::to_string(timeSinceBoot).c_str(), acc);
1997 reportManager->OnReportLocation(location, abilityName);
1998 }
1999 }
2000
SendSwitchStateToHifenceEvent(const AppExecFwk::InnerEvent::Pointer & event)2001 void LocatorHandler::SendSwitchStateToHifenceEvent(const AppExecFwk::InnerEvent::Pointer& event)
2002 {
2003 auto locatorAbility = LocatorAbility::GetInstance();
2004 if (locatorAbility != nullptr) {
2005 int state = event->GetParam();
2006 if (!SaLoadWithStatistic::InitLocationSa(COMMON_SA_ID)) {
2007 return;
2008 }
2009 MessageParcel data;
2010 MessageParcel reply;
2011 MessageOption option;
2012 if (!data.WriteInterfaceToken(COMMON_DESCRIPTION)) {
2013 return;
2014 }
2015 data.WriteInt32(state);
2016 sptr<IRemoteObject> object =
2017 CommonUtils::GetRemoteObject(COMMON_SA_ID, CommonUtils::InitDeviceId());
2018 if (object == nullptr) {
2019 return;
2020 }
2021 object->SendRequest(COMMON_SWITCH_STATE_ID, data, reply, option);
2022 }
2023 }
2024
StartLocatingEvent(const AppExecFwk::InnerEvent::Pointer & event)2025 void LocatorHandler::StartLocatingEvent(const AppExecFwk::InnerEvent::Pointer& event)
2026 {
2027 auto requestManager = RequestManager::GetInstance();
2028 std::shared_ptr<Request> request = event->GetSharedObject<Request>();
2029 if (request == nullptr) {
2030 return;
2031 }
2032 if (requestManager != nullptr) {
2033 HookUtils::ExecuteHookWhenStartLocation(request);
2034 requestManager->HandleStartLocating(request);
2035 }
2036 }
2037
StopLocatingEvent(const AppExecFwk::InnerEvent::Pointer & event)2038 void LocatorHandler::StopLocatingEvent(const AppExecFwk::InnerEvent::Pointer& event)
2039 {
2040 auto requestManager = RequestManager::GetInstance();
2041 std::unique_ptr<LocatorCallbackMessage> callbackMessage = event->GetUniqueObject<LocatorCallbackMessage>();
2042 if (callbackMessage == nullptr) {
2043 return;
2044 }
2045 if (requestManager != nullptr) {
2046 requestManager->HandleStopLocating(callbackMessage->GetCallback());
2047 }
2048 }
2049
UpdateLastLocationRequestNum(const AppExecFwk::InnerEvent::Pointer & event)2050 void LocatorHandler::UpdateLastLocationRequestNum(const AppExecFwk::InnerEvent::Pointer& event)
2051 {
2052 auto workRecordStatistic = WorkRecordStatistic::GetInstance();
2053 if (!workRecordStatistic->Update("CacheLocation", -1)) {
2054 LBSLOGE(LOCATOR, "%{public}s line:%{public}d workRecordStatistic::Update failed", __func__, __LINE__);
2055 }
2056 }
2057
UnloadSaEvent(const AppExecFwk::InnerEvent::Pointer & event)2058 void LocatorHandler::UnloadSaEvent(const AppExecFwk::InnerEvent::Pointer& event)
2059 {
2060 auto locationSaLoadManager = LocationSaLoadManager::GetInstance();
2061 if (locationSaLoadManager != nullptr) {
2062 locationSaLoadManager->UnloadLocationSa(LOCATION_LOCATOR_SA_ID);
2063 }
2064 }
2065
RegLocationErrorEvent(const AppExecFwk::InnerEvent::Pointer & event)2066 void LocatorHandler::RegLocationErrorEvent(const AppExecFwk::InnerEvent::Pointer& event)
2067 {
2068 auto requestManager = RequestManager::GetInstance();
2069 std::unique_ptr<LocatorCallbackMessage> callbackMessage = event->GetUniqueObject<LocatorCallbackMessage>();
2070 if (callbackMessage == nullptr) {
2071 return;
2072 }
2073 if (requestManager != nullptr) {
2074 requestManager->RegisterLocationErrorCallback(callbackMessage->GetCallback(),
2075 callbackMessage->GetAppIdentity());
2076 }
2077 }
2078
UnRegLocationErrorEvent(const AppExecFwk::InnerEvent::Pointer & event)2079 void LocatorHandler::UnRegLocationErrorEvent(const AppExecFwk::InnerEvent::Pointer& event)
2080 {
2081 auto requestManager = RequestManager::GetInstance();
2082 std::unique_ptr<LocatorCallbackMessage> callbackMessage = event->GetUniqueObject<LocatorCallbackMessage>();
2083 if (callbackMessage == nullptr) {
2084 return;
2085 }
2086 if (requestManager != nullptr) {
2087 requestManager->UnRegisterLocationErrorCallback(callbackMessage->GetCallback());
2088 }
2089 }
2090
ReportNetworkLocatingErrorEvent(const AppExecFwk::InnerEvent::Pointer & event)2091 void LocatorHandler::ReportNetworkLocatingErrorEvent(const AppExecFwk::InnerEvent::Pointer& event)
2092 {
2093 std::unique_ptr<LocatorErrorMessage> locatorErrorMessage = event->GetUniqueObject<LocatorErrorMessage>();
2094 if (locatorErrorMessage == nullptr) {
2095 return;
2096 }
2097 auto uuid = locatorErrorMessage->GetUuid();
2098 auto errCode = locatorErrorMessage->GetErrCode();
2099 auto requestMap = LocatorAbility::GetInstance()->GetRequests();
2100 if (requestMap == nullptr || requestMap->empty()) {
2101 LBSLOGE(REQUEST_MANAGER, "requests map is empty");
2102 return;
2103 }
2104 auto requestListIter = requestMap->find(NETWORK_ABILITY);
2105 if (requestListIter == requestMap->end()) {
2106 return;
2107 }
2108 auto requestList = requestListIter->second;
2109 for (auto iter = requestList.begin(); iter != requestList.end(); iter++) {
2110 auto request = *iter;
2111 if (uuid.compare(request->GetUuid()) == 0) {
2112 RequestManager::GetInstance()->ReportLocationError(errCode, request);
2113 break;
2114 }
2115 }
2116 }
2117
SyncSwitchStatus(const AppExecFwk::InnerEvent::Pointer & event)2118 void LocatorHandler::SyncSwitchStatus(const AppExecFwk::InnerEvent::Pointer& event)
2119 {
2120 LocationDataRdbManager::SyncSwitchStatus();
2121 }
2122
IsSwitchObserverReg()2123 bool LocatorHandler::IsSwitchObserverReg()
2124 {
2125 std::unique_lock<ffrt::mutex> lock(isSwitchObserverRegMutex_);
2126 return isSwitchObserverReg_;
2127 }
2128
SetIsSwitchObserverReg(bool isSwitchObserverReg)2129 void LocatorHandler::SetIsSwitchObserverReg(bool isSwitchObserverReg)
2130 {
2131 std::unique_lock<ffrt::mutex> lock(isSwitchObserverRegMutex_);
2132 isSwitchObserverReg_ = isSwitchObserverReg;
2133 }
2134
WatchSwitchParameter(const AppExecFwk::InnerEvent::Pointer & event)2135 void LocatorHandler::WatchSwitchParameter(const AppExecFwk::InnerEvent::Pointer& event)
2136 {
2137 if (IsSwitchObserverReg()) {
2138 return;
2139 }
2140 auto eventCallback = [](const char *key, const char *value, void *context) {
2141 LocationDataRdbManager::SyncSwitchStatus();
2142 };
2143
2144 int ret = WatchParameter(LOCATION_SWITCH_MODE, eventCallback, nullptr);
2145 if (ret != SUCCESS) {
2146 LBSLOGE(LOCATOR, "WatchParameter fail");
2147 return;
2148 }
2149 SetIsSwitchObserverReg(true);
2150 }
2151
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)2152 void LocatorHandler::ProcessEvent(const AppExecFwk::InnerEvent::Pointer& event)
2153 {
2154 uint32_t eventId = event->GetInnerEventId();
2155 LBSLOGD(LOCATOR, "ProcessEvent event:%{public}d, timestamp = %{public}s",
2156 eventId, std::to_string(CommonUtils::GetCurrentTimeStamp()).c_str());
2157 auto handleFunc = locatorHandlerEventMap_.find(eventId);
2158 if (handleFunc != locatorHandlerEventMap_.end() && handleFunc->second != nullptr) {
2159 auto memberFunc = handleFunc->second;
2160 #ifdef LOCATION_HICOLLIE_ENABLE
2161 int tid = gettid();
2162 std::string moduleName = "LocatorHandler";
2163 XCollieCallback callbackFunc = [moduleName, eventId, tid](void *) {
2164 LBSLOGE(LOCATOR, "TimeoutCallback tid:%{public}d moduleName:%{public}s excute eventId:%{public}u timeout.",
2165 tid, moduleName.c_str(), eventId);
2166 _exit(0);
2167 };
2168 std::string dfxInfo = moduleName + "_" + std::to_string(eventId) + "_" + std::to_string(tid);
2169 int timerId = HiviewDFX::XCollie::GetInstance().SetTimer(dfxInfo, TIMEOUT_WATCHDOG, callbackFunc, nullptr,
2170 HiviewDFX::XCOLLIE_FLAG_NOOP);
2171 memberFunc(event);
2172 HiviewDFX::XCollie::GetInstance().CancelTimer(timerId);
2173 #else
2174 memberFunc(event);
2175 #endif
2176 } else {
2177 LBSLOGE(LOCATOR, "ProcessEvent event:%{public}d, unsupport service.", eventId);
2178 }
2179 }
2180
RequestCheckEvent(const AppExecFwk::InnerEvent::Pointer & event)2181 void LocatorHandler::RequestCheckEvent(const AppExecFwk::InnerEvent::Pointer& event)
2182 {
2183 auto locatorAbility = LocatorAbility::GetInstance();
2184 if (locatorAbility != nullptr) {
2185 locatorAbility->RemoveInvalidRequests();
2186 }
2187 SendHighPriorityEvent(EVENT_PERIODIC_CHECK, 0, EVENT_PERIODIC_INTERVAL);
2188 }
2189
SyncStillMovementState(const AppExecFwk::InnerEvent::Pointer & event)2190 void LocatorHandler::SyncStillMovementState(const AppExecFwk::InnerEvent::Pointer& event)
2191 {
2192 bool state = event->GetParam();
2193 RequestManager::GetInstance()->SyncStillMovementState(state);
2194 LocatorRequiredDataManager::GetInstance()->SyncStillMovementState(state);
2195 }
2196
SyncIdleState(const AppExecFwk::InnerEvent::Pointer & event)2197 void LocatorHandler::SyncIdleState(const AppExecFwk::InnerEvent::Pointer& event)
2198 {
2199 auto requestManager = RequestManager::GetInstance();
2200 if (requestManager != nullptr) {
2201 bool state = event->GetParam();
2202 requestManager->SyncIdleState(state);
2203 }
2204 }
2205
SendGeoRequestEvent(const AppExecFwk::InnerEvent::Pointer & event)2206 void LocatorHandler::SendGeoRequestEvent(const AppExecFwk::InnerEvent::Pointer& event)
2207 {
2208 auto locatorAbility = LocatorAbility::GetInstance();
2209 if (locatorAbility != nullptr) {
2210 std::unique_ptr<GeoConvertRequest> geoConvertRequest = event->GetUniqueObject<GeoConvertRequest>();
2211 if (geoConvertRequest == nullptr) {
2212 return;
2213 }
2214 MessageParcel dataParcel;
2215 MessageParcel replyParcel;
2216 if (!dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor())) {
2217 return;
2218 }
2219 geoConvertRequest->Marshalling(dataParcel);
2220 locatorAbility->SendGeoRequest(
2221 geoConvertRequest->GetRequestType() == GeoCodeType::REQUEST_GEOCODE ?
2222 static_cast<int>(LocatorInterfaceCode::GET_FROM_LOCATION_NAME) :
2223 static_cast<int>(LocatorInterfaceCode::GET_FROM_COORDINATE),
2224 dataParcel, replyParcel);
2225 }
2226 }
2227
InitMonitorManagerEvent(const AppExecFwk::InnerEvent::Pointer & event)2228 void LocatorHandler::InitMonitorManagerEvent(const AppExecFwk::InnerEvent::Pointer& event)
2229 {
2230 #ifdef MOVEMENT_CLIENT_ENABLE
2231 LocatorMsdpMonitorManager::GetInstance();
2232 #endif
2233 }
2234
IsStandByEvent(const AppExecFwk::InnerEvent::Pointer & event)2235 void LocatorHandler::IsStandByEvent(const AppExecFwk::InnerEvent::Pointer& event)
2236 {
2237 auto requestManager = RequestManager::GetInstance();
2238 if (requestManager != nullptr) {
2239 requestManager->IsStandby();
2240 }
2241 }
2242
SetLocationWorkingStateEvent(const AppExecFwk::InnerEvent::Pointer & event)2243 void LocatorHandler::SetLocationWorkingStateEvent(const AppExecFwk::InnerEvent::Pointer& event)
2244 {
2245 if (!LocationDataRdbManager::SetLocationWorkingState(0)) {
2246 LBSLOGD(LOCATOR, "LocatorAbility::reset LocationWorkingState failed.");
2247 }
2248 }
2249
SetSwitchStateToDbEvent(const AppExecFwk::InnerEvent::Pointer & event)2250 void LocatorHandler::SetSwitchStateToDbEvent(const AppExecFwk::InnerEvent::Pointer& event)
2251 {
2252 int modeValue = event->GetParam();
2253 if (LocationDataRdbManager::SetSwitchStateToDb(modeValue) != ERRCODE_SUCCESS) {
2254 LBSLOGE(LOCATOR, "%{public}s: can not set state to db", __func__);
2255 return;
2256 }
2257 auto locatorAbility = LocatorAbility::GetInstance();
2258 if (locatorAbility != nullptr) {
2259 locatorAbility->UpdateSaAbility();
2260 locatorAbility->ApplyRequests(0);
2261 bool isEnabled = (modeValue == ENABLED);
2262 std::string state = isEnabled ? "enable" : "disable";
2263 locatorAbility->ReportDataToResSched(state);
2264 WriteLocationSwitchStateEvent(state);
2265 }
2266 }
2267
SetSwitchStateToDbForUserEvent(const AppExecFwk::InnerEvent::Pointer & event)2268 void LocatorHandler::SetSwitchStateToDbForUserEvent(const AppExecFwk::InnerEvent::Pointer& event)
2269 {
2270 std::unique_ptr<LocatorSwitchMessage> locatorSwitchMessage = event->GetUniqueObject<LocatorSwitchMessage>();
2271 if (locatorSwitchMessage == nullptr) {
2272 return;
2273 }
2274 auto modeValue = locatorSwitchMessage->GetModeValue();
2275 auto userId = locatorSwitchMessage->GetUserId();
2276 if (LocationDataRdbManager::SetSwitchStateToDbForUser(modeValue, userId) != ERRCODE_SUCCESS) {
2277 LBSLOGE(LOCATOR, "%{public}s: can not set state to db", __func__);
2278 return;
2279 }
2280 LocatorAbility::GetInstance()->UpdateSaAbility();
2281 LocatorAbility::GetInstance()->ApplyRequests(0);
2282 int currentUserId = 0;
2283 if (CommonUtils::GetCurrentUserId(currentUserId) && userId != currentUserId) {
2284 return;
2285 }
2286 bool isEnabled = (modeValue == ENABLED);
2287 std::string state = isEnabled ? "enable" : "disable";
2288 // background task only check the current user switch state
2289 LocatorAbility::GetInstance()->ReportDataToResSched(state);
2290 WriteLocationSwitchStateEvent(state);
2291 }
2292
LocatorCallbackDeathRecipient(int32_t tokenId)2293 LocatorCallbackDeathRecipient::LocatorCallbackDeathRecipient(int32_t tokenId)
2294 {
2295 tokenId_ = tokenId;
2296 }
2297
~LocatorCallbackDeathRecipient()2298 LocatorCallbackDeathRecipient::~LocatorCallbackDeathRecipient()
2299 {
2300 }
2301
OnRemoteDied(const wptr<IRemoteObject> & remote)2302 void LocatorCallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
2303 {
2304 sptr<ILocatorCallback> callback = iface_cast<ILocatorCallback>(remote.promote());
2305 auto locatorAbility = LocatorAbility::GetInstance();
2306 if (locatorAbility != nullptr) {
2307 locatorAbility->RemoveUnloadTask(DEFAULT_CODE);
2308 locatorAbility->StopLocating(callback);
2309 locatorAbility->PostUnloadTask(DEFAULT_CODE);
2310 LBSLOGI(LOCATOR, "locator callback OnRemoteDied tokenId = %{public}d", tokenId_);
2311 }
2312 }
2313 } // namespace Location
2314 } // namespace OHOS
2315