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 
GnssWorkingStatusUpdate(uint16_t * status)195 static void GnssWorkingStatusUpdate(uint16_t* status)
196 {
197     if (status == nullptr) {
198         HDF_LOGE("%{public}s:param is nullptr.", __func__);
199         return;
200     }
201     std::unique_lock<std::mutex> lock(g_mutex);
202     GnssWorkingStatus gnssStatus = static_cast<GnssWorkingStatus>(*status);
203     for (const auto& iter : g_locationCallBackMap) {
204         auto& callback = iter.second;
205         if (callback != nullptr) {
206             callback->ReportGnssWorkingStatus(gnssStatus);
207         }
208     }
209 }
210 
SvStatusCallback(GnssSatelliteStatus * svInfo)211 static void SvStatusCallback(GnssSatelliteStatus* svInfo)
212 {
213     if (svInfo == nullptr) {
214         HDF_LOGE("%{public}s:sv_info is null.", __func__);
215         return;
216     }
217     std::unique_lock<std::mutex> lock(g_mutex);
218     SatelliteStatusInfo svStatus;
219     svStatus.satellitesNumber = svInfo->satellitesNum;
220     for (unsigned int i = 0; i < svInfo->satellitesNum; i++) {
221         svStatus.satelliteIds.push_back(svInfo->satellitesList[i].satelliteId);
222         svStatus.constellation.push_back(
223             static_cast<ConstellationCategory>(svInfo->satellitesList[i].constellationCategory));
224         svStatus.elevation.push_back(svInfo->satellitesList[i].elevation);
225         svStatus.azimuths.push_back(svInfo->satellitesList[i].azimuth);
226         svStatus.carrierFrequencies.push_back(svInfo->satellitesList[i].carrierFrequency);
227         svStatus.carrierToNoiseDensitys.push_back(svInfo->satellitesList[i].cn0);
228         svStatus.additionalInfo.push_back(svInfo->satellitesList[i].satelliteAdditionalInfo);
229     }
230     for (const auto& iter : g_locationCallBackMap) {
231         auto& callback = iter.second;
232         if (callback != nullptr) {
233             callback->ReportSatelliteStatusInfo(svStatus);
234         }
235     }
236 }
237 
NmeaCallback(int64_t timestamp,const char * nmea,int length)238 static void NmeaCallback(int64_t timestamp, const char* nmea, int length)
239 {
240     if (nmea == nullptr) {
241         HDF_LOGE("%{public}s:nmea is nullptr.", __func__);
242         return;
243     }
244     std::unique_lock<std::mutex> lock(g_mutex);
245     for (const auto& iter : g_locationCallBackMap) {
246         auto& callback = iter.second;
247         if (callback != nullptr) {
248             callback->ReportNmea(timestamp, nmea, length);
249         }
250     }
251 }
252 
GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces * device)253 static void GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces* device)
254 {
255     if (device == nullptr) {
256         return;
257     }
258     device->size = sizeof(GnssCallbackStruct);
259     device->locationUpdate = LocationUpdate;
260     device->gnssWorkingStatusUpdate = GnssWorkingStatusUpdate;
261     device->satelliteStatusUpdate = SvStatusCallback;
262     device->nmeaUpdate = NmeaCallback;
263     device->capabilitiesUpdate = nullptr;
264     device->requestRefInfo = nullptr;
265     device->requestExtendedEphemeris = nullptr;
266 }
267 
GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces * device)268 static void GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces* device)
269 {
270     if (device == nullptr) {
271         return;
272     }
273     device->size = 0;
274     device->cachedLocationUpdate = nullptr;
275 }
276 
GetGnssCallbackMethods(GnssCallbackStruct * device)277 static void GetGnssCallbackMethods(GnssCallbackStruct* device)
278 {
279     if (device == nullptr) {
280         return;
281     }
282     device->size = sizeof(GnssCallbackStruct);
283     static GnssBasicCallbackIfaces basicCallback;
284     GetGnssBasicCallbackMethods(&basicCallback);
285     device->gnssCallback = basicCallback;
286     static GnssCacheCallbackIfaces cacheCallback;
287     GetGnssCacheCallbackMethods(&cacheCallback);
288     device->gnssCacheCallback = cacheCallback;
289 }
290 
291 #ifndef EMULATOR_ENABLED
GetGnssMeasurementCallbackMethods(GnssMeasurementCallbackIfaces * device)292 static void GetGnssMeasurementCallbackMethods(GnssMeasurementCallbackIfaces* device)
293 {
294     if (device == nullptr) {
295         return;
296     }
297     device->size = sizeof(GnssMeasurementCallbackIfaces);
298     device->gnssMeasurementUpdate = GnssMeasurementUpdate;
299 }
300 #endif
301 
GnssInterfaceImpl()302 GnssInterfaceImpl::GnssInterfaceImpl()
303 {
304 }
305 
~GnssInterfaceImpl()306 GnssInterfaceImpl::~GnssInterfaceImpl()
307 {
308     ResetGnssDeathRecipient();
309 }
310 
SetGnssConfigPara(const GnssConfigPara & para)311 int32_t GnssInterfaceImpl::SetGnssConfigPara(const GnssConfigPara& para)
312 {
313     HDF_LOGI("%{public}s.", __func__);
314     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
315     if (gnssInterface == nullptr) {
316         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
317         return HDF_ERR_INVALID_PARAM;
318     }
319     g_configPara.startCategory = static_cast<uint32_t>(GnssStartCategory::GNSS_START_CATEGORY_NORMAL);
320     g_configPara.u.gnssBasicConfig.gnssMode = para.gnssBasic.gnssMode;
321     g_configPara.u.gnssBasicConfig.size = sizeof(GnssBasicConfigPara);
322     int ret = gnssInterface->setGnssConfigPara(&g_configPara);
323     HDF_LOGI("%{public}s, ret=%{public}d", __func__, ret);
324     return ret;
325 }
326 
EnableGnss(const sptr<IGnssCallback> & callbackObj)327 int32_t GnssInterfaceImpl::EnableGnss(const sptr<IGnssCallback>& callbackObj)
328 {
329     HDF_LOGI("%{public}s.", __func__);
330     if (callbackObj == nullptr) {
331         HDF_LOGE("%{public}s:invalid callbackObj", __func__);
332         return HDF_ERR_INVALID_PARAM;
333     }
334     std::unique_lock<std::mutex> lock(g_mutex);
335     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
336     if (remote == nullptr) {
337         HDF_LOGE("%{public}s:invalid remote", __func__);
338         return HDF_ERR_INVALID_PARAM;
339     }
340     static GnssCallbackStruct gnssCallback;
341     GetGnssCallbackMethods(&gnssCallback);
342     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
343     if (gnssInterface == nullptr) {
344         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
345         return HDF_ERR_INVALID_PARAM;
346     }
347     int ret = gnssInterface->enableGnss(&gnssCallback);
348     if (ret != HDF_SUCCESS) {
349         HDF_LOGE("enableGnss failed.");
350         return HDF_FAILURE;
351     }
352     static GnssNetInitiatedCallbacks niCallback;
353     niCallback.reportNiNotification = NiNotifyCallback;
354     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
355     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
356         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
357     if (niInterface != nullptr) {
358         niInterface->setCallback(&niCallback);
359     } else {
360         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
361     }
362 
363     if (g_locationCallBackMap.size() > 0) {
364         for (const auto& iter : g_locationCallBackMap) {
365             const auto& callback = iter.second;
366             if (callback != nullptr) {
367                 RemoveGnssDeathRecipient(callback);
368             }
369         }
370         g_locationCallBackMap.clear();
371     }
372     AddGnssDeathRecipient(callbackObj);
373     g_locationCallBackMap[remote.GetRefPtr()] = callbackObj;
374     return ret;
375 }
376 
DisableGnss()377 int32_t GnssInterfaceImpl::DisableGnss()
378 {
379     HDF_LOGI("%{public}s.", __func__);
380     std::unique_lock<std::mutex> lock(g_mutex);
381     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
382     if (gnssInterface == nullptr) {
383         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
384         return HDF_ERR_INVALID_PARAM;
385     }
386     int ret = gnssInterface->disableGnss();
387     g_locationCallBackMap.clear();
388     return ret;
389 }
390 
StartGnss(GnssStartType type)391 int32_t GnssInterfaceImpl::StartGnss(GnssStartType type)
392 {
393     HDF_LOGI("%{public}s.", __func__);
394     int startType = int(type);
395     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
396     if (gnssInterface == nullptr) {
397         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
398         return HDF_ERR_INVALID_PARAM;
399     }
400     int ret = gnssInterface->startGnss(startType);
401     return ret;
402 }
403 
StopGnss(GnssStartType type)404 int32_t GnssInterfaceImpl::StopGnss(GnssStartType type)
405 {
406     HDF_LOGI("%{public}s.", __func__);
407     int startType = static_cast<int>(type);
408     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
409     if (gnssInterface == nullptr) {
410         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
411         return HDF_ERR_INVALID_PARAM;
412     }
413     int ret = gnssInterface->stopGnss(startType);
414     return ret;
415 }
416 
SetGnssReferenceInfo(const GnssRefInfo & refInfo)417 int32_t GnssInterfaceImpl::SetGnssReferenceInfo(const GnssRefInfo& refInfo)
418 {
419     HDF_LOGI("%{public}s.", __func__);
420     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
421     if (gnssInterface == nullptr) {
422         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
423         return HDF_ERR_INVALID_PARAM;
424     }
425     GnssReferenceInfo referenceInfo;
426     referenceInfo.category = refInfo.type;
427     switch (refInfo.type) {
428         case GNSS_REF_INFO_TIME:
429             referenceInfo.u.time.size = sizeof(GnssRefTime);
430             referenceInfo.u.time.time = refInfo.time.time;
431             referenceInfo.u.time.elapsedRealtime = refInfo.time.elapsedRealtime;
432             referenceInfo.u.time.uncertaintyOfTime = refInfo.time.uncertaintyOfTime;
433             referenceInfo.size = sizeof(GnssReferenceInfo);
434             return gnssInterface->injectsGnssReferenceInfo(referenceInfo.category, &referenceInfo);
435         case GNSS_REF_INFO_LOCATION:
436             referenceInfo.u.gnssLocation.size = sizeof(GnssLocation);
437             referenceInfo.u.gnssLocation.fieldValidity = refInfo.gnssLocation.fieldValidity;
438             referenceInfo.u.gnssLocation.latitude = refInfo.gnssLocation.latitude;
439             referenceInfo.u.gnssLocation.longitude = refInfo.gnssLocation.longitude;
440             referenceInfo.u.gnssLocation.altitude = refInfo.gnssLocation.altitude;
441             referenceInfo.u.gnssLocation.speed = refInfo.gnssLocation.speed;
442             referenceInfo.u.gnssLocation.bearing = refInfo.gnssLocation.bearing;
443             referenceInfo.u.gnssLocation.horizontalAccuracy = refInfo.gnssLocation.horizontalAccuracy;
444             referenceInfo.u.gnssLocation.verticalAccuracy = refInfo.gnssLocation.verticalAccuracy;
445             referenceInfo.u.gnssLocation.speedAccuracy = refInfo.gnssLocation.speedAccuracy;
446             referenceInfo.u.gnssLocation.bearingAccuracy = refInfo.gnssLocation.bearingAccuracy;
447             referenceInfo.u.gnssLocation.timeForFix = refInfo.gnssLocation.timeForFix;
448             referenceInfo.u.gnssLocation.timeSinceBoot = refInfo.gnssLocation.timeSinceBoot;
449             referenceInfo.u.gnssLocation.timeUncertainty = refInfo.gnssLocation.timeUncertainty;
450             referenceInfo.size = sizeof(GnssReferenceInfo);
451             return gnssInterface->injectsGnssReferenceInfo(referenceInfo.category, &referenceInfo);
452         default:
453             HDF_LOGI("%{public}s: do not support now", __func__);
454             return HDF_ERR_INVALID_PARAM;
455     }
456 }
457 
DeleteAuxiliaryData(unsigned short data)458 int32_t GnssInterfaceImpl::DeleteAuxiliaryData(unsigned short data)
459 {
460     HDF_LOGI("%{public}s.", __func__);
461     uint16_t flags = data;
462     HDF_LOGI("%{public}s, flag=%{public}d", __func__, flags);
463     auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
464     if (gnssInterface == nullptr) {
465         HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
466         return HDF_ERR_INVALID_PARAM;
467     }
468     gnssInterface->removeAuxiliaryData(flags);
469     return HDF_SUCCESS;
470 }
471 
SetPredictGnssData(const std::string & data)472 int32_t GnssInterfaceImpl::SetPredictGnssData(const std::string& data)
473 {
474     HDF_LOGI("%{public}s.", __func__);
475     return HDF_SUCCESS;
476 }
477 
GetCachedGnssLocationsSize(int32_t & size)478 int32_t GnssInterfaceImpl::GetCachedGnssLocationsSize(int32_t& size)
479 {
480     HDF_LOGI("%{public}s.", __func__);
481     return HDF_SUCCESS;
482 }
483 
GetCachedGnssLocations()484 int32_t GnssInterfaceImpl::GetCachedGnssLocations()
485 {
486     HDF_LOGI("%{public}s.", __func__);
487     return HDF_SUCCESS;
488 }
489 
AddGnssDeathRecipient(const sptr<IGnssCallback> & callbackObj)490 int32_t GnssInterfaceImpl::AddGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)
491 {
492     sptr<IRemoteObject::DeathRecipient> death(new (std::nothrow) GnssCallBackDeathRecipient(this));
493     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
494     bool result = remote->AddDeathRecipient(death);
495     if (!result) {
496         HDF_LOGE("%{public}s: GnssInterfaceImpl add deathRecipient fail", __func__);
497         return HDF_FAILURE;
498     }
499     std::unique_lock<std::mutex> lock(g_deathMutex);
500     g_gnssCallBackDeathRecipientMap[remote.GetRefPtr()] = death;
501     return HDF_SUCCESS;
502 }
503 
RemoveGnssDeathRecipient(const sptr<IGnssCallback> & callbackObj)504 int32_t GnssInterfaceImpl::RemoveGnssDeathRecipient(const sptr<IGnssCallback>& callbackObj)
505 {
506     std::unique_lock<std::mutex> lock(g_deathMutex);
507     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
508     auto iter = g_gnssCallBackDeathRecipientMap.find(remote.GetRefPtr());
509     if (iter == g_gnssCallBackDeathRecipientMap.end()) {
510         HDF_LOGE("%{public}s: GnssInterfaceImpl can not find deathRecipient", __func__);
511         return HDF_FAILURE;
512     }
513     auto recipient = iter->second;
514     bool result = remote->RemoveDeathRecipient(recipient);
515     g_gnssCallBackDeathRecipientMap.erase(iter);
516     if (!result) {
517         HDF_LOGE("%{public}s: GnssInterfaceImpl remove deathRecipient fail", __func__);
518         return HDF_FAILURE;
519     }
520     return HDF_SUCCESS;
521 }
522 
SendNiUserResponse(int32_t gnssNiNotificationId,GnssNiResponseCmd userResponse)523 int32_t GnssInterfaceImpl::SendNiUserResponse(int32_t gnssNiNotificationId, GnssNiResponseCmd userResponse)
524 {
525     HDF_LOGI("%{public}s.", __func__);
526     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
527     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
528         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
529     if (niInterface == nullptr) {
530         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
531         return HDF_ERR_INVALID_PARAM;
532     }
533     niInterface->sendUserResponse(gnssNiNotificationId, static_cast<int32_t>(userResponse));
534     return HDF_SUCCESS;
535 }
536 
SendNetworkInitiatedMsg(const std::string & msg,int length)537 int32_t GnssInterfaceImpl::SendNetworkInitiatedMsg(const std::string& msg, int length)
538 {
539     HDF_LOGI("%{public}s.", __func__);
540     if (msg.empty()) {
541         HDF_LOGE("%{public}s msg is empty", __func__);
542         return HDF_FAILURE;
543     }
544     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_NET_INITIATED_MODULE_INTERFACE);
545     auto niInterface = static_cast<const GnssNetInitiatedInterface*>
546         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
547     if (niInterface == nullptr) {
548         HDF_LOGE("%{public}s:can not get gnssNiInterface.", __func__);
549         return HDF_ERR_INVALID_PARAM;
550     }
551     std::vector<uint8_t> data = StringUtils::HexToByteVector(msg);
552     HDF_LOGI("%{public}s. msg : %{public}s, length %{public}d, msg size %{public}d, data size %{public}d",
553         __func__, msg.c_str(), length, int(msg.size()), int(data.size()));
554 
555     niInterface->sendNetworkInitiatedMsg(data.data(), data.size());
556     return HDF_SUCCESS;
557 }
558 
EnableGnssMeasurement(const sptr<IGnssMeasurementCallback> & callbackObj)559 int32_t GnssInterfaceImpl::EnableGnssMeasurement(const sptr<IGnssMeasurementCallback>& callbackObj)
560 {
561 #ifndef EMULATOR_ENABLED
562     HDF_LOGI("%{public}s.", __func__);
563     if (callbackObj == nullptr) {
564         HDF_LOGE("%{public}s:invalid callbackObj", __func__);
565         return HDF_ERR_INVALID_PARAM;
566     }
567     std::unique_lock<std::mutex> lock(g_mutex);
568     const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<IGnssMeasurementCallback>(callbackObj);
569     if (remote == nullptr) {
570         HDF_LOGE("%{public}s:invalid remote", __func__);
571         return HDF_ERR_INVALID_PARAM;
572     }
573 
574     static GnssMeasurementCallbackIfaces gnssMeasurementCallback;
575     GetGnssMeasurementCallbackMethods(&gnssMeasurementCallback);
576     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_MEASUREMENT_MODULE_INTERFACE);
577     auto gnssMeasurementInterface = static_cast<const GnssMeasurementInterface*>
578         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
579     if (gnssMeasurementInterface == nullptr) {
580         HDF_LOGE("%{public}s:GetModuleInterface return nullptr.", __func__);
581         return HDF_ERR_INVALID_PARAM;
582     }
583     bool result = gnssMeasurementInterface->enable(&gnssMeasurementCallback);
584     if (!result) {
585         HDF_LOGE("enableGnssMeasurement failed.");
586         return HDF_FAILURE;
587     }
588     if (g_gnssMeasurementCallbackMap.size() > 0) {
589         g_gnssMeasurementCallbackMap.clear();
590     }
591     g_gnssMeasurementCallbackMap[remote.GetRefPtr()] = callbackObj;
592     return HDF_SUCCESS;
593 #else
594     return HDF_SUCCESS;
595 #endif
596 }
597 
DisableGnssMeasurement()598 int32_t GnssInterfaceImpl::DisableGnssMeasurement()
599 {
600 #ifndef EMULATOR_ENABLED
601     HDF_LOGI("%{public}s.", __func__);
602     std::unique_lock<std::mutex> lock(g_mutex);
603     int moduleType = static_cast<int>(GnssModuleIfaceCategory::GNSS_MEASUREMENT_MODULE_INTERFACE);
604     auto gnssMeasurementInterface = static_cast<const GnssMeasurementInterface*>
605         (LocationVendorInterface::GetInstance()->GetModuleInterface(moduleType));
606     if (gnssMeasurementInterface == nullptr) {
607         HDF_LOGE("%{public}s:GnssMeasurementInterface return nullptr.", __func__);
608         return HDF_ERR_INVALID_PARAM;
609     }
610     gnssMeasurementInterface->disable();
611     g_gnssMeasurementCallbackMap.clear();
612 #endif
613     return HDF_SUCCESS;
614 }
615 
ResetGnssDeathRecipient()616 void GnssInterfaceImpl::ResetGnssDeathRecipient()
617 {
618     std::unique_lock<std::mutex> lock(g_mutex);
619     for (const auto& iter : g_locationCallBackMap) {
620         const auto& callback = iter.second;
621         if (callback != nullptr) {
622             RemoveGnssDeathRecipient(callback);
623         }
624     }
625 }
626 
ResetGnss()627 void GnssInterfaceImpl::ResetGnss()
628 {
629     HDF_LOGI("%{public}s called.", __func__);
630     ResetGnssDeathRecipient();
631     StopGnss(GNSS_START_TYPE_NORMAL);
632     DisableGnssMeasurement();
633     DisableGnss();
634 }
635 } // V2_0
636 } // Gnss
637 } // Location
638 } // HDI
639 } // OHOS
640