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 "gnss_interface_impl.h"
17 
18 #include <hdf_base.h>
19 #include <hdf_log.h>
20 #include <iproxy_broker.h>
21 #include <mutex>
22 #include <unordered_map>
23 
24 #include "idevmgr_hdi.h"
25 
26 #include "location_vendor_interface.h"
27 #include "location_vendor_lib.h"
28 #include "string_utils.h"
29 
30 namespace OHOS {
31 namespace HDI {
32 namespace Location {
33 namespace Gnss {
34 namespace V2_0 {
35 namespace {
36 using LocationCallBackMap = std::unordered_map<IRemoteObject*, sptr<IGnssCallback>>;
37 #ifndef EMULATOR_ENABLED
38 using GnssMeasurementCallbackMap = std::unordered_map<IRemoteObject*, sptr<IGnssMeasurementCallback>>;
39 #endif
40 using GnssDeathRecipientMap = std::unordered_map<IRemoteObject*, sptr<IRemoteObject::DeathRecipient>>;
41 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
42 LocationCallBackMap g_locationCallBackMap;
43 #ifndef EMULATOR_ENABLED
44 GnssMeasurementCallbackMap g_gnssMeasurementCallbackMap;
45 #endif
46 GnssDeathRecipientMap g_gnssCallBackDeathRecipientMap;
47 GnssConfigParameter g_configPara;
48 std::mutex g_mutex;
49 std::mutex g_deathMutex;
50 } // namespace
51 
GnssInterfaceImplGetInstance(void)52 extern "C" IGnssInterface* GnssInterfaceImplGetInstance(void)
53 {
54     return new (std::nothrow) GnssInterfaceImpl();
55 }
56 
NiNotifyCallback(OHOS::HDI::Location::GnssNiNotificationRequest *notification)57 static void NiNotifyCallback(OHOS::HDI::Location::GnssNiNotificationRequest *notification)
58 {
59     if (notification == nullptr) {
60         HDF_LOGE("%{public}s:niNotificationRequest is nullptr.", __func__);
61         return;
62     }
63     HDF_LOGI("%{public}s:NiNotifyCb.", __func__);
64     std::unique_lock<std::mutex> lock(g_mutex);
65     GnssNiNotificationRequest niNotification;
66     niNotification.gnssNiNotificationId = notification->gnssNiNotificationId;
67     niNotification.gnssNiRequestCategory = GnssNiRequestCategory(notification->gnssNiRequestCategory);
68     niNotification.notificationCategory = notification->notificationCategory;
69     niNotification.requestTimeout = notification->requestTimeout;
70     niNotification.defaultResponseCmd = notification->defaultResponseCmd;
71     niNotification.supplicantInfo = notification->supplicantInfo;
72     niNotification.notificationText = notification->notificationText;
73     niNotification.supplicantInfoEncoding = GnssNiRequestEncodingFormat(notification->supplicantInfoEncoding);
74     niNotification.notificationTextEncoding = GnssNiRequestEncodingFormat(notification->notificationTextEncoding);
75 
76     HDF_LOGI("reportNiNotification: notificationId %{public}u, niType %{public}d, notifyType %{public}d, timeout "
77         "%{public}d, defaultRespone %{private}d",
78         niNotification.gnssNiNotificationId,
79         niNotification.gnssNiRequestCategory,
80         niNotification.notificationCategory,
81         niNotification.requestTimeout,
82         niNotification.defaultResponseCmd);
83 
84     for (const auto& iter : g_locationCallBackMap) {
85         auto& callback = iter.second;
86         if (callback != nullptr) {
87             callback->ReportGnssNiNotification(niNotification);
88         }
89     }
90     HDF_LOGI("%{public}s:NiNotifyCallback.", __func__);
91 }
92 
LocationUpdate(GnssLocation* location)93 static void LocationUpdate(GnssLocation* location)
94 {
95     if (location == nullptr) {
96         HDF_LOGE("%{public}s:location is nullptr.", __func__);
97         return;
98     }
99     HDF_LOGI("%{public}s:LocationUpdate.", __func__);
100     std::unique_lock<std::mutex> lock(g_mutex);
101     LocationInfo locationNew;
102     locationNew.fieldValidity = location->fieldValidity;
103     locationNew.latitude = location->latitude;
104     locationNew.longitude = location->longitude;
105     locationNew.altitude = location->altitude;
106     locationNew.horizontalAccuracy = location->horizontalAccuracy;
107     locationNew.speed = location->speed;
108     locationNew.bearing = location->bearing;
109     locationNew.verticalAccuracy = location->verticalAccuracy;
110     locationNew.speedAccuracy = location->speedAccuracy;
111     locationNew.bearingAccuracy = location->bearingAccuracy;
112     locationNew.timeForFix = location->timeForFix;
113     locationNew.timeSinceBoot = location->timeSinceBoot;
114     locationNew.timeUncertainty = location->timeUncertainty;
115     for (const auto& iter : g_locationCallBackMap) {
116         auto& callback = iter.second;
117         if (callback != nullptr) {
118             callback->ReportLocation(locationNew);
119         }
120     }
121 }
122 
123 #ifndef EMULATOR_ENABLED
SetGnssClock(OHOS::HDI::Location::Gnss::V2_0::GnssMeasurementInfo* gnssMeasurementInfoNew, OHOS::HDI::Location::GnssMeasurementInfo* gnssMeasurementInfo)124 static void SetGnssClock(OHOS::HDI::Location::Gnss::V2_0::GnssMeasurementInfo* gnssMeasurementInfoNew,
125     OHOS::HDI::Location::GnssMeasurementInfo* gnssMeasurementInfo)
126 {
127     gnssMeasurementInfoNew->gnssClock.fieldValidFlags = gnssMeasurementInfo->gnssClock.fieldValidFlags;
128     gnssMeasurementInfoNew->gnssClock.leapSecond = gnssMeasurementInfo->gnssClock.leapSecond;
129     gnssMeasurementInfoNew->gnssClock.receiverClockTime = gnssMeasurementInfo->gnssClock.receiverClockTime;
130     gnssMeasurementInfoNew->gnssClock.timeUncertainty = gnssMeasurementInfo->gnssClock.timeUncertainty;
131     gnssMeasurementInfoNew->gnssClock.rcvClockFullBias = gnssMeasurementInfo->gnssClock.rcvClockFullBias;
132     gnssMeasurementInfoNew->gnssClock.rcvClockSubBias = gnssMeasurementInfo->gnssClock.rcvClockSubBias;
133     gnssMeasurementInfoNew->gnssClock.biasUncertainty = gnssMeasurementInfo->gnssClock.biasUncertainty;
134     gnssMeasurementInfoNew->gnssClock.clockDrift = gnssMeasurementInfo->gnssClock.clockDrift;
135     gnssMeasurementInfoNew->gnssClock.clockDriftUncertainty = gnssMeasurementInfo->gnssClock.clockDriftUncertainty;
136     gnssMeasurementInfoNew->gnssClock.clockInterruptCnt = gnssMeasurementInfo->gnssClock.clockInterruptCnt;
137     gnssMeasurementInfoNew->gnssClock.clockJumpThreshold = gnssMeasurementInfo->gnssClock.clockJumpThreshold;
138     gnssMeasurementInfoNew->gnssClock.clockHWFreBiasIndicator = gnssMeasurementInfo->gnssClock.clockHWFreBiasIndicator;
139     gnssMeasurementInfoNew->gnssClock.clockHWFreDriftIndicator =
140         gnssMeasurementInfo->gnssClock.clockHWFreDriftIndicator;
141 }
142 
GnssMeasurementUpdate(OHOS::HDI::Location::GnssMeasurementInfo* gnssMeasurementInfo)143 static void GnssMeasurementUpdate(OHOS::HDI::Location::GnssMeasurementInfo* gnssMeasurementInfo)
144 {
145     if (gnssMeasurementInfo == nullptr) {
146         HDF_LOGE("%{public}s:gnssMeasurementInfo is nullptr.", __func__);
147         return;
148     }
149     std::unique_lock<std::mutex> lock(g_mutex);
150     OHOS::HDI::Location::Gnss::V2_0::GnssMeasurementInfo gnssMeasurementInfoNew;
151     SetGnssClock(&gnssMeasurementInfoNew, gnssMeasurementInfo);
152     gnssMeasurementInfoNew.elapsedRealtime = static_cast<long>(gnssMeasurementInfo->elapsedRealtime);
153     gnssMeasurementInfoNew.uncertainty = static_cast<long>(gnssMeasurementInfo->uncertainty);
154     gnssMeasurementInfoNew.measurementCount = static_cast<int>(gnssMeasurementInfo->measurementCount);
155 
156     std::vector<OHOS::HDI::Location::Gnss::V2_0::GnssMeasurement> gnssMeasurements;
157     for (OHOS::HDI::Location::GnssMeasurement infoItem : gnssMeasurementInfo->measurements) {
158         OHOS::HDI::Location::Gnss::V2_0::GnssMeasurement gnssMeasurement;
159         gnssMeasurement.fieldValidflags = infoItem.fieldValidflags;
160         gnssMeasurement.satelliteId = infoItem.satelliteId;
161         gnssMeasurement.constellationCategory = infoItem.constellationCategory;
162         gnssMeasurement.timeOffset = infoItem.timeOffset;
163         gnssMeasurement.syncState = infoItem.syncState;
164         gnssMeasurement.receivedSatelliteTime = infoItem.receivedSatelliteTime;
165         gnssMeasurement.receivedSatelliteTimeUncertainty = infoItem.receivedSatelliteTimeUncertainty;
166         gnssMeasurement.cn0 = infoItem.cn0;
167         gnssMeasurement.pseudorangeRate = infoItem.pseudorangeRate;
168         gnssMeasurement.pseudorangeRateUncertainty = infoItem.pseudorangeRateUncertainty;
169         gnssMeasurement.accumulatedDeltaRangeFlag = infoItem.accumulatedDeltaRangeFlag;
170         gnssMeasurement.accumulatedDeltaRange = infoItem.accumulatedDeltaRange;
171         gnssMeasurement.accumulatedDeltaRangeUncertainty = infoItem.accumulatedDeltaRangeUncertainty;
172         gnssMeasurement.carrierFrequency = infoItem.carrierFrequency;
173         gnssMeasurement.carrierCyclesCount = infoItem.carrierCyclesCount;
174         gnssMeasurement.carrierPhase = infoItem.carrierPhase;
175         gnssMeasurement.carrierPhaseUncertainty = infoItem.carrierPhaseUncertainty;
176         gnssMeasurement.multipathFlag = infoItem.multipathFlag;
177         gnssMeasurement.agcGain = infoItem.agcGain;
178         gnssMeasurement.codeCategory = infoItem.codeCategory;
179         gnssMeasurement.ionoCorrect = infoItem.ionoCorrect;
180         gnssMeasurement.tropCorrect = infoItem.tropCorrect;
181         gnssMeasurement.satelliteClockBias = infoItem.satelliteClockBias;
182         gnssMeasurement.satelliteClockDriftBias = infoItem.satelliteClockDriftBias;
183         gnssMeasurements.push_back(gnssMeasurement);
184     }
185     gnssMeasurementInfoNew.measurements = gnssMeasurements;
186     for (const auto& iter : g_gnssMeasurementCallbackMap) {
187         auto& callback = iter.second;
188         if (callback != nullptr) {
189             callback->ReportGnssMeasurementInfo(gnssMeasurementInfoNew);
190         }
191     }
192 }
193 #endif
194 
195 __attribute__((no_sanitize("cfi")))
GnssWorkingStatusUpdate(uint16_t* status)196 static void GnssWorkingStatusUpdate(uint16_t* status)
197 {
198     if (status == nullptr) {
199         HDF_LOGE("%{public}s:param is nullptr.", __func__);
200         return;
201     }
202     std::unique_lock<std::mutex> lock(g_mutex);
203     GnssWorkingStatus gnssStatus = static_cast<GnssWorkingStatus>(*status);
204     for (const auto& iter : g_locationCallBackMap) {
205         auto& callback = iter.second;
206         if (callback != nullptr) {
207             callback->ReportGnssWorkingStatus(gnssStatus);
208         }
209     }
210 }
211 
212 __attribute__((no_sanitize("cfi")))
SvStatusCallback(GnssSatelliteStatus* svInfo)213 static void SvStatusCallback(GnssSatelliteStatus* svInfo)
214 {
215     if (svInfo == nullptr) {
216         HDF_LOGE("%{public}s:sv_info is null.", __func__);
217         return;
218     }
219     std::unique_lock<std::mutex> lock(g_mutex);
220     SatelliteStatusInfo svStatus;
221     svStatus.satellitesNumber = svInfo->satellitesNum;
222     for (unsigned int i = 0; i < svInfo->satellitesNum; i++) {
223         svStatus.satelliteIds.push_back(svInfo->satellitesList[i].satelliteId);
224         svStatus.constellation.push_back(
225             static_cast<ConstellationCategory>(svInfo->satellitesList[i].constellationCategory));
226         svStatus.elevation.push_back(svInfo->satellitesList[i].elevation);
227         svStatus.azimuths.push_back(svInfo->satellitesList[i].azimuth);
228         svStatus.carrierFrequencies.push_back(svInfo->satellitesList[i].carrierFrequency);
229         svStatus.carrierToNoiseDensitys.push_back(svInfo->satellitesList[i].cn0);
230         svStatus.additionalInfo.push_back(svInfo->satellitesList[i].satelliteAdditionalInfo);
231     }
232     for (const auto& iter : g_locationCallBackMap) {
233         auto& callback = iter.second;
234         if (callback != nullptr) {
235             callback->ReportSatelliteStatusInfo(svStatus);
236         }
237     }
238 }
239 
NmeaCallback(int64_t timestamp, const char* nmea, int length)240 static void NmeaCallback(int64_t timestamp, const char* nmea, int length)
241 {
242     if (nmea == nullptr) {
243         HDF_LOGE("%{public}s:nmea is nullptr.", __func__);
244         return;
245     }
246     std::unique_lock<std::mutex> lock(g_mutex);
247     for (const auto& iter : g_locationCallBackMap) {
248         auto& callback = iter.second;
249         if (callback != nullptr) {
250             callback->ReportNmea(timestamp, nmea, length);
251         }
252     }
253 }
254 
GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces* device)255 static void GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces* device)
256 {
257     if (device == nullptr) {
258         return;
259     }
260     device->size = sizeof(GnssCallbackStruct);
261     device->locationUpdate = LocationUpdate;
262     device->gnssWorkingStatusUpdate = GnssWorkingStatusUpdate;
263     device->satelliteStatusUpdate = SvStatusCallback;
264     device->nmeaUpdate = NmeaCallback;
265     device->capabilitiesUpdate = nullptr;
266     device->requestRefInfo = nullptr;
267     device->requestExtendedEphemeris = nullptr;
268 }
269 
GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces* device)270 static void GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces* device)
271 {
272     if (device == nullptr) {
273         return;
274     }
275     device->size = 0;
276     device->cachedLocationUpdate = nullptr;
277 }
278 
GetGnssCallbackMethods(GnssCallbackStruct* device)279 static void GetGnssCallbackMethods(GnssCallbackStruct* device)
280 {
281     if (device == nullptr) {
282         return;
283     }
284     device->size = sizeof(GnssCallbackStruct);
285     static GnssBasicCallbackIfaces basicCallback;
286     GetGnssBasicCallbackMethods(&basicCallback);
287     device->gnssCallback = basicCallback;
288     static GnssCacheCallbackIfaces cacheCallback;
289     GetGnssCacheCallbackMethods(&cacheCallback);
290     device->gnssCacheCallback = cacheCallback;
291 }
292 
293 #ifndef EMULATOR_ENABLED
GetGnssMeasurementCallbackMethods(GnssMeasurementCallbackIfaces* device)294 static void GetGnssMeasurementCallbackMethods(GnssMeasurementCallbackIfaces* device)
295 {
296     if (device == nullptr) {
297         return;
298     }
299     device->size = sizeof(GnssMeasurementCallbackIfaces);
300     device->gnssMeasurementUpdate = GnssMeasurementUpdate;
301 }
302 #endif
303 
GnssInterfaceImpl()304 GnssInterfaceImpl::GnssInterfaceImpl()
305 {
306 }
307 
~GnssInterfaceImpl()308 GnssInterfaceImpl::~GnssInterfaceImpl()
309 {
310     ResetGnssDeathRecipient();
311 }
312 
SetGnssConfigPara(const GnssConfigPara& para)313 int32_t GnssInterfaceImpl::SetGnssConfigPara(const GnssConfigPara& para)
314 {
315     HDF_LOGI("%{public}s.", __func__);
316     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
317     if (gnssInterface == nullptr) {
318         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
319         return HDF_ERR_INVALID_PARAM;
320     }
321     g_configPara.startCategory = static_cast<uint32_t>(GnssStartCategory::GNSS_START_CATEGORY_NORMAL);
322     g_configPara.u.gnssBasicConfig.gnssMode = para.gnssBasic.gnssMode;
323     g_configPara.u.gnssBasicConfig.size = sizeof(GnssBasicConfigPara);
324     int ret = gnssInterface->setGnssConfigPara(&g_configPara);
325     HDF_LOGI("%{public}s, ret=%{public}d", __func__, ret);
326     return ret;
327 }
328 
EnableGnss(const sptr<IGnssCallback>& callbackObj)329 int32_t GnssInterfaceImpl::EnableGnss(const sptr<IGnssCallback>& callbackObj)
330 {
331     HDF_LOGI("%{public}s.", __func__);
332     if (callbackObj == nullptr) {
333         HDF_LOGE("%{public}s:invalid callbackObj", __func__);
334         return HDF_ERR_INVALID_PARAM;
335     }
336     std::unique_lock<std::mutex> lock(g_mutex);
337     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
338     if (remote == nullptr) {
339         HDF_LOGE("%{public}s:invalid remote", __func__);
340         return HDF_ERR_INVALID_PARAM;
341     }
342     static GnssCallbackStruct gnssCallback;
343     GetGnssCallbackMethods(&gnssCallback);
344     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
345     if (gnssInterface == nullptr) {
346         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
347         return HDF_ERR_INVALID_PARAM;
348     }
349     int ret = gnssInterface->enableGnss(&gnssCallback);
350     if (ret != HDF_SUCCESS) {
351         HDF_LOGE("enableGnss failed.");
352         return HDF_FAILURE;
353     }
354     static GnssNetInitiatedCallbacks niCallback;
355     niCallback.reportNiNotification = NiNotifyCallback;
356     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
357     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
358         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
359     if (niInterface != nullptr) {
360         niInterface->setCallback(&niCallback);
361     } else {
362         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
363     }
364 
365     if (g_locationCallBackMap.size() > 0) {
366         for (const auto& iter : g_locationCallBackMap) {
367             const auto& callback = iter.second;
368             if (callback != nullptr) {
369                 RemoveGnssDeathRecipient(callback);
370             }
371         }
372         g_locationCallBackMap.clear();
373     }
374     AddGnssDeathRecipient(callbackObj);
375     g_locationCallBackMap[remote.GetRefPtr()] = callbackObj;
376     return ret;
377 }
378 
DisableGnss()379 int32_t GnssInterfaceImpl::DisableGnss()
380 {
381     HDF_LOGI("%{public}s.", __func__);
382     std::unique_lock<std::mutex> lock(g_mutex);
383     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
384     if (gnssInterface == nullptr) {
385         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
386         return HDF_ERR_INVALID_PARAM;
387     }
388     int ret = gnssInterface->disableGnss();
389     g_locationCallBackMap.clear();
390     return ret;
391 }
392 
StartGnss(GnssStartType type)393 int32_t GnssInterfaceImpl::StartGnss(GnssStartType type)
394 {
395     HDF_LOGI("%{public}s.", __func__);
396     int startType = int(type);
397     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
398     if (gnssInterface == nullptr) {
399         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
400         return HDF_ERR_INVALID_PARAM;
401     }
402     int ret = gnssInterface->startGnss(startType);
403     return ret;
404 }
405 
StopGnss(GnssStartType type)406 int32_t GnssInterfaceImpl::StopGnss(GnssStartType type)
407 {
408     HDF_LOGI("%{public}s.", __func__);
409     int startType = static_cast<int>(type);
410     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
411     if (gnssInterface == nullptr) {
412         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
413         return HDF_ERR_INVALID_PARAM;
414     }
415     int ret = gnssInterface->stopGnss(startType);
416     return ret;
417 }
418 
SetGnssReferenceInfo(const GnssRefInfo& refInfo)419 int32_t GnssInterfaceImpl::SetGnssReferenceInfo(const GnssRefInfo& refInfo)
420 {
421     HDF_LOGI("%{public}s.", __func__);
422     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
423     if (gnssInterface == nullptr) {
424         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
425         return HDF_ERR_INVALID_PARAM;
426     }
427     GnssReferenceInfo referenceInfo;
428     referenceInfo.category = refInfo.type;
429     switch (refInfo.type) {
430         case GNSS_REF_INFO_TIME:
431             referenceInfo.u.time.size = sizeof(GnssRefTime);
432             referenceInfo.u.time.time = refInfo.time.time;
433             referenceInfo.u.time.elapsedRealtime = refInfo.time.elapsedRealtime;
434             referenceInfo.u.time.uncertaintyOfTime = refInfo.time.uncertaintyOfTime;
435             referenceInfo.size = sizeof(GnssReferenceInfo);
436             return gnssInterface->injectsGnssReferenceInfo(referenceInfo.category, &referenceInfo);
437         case GNSS_REF_INFO_LOCATION:
438             referenceInfo.u.gnssLocation.size = sizeof(GnssLocation);
439             referenceInfo.u.gnssLocation.fieldValidity = refInfo.gnssLocation.fieldValidity;
440             referenceInfo.u.gnssLocation.latitude = refInfo.gnssLocation.latitude;
441             referenceInfo.u.gnssLocation.longitude = refInfo.gnssLocation.longitude;
442             referenceInfo.u.gnssLocation.altitude = refInfo.gnssLocation.altitude;
443             referenceInfo.u.gnssLocation.speed = refInfo.gnssLocation.speed;
444             referenceInfo.u.gnssLocation.bearing = refInfo.gnssLocation.bearing;
445             referenceInfo.u.gnssLocation.horizontalAccuracy = refInfo.gnssLocation.horizontalAccuracy;
446             referenceInfo.u.gnssLocation.verticalAccuracy = refInfo.gnssLocation.verticalAccuracy;
447             referenceInfo.u.gnssLocation.speedAccuracy = refInfo.gnssLocation.speedAccuracy;
448             referenceInfo.u.gnssLocation.bearingAccuracy = refInfo.gnssLocation.bearingAccuracy;
449             referenceInfo.u.gnssLocation.timeForFix = refInfo.gnssLocation.timeForFix;
450             referenceInfo.u.gnssLocation.timeSinceBoot = refInfo.gnssLocation.timeSinceBoot;
451             referenceInfo.u.gnssLocation.timeUncertainty = refInfo.gnssLocation.timeUncertainty;
452             referenceInfo.size = sizeof(GnssReferenceInfo);
453             return gnssInterface->injectsGnssReferenceInfo(referenceInfo.category, &referenceInfo);
454         default:
455             HDF_LOGI("%{public}s: do not support now", __func__);
456             return HDF_ERR_INVALID_PARAM;
457     }
458 }
459 
DeleteAuxiliaryData(unsigned short data)460 int32_t GnssInterfaceImpl::DeleteAuxiliaryData(unsigned short data)
461 {
462     HDF_LOGI("%{public}s.", __func__);
463     uint16_t flags = data;
464     HDF_LOGI("%{public}s, flag=%{public}d", __func__, flags);
465     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
466     if (gnssInterface == nullptr) {
467         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
468         return HDF_ERR_INVALID_PARAM;
469     }
470     gnssInterface->removeAuxiliaryData(flags);
471     return HDF_SUCCESS;
472 }
473 
SetPredictGnssData(const std::string& data)474 int32_t GnssInterfaceImpl::SetPredictGnssData(const std::string& data)
475 {
476     HDF_LOGI("%{public}s.", __func__);
477     return HDF_SUCCESS;
478 }
479 
GetCachedGnssLocationsSize(int32_t& size)480 int32_t GnssInterfaceImpl::GetCachedGnssLocationsSize(int32_t& size)
481 {
482     HDF_LOGI("%{public}s.", __func__);
483     return HDF_SUCCESS;
484 }
485 
GetCachedGnssLocations()486 int32_t GnssInterfaceImpl::GetCachedGnssLocations()
487 {
488     HDF_LOGI("%{public}s.", __func__);
489     return HDF_SUCCESS;
490 }
491 
AddGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)492 int32_t GnssInterfaceImpl::AddGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)
493 {
494     sptr<IRemoteObject::DeathRecipient> death(new (std::nothrow) GnssCallBackDeathRecipient(this));
495     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
496     bool result = remote->AddDeathRecipient(death);
497     if (!result) {
498         HDF_LOGE("%{public}s: GnssInterfaceImpl add deathRecipient fail", __func__);
499         return HDF_FAILURE;
500     }
501     std::unique_lock<std::mutex> lock(g_deathMutex);
502     g_gnssCallBackDeathRecipientMap[remote.GetRefPtr()] = death;
503     return HDF_SUCCESS;
504 }
505 
506 __attribute__((no_sanitize("cfi")))
RemoveGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)507 int32_t GnssInterfaceImpl::RemoveGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)
508 {
509     std::unique_lock<std::mutex> lock(g_deathMutex);
510     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
511     auto iter = g_gnssCallBackDeathRecipientMap.find(remote.GetRefPtr());
512     if (iter == g_gnssCallBackDeathRecipientMap.end()) {
513         HDF_LOGE("%{public}s: GnssInterfaceImpl can not find deathRecipient", __func__);
514         return HDF_FAILURE;
515     }
516     auto recipient = iter->second;
517     bool result = remote->RemoveDeathRecipient(recipient);
518     g_gnssCallBackDeathRecipientMap.erase(iter);
519     if (!result) {
520         HDF_LOGE("%{public}s: GnssInterfaceImpl remove deathRecipient fail", __func__);
521         return HDF_FAILURE;
522     }
523     return HDF_SUCCESS;
524 }
525 
SendNiUserResponse(int32_t gnssNiNotificationId, GnssNiResponseCmd userResponse)526 int32_t GnssInterfaceImpl::SendNiUserResponse(int32_t gnssNiNotificationId, GnssNiResponseCmd userResponse)
527 {
528     HDF_LOGI("%{public}s.", __func__);
529     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
530     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
531         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
532     if (niInterface == nullptr) {
533         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
534         return HDF_ERR_INVALID_PARAM;
535     }
536     niInterface->sendUserResponse(gnssNiNotificationId, static_cast<int32_t>(userResponse));
537     return HDF_SUCCESS;
538 }
539 
SendNetworkInitiatedMsg(const std::string& msg, int length)540 int32_t GnssInterfaceImpl::SendNetworkInitiatedMsg(const std::string& msg, int length)
541 {
542     HDF_LOGI("%{public}s.", __func__);
543     if (msg.empty()) {
544         HDF_LOGE("%{public}s msg is empty", __func__);
545         return HDF_FAILURE;
546     }
547     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
548     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
549         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
550     if (niInterface == nullptr) {
551         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
552         return HDF_ERR_INVALID_PARAM;
553     }
554     std::vector<uint8_t> data = StringUtils::HexToByteVector(msg);
555     HDF_LOGI("%{public}s. msg : %{public}s, length %{public}d, msg size %{public}d, data size %{public}d",
556         __func__, msg.c_str(), length, int(msg.size()), int(data.size()));
557 
558     niInterface->sendNetworkInitiatedMsg(data.data(), data.size());
559     return HDF_SUCCESS;
560 }
561 
EnableGnssMeasurement(const sptr<IGnssMeasurementCallback>& callbackObj)562 int32_t GnssInterfaceImpl::EnableGnssMeasurement(const sptr<IGnssMeasurementCallback>& callbackObj)
563 {
564 #ifndef EMULATOR_ENABLED
565     HDF_LOGI("%{public}s.", __func__);
566     if (callbackObj == nullptr) {
567         HDF_LOGE("%{public}s:invalid callbackObj", __func__);
568         return HDF_ERR_INVALID_PARAM;
569     }
570     std::unique_lock<std::mutex> lock(g_mutex);
571     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssMeasurementCallback>(callbackObj);
572     if (remote == nullptr) {
573         HDF_LOGE("%{public}s:invalid remote", __func__);
574         return HDF_ERR_INVALID_PARAM;
575     }
576 
577     static GnssMeasurementCallbackIfaces gnssMeasurementCallback;
578     GetGnssMeasurementCallbackMethods(&gnssMeasurementCallback);
579     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_MEASUREMENT_MODULE_INTERFACE);
580     auto gnssMeasurementInterface = static_cast<const GnssMeasurementInterface*>
581         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
582     if (gnssMeasurementInterface == nullptr) {
583         HDF_LOGE("%{public}s:GetModuleInterface return nullptr.", __func__);
584         return HDF_ERR_INVALID_PARAM;
585     }
586     bool result = gnssMeasurementInterface->enable(&gnssMeasurementCallback);
587     if (!result) {
588         HDF_LOGE("enableGnssMeasurement failed.");
589         return HDF_FAILURE;
590     }
591     if (g_gnssMeasurementCallbackMap.size() > 0) {
592         g_gnssMeasurementCallbackMap.clear();
593     }
594     g_gnssMeasurementCallbackMap[remote.GetRefPtr()] = callbackObj;
595     return HDF_SUCCESS;
596 #else
597     return HDF_SUCCESS;
598 #endif
599 }
600 
DisableGnssMeasurement()601 int32_t GnssInterfaceImpl::DisableGnssMeasurement()
602 {
603 #ifndef EMULATOR_ENABLED
604     HDF_LOGI("%{public}s.", __func__);
605     std::unique_lock<std::mutex> lock(g_mutex);
606     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_MEASUREMENT_MODULE_INTERFACE);
607     auto gnssMeasurementInterface = static_cast<const GnssMeasurementInterface*>
608         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
609     if (gnssMeasurementInterface == nullptr) {
610         HDF_LOGE("%{public}s:GnssMeasurementInterface return nullptr.", __func__);
611         return HDF_ERR_INVALID_PARAM;
612     }
613     gnssMeasurementInterface->disable();
614     g_gnssMeasurementCallbackMap.clear();
615 #endif
616     return HDF_SUCCESS;
617 }
618 
ResetGnssDeathRecipient()619 void GnssInterfaceImpl::ResetGnssDeathRecipient()
620 {
621     std::unique_lock<std::mutex> lock(g_mutex);
622     for (const auto& iter : g_locationCallBackMap) {
623         const auto& callback = iter.second;
624         if (callback != nullptr) {
625             RemoveGnssDeathRecipient(callback);
626         }
627     }
628 }
629 
ResetGnss()630 void GnssInterfaceImpl::ResetGnss()
631 {
632     HDF_LOGI("%{public}s called.", __func__);
633     ResetGnssDeathRecipient();
634     StopGnss(GNSS_START_TYPE_NORMAL);
635     DisableGnssMeasurement();
636 }
637 } // V2_0
638 } // Gnss
639 } // Location
640 } // HDI
641 } // OHOS
642