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 "location_vendor_interface.h"
25 #include "location_vendor_lib.h"
26
27 namespace OHOS {
28 namespace HDI {
29 namespace Location {
30 namespace Gnss {
31 namespace V1_0 {
32 namespace {
33 using LocationCallBackMap = std::unordered_map<IRemoteObject *, sptr<IGnssCallback>>;
34 LocationCallBackMap g_locationCallBackMap;
35 std::mutex g_mutex;
36 } // namespace
37
GnssInterfaceImplGetInstance(void)38 extern "C" IGnssInterface *GnssInterfaceImplGetInstance(void)
39 {
40 return new (std::nothrow) GnssInterfaceImpl();
41 }
42
LocationUpdate(GnssLocation * location)43 static void LocationUpdate(GnssLocation *location)
44 {
45 if (location == nullptr) {
46 HDF_LOGE("%{public}s:location is nullptr.", __func__);
47 return;
48 }
49 HDF_LOGI("%{public}s:LocationUpdate.", __func__);
50 LocationInfo locationNew;
51 locationNew.latitude = location->latitude;
52 locationNew.longitude = location->longitude;
53 locationNew.altitude = location->altitude;
54 locationNew.accuracy = location->horizontalAccuracy;
55 locationNew.speed = location->speed;
56 locationNew.direction = location->bearing;
57 locationNew.timeStamp = location->timestamp;
58 locationNew.timeSinceBoot = location->timestampSinceBoot;
59 for (const auto &iter : g_locationCallBackMap) {
60 auto &callback = iter.second;
61 if (callback != nullptr) {
62 callback->ReportLocation(locationNew);
63 }
64 }
65 }
66
StatusCallback(uint16_t * status)67 static void StatusCallback(uint16_t *status)
68 {
69 if (status == nullptr) {
70 HDF_LOGE("%{public}s:param is nullptr.", __func__);
71 return;
72 }
73 GnssWorkingStatus gnssStatus = static_cast<GnssWorkingStatus>(*status);
74 for (const auto &iter : g_locationCallBackMap) {
75 auto &callback = iter.second;
76 if (callback != nullptr) {
77 callback->ReportGnssWorkingStatus(gnssStatus);
78 }
79 }
80 }
81
SvStatusCallback(GnssSatelliteStatus * svInfo)82 static void SvStatusCallback(GnssSatelliteStatus *svInfo)
83 {
84 if (svInfo == nullptr) {
85 HDF_LOGE("%{public}s:sv_info is null.", __func__);
86 return;
87 }
88 if (svInfo->satellitesNum == 0) {
89 HDF_LOGE("%{public}s:satellites_num == 0.", __func__);
90 return;
91 }
92 SatelliteStatusInfo svStatus;
93 svStatus.satellitesNumber = svInfo->satellitesNum;
94 for (unsigned int i = 0; i < svInfo->satellitesNum; i++) {
95 svStatus.satelliteIds.push_back(svInfo->satellitesList[i].satelliteId);
96 svStatus.constellation.push_back(
97 static_cast<GnssConstellationType>(svInfo->satellitesList[i].constellationType));
98 svStatus.elevation.push_back(svInfo->satellitesList[i].elevation);
99 svStatus.azimuths.push_back(svInfo->satellitesList[i].azimuth);
100 svStatus.carrierFrequencies.push_back(svInfo->satellitesList[i].carrierFrequencie);
101 svStatus.carrierToNoiseDensitys.push_back(svInfo->satellitesList[i].cn0);
102 }
103 for (const auto &iter : g_locationCallBackMap) {
104 auto &callback = iter.second;
105 if (callback != nullptr) {
106 callback->ReportSatelliteStatusInfo(svStatus);
107 }
108 }
109 }
110
NmeaCallback(int64_t timestamp,const char * nmea,int length)111 static void NmeaCallback(int64_t timestamp, const char *nmea, int length)
112 {
113 if (nmea == nullptr) {
114 HDF_LOGE("%{public}s:nmea is nullptr.", __func__);
115 return;
116 }
117 for (const auto &iter : g_locationCallBackMap) {
118 auto &callback = iter.second;
119 if (callback != nullptr) {
120 callback->ReportNmea(timestamp, nmea, length);
121 }
122 }
123 }
124
GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces * device)125 static void GetGnssBasicCallbackMethods(GnssBasicCallbackIfaces *device)
126 {
127 if (device == nullptr) {
128 return;
129 }
130 device->size = sizeof(GnssCallbackStruct);
131 device->locationUpdate = LocationUpdate;
132 device->statusUpdate = StatusCallback;
133 device->svStatusUpdate = SvStatusCallback;
134 device->nmeaUpdate = NmeaCallback;
135 device->capabilitiesUpdate = nullptr;
136 device->refInfoRequest = nullptr;
137 device->downloadRequestCb = nullptr;
138 }
139
GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces * device)140 static void GetGnssCacheCallbackMethods(GnssCacheCallbackIfaces *device)
141 {
142 if (device == nullptr) {
143 return;
144 }
145 device->size = 0;
146 device->cachedLocationCb = nullptr;
147 }
148
GetGnssCallbackMethods(GnssCallbackStruct * device)149 static void GetGnssCallbackMethods(GnssCallbackStruct *device)
150 {
151 if (device == nullptr) {
152 return;
153 }
154 device->size = sizeof(GnssCallbackStruct);
155 static GnssBasicCallbackIfaces basicCallback;
156 GetGnssBasicCallbackMethods(&basicCallback);
157 device->gnssCb = basicCallback;
158 static GnssCacheCallbackIfaces cacheCallback;
159 GetGnssCacheCallbackMethods(&cacheCallback);
160 device->gnssCacheCb = cacheCallback;
161 }
162
GnssInterfaceImpl()163 GnssInterfaceImpl::GnssInterfaceImpl()
164 {
165 }
166
~GnssInterfaceImpl()167 GnssInterfaceImpl::~GnssInterfaceImpl()
168 {
169 }
170
SetGnssConfigPara(const GnssConfigPara & para)171 int32_t GnssInterfaceImpl::SetGnssConfigPara(const GnssConfigPara& para)
172 {
173 HDF_LOGI("%{public}s.", __func__);
174 return HDF_SUCCESS;
175 }
176
EnableGnss(const sptr<IGnssCallback> & callbackObj)177 int32_t GnssInterfaceImpl::EnableGnss(const sptr<IGnssCallback>& callbackObj)
178 {
179 HDF_LOGI("%{public}s.", __func__);
180 if (callbackObj == nullptr) {
181 HDF_LOGE("%{public}s:invalid callbackObj", __func__);
182 return HDF_ERR_INVALID_PARAM;
183 }
184 std::lock_guard<std::mutex> lock(g_mutex);
185 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
186 if (remote == nullptr) {
187 HDF_LOGE("%{public}s:invalid remote", __func__);
188 return HDF_ERR_INVALID_PARAM;
189 }
190 auto callBackIter = g_locationCallBackMap.find(remote.GetRefPtr());
191 if (callBackIter != g_locationCallBackMap.end()) {
192 const sptr<IRemoteObject> &lhs = OHOS::HDI::hdi_objcast<IGnssCallback>(callbackObj);
193 const sptr<IRemoteObject> &rhs = OHOS::HDI::hdi_objcast<IGnssCallback>(callBackIter->second);
194 return lhs == rhs ? HDF_SUCCESS : HDF_FAILURE;
195 }
196 static GnssCallbackStruct gnssCallback;
197 GetGnssCallbackMethods(&gnssCallback);
198 auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
199 if (gnssInterface == nullptr) {
200 HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
201 return HDF_ERR_INVALID_PARAM;
202 }
203 int ret = gnssInterface->enable_gnss(&gnssCallback);
204 g_locationCallBackMap[remote.GetRefPtr()] = callbackObj;
205 return ret;
206 }
207
DisableGnss()208 int32_t GnssInterfaceImpl::DisableGnss()
209 {
210 HDF_LOGI("%{public}s.", __func__);
211 std::lock_guard<std::mutex> lock(g_mutex);
212 auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
213 if (gnssInterface == nullptr) {
214 HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
215 return HDF_ERR_INVALID_PARAM;
216 }
217 int ret = gnssInterface->disable_gnss();
218 g_locationCallBackMap.clear();
219 return ret;
220 }
221
StartGnss(GnssStartType type)222 int32_t GnssInterfaceImpl::StartGnss(GnssStartType type)
223 {
224 HDF_LOGI("%{public}s.", __func__);
225 int startType = int(type);
226 auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
227 if (gnssInterface == nullptr) {
228 HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
229 return HDF_ERR_INVALID_PARAM;
230 }
231 int ret = gnssInterface->start_gnss(startType);
232 return ret;
233 }
234
StopGnss(GnssStartType type)235 int32_t GnssInterfaceImpl::StopGnss(GnssStartType type)
236 {
237 HDF_LOGI("%{public}s.", __func__);
238 int startType = static_cast<int>(type);
239 auto gnssInterface = LocationVendorInterface::GetInstance()->GetGnssVendorInterface();
240 if (gnssInterface == nullptr) {
241 HDF_LOGE("%{public}s:GetGnssVendorInterface return nullptr.", __func__);
242 return HDF_ERR_INVALID_PARAM;
243 }
244 int ret = gnssInterface->stop_gnss(startType);
245 return ret;
246 }
247
SetGnssReferenceInfo(const GnssRefInfo & refInfo)248 int32_t GnssInterfaceImpl::SetGnssReferenceInfo(const GnssRefInfo& refInfo)
249 {
250 HDF_LOGI("%{public}s.", __func__);
251 return HDF_SUCCESS;
252 }
253
DeleteAuxiliaryData(GnssAuxiliaryData data)254 int32_t GnssInterfaceImpl::DeleteAuxiliaryData(GnssAuxiliaryData data)
255 {
256 HDF_LOGI("%{public}s.", __func__);
257 return HDF_SUCCESS;
258 }
259
SetPredictGnssData(const std::string & data)260 int32_t GnssInterfaceImpl::SetPredictGnssData(const std::string& data)
261 {
262 HDF_LOGI("%{public}s.", __func__);
263 return HDF_SUCCESS;
264 }
265
GetCachedGnssLocationsSize(int32_t & size)266 int32_t GnssInterfaceImpl::GetCachedGnssLocationsSize(int32_t& size)
267 {
268 HDF_LOGI("%{public}s.", __func__);
269 return HDF_SUCCESS;
270 }
271
GetCachedGnssLocations()272 int32_t GnssInterfaceImpl::GetCachedGnssLocations()
273 {
274 HDF_LOGI("%{public}s.", __func__);
275 return HDF_SUCCESS;
276 }
277 } // V1_0
278 } // Gnss
279 } // Location
280 } // HDI
281 } // OHOS
282