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 "report_manager.h"
17 
18 #include <cmath>
19 #include "privacy_kit.h"
20 #include "common_utils.h"
21 #include "fusion_controller.h"
22 #include "i_locator_callback.h"
23 #include "location_log.h"
24 #include "locator_ability.h"
25 #include "locator_background_proxy.h"
26 #include "location_log_event_ids.h"
27 #include "common_hisysevent.h"
28 #include "permission_manager.h"
29 
30 #include "hook_utils.h"
31 
32 namespace OHOS {
33 namespace Location {
34 const long NANOS_PER_MILLI = 1000000L;
35 const int MAX_SA_SCHEDULING_JITTER_MS = 200;
36 static constexpr double MAXIMUM_FUZZY_LOCATION_DISTANCE = 4000.0; // Unit m
37 static constexpr double MINIMUM_FUZZY_LOCATION_DISTANCE = 3000.0; // Unit m
38 static constexpr int CACHED_TIME = 25;
39 static constexpr int LONG_CACHE_DURATION = 90;
40 static constexpr int MAX_LOCATION_REPORT_DELAY_TIME = 30000; // Unit ms
41 static constexpr int MIN_RESET_TIME_THRESHOLD = 1 * 60 * 60 * 1000; // Unit ms
42 
GetInstance()43 ReportManager* ReportManager::GetInstance()
44 {
45     static ReportManager data;
46     return &data;
47 }
48 
ReportManager()49 ReportManager::ReportManager()
50 {
51     clock_gettime(CLOCK_REALTIME, &lastUpdateTime_);
52     offsetRandom_ = CommonUtils::DoubleRandom(0, 1);
53     lastResetRecordTime_ = CommonUtils::GetSinceBootTime();
54 }
55 
~ReportManager()56 ReportManager::~ReportManager() {}
57 
OnReportLocation(const std::unique_ptr<Location> & location,std::string abilityName)58 bool ReportManager::OnReportLocation(const std::unique_ptr<Location>& location, std::string abilityName)
59 {
60     auto fusionController = FusionController::GetInstance();
61     if (fusionController == nullptr) {
62         return false;
63     }
64     UpdateCacheLocation(location, abilityName);
65     auto locatorAbility = LocatorAbility::GetInstance();
66     if (locatorAbility == nullptr) {
67         return false;
68     }
69     auto requestMap = locatorAbility->GetRequests();
70     if (requestMap == nullptr) {
71         return false;
72     }
73     auto requestListIter = requestMap->find(abilityName);
74     if (requestListIter == requestMap->end()) {
75         return false;
76     }
77     auto requestList = requestListIter->second;
78     auto deadRequests = std::make_unique<std::list<std::shared_ptr<Request>>>();
79     for (auto iter = requestList.begin(); iter != requestList.end(); iter++) {
80         auto request = *iter;
81         WriteNetWorkReportEvent(abilityName, request, location);
82         if (abilityName == NETWORK_ABILITY) {
83             if (request->GetUuid() == location->GetUuid() || location->GetIsFromMock()) {
84                 ProcessRequestForReport(request, deadRequests, location, abilityName);
85                 break;
86             }
87         } else if (abilityName == GNSS_ABILITY || abilityName == PASSIVE_ABILITY) {
88             ProcessRequestForReport(request, deadRequests, location, abilityName);
89         }
90     }
91     for (auto iter = deadRequests->begin(); iter != deadRequests->end(); ++iter) {
92         auto request = *iter;
93         if (request == nullptr) {
94             continue;
95         }
96         auto requestManger = RequestManager::GetInstance();
97         if (requestManger != nullptr) {
98             requestManger->UpdateRequestRecord(request, false);
99             requestManger->UpdateUsingPermission(request, false);
100         }
101     }
102     if (deadRequests->size() > 0) {
103         locatorAbility->ApplyRequests(1);
104         deadRequests->clear();
105     }
106     return true;
107 }
108 
UpdateLocationByRequest(const uint32_t tokenId,const uint64_t tokenIdEx,std::unique_ptr<Location> & location)109 void ReportManager::UpdateLocationByRequest(const uint32_t tokenId, const uint64_t tokenIdEx,
110     std::unique_ptr<Location>& location)
111 {
112     if (location == nullptr) {
113         return;
114     }
115     if (!PermissionManager::CheckSystemPermission(tokenId, tokenIdEx)) {
116         location->SetIsSystemApp(0);
117     } else {
118         location->SetIsSystemApp(1);
119     }
120 }
121 
ProcessRequestForReport(std::shared_ptr<Request> & request,std::unique_ptr<std::list<std::shared_ptr<Request>>> & deadRequests,const std::unique_ptr<Location> & location,std::string abilityName)122 bool ReportManager::ProcessRequestForReport(std::shared_ptr<Request>& request,
123     std::unique_ptr<std::list<std::shared_ptr<Request>>>& deadRequests,
124     const std::unique_ptr<Location>& location, std::string abilityName)
125 {
126     if (location == nullptr ||
127         request == nullptr || request->GetRequestConfig() == nullptr || !request->GetIsRequesting()) {
128         return false;
129     }
130     std::unique_ptr<Location> fuseLocation;
131     std::unique_ptr<Location> finalLocation;
132     if (IsRequestFuse(request)) {
133         auto fusionController = FusionController::GetInstance();
134         if (fusionController == nullptr) {
135             return false;
136         }
137         fuseLocation = fusionController->GetFuseLocation(location, request->GetBestLocation());
138         request->SetBestLocation(fuseLocation);
139     }
140     auto locatorAbility = LocatorAbility::GetInstance();
141     if (locatorAbility == nullptr) {
142         return false;
143     }
144     finalLocation = GetPermittedLocation(request, IsRequestFuse(request) ? fuseLocation : location);
145     if (!ResultCheck(finalLocation, request)) {
146         // add location permission using record
147         int permUsedType = request->GetPermUsedType();
148         locatorAbility->UpdatePermissionUsedRecord(request->GetTokenId(),
149             ACCESS_APPROXIMATELY_LOCATION, permUsedType, 0, 1);
150         return false;
151     }
152     LocationReportDelayTimeCheck(finalLocation, request);
153     UpdateLocationByRequest(request->GetTokenId(), request->GetTokenIdEx(), finalLocation);
154     finalLocation = ExecuteReportProcess(request, finalLocation, abilityName);
155     if (finalLocation == nullptr) {
156         LBSLOGE(REPORT_MANAGER, "%{public}s no need report location", __func__);
157         return false;
158     }
159     request->SetLastLocation(finalLocation);
160     auto locatorCallback = request->GetLocatorCallBack();
161     if (locatorCallback != nullptr) {
162         // add location permission using record
163         int ret = locatorAbility->UpdatePermissionUsedRecord(request->GetTokenId(),
164             ACCESS_APPROXIMATELY_LOCATION, request->GetPermUsedType(), 1, 0);
165         if (ret != ERRCODE_SUCCESS && locatorAbility->IsHapCaller(request->GetTokenId())) {
166             LBSLOGE(REPORT_MANAGER, "UpdatePermissionUsedRecord failed ret=%{public}d", ret);
167             return false;
168         }
169         LBSLOGI(REPORT_MANAGER, "report location to %{public}d, TimeSinceBoot : %{public}s, SourceType : %{public}d",
170             request->GetTokenId(), std::to_string(finalLocation->GetTimeSinceBoot()).c_str(),
171             finalLocation->GetLocationSourceType());
172         locatorCallback->OnLocationReport(finalLocation);
173         RequestManager::GetInstance()->UpdateLocationError(request);
174     }
175 
176     int fixTime = request->GetRequestConfig()->GetFixNumber();
177     if (fixTime > 0) {
178         deadRequests->push_back(request);
179         return false;
180     }
181     return true;
182 }
183 
LocationReportDelayTimeCheck(const std::unique_ptr<Location> & location,const std::shared_ptr<Request> & request)184 void ReportManager::LocationReportDelayTimeCheck(const std::unique_ptr<Location>& location,
185     const std::shared_ptr<Request>& request)
186 {
187     if (location == nullptr || request == nullptr) {
188         return;
189     }
190     int64_t currentTime = CommonUtils::GetSinceBootTime();
191     long deltaMs = (currentTime - location->GetTimeSinceBoot()) / NANOS_PER_MILLI;
192     if (deltaMs > MAX_LOCATION_REPORT_DELAY_TIME) {
193         long recordDeltaMs = (currentTime - lastResetRecordTime_) / NANOS_PER_MILLI;
194         if (recordDeltaMs < MIN_RESET_TIME_THRESHOLD) {
195             return;
196         }
197         LBSLOGE(REPORT_MANAGER, "%{public}s: %{public}d check fail, current deltaMs = %{public}ld", __func__,
198             request->GetTokenId(), deltaMs);
199         lastResetRecordTime_ = currentTime;
200         _exit(0);
201     }
202 }
203 
ExecuteReportProcess(std::shared_ptr<Request> & request,std::unique_ptr<Location> & location,std::string abilityName)204 std::unique_ptr<Location> ReportManager::ExecuteReportProcess(std::shared_ptr<Request>& request,
205     std::unique_ptr<Location>& location, std::string abilityName)
206 {
207     LocationSupplicantInfo reportStruct;
208     reportStruct.request = *request;
209     reportStruct.location = *location;
210     reportStruct.abilityName = abilityName;
211     reportStruct.retCode = true;
212     HookUtils::ExecuteHook(
213         LocationProcessStage::LOCATOR_SA_LOCATION_REPORT_PROCESS, (void *)&reportStruct, nullptr);
214     if (!reportStruct.retCode) {
215         return nullptr;
216     }
217     return std::make_unique<Location>(reportStruct.location);
218 }
219 
GetPermittedLocation(const std::shared_ptr<Request> & request,const std::unique_ptr<Location> & location)220 std::unique_ptr<Location> ReportManager::GetPermittedLocation(const std::shared_ptr<Request>& request,
221     const std::unique_ptr<Location>& location)
222 {
223     if (location == nullptr) {
224         return nullptr;
225     }
226     std::string bundleName = "";
227     auto tokenId = request->GetTokenId();
228     auto firstTokenId = request->GetFirstTokenId();
229     auto tokenIdEx = request->GetTokenIdEx();
230     auto uid =  request->GetUid();
231     if (!CommonUtils::GetBundleNameByUid(uid, bundleName)) {
232         LBSLOGD(REPORT_MANAGER, "Fail to Get bundle name: uid = %{public}d.", uid);
233     }
234     if (request->GetRequestConfig()->GetFixNumber() == 0 &&
235         IsAppBackground(bundleName, tokenId, tokenIdEx, uid, request->GetPid()) &&
236         !PermissionManager::CheckBackgroundPermission(tokenId, firstTokenId)) {
237         //app background, no background permission, not ContinuousTasks
238         RequestManager::GetInstance()->ReportLocationError(LOCATING_FAILED_BACKGROUND_PERMISSION_DENIED, request);
239         return nullptr;
240     }
241     AppIdentity identity;
242     identity.SetUid(request->GetUid());
243     identity.SetTokenId(request->GetTokenId());
244     if (!CommonUtils::IsAppBelongCurrentAccount(identity)) {
245         //app is not in current user, not need to report
246         LBSLOGI(REPORT_MANAGER, "GetPermittedLocation uid: %{public}d CheckAppForUser fail", tokenId);
247         auto locationErrorCallback = request->GetLocationErrorCallBack();
248         if (locationErrorCallback != nullptr) {
249             locationErrorCallback->OnErrorReport(LOCATING_FAILED_LOCATION_PERMISSION_DENIED);
250         }
251         return nullptr;
252     }
253     std::unique_ptr<Location> finalLocation = std::make_unique<Location>(*location);
254     // for api8 and previous version, only ACCESS_LOCATION permission granted also report original location info.
255     if (PermissionManager::CheckLocationPermission(tokenId, firstTokenId)) {
256         return finalLocation;
257     }
258     if (PermissionManager::CheckApproximatelyPermission(tokenId, firstTokenId)) {
259         LBSLOGI(REPORT_MANAGER, "%{public}d has ApproximatelyLocation permission", tokenId);
260         finalLocation = ApproximatelyLocation(location);
261         return finalLocation;
262     }
263     LBSLOGE(REPORT_MANAGER, "%{public}d has no location permission failed", tokenId);
264     RequestManager::GetInstance()->ReportLocationError(LOCATING_FAILED_LOCATION_PERMISSION_DENIED, request);
265     return nullptr;
266 }
267 
ReportRemoteCallback(sptr<ILocatorCallback> & locatorCallback,int type,int result)268 bool ReportManager::ReportRemoteCallback(sptr<ILocatorCallback>& locatorCallback, int type, int result)
269 {
270     switch (type) {
271         case ILocatorCallback::RECEIVE_LOCATION_STATUS_EVENT: {
272             locatorCallback->OnLocatingStatusChange(result);
273             break;
274         }
275         case ILocatorCallback::RECEIVE_ERROR_INFO_EVENT: {
276             locatorCallback->OnErrorReport(result);
277             break;
278         }
279         default:
280             return false;
281     }
282     return true;
283 }
284 
ResultCheck(const std::unique_ptr<Location> & location,const std::shared_ptr<Request> & request)285 bool ReportManager::ResultCheck(const std::unique_ptr<Location>& location,
286     const std::shared_ptr<Request>& request)
287 {
288     if (request == nullptr) {
289         return false;
290     }
291     if (location == nullptr) {
292         return false;
293     }
294     auto locatorAbility = LocatorAbility::GetInstance();
295     if (locatorAbility == nullptr) {
296         return false;
297     }
298     if (locatorAbility->IsProxyPid(request->GetPid())) {
299         LBSLOGE(REPORT_MANAGER, "pid:%{public}d is proxy by freeze, no need to report", request->GetPid());
300         return false;
301     }
302     int permissionLevel = PermissionManager::GetPermissionLevel(request->GetTokenId(), request->GetFirstTokenId());
303     if (request->GetLastLocation() == nullptr || request->GetRequestConfig() == nullptr) {
304         return true;
305     }
306     float maxAcc = request->GetRequestConfig()->GetMaxAccuracy();
307     LBSLOGD(REPORT_MANAGER, "acc ResultCheck :  %{public}f - %{public}f", maxAcc, location->GetAccuracy());
308     if ((permissionLevel == PERMISSION_ACCURATE) &&
309         (maxAcc > 0) && (location->GetAccuracy() > maxAcc)) {
310         LBSLOGE(REPORT_MANAGER, "accuracy check fail, do not report location");
311         return false;
312     }
313     if (CommonUtils::DoubleEqual(request->GetLastLocation()->GetLatitude(), MIN_LATITUDE - 1) ||
314         request->GetLastLocation()->GetIsFromMock() != location->GetIsFromMock()) {
315         LBSLOGD(REPORT_MANAGER, "no valid cache location, no need to check");
316         return true;
317     }
318     int minTime = request->GetRequestConfig()->GetTimeInterval();
319     long deltaMs = (location->GetTimeSinceBoot() - request->GetLastLocation()->GetTimeSinceBoot()) / NANOS_PER_MILLI;
320     if (deltaMs < (minTime * MILLI_PER_SEC - MAX_SA_SCHEDULING_JITTER_MS)) {
321         LBSLOGE(REPORT_MANAGER,
322             "%{public}d timeInterval check fail, do not report location, current deltaMs = %{public}ld",
323             request->GetTokenId(), deltaMs);
324         return false;
325     }
326 
327     double distanceInterval = request->GetRequestConfig()->GetDistanceInterval();
328     double deltaDis = CommonUtils::CalDistance(location->GetLatitude(), location->GetLongitude(),
329         request->GetLastLocation()->GetLatitude(), request->GetLastLocation()->GetLongitude());
330     if (deltaDis - distanceInterval < 0) {
331         LBSLOGE(REPORT_MANAGER, "%{public}d distanceInterval check fail, do not report location",
332             request->GetTokenId());
333         return false;
334     }
335     return true;
336 }
337 
UpdateCacheLocation(const std::unique_ptr<Location> & location,std::string abilityName)338 void ReportManager::UpdateCacheLocation(const std::unique_ptr<Location>& location, std::string abilityName)
339 {
340     if (abilityName == GNSS_ABILITY) {
341         if (HookUtils::CheckGnssLocationValidity(location)) {
342             cacheGnssLocation_ = *location;
343             UpdateLastLocation(location);
344         }
345     } else if (abilityName == NETWORK_ABILITY &&
346         location->GetLocationSourceType() != LocationSourceType::INDOOR_TYPE) {
347         cacheNlpLocation_ = *location;
348         UpdateLastLocation(location);
349     } else {
350         UpdateLastLocation(location);
351     }
352 }
353 
UpdateLastLocation(const std::unique_ptr<Location> & location)354 void ReportManager::UpdateLastLocation(const std::unique_ptr<Location>& location)
355 {
356     int currentUserId = 0;
357     if (CommonUtils::GetCurrentUserId(currentUserId)) {
358         std::unique_lock<std::mutex> lock(lastLocationMutex_);
359         lastLocationsMap_[currentUserId] = std::make_shared<Location>(*location);
360     }
361 }
362 
GetLastLocation()363 std::unique_ptr<Location> ReportManager::GetLastLocation()
364 {
365     int currentUserId = 0;
366     if (CommonUtils::GetCurrentUserId(currentUserId)) {
367         std::unique_lock<std::mutex> lock(lastLocationMutex_);
368         auto iter = lastLocationsMap_.find(currentUserId);
369         if (iter == lastLocationsMap_.end()) {
370             return nullptr;
371         }
372         std::unique_ptr<Location> lastLocation = std::make_unique<Location>(*(iter->second));
373         if (CommonUtils::DoubleEqual(lastLocation->GetLatitude(), MIN_LATITUDE - 1)) {
374             return nullptr;
375         }
376         return lastLocation;
377     }
378     return nullptr;
379 }
380 
GetCacheLocation(const std::shared_ptr<Request> & request)381 std::unique_ptr<Location> ReportManager::GetCacheLocation(const std::shared_ptr<Request>& request)
382 {
383     int64_t curTime = CommonUtils::GetCurrentTimeStamp();
384     std::unique_ptr<Location> cacheLocation = nullptr;
385     std::string packageName = request->GetPackageName();
386     int cachedTime = 0;
387     if (HookUtils::ExecuteHookWhenCheckAppForCacheTime(packageName)) {
388         cachedTime = LONG_CACHE_DURATION;
389     } else {
390         cachedTime = CACHED_TIME;
391     }
392     if (!CommonUtils::DoubleEqual(cacheGnssLocation_.GetLatitude(), MIN_LATITUDE - 1) &&
393         (curTime - cacheGnssLocation_.GetTimeStamp() / MILLI_PER_SEC) <= cachedTime) {
394         cacheLocation = std::make_unique<Location>(cacheGnssLocation_);
395     } else if (!CommonUtils::DoubleEqual(cacheNlpLocation_.GetLatitude(), MIN_LATITUDE - 1) &&
396         (curTime - cacheNlpLocation_.GetTimeStamp() / MILLI_PER_SEC) <= cachedTime) {
397         cacheLocation = std::make_unique<Location>(cacheNlpLocation_);
398     }
399     std::unique_ptr<Location> finalLocation = GetPermittedLocation(request, cacheLocation);
400     if (!ResultCheck(finalLocation, request)) {
401         return nullptr;
402     }
403     UpdateLocationByRequest(request->GetTokenId(), request->GetTokenIdEx(), finalLocation);
404     return finalLocation;
405 }
406 
UpdateRandom()407 void ReportManager::UpdateRandom()
408 {
409     auto locatorAbility = LocatorAbility::GetInstance();
410     if (locatorAbility == nullptr) {
411         return;
412     }
413     int num = locatorAbility->GetActiveRequestNum();
414     if (num > 0) {
415         LBSLOGD(REPORT_MANAGER, "Exists %{public}d active request, cannot refresh offset", num);
416         return;
417     }
418     struct timespec now;
419     clock_gettime(CLOCK_REALTIME, &now);
420     if (abs(now.tv_sec - lastUpdateTime_.tv_sec) > LONG_TIME_INTERVAL) {
421         offsetRandom_ = CommonUtils::DoubleRandom(0, 1);
422     }
423 }
424 
ApproximatelyLocation(const std::unique_ptr<Location> & location)425 std::unique_ptr<Location> ReportManager::ApproximatelyLocation(const std::unique_ptr<Location>& location)
426 {
427     std::unique_ptr<Location> coarseLocation = std::make_unique<Location>(*location);
428     double startLat = coarseLocation->GetLatitude();
429     double startLon = coarseLocation->GetLongitude();
430     double brg = offsetRandom_ * DIS_FROMLL_PARAMETER * M_PI; // 2PI
431     double dist = offsetRandom_ * (MAXIMUM_FUZZY_LOCATION_DISTANCE -
432         MINIMUM_FUZZY_LOCATION_DISTANCE) + MINIMUM_FUZZY_LOCATION_DISTANCE;
433     double perlat = (DIS_FROMLL_PARAMETER * M_PI * EARTH_RADIUS) / DEGREE_DOUBLE_PI; // the radian value of per degree
434 
435     double lat = startLat + (dist * sin(brg)) / perlat;
436     double lon;
437     if (cos(brg) < 0) {
438         lon = startLon - (dist * DEGREE_DOUBLE_PI) / (DIS_FROMLL_PARAMETER * M_PI * EARTH_RADIUS);
439     } else {
440         lon = startLon + (dist * DEGREE_DOUBLE_PI) / (DIS_FROMLL_PARAMETER * M_PI * EARTH_RADIUS);
441     }
442     if (lat < -MAX_LATITUDE) {
443         lat = -MAX_LATITUDE;
444     } else if (lat > MAX_LATITUDE) {
445         lat = MAX_LATITUDE;
446     } else {
447         lat = std::round(lat * std::pow(10, 8)) / std::pow(10, 8); // 8 decimal
448     }
449     if (lon < -MAX_LONGITUDE) {
450         lon = -MAX_LONGITUDE;
451     } else if (lon > MAX_LONGITUDE) {
452         lon = MAX_LONGITUDE;
453     } else {
454         lon = std::round(lon * std::pow(10, 8)) / std::pow(10, 8); // 8 decimal
455     }
456     coarseLocation->SetLatitude(lat);
457     coarseLocation->SetLongitude(lon);
458     coarseLocation->SetAccuracy(DEFAULT_APPROXIMATELY_ACCURACY); // approximately location acc
459     std::vector<std::string> emptyAdds;
460     coarseLocation->SetAdditions(emptyAdds, false);
461     coarseLocation->SetAdditionSize(0);
462     return coarseLocation;
463 }
464 
IsRequestFuse(const std::shared_ptr<Request> & request)465 bool ReportManager::IsRequestFuse(const std::shared_ptr<Request>& request)
466 {
467     if (request == nullptr || request->GetRequestConfig() == nullptr) {
468         return false;
469     }
470     if ((request->GetRequestConfig()->GetScenario() == SCENE_UNSET &&
471         request->GetRequestConfig()->GetPriority() == PRIORITY_LOW_POWER) ||
472         request->GetRequestConfig()->GetScenario() == SCENE_NO_POWER ||
473         request->GetRequestConfig()->GetScenario() == SCENE_DAILY_LIFE_SERVICE ||
474         request->GetRequestConfig()->GetScenario() == LOCATION_SCENE_DAILY_LIFE_SERVICE ||
475         request->GetRequestConfig()->GetScenario() == LOCATION_SCENE_LOW_POWER_CONSUMPTION ||
476         request->GetRequestConfig()->GetScenario() == LOCATION_SCENE_NO_POWER_CONSUMPTION) {
477         return false;
478     }
479     return true;
480 }
481 
WriteNetWorkReportEvent(std::string abilityName,const std::shared_ptr<Request> & request,const std::unique_ptr<Location> & location)482 void ReportManager::WriteNetWorkReportEvent(std::string abilityName, const std::shared_ptr<Request>& request,
483     const std::unique_ptr<Location>& location)
484 {
485     if (abilityName == NETWORK_ABILITY && request != nullptr) {
486         WriteLocationInnerEvent(RECEIVE_NETWORK_LOCATION, {
487             "PackageName", request->GetPackageName(),
488             "abilityName", abilityName,
489             "requestAddress", request->GetUuid(),
490             "latitude", std::to_string(location->GetLatitude()),
491             "longitude", std::to_string(location->GetLongitude()),
492             "accuracy", std::to_string(location->GetAccuracy())
493         });
494     }
495 }
496 
IsAppBackground(std::string bundleName,uint32_t tokenId,uint64_t tokenIdEx,pid_t uid,pid_t pid)497 bool ReportManager::IsAppBackground(std::string bundleName, uint32_t tokenId, uint64_t tokenIdEx, pid_t uid, pid_t pid)
498 {
499     auto locatorBackgroundProxy = LocatorBackgroundProxy::GetInstance();
500     if (locatorBackgroundProxy == nullptr) {
501         return false;
502     }
503     if (!locatorBackgroundProxy->IsAppBackground(bundleName)) {
504         return false;
505     }
506     if (locatorBackgroundProxy->IsAppHasFormVisible(tokenId, tokenIdEx)) {
507         return false;
508     }
509     if (locatorBackgroundProxy->IsAppInLocationContinuousTasks(uid, pid)) {
510         return false;
511     }
512     return true;
513 }
514 
IsCacheGnssLocationValid()515 bool ReportManager::IsCacheGnssLocationValid()
516 {
517     int64_t curTime = CommonUtils::GetCurrentTimeStamp();
518     if (!CommonUtils::DoubleEqual(cacheGnssLocation_.GetLatitude(), MIN_LATITUDE - 1) &&
519         (curTime - cacheGnssLocation_.GetTimeStamp() / MILLI_PER_SEC) <= CACHED_TIME) {
520         return true;
521     }
522     return false;
523 }
524 } // namespace OHOS
525 } // namespace Location
526