1 /*
2 * Copyright (C) 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "GnssAidl"
18
19 #include "Gnss.h"
20 #include <inttypes.h>
21 #include <log/log.h>
22 #include <utils/Timers.h>
23 #include "AGnss.h"
24 #include "AGnssRil.h"
25 #include "DeviceFileReader.h"
26 #include "FixLocationParser.h"
27 #include "GnssAntennaInfo.h"
28 #include "GnssAssistanceInterface.h"
29 #include "GnssBatching.h"
30 #include "GnssConfiguration.h"
31 #include "GnssDebug.h"
32 #include "GnssGeofence.h"
33 #include "GnssNavigationMessageInterface.h"
34 #include "GnssPsds.h"
35 #include "GnssVisibilityControl.h"
36 #include "MeasurementCorrectionsInterface.h"
37 #include "Utils.h"
38
39 namespace aidl::android::hardware::gnss {
40 using ::android::hardware::gnss::common::Utils;
41
42 using ndk::ScopedAStatus;
43 using GnssSvInfo = IGnssCallback::GnssSvInfo;
44
45 constexpr int TTFF_MILLIS = 2200;
46
47 std::shared_ptr<IGnssCallback> Gnss::sGnssCallback = nullptr;
48
Gnss()49 Gnss::Gnss() : mMinIntervalMs(1000), mFirstFixReceived(false) {}
50
setCallback(const std::shared_ptr<IGnssCallback> & callback)51 ScopedAStatus Gnss::setCallback(const std::shared_ptr<IGnssCallback>& callback) {
52 ALOGD("setCallback");
53 if (callback == nullptr) {
54 ALOGE("%s: Null callback ignored", __func__);
55 return ScopedAStatus::fromExceptionCode(STATUS_INVALID_OPERATION);
56 }
57 sGnssCallback = callback;
58
59 int capabilities =
60 (int)(IGnssCallback::CAPABILITY_MEASUREMENTS | IGnssCallback::CAPABILITY_SCHEDULING |
61 IGnssCallback::CAPABILITY_SATELLITE_BLOCKLIST |
62 IGnssCallback::CAPABILITY_SATELLITE_PVT |
63 IGnssCallback::CAPABILITY_CORRELATION_VECTOR |
64 IGnssCallback::CAPABILITY_ANTENNA_INFO |
65 IGnssCallback::CAPABILITY_ACCUMULATED_DELTA_RANGE);
66 auto status = sGnssCallback->gnssSetCapabilitiesCb(capabilities);
67 if (!status.isOk()) {
68 ALOGE("%s: Unable to invoke callback.gnssSetCapabilitiesCb", __func__);
69 }
70
71 IGnssCallback::GnssSystemInfo systemInfo = {
72 .yearOfHw = 2022,
73 .name = "Google, Cuttlefish, AIDL v3",
74 };
75 status = sGnssCallback->gnssSetSystemInfoCb(systemInfo);
76 if (!status.isOk()) {
77 ALOGE("%s: Unable to invoke callback.gnssSetSystemInfoCb", __func__);
78 }
79 GnssSignalType signalType1 = {
80 .constellation = GnssConstellationType::GPS,
81 .carrierFrequencyHz = 1.57542e+09,
82 .codeType = GnssSignalType::CODE_TYPE_C,
83 };
84 GnssSignalType signalType2 = {
85 .constellation = GnssConstellationType::GLONASS,
86 .carrierFrequencyHz = 1.5980625e+09,
87 .codeType = GnssSignalType::CODE_TYPE_C,
88 };
89 status = sGnssCallback->gnssSetSignalTypeCapabilitiesCb(
90 std::vector<GnssSignalType>({signalType1, signalType2}));
91 if (!status.isOk()) {
92 ALOGE("%s: Unable to invoke callback.gnssSetSignalTypeCapabilitiesCb", __func__);
93 }
94 return ScopedAStatus::ok();
95 }
96
getLocationFromHW()97 std::unique_ptr<GnssLocation> Gnss::getLocationFromHW() {
98 if (!::android::hardware::gnss::common::ReplayUtils::hasFixedLocationDeviceFile()) {
99 return nullptr;
100 }
101 std::string inputStr =
102 ::android::hardware::gnss::common::DeviceFileReader::Instance().getLocationData();
103 return ::android::hardware::gnss::common::FixLocationParser::getLocationFromInputStr(inputStr);
104 }
105
start()106 ScopedAStatus Gnss::start() {
107 ALOGD("start()");
108 if (mIsActive) {
109 ALOGW("Gnss has started. Restarting...");
110 stop();
111 }
112
113 mIsActive = true;
114 mThreadBlocker.reset();
115 // notify measurement engine to update measurement interval
116 mGnssMeasurementInterface->setLocationEnabled(true);
117 this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
118 mThread = std::thread([this]() {
119 if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
120 this->reportSvStatus();
121 }
122 if (!mFirstFixReceived) {
123 std::this_thread::sleep_for(std::chrono::milliseconds(TTFF_MILLIS));
124 mFirstFixReceived = true;
125 }
126 int reportGnssCount = 0;
127 do {
128 if (!mIsActive) {
129 ALOGD("Do not report location. mIsActive is false");
130 break;
131 }
132 reportGnssCount += 1;
133 if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
134 this->reportSvStatus();
135 }
136 this->reportNmea();
137
138 auto currentLocation = getLocationFromHW();
139 mGnssPowerIndication->notePowerConsumption();
140 if (currentLocation != nullptr) {
141 this->reportLocation(*currentLocation);
142 } else {
143 const auto location = Utils::getMockLocation();
144 this->reportLocation(location);
145 }
146 } while (mIsActive && mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMs)));
147 ALOGD("reportGnssCount: %d", reportGnssCount);
148 });
149 return ScopedAStatus::ok();
150 }
151
stop()152 ScopedAStatus Gnss::stop() {
153 ALOGD("stop");
154 mIsActive = false;
155 mGnssMeasurementInterface->setLocationEnabled(false);
156 this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_END);
157 mThreadBlocker.notify();
158 if (mThread.joinable()) {
159 mThread.join();
160 }
161 return ScopedAStatus::ok();
162 }
163
close()164 ScopedAStatus Gnss::close() {
165 ALOGD("close");
166 sGnssCallback = nullptr;
167 return ScopedAStatus::ok();
168 }
169
reportLocation(const GnssLocation & location)170 void Gnss::reportLocation(const GnssLocation& location) {
171 std::unique_lock<std::mutex> lock(mMutex);
172 if (sGnssCallback == nullptr) {
173 ALOGE("%s: GnssCallback is null.", __func__);
174 return;
175 }
176 mLastLocation = std::make_shared<GnssLocation>(location);
177 auto status = sGnssCallback->gnssLocationCb(location);
178 if (!status.isOk()) {
179 ALOGE("%s: Unable to invoke gnssLocationCb", __func__);
180 }
181 return;
182 }
183
reportSvStatus() const184 void Gnss::reportSvStatus() const {
185 if (mIsSvStatusActive) {
186 auto svStatus = filterBlocklistedSatellites(Utils::getMockSvInfoList());
187 reportSvStatus(svStatus);
188 }
189 }
190
reportSvStatus(const std::vector<GnssSvInfo> & svInfoList) const191 void Gnss::reportSvStatus(const std::vector<GnssSvInfo>& svInfoList) const {
192 std::unique_lock<std::mutex> lock(mMutex);
193 if (sGnssCallback == nullptr) {
194 ALOGE("%s: sGnssCallback is null.", __func__);
195 return;
196 }
197 auto status = sGnssCallback->gnssSvStatusCb(svInfoList);
198 if (!status.isOk()) {
199 ALOGE("%s: Unable to invoke callback", __func__);
200 }
201 }
202
filterBlocklistedSatellites(std::vector<GnssSvInfo> gnssSvInfoList) const203 std::vector<GnssSvInfo> Gnss::filterBlocklistedSatellites(
204 std::vector<GnssSvInfo> gnssSvInfoList) const {
205 for (uint32_t i = 0; i < gnssSvInfoList.size(); i++) {
206 if (mGnssConfiguration->isBlocklisted(gnssSvInfoList[i])) {
207 gnssSvInfoList[i].svFlag &= ~(uint32_t)IGnssCallback::GnssSvFlags::USED_IN_FIX;
208 }
209 }
210 return gnssSvInfoList;
211 }
212
reportGnssStatusValue(const IGnssCallback::GnssStatusValue gnssStatusValue) const213 void Gnss::reportGnssStatusValue(const IGnssCallback::GnssStatusValue gnssStatusValue) const {
214 std::unique_lock<std::mutex> lock(mMutex);
215 if (sGnssCallback == nullptr) {
216 ALOGE("%s: sGnssCallback is null.", __func__);
217 return;
218 }
219 auto status = sGnssCallback->gnssStatusCb(gnssStatusValue);
220 if (!status.isOk()) {
221 ALOGE("%s: Unable to invoke gnssStatusCb", __func__);
222 }
223 }
224
reportNmea() const225 void Gnss::reportNmea() const {
226 if (mIsNmeaActive) {
227 std::unique_lock<std::mutex> lock(mMutex);
228 if (sGnssCallback == nullptr) {
229 ALOGE("%s: sGnssCallback is null.", __func__);
230 return;
231 }
232 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
233 auto status = sGnssCallback->gnssNmeaCb(now, "$TEST,0,1,2,3,4,5");
234 if (!status.isOk()) {
235 ALOGE("%s: Unable to invoke callback", __func__);
236 }
237 }
238 }
239
startSvStatus()240 ScopedAStatus Gnss::startSvStatus() {
241 ALOGD("startSvStatus");
242 mIsSvStatusActive = true;
243 return ScopedAStatus::ok();
244 }
245
stopSvStatus()246 ScopedAStatus Gnss::stopSvStatus() {
247 ALOGD("stopSvStatus");
248 mIsSvStatusActive = false;
249 return ScopedAStatus::ok();
250 }
startNmea()251 ScopedAStatus Gnss::startNmea() {
252 ALOGD("startNmea");
253 mIsNmeaActive = true;
254 return ScopedAStatus::ok();
255 }
stopNmea()256 ScopedAStatus Gnss::stopNmea() {
257 ALOGD("stopNmea");
258 mIsNmeaActive = false;
259 return ScopedAStatus::ok();
260 }
261
getExtensionAGnss(std::shared_ptr<IAGnss> * iAGnss)262 ScopedAStatus Gnss::getExtensionAGnss(std::shared_ptr<IAGnss>* iAGnss) {
263 ALOGD("Gnss::getExtensionAGnss");
264 *iAGnss = SharedRefBase::make<AGnss>();
265 return ndk::ScopedAStatus::ok();
266 }
267
injectTime(int64_t timeMs,int64_t timeReferenceMs,int uncertaintyMs)268 ScopedAStatus Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, int uncertaintyMs) {
269 ALOGD("injectTime. timeMs:%" PRId64 ", timeReferenceMs:%" PRId64 ", uncertaintyMs:%d", timeMs,
270 timeReferenceMs, uncertaintyMs);
271 return ScopedAStatus::ok();
272 }
273
getExtensionAGnssRil(std::shared_ptr<IAGnssRil> * iAGnssRil)274 ScopedAStatus Gnss::getExtensionAGnssRil(std::shared_ptr<IAGnssRil>* iAGnssRil) {
275 ALOGD("Gnss::getExtensionAGnssRil");
276 *iAGnssRil = SharedRefBase::make<AGnssRil>();
277 return ndk::ScopedAStatus::ok();
278 }
279
injectLocation(const GnssLocation & location)280 ScopedAStatus Gnss::injectLocation(const GnssLocation& location) {
281 ALOGD("injectLocation. lat:%lf, lng:%lf, acc:%f", location.latitudeDegrees,
282 location.longitudeDegrees, location.horizontalAccuracyMeters);
283 return ScopedAStatus::ok();
284 }
285
injectBestLocation(const GnssLocation & location)286 ScopedAStatus Gnss::injectBestLocation(const GnssLocation& location) {
287 ALOGD("injectBestLocation. lat:%lf, lng:%lf, acc:%f", location.latitudeDegrees,
288 location.longitudeDegrees, location.horizontalAccuracyMeters);
289 return ScopedAStatus::ok();
290 }
291
deleteAidingData(GnssAidingData aidingDataFlags)292 ScopedAStatus Gnss::deleteAidingData(GnssAidingData aidingDataFlags) {
293 ALOGD("deleteAidingData. flags:%d", (int)aidingDataFlags);
294 mFirstFixReceived = false;
295 return ScopedAStatus::ok();
296 }
297
setPositionMode(const PositionModeOptions & options)298 ScopedAStatus Gnss::setPositionMode(const PositionModeOptions& options) {
299 ALOGD("setPositionMode. minIntervalMs:%d, lowPowerMode:%d", options.minIntervalMs,
300 (int)options.lowPowerMode);
301 mMinIntervalMs = std::max(1000, options.minIntervalMs);
302 mGnssMeasurementInterface->setLocationInterval(mMinIntervalMs);
303 return ScopedAStatus::ok();
304 }
305
getExtensionPsds(std::shared_ptr<IGnssPsds> * iGnssPsds)306 ScopedAStatus Gnss::getExtensionPsds(std::shared_ptr<IGnssPsds>* iGnssPsds) {
307 ALOGD("getExtensionPsds");
308 *iGnssPsds = SharedRefBase::make<GnssPsds>();
309 return ScopedAStatus::ok();
310 }
311
getExtensionGnssConfiguration(std::shared_ptr<IGnssConfiguration> * iGnssConfiguration)312 ScopedAStatus Gnss::getExtensionGnssConfiguration(
313 std::shared_ptr<IGnssConfiguration>* iGnssConfiguration) {
314 ALOGD("getExtensionGnssConfiguration");
315 if (mGnssConfiguration == nullptr) {
316 mGnssConfiguration = SharedRefBase::make<GnssConfiguration>();
317 }
318 *iGnssConfiguration = mGnssConfiguration;
319 return ScopedAStatus::ok();
320 }
321
getExtensionGnssPowerIndication(std::shared_ptr<IGnssPowerIndication> * iGnssPowerIndication)322 ScopedAStatus Gnss::getExtensionGnssPowerIndication(
323 std::shared_ptr<IGnssPowerIndication>* iGnssPowerIndication) {
324 ALOGD("getExtensionGnssPowerIndication");
325 if (mGnssPowerIndication == nullptr) {
326 mGnssPowerIndication = SharedRefBase::make<GnssPowerIndication>();
327 }
328
329 *iGnssPowerIndication = mGnssPowerIndication;
330 return ScopedAStatus::ok();
331 }
332
getExtensionGnssMeasurement(std::shared_ptr<IGnssMeasurementInterface> * iGnssMeasurement)333 ScopedAStatus Gnss::getExtensionGnssMeasurement(
334 std::shared_ptr<IGnssMeasurementInterface>* iGnssMeasurement) {
335 ALOGD("getExtensionGnssMeasurement");
336 if (mGnssMeasurementInterface == nullptr) {
337 mGnssMeasurementInterface = SharedRefBase::make<GnssMeasurementInterface>();
338 mGnssMeasurementInterface->setGnssInterface(static_cast<std::shared_ptr<Gnss>>(this));
339 }
340 *iGnssMeasurement = mGnssMeasurementInterface;
341 return ScopedAStatus::ok();
342 }
343
getExtensionGnssBatching(std::shared_ptr<IGnssBatching> * iGnssBatching)344 ScopedAStatus Gnss::getExtensionGnssBatching(std::shared_ptr<IGnssBatching>* iGnssBatching) {
345 ALOGD("getExtensionGnssBatching");
346
347 *iGnssBatching = SharedRefBase::make<GnssBatching>();
348 return ScopedAStatus::ok();
349 }
350
getExtensionGnssGeofence(std::shared_ptr<IGnssGeofence> * iGnssGeofence)351 ScopedAStatus Gnss::getExtensionGnssGeofence(std::shared_ptr<IGnssGeofence>* iGnssGeofence) {
352 ALOGD("getExtensionGnssGeofence");
353
354 *iGnssGeofence = SharedRefBase::make<GnssGeofence>();
355 return ScopedAStatus::ok();
356 }
357
getExtensionGnssNavigationMessage(std::shared_ptr<IGnssNavigationMessageInterface> * iGnssNavigationMessage)358 ScopedAStatus Gnss::getExtensionGnssNavigationMessage(
359 std::shared_ptr<IGnssNavigationMessageInterface>* iGnssNavigationMessage) {
360 ALOGD("getExtensionGnssNavigationMessage");
361
362 *iGnssNavigationMessage = SharedRefBase::make<GnssNavigationMessageInterface>();
363 return ScopedAStatus::ok();
364 }
365
getExtensionGnssDebug(std::shared_ptr<IGnssDebug> * iGnssDebug)366 ndk::ScopedAStatus Gnss::getExtensionGnssDebug(std::shared_ptr<IGnssDebug>* iGnssDebug) {
367 ALOGD("Gnss::getExtensionGnssDebug");
368 *iGnssDebug = SharedRefBase::make<GnssDebug>();
369 return ndk::ScopedAStatus::ok();
370 }
371
getExtensionGnssVisibilityControl(std::shared_ptr<visibility_control::IGnssVisibilityControl> * iGnssVisibilityControl)372 ndk::ScopedAStatus Gnss::getExtensionGnssVisibilityControl(
373 std::shared_ptr<visibility_control::IGnssVisibilityControl>* iGnssVisibilityControl) {
374 ALOGD("Gnss::getExtensionGnssVisibilityControl");
375
376 *iGnssVisibilityControl = SharedRefBase::make<visibility_control::GnssVisibilityControl>();
377 return ndk::ScopedAStatus::ok();
378 }
379
getExtensionGnssAntennaInfo(std::shared_ptr<IGnssAntennaInfo> * iGnssAntennaInfo)380 ndk::ScopedAStatus Gnss::getExtensionGnssAntennaInfo(
381 std::shared_ptr<IGnssAntennaInfo>* iGnssAntennaInfo) {
382 ALOGD("Gnss::getExtensionGnssAntennaInfo");
383
384 *iGnssAntennaInfo = SharedRefBase::make<GnssAntennaInfo>();
385 return ndk::ScopedAStatus::ok();
386 }
387
getExtensionMeasurementCorrections(std::shared_ptr<measurement_corrections::IMeasurementCorrectionsInterface> * iMeasurementCorrections)388 ndk::ScopedAStatus Gnss::getExtensionMeasurementCorrections(
389 std::shared_ptr<measurement_corrections::IMeasurementCorrectionsInterface>*
390 iMeasurementCorrections) {
391 ALOGD("Gnss::getExtensionMeasurementCorrections");
392
393 *iMeasurementCorrections =
394 SharedRefBase::make<measurement_corrections::MeasurementCorrectionsInterface>();
395 return ndk::ScopedAStatus::ok();
396 }
397
getExtensionGnssAssistanceInterface(std::shared_ptr<gnss_assistance::IGnssAssistanceInterface> * iGnssAssistanceInterface)398 ndk::ScopedAStatus Gnss::getExtensionGnssAssistanceInterface(
399 std::shared_ptr<gnss_assistance::IGnssAssistanceInterface>* iGnssAssistanceInterface) {
400 ALOGD("Gnss::getExtensionGnssAssistanceInterface");
401
402 *iGnssAssistanceInterface = SharedRefBase::make<gnss_assistance::GnssAssistanceInterface>();
403 return ndk::ScopedAStatus::ok();
404 }
405
setGnssMeasurementEnabled(const bool enabled)406 void Gnss::setGnssMeasurementEnabled(const bool enabled) {
407 mGnssMeasurementEnabled = enabled;
408 }
409
setGnssMeasurementInterval(const long intervalMs)410 void Gnss::setGnssMeasurementInterval(const long intervalMs) {
411 mGnssMeasurementIntervalMs = intervalMs;
412 }
413
getLastLocation() const414 std::shared_ptr<GnssLocation> Gnss::getLastLocation() const {
415 return mLastLocation;
416 }
417
418 } // namespace aidl::android::hardware::gnss
419