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 "GnssBatching.h"
29 #include "GnssConfiguration.h"
30 #include "GnssDebug.h"
31 #include "GnssGeofence.h"
32 #include "GnssNavigationMessageInterface.h"
33 #include "GnssPsds.h"
34 #include "GnssVisibilityControl.h"
35 #include "MeasurementCorrectionsInterface.h"
36 #include "Utils.h"
37
38 namespace aidl::android::hardware::gnss {
39 using ::android::hardware::gnss::common::Utils;
40
41 using ndk::ScopedAStatus;
42 using GnssSvInfo = IGnssCallback::GnssSvInfo;
43
44 constexpr int TTFF_MILLIS = 2200;
45
46 std::shared_ptr<IGnssCallback> Gnss::sGnssCallback = nullptr;
47
Gnss()48 Gnss::Gnss() : mMinIntervalMs(1000), mFirstFixReceived(false) {}
49
setCallback(const std::shared_ptr<IGnssCallback> & callback)50 ScopedAStatus Gnss::setCallback(const std::shared_ptr<IGnssCallback>& callback) {
51 ALOGD("setCallback");
52 if (callback == nullptr) {
53 ALOGE("%s: Null callback ignored", __func__);
54 return ScopedAStatus::fromExceptionCode(STATUS_INVALID_OPERATION);
55 }
56 sGnssCallback = callback;
57
58 int capabilities =
59 (int)(IGnssCallback::CAPABILITY_MEASUREMENTS | IGnssCallback::CAPABILITY_SCHEDULING |
60 IGnssCallback::CAPABILITY_SATELLITE_BLOCKLIST |
61 IGnssCallback::CAPABILITY_SATELLITE_PVT |
62 IGnssCallback::CAPABILITY_CORRELATION_VECTOR |
63 IGnssCallback::CAPABILITY_ANTENNA_INFO);
64 auto status = sGnssCallback->gnssSetCapabilitiesCb(capabilities);
65 if (!status.isOk()) {
66 ALOGE("%s: Unable to invoke callback.gnssSetCapabilitiesCb", __func__);
67 }
68
69 IGnssCallback::GnssSystemInfo systemInfo = {
70 .yearOfHw = 2022,
71 .name = "Google, Cuttlefish, AIDL v2",
72 };
73 status = sGnssCallback->gnssSetSystemInfoCb(systemInfo);
74 if (!status.isOk()) {
75 ALOGE("%s: Unable to invoke callback.gnssSetSystemInfoCb", __func__);
76 }
77
78 return ScopedAStatus::ok();
79 }
80
getLocationFromHW()81 std::unique_ptr<GnssLocation> Gnss::getLocationFromHW() {
82 if (!::android::hardware::gnss::common::ReplayUtils::hasFixedLocationDeviceFile()) {
83 return nullptr;
84 }
85 std::string inputStr =
86 ::android::hardware::gnss::common::DeviceFileReader::Instance().getLocationData();
87 return ::android::hardware::gnss::common::FixLocationParser::getLocationFromInputStr(inputStr);
88 }
89
start()90 ScopedAStatus Gnss::start() {
91 ALOGD("start()");
92 if (mIsActive) {
93 ALOGW("Gnss has started. Restarting...");
94 stop();
95 }
96
97 mIsActive = true;
98 mThreadBlocker.reset();
99 // notify measurement engine to update measurement interval
100 mGnssMeasurementInterface->setLocationEnabled(true);
101 this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
102 mThread = std::thread([this]() {
103 this->reportSvStatus();
104 if (!mFirstFixReceived) {
105 std::this_thread::sleep_for(std::chrono::milliseconds(TTFF_MILLIS));
106 mFirstFixReceived = true;
107 }
108 do {
109 if (!mIsActive) {
110 break;
111 }
112 this->reportSvStatus();
113 this->reportNmea();
114
115 auto currentLocation = getLocationFromHW();
116 mGnssPowerIndication->notePowerConsumption();
117 if (currentLocation != nullptr) {
118 this->reportLocation(*currentLocation);
119 } else {
120 const auto location = Utils::getMockLocation();
121 this->reportLocation(location);
122 }
123 } while (mIsActive && mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMs)));
124 });
125 return ScopedAStatus::ok();
126 }
127
stop()128 ScopedAStatus Gnss::stop() {
129 ALOGD("stop");
130 mIsActive = false;
131 mGnssMeasurementInterface->setLocationEnabled(false);
132 this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_END);
133 mThreadBlocker.notify();
134 if (mThread.joinable()) {
135 mThread.join();
136 }
137 return ScopedAStatus::ok();
138 }
139
close()140 ScopedAStatus Gnss::close() {
141 ALOGD("close");
142 sGnssCallback = nullptr;
143 return ScopedAStatus::ok();
144 }
145
reportLocation(const GnssLocation & location) const146 void Gnss::reportLocation(const GnssLocation& location) const {
147 std::unique_lock<std::mutex> lock(mMutex);
148 if (sGnssCallback == nullptr) {
149 ALOGE("%s: GnssCallback is null.", __func__);
150 return;
151 }
152 auto status = sGnssCallback->gnssLocationCb(location);
153 if (!status.isOk()) {
154 ALOGE("%s: Unable to invoke gnssLocationCb", __func__);
155 }
156 return;
157 }
158
reportSvStatus() const159 void Gnss::reportSvStatus() const {
160 if (mIsSvStatusActive) {
161 auto svStatus = filterBlocklistedSatellites(Utils::getMockSvInfoList());
162 reportSvStatus(svStatus);
163 }
164 }
165
reportSvStatus(const std::vector<GnssSvInfo> & svInfoList) const166 void Gnss::reportSvStatus(const std::vector<GnssSvInfo>& svInfoList) const {
167 std::unique_lock<std::mutex> lock(mMutex);
168 if (sGnssCallback == nullptr) {
169 ALOGE("%s: sGnssCallback is null.", __func__);
170 return;
171 }
172 auto status = sGnssCallback->gnssSvStatusCb(svInfoList);
173 if (!status.isOk()) {
174 ALOGE("%s: Unable to invoke callback", __func__);
175 }
176 }
177
filterBlocklistedSatellites(std::vector<GnssSvInfo> gnssSvInfoList) const178 std::vector<GnssSvInfo> Gnss::filterBlocklistedSatellites(
179 std::vector<GnssSvInfo> gnssSvInfoList) const {
180 for (uint32_t i = 0; i < gnssSvInfoList.size(); i++) {
181 if (mGnssConfiguration->isBlocklisted(gnssSvInfoList[i])) {
182 gnssSvInfoList[i].svFlag &= ~(uint32_t)IGnssCallback::GnssSvFlags::USED_IN_FIX;
183 }
184 }
185 return gnssSvInfoList;
186 }
187
reportGnssStatusValue(const IGnssCallback::GnssStatusValue gnssStatusValue) const188 void Gnss::reportGnssStatusValue(const IGnssCallback::GnssStatusValue gnssStatusValue) const {
189 std::unique_lock<std::mutex> lock(mMutex);
190 if (sGnssCallback == nullptr) {
191 ALOGE("%s: sGnssCallback is null.", __func__);
192 return;
193 }
194 auto status = sGnssCallback->gnssStatusCb(gnssStatusValue);
195 if (!status.isOk()) {
196 ALOGE("%s: Unable to invoke gnssStatusCb", __func__);
197 }
198 }
199
reportNmea() const200 void Gnss::reportNmea() const {
201 if (mIsNmeaActive) {
202 std::unique_lock<std::mutex> lock(mMutex);
203 if (sGnssCallback == nullptr) {
204 ALOGE("%s: sGnssCallback is null.", __func__);
205 return;
206 }
207 nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
208 auto status = sGnssCallback->gnssNmeaCb(now, "$TEST,0,1,2,3,4,5");
209 if (!status.isOk()) {
210 ALOGE("%s: Unable to invoke callback", __func__);
211 }
212 }
213 }
214
startSvStatus()215 ScopedAStatus Gnss::startSvStatus() {
216 ALOGD("startSvStatus");
217 mIsSvStatusActive = true;
218 return ScopedAStatus::ok();
219 }
220
stopSvStatus()221 ScopedAStatus Gnss::stopSvStatus() {
222 ALOGD("stopSvStatus");
223 mIsSvStatusActive = false;
224 return ScopedAStatus::ok();
225 }
startNmea()226 ScopedAStatus Gnss::startNmea() {
227 ALOGD("startNmea");
228 mIsNmeaActive = true;
229 return ScopedAStatus::ok();
230 }
stopNmea()231 ScopedAStatus Gnss::stopNmea() {
232 ALOGD("stopNmea");
233 mIsNmeaActive = false;
234 return ScopedAStatus::ok();
235 }
236
getExtensionAGnss(std::shared_ptr<IAGnss> * iAGnss)237 ScopedAStatus Gnss::getExtensionAGnss(std::shared_ptr<IAGnss>* iAGnss) {
238 ALOGD("Gnss::getExtensionAGnss");
239 *iAGnss = SharedRefBase::make<AGnss>();
240 return ndk::ScopedAStatus::ok();
241 }
242
injectTime(int64_t timeMs,int64_t timeReferenceMs,int uncertaintyMs)243 ScopedAStatus Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, int uncertaintyMs) {
244 ALOGD("injectTime. timeMs:%" PRId64 ", timeReferenceMs:%" PRId64 ", uncertaintyMs:%d", timeMs,
245 timeReferenceMs, uncertaintyMs);
246 return ScopedAStatus::ok();
247 }
248
getExtensionAGnssRil(std::shared_ptr<IAGnssRil> * iAGnssRil)249 ScopedAStatus Gnss::getExtensionAGnssRil(std::shared_ptr<IAGnssRil>* iAGnssRil) {
250 ALOGD("Gnss::getExtensionAGnssRil");
251 *iAGnssRil = SharedRefBase::make<AGnssRil>();
252 return ndk::ScopedAStatus::ok();
253 }
254
injectLocation(const GnssLocation & location)255 ScopedAStatus Gnss::injectLocation(const GnssLocation& location) {
256 ALOGD("injectLocation. lat:%lf, lng:%lf, acc:%f", location.latitudeDegrees,
257 location.longitudeDegrees, location.horizontalAccuracyMeters);
258 return ScopedAStatus::ok();
259 }
260
injectBestLocation(const GnssLocation & location)261 ScopedAStatus Gnss::injectBestLocation(const GnssLocation& location) {
262 ALOGD("injectBestLocation. lat:%lf, lng:%lf, acc:%f", location.latitudeDegrees,
263 location.longitudeDegrees, location.horizontalAccuracyMeters);
264 return ScopedAStatus::ok();
265 }
266
deleteAidingData(GnssAidingData aidingDataFlags)267 ScopedAStatus Gnss::deleteAidingData(GnssAidingData aidingDataFlags) {
268 ALOGD("deleteAidingData. flags:%d", (int)aidingDataFlags);
269 mFirstFixReceived = false;
270 return ScopedAStatus::ok();
271 }
272
setPositionMode(const PositionModeOptions & options)273 ScopedAStatus Gnss::setPositionMode(const PositionModeOptions& options) {
274 ALOGD("setPositionMode. minIntervalMs:%d, lowPowerMode:%d", options.minIntervalMs,
275 (int)options.lowPowerMode);
276 mMinIntervalMs = std::max(1000, options.minIntervalMs);
277 mGnssMeasurementInterface->setLocationInterval(mMinIntervalMs);
278 return ScopedAStatus::ok();
279 }
280
getExtensionPsds(std::shared_ptr<IGnssPsds> * iGnssPsds)281 ScopedAStatus Gnss::getExtensionPsds(std::shared_ptr<IGnssPsds>* iGnssPsds) {
282 ALOGD("getExtensionPsds");
283 *iGnssPsds = SharedRefBase::make<GnssPsds>();
284 return ScopedAStatus::ok();
285 }
286
getExtensionGnssConfiguration(std::shared_ptr<IGnssConfiguration> * iGnssConfiguration)287 ScopedAStatus Gnss::getExtensionGnssConfiguration(
288 std::shared_ptr<IGnssConfiguration>* iGnssConfiguration) {
289 ALOGD("getExtensionGnssConfiguration");
290 if (mGnssConfiguration == nullptr) {
291 mGnssConfiguration = SharedRefBase::make<GnssConfiguration>();
292 }
293 *iGnssConfiguration = mGnssConfiguration;
294 return ScopedAStatus::ok();
295 }
296
getExtensionGnssPowerIndication(std::shared_ptr<IGnssPowerIndication> * iGnssPowerIndication)297 ScopedAStatus Gnss::getExtensionGnssPowerIndication(
298 std::shared_ptr<IGnssPowerIndication>* iGnssPowerIndication) {
299 ALOGD("getExtensionGnssPowerIndication");
300 if (mGnssPowerIndication == nullptr) {
301 mGnssPowerIndication = SharedRefBase::make<GnssPowerIndication>();
302 }
303
304 *iGnssPowerIndication = mGnssPowerIndication;
305 return ScopedAStatus::ok();
306 }
307
getExtensionGnssMeasurement(std::shared_ptr<IGnssMeasurementInterface> * iGnssMeasurement)308 ScopedAStatus Gnss::getExtensionGnssMeasurement(
309 std::shared_ptr<IGnssMeasurementInterface>* iGnssMeasurement) {
310 ALOGD("getExtensionGnssMeasurement");
311 if (mGnssMeasurementInterface == nullptr) {
312 mGnssMeasurementInterface = SharedRefBase::make<GnssMeasurementInterface>();
313 }
314 *iGnssMeasurement = mGnssMeasurementInterface;
315 return ScopedAStatus::ok();
316 }
317
getExtensionGnssBatching(std::shared_ptr<IGnssBatching> * iGnssBatching)318 ScopedAStatus Gnss::getExtensionGnssBatching(std::shared_ptr<IGnssBatching>* iGnssBatching) {
319 ALOGD("getExtensionGnssBatching");
320
321 *iGnssBatching = SharedRefBase::make<GnssBatching>();
322 return ScopedAStatus::ok();
323 }
324
getExtensionGnssGeofence(std::shared_ptr<IGnssGeofence> * iGnssGeofence)325 ScopedAStatus Gnss::getExtensionGnssGeofence(std::shared_ptr<IGnssGeofence>* iGnssGeofence) {
326 ALOGD("getExtensionGnssGeofence");
327
328 *iGnssGeofence = SharedRefBase::make<GnssGeofence>();
329 return ScopedAStatus::ok();
330 }
331
getExtensionGnssNavigationMessage(std::shared_ptr<IGnssNavigationMessageInterface> * iGnssNavigationMessage)332 ScopedAStatus Gnss::getExtensionGnssNavigationMessage(
333 std::shared_ptr<IGnssNavigationMessageInterface>* iGnssNavigationMessage) {
334 ALOGD("getExtensionGnssNavigationMessage");
335
336 *iGnssNavigationMessage = SharedRefBase::make<GnssNavigationMessageInterface>();
337 return ScopedAStatus::ok();
338 }
339
getExtensionGnssDebug(std::shared_ptr<IGnssDebug> * iGnssDebug)340 ndk::ScopedAStatus Gnss::getExtensionGnssDebug(std::shared_ptr<IGnssDebug>* iGnssDebug) {
341 ALOGD("Gnss::getExtensionGnssDebug");
342
343 *iGnssDebug = SharedRefBase::make<GnssDebug>();
344 return ndk::ScopedAStatus::ok();
345 }
346
getExtensionGnssVisibilityControl(std::shared_ptr<visibility_control::IGnssVisibilityControl> * iGnssVisibilityControl)347 ndk::ScopedAStatus Gnss::getExtensionGnssVisibilityControl(
348 std::shared_ptr<visibility_control::IGnssVisibilityControl>* iGnssVisibilityControl) {
349 ALOGD("Gnss::getExtensionGnssVisibilityControl");
350
351 *iGnssVisibilityControl = SharedRefBase::make<visibility_control::GnssVisibilityControl>();
352 return ndk::ScopedAStatus::ok();
353 }
354
getExtensionGnssAntennaInfo(std::shared_ptr<IGnssAntennaInfo> * iGnssAntennaInfo)355 ndk::ScopedAStatus Gnss::getExtensionGnssAntennaInfo(
356 std::shared_ptr<IGnssAntennaInfo>* iGnssAntennaInfo) {
357 ALOGD("Gnss::getExtensionGnssAntennaInfo");
358
359 *iGnssAntennaInfo = SharedRefBase::make<GnssAntennaInfo>();
360 return ndk::ScopedAStatus::ok();
361 }
362
getExtensionMeasurementCorrections(std::shared_ptr<measurement_corrections::IMeasurementCorrectionsInterface> * iMeasurementCorrections)363 ndk::ScopedAStatus Gnss::getExtensionMeasurementCorrections(
364 std::shared_ptr<measurement_corrections::IMeasurementCorrectionsInterface>*
365 iMeasurementCorrections) {
366 ALOGD("Gnss::getExtensionMeasurementCorrections");
367
368 *iMeasurementCorrections =
369 SharedRefBase::make<measurement_corrections::MeasurementCorrectionsInterface>();
370 return ndk::ScopedAStatus::ok();
371 }
372
373 } // namespace aidl::android::hardware::gnss
374