blob: 3907f57dc745ddce3aa9640d5486403c8a878ed4 [file] [log] [blame]
Yu-Han Yang1e1a6762020-09-30 17:01:53 -07001/*
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
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080017#define LOG_TAG "GnssHalTest"
18
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070019#include "gnss_hal_test.h"
20#include <hidl/ServiceManagement.h>
Yu-Han Yang19a32b62022-04-27 09:57:01 -070021#include <algorithm>
22#include <cmath>
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080023#include "Utils.h"
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070024
Yu-Han Yang19a32b62022-04-27 09:57:01 -070025using android::hardware::gnss::GnssClock;
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080026using android::hardware::gnss::GnssConstellationType;
Yu-Han Yang19a32b62022-04-27 09:57:01 -070027using android::hardware::gnss::GnssData;
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080028using android::hardware::gnss::GnssLocation;
Yu-Han Yang19a32b62022-04-27 09:57:01 -070029using android::hardware::gnss::GnssMeasurement;
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080030using android::hardware::gnss::IGnss;
31using android::hardware::gnss::IGnssCallback;
Yu-Han Yang19a32b62022-04-27 09:57:01 -070032using android::hardware::gnss::IGnssMeasurementInterface;
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080033using android::hardware::gnss::common::Utils;
34using GnssConstellationTypeV2_0 = android::hardware::gnss::V2_0::GnssConstellationType;
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070035
Yu-Han Yang19a32b62022-04-27 09:57:01 -070036namespace {
37// The difference between the mean of the received intervals and the requested interval should not
38// be larger mInterval * ALLOWED_MEAN_ERROR_RATIO
39constexpr double ALLOWED_MEAN_ERROR_RATIO = 0.25;
40
41// The standard deviation computed for the deltas should not be bigger
42// than mInterval * ALLOWED_STDEV_ERROR_RATIO or MIN_STDEV_MS, whichever is higher.
43constexpr double ALLOWED_STDEV_ERROR_RATIO = 0.50;
44constexpr double MIN_STDEV_MS = 1000;
45
46double computeMean(std::vector<int>& deltas) {
47 long accumulator = 0;
48 for (auto& d : deltas) {
49 accumulator += d;
50 }
51 return accumulator / deltas.size();
52}
53
54double computeStdev(double mean, std::vector<int>& deltas) {
55 double accumulator = 0;
56 for (auto& d : deltas) {
57 double diff = d - mean;
58 accumulator += diff * diff;
59 }
60 return std::sqrt(accumulator / (deltas.size() - 1));
61}
62
63} // anonymous namespace
64
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070065void GnssHalTest::SetUp() {
66 // Get AIDL handle
67 aidl_gnss_hal_ = android::waitForDeclaredService<IGnssAidl>(String16(GetParam().c_str()));
68 ASSERT_NE(aidl_gnss_hal_, nullptr);
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080069 ALOGD("AIDL Interface Version = %d", aidl_gnss_hal_->getInterfaceVersion());
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070070
Yu-Han Yang4165ed12022-02-09 14:47:50 -080071 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080072 const auto& hidlInstanceNames = android::hardware::getAllHalInstanceNames(
73 android::hardware::gnss::V2_1::IGnss::descriptor);
74 gnss_hal_ = IGnss_V2_1::getService(hidlInstanceNames[0]);
75 ASSERT_NE(gnss_hal_, nullptr);
76 }
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070077
78 SetUpGnssCallback();
79}
80
81void GnssHalTest::SetUpGnssCallback() {
82 aidl_gnss_cb_ = new GnssCallbackAidl();
83 ASSERT_NE(aidl_gnss_cb_, nullptr);
84
85 auto status = aidl_gnss_hal_->setCallback(aidl_gnss_cb_);
86 if (!status.isOk()) {
87 ALOGE("Failed to setCallback");
88 }
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070089 ASSERT_TRUE(status.isOk());
90
91 /*
92 * Capabilities callback should trigger.
93 */
94 EXPECT_TRUE(aidl_gnss_cb_->capabilities_cbq_.retrieve(aidl_gnss_cb_->last_capabilities_,
95 TIMEOUT_SEC));
Yu-Han Yang1e1a6762020-09-30 17:01:53 -070096 EXPECT_EQ(aidl_gnss_cb_->capabilities_cbq_.calledCount(), 1);
97
Yu-Han Yang4165ed12022-02-09 14:47:50 -080098 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -080099 // Invoke the super method.
100 GnssHalTestTemplate<IGnss_V2_1>::SetUpGnssCallback();
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800101 } else {
102 /*
103 * SystemInfo callback should trigger
104 */
105 EXPECT_TRUE(aidl_gnss_cb_->info_cbq_.retrieve(aidl_gnss_cb_->last_info_, TIMEOUT_SEC));
106 EXPECT_EQ(aidl_gnss_cb_->info_cbq_.calledCount(), 1);
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800107 }
108}
109
Yu-Han Yang25cd9d62022-10-13 23:06:31 +0000110void GnssHalTest::TearDown() {
111 GnssHalTestTemplate<IGnss_V2_1>::TearDown();
112 if (aidl_gnss_hal_ != nullptr) {
113 aidl_gnss_hal_->close();
114 aidl_gnss_hal_ = nullptr;
115 }
116
117 // Set to nullptr to destruct the callback event queues and warn of any unprocessed events.
118 aidl_gnss_cb_ = nullptr;
119}
120
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800121void GnssHalTest::CheckLocation(const GnssLocation& location, bool check_speed) {
122 Utils::checkLocation(location, check_speed, /* check_more_accuracies= */ true);
123}
124
125void GnssHalTest::SetPositionMode(const int min_interval_msec, const bool low_power_mode) {
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800126 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800127 // Invoke the super method.
128 return GnssHalTestTemplate<IGnss_V2_1>::SetPositionMode(min_interval_msec, low_power_mode);
129 }
130
131 const int kPreferredAccuracy = 0; // Ideally perfect (matches GnssLocationProvider)
132 const int kPreferredTimeMsec = 0; // Ideally immediate
133
Yu-Han Yang75934f72022-01-24 15:35:25 -0800134 IGnss::PositionModeOptions options;
135 options.mode = IGnss::GnssPositionMode::MS_BASED;
136 options.recurrence = IGnss::GnssPositionRecurrence::RECURRENCE_PERIODIC;
137 options.minIntervalMs = min_interval_msec;
138 options.preferredAccuracyMeters = kPreferredAccuracy;
139 options.preferredTimeMs = kPreferredTimeMsec;
140 options.lowPowerMode = low_power_mode;
141 auto status = aidl_gnss_hal_->setPositionMode(options);
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800142
143 ASSERT_TRUE(status.isOk());
144}
145
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700146bool GnssHalTest::StartAndCheckFirstLocation(const int min_interval_msec, const bool low_power_mode,
147 const bool start_sv_status, const bool start_nmea) {
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800148 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800149 // Invoke the super method.
150 return GnssHalTestTemplate<IGnss_V2_1>::StartAndCheckFirstLocation(min_interval_msec,
151 low_power_mode);
152 }
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800153 SetPositionMode(min_interval_msec, low_power_mode);
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700154
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700155 if (start_sv_status) {
Yu-Han Yangdcf3c512022-06-09 23:01:28 +0000156 auto status = aidl_gnss_hal_->startSvStatus();
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700157 EXPECT_TRUE(status.isOk());
158 }
159 if (start_nmea) {
Yu-Han Yangdcf3c512022-06-09 23:01:28 +0000160 auto status = aidl_gnss_hal_->startNmea();
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700161 EXPECT_TRUE(status.isOk());
162 }
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800163
Yu-Han Yangdcf3c512022-06-09 23:01:28 +0000164 auto status = aidl_gnss_hal_->start();
165 EXPECT_TRUE(status.isOk());
166
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800167 /*
168 * GnssLocationProvider support of AGPS SUPL & XtraDownloader is not available in VTS,
169 * so allow time to demodulate ephemeris over the air.
170 */
171 const int kFirstGnssLocationTimeoutSeconds = 75;
172
173 EXPECT_TRUE(aidl_gnss_cb_->location_cbq_.retrieve(aidl_gnss_cb_->last_location_,
174 kFirstGnssLocationTimeoutSeconds));
175 int locationCalledCount = aidl_gnss_cb_->location_cbq_.calledCount();
176 EXPECT_EQ(locationCalledCount, 1);
177
178 if (locationCalledCount > 0) {
179 // don't require speed on first fix
180 CheckLocation(aidl_gnss_cb_->last_location_, false);
181 return true;
182 }
183 return false;
184}
185
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700186bool GnssHalTest::StartAndCheckFirstLocation(const int min_interval_msec,
187 const bool low_power_mode) {
188 return StartAndCheckFirstLocation(min_interval_msec, low_power_mode,
189 /* start_sv_status= */ true, /* start_nmea= */ true);
190}
191
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800192void GnssHalTest::StopAndClearLocations() {
193 ALOGD("StopAndClearLocations");
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800194 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800195 // Invoke the super method.
196 return GnssHalTestTemplate<IGnss_V2_1>::StopAndClearLocations();
197 }
Yu-Han Yang69f0f8b2022-01-21 13:03:32 -0800198 auto status = aidl_gnss_hal_->stopSvStatus();
199 EXPECT_TRUE(status.isOk());
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700200 status = aidl_gnss_hal_->stopNmea();
201 EXPECT_TRUE(status.isOk());
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800202
Yu-Han Yang69f0f8b2022-01-21 13:03:32 -0800203 status = aidl_gnss_hal_->stop();
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800204 EXPECT_TRUE(status.isOk());
205
206 /*
207 * Clear notify/waiting counter, allowing up till the timeout after
208 * the last reply for final startup messages to arrive (esp. system
209 * info.)
210 */
211 while (aidl_gnss_cb_->location_cbq_.retrieve(aidl_gnss_cb_->last_location_, TIMEOUT_SEC)) {
212 }
213 aidl_gnss_cb_->location_cbq_.reset();
214}
215
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700216void GnssHalTest::StartAndCheckLocations(const int count, const bool start_sv_status,
217 const bool start_nmea) {
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800218 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800219 // Invoke the super method.
220 return GnssHalTestTemplate<IGnss_V2_1>::StartAndCheckLocations(count);
221 }
222 const int kMinIntervalMsec = 500;
223 const int kLocationTimeoutSubsequentSec = 2;
224 const bool kLowPowerMode = false;
225
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700226 EXPECT_TRUE(StartAndCheckFirstLocation(kMinIntervalMsec, kLowPowerMode, start_sv_status,
227 start_nmea));
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800228
229 for (int i = 1; i < count; i++) {
230 EXPECT_TRUE(aidl_gnss_cb_->location_cbq_.retrieve(aidl_gnss_cb_->last_location_,
231 kLocationTimeoutSubsequentSec));
232 int locationCalledCount = aidl_gnss_cb_->location_cbq_.calledCount();
233 EXPECT_EQ(locationCalledCount, i + 1);
234 // Don't cause confusion by checking details if no location yet
235 if (locationCalledCount > 0) {
236 // Should be more than 1 location by now, but if not, still don't check first fix speed
237 CheckLocation(aidl_gnss_cb_->last_location_, locationCalledCount > 1);
238 }
239 }
240}
241
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700242void GnssHalTest::StartAndCheckLocations(const int count) {
243 StartAndCheckLocations(count, /* start_sv_status= */ true, /* start_nmea= */ true);
244}
245
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800246std::list<std::vector<IGnssCallback::GnssSvInfo>> GnssHalTest::convertToAidl(
247 const std::list<hidl_vec<IGnssCallback_2_1::GnssSvInfo>>& sv_info_list) {
248 std::list<std::vector<IGnssCallback::GnssSvInfo>> aidl_sv_info_list;
249 for (const auto& sv_info_vec : sv_info_list) {
250 std::vector<IGnssCallback::GnssSvInfo> aidl_sv_info_vec;
251 for (const auto& sv_info : sv_info_vec) {
252 IGnssCallback::GnssSvInfo aidl_sv_info;
253 aidl_sv_info.svid = sv_info.v2_0.v1_0.svid;
254 aidl_sv_info.constellation =
255 static_cast<GnssConstellationType>(sv_info.v2_0.constellation);
256 aidl_sv_info.cN0Dbhz = sv_info.v2_0.v1_0.cN0Dbhz;
257 aidl_sv_info.basebandCN0DbHz = sv_info.basebandCN0DbHz;
258 aidl_sv_info.elevationDegrees = sv_info.v2_0.v1_0.elevationDegrees;
259 aidl_sv_info.azimuthDegrees = sv_info.v2_0.v1_0.azimuthDegrees;
260 aidl_sv_info.carrierFrequencyHz = (int64_t)sv_info.v2_0.v1_0.carrierFrequencyHz;
261 aidl_sv_info.svFlag = (int)sv_info.v2_0.v1_0.svFlag;
262 aidl_sv_info_vec.push_back(aidl_sv_info);
263 }
264 aidl_sv_info_list.push_back(aidl_sv_info_vec);
265 }
266 return aidl_sv_info_list;
267}
268
269/*
270 * FindStrongFrequentNonGpsSource:
271 *
272 * Search through a GnssSvStatus list for the strongest non-GPS satellite observed enough times
273 *
274 * returns the strongest source,
275 * or a source with constellation == UNKNOWN if none are found sufficient times
276 */
277BlocklistedSource GnssHalTest::FindStrongFrequentNonGpsSource(
278 const std::list<hidl_vec<IGnssCallback_2_1::GnssSvInfo>> sv_info_list,
279 const int min_observations) {
280 return FindStrongFrequentNonGpsSource(convertToAidl(sv_info_list), min_observations);
281}
282
283BlocklistedSource GnssHalTest::FindStrongFrequentNonGpsSource(
284 const std::list<std::vector<IGnssCallback::GnssSvInfo>> sv_info_list,
285 const int min_observations) {
286 std::map<ComparableBlocklistedSource, SignalCounts> mapSignals;
287
288 for (const auto& sv_info_vec : sv_info_list) {
289 for (uint32_t iSv = 0; iSv < sv_info_vec.size(); iSv++) {
290 const auto& gnss_sv = sv_info_vec[iSv];
291 if ((gnss_sv.svFlag & (int)IGnssCallback::GnssSvFlags::USED_IN_FIX) &&
292 (gnss_sv.constellation != GnssConstellationType::GPS)) {
293 ComparableBlocklistedSource source;
294 source.id.svid = gnss_sv.svid;
295 source.id.constellation = gnss_sv.constellation;
296
297 const auto& itSignal = mapSignals.find(source);
298 if (itSignal == mapSignals.end()) {
299 SignalCounts counts;
300 counts.observations = 1;
301 counts.max_cn0_dbhz = gnss_sv.cN0Dbhz;
302 mapSignals.insert(
303 std::pair<ComparableBlocklistedSource, SignalCounts>(source, counts));
304 } else {
305 itSignal->second.observations++;
306 if (itSignal->second.max_cn0_dbhz < gnss_sv.cN0Dbhz) {
307 itSignal->second.max_cn0_dbhz = gnss_sv.cN0Dbhz;
308 }
309 }
310 }
311 }
312 }
313
314 float max_cn0_dbhz_with_sufficient_count = 0.;
315 int total_observation_count = 0;
316 int blocklisted_source_count_observation = 0;
317
318 ComparableBlocklistedSource source_to_blocklist; // initializes to zero = UNKNOWN constellation
319 for (auto const& pairSignal : mapSignals) {
320 total_observation_count += pairSignal.second.observations;
321 if ((pairSignal.second.observations >= min_observations) &&
322 (pairSignal.second.max_cn0_dbhz > max_cn0_dbhz_with_sufficient_count)) {
323 source_to_blocklist = pairSignal.first;
324 blocklisted_source_count_observation = pairSignal.second.observations;
325 max_cn0_dbhz_with_sufficient_count = pairSignal.second.max_cn0_dbhz;
326 }
327 }
328 ALOGD("Among %d observations, chose svid %d, constellation %d, "
329 "with %d observations at %.1f max CNo",
330 total_observation_count, source_to_blocklist.id.svid,
331 (int)source_to_blocklist.id.constellation, blocklisted_source_count_observation,
332 max_cn0_dbhz_with_sufficient_count);
333
334 return source_to_blocklist.id;
335}
336
337GnssConstellationType GnssHalTest::startLocationAndGetNonGpsConstellation(
338 const int locations_to_await, const int gnss_sv_info_list_timeout) {
Yu-Han Yang4165ed12022-02-09 14:47:50 -0800339 if (aidl_gnss_hal_->getInterfaceVersion() <= 1) {
Yu-Han Yang1afbd5f2021-11-24 16:39:13 -0800340 return static_cast<GnssConstellationType>(
341 GnssHalTestTemplate<IGnss_V2_1>::startLocationAndGetNonGpsConstellation(
342 locations_to_await, gnss_sv_info_list_timeout));
343 }
344 aidl_gnss_cb_->location_cbq_.reset();
345 StartAndCheckLocations(locations_to_await);
346 const int location_called_count = aidl_gnss_cb_->location_cbq_.calledCount();
347
348 // Tolerate 1 less sv status to handle edge cases in reporting.
349 int sv_info_list_cbq_size = aidl_gnss_cb_->sv_info_list_cbq_.size();
350 EXPECT_GE(sv_info_list_cbq_size + 1, locations_to_await);
351 ALOGD("Observed %d GnssSvInfo, while awaiting %d Locations (%d received)",
352 sv_info_list_cbq_size, locations_to_await, location_called_count);
353
354 // Find first non-GPS constellation to blocklist
355 GnssConstellationType constellation_to_blocklist = GnssConstellationType::UNKNOWN;
356 for (int i = 0; i < sv_info_list_cbq_size; ++i) {
357 std::vector<IGnssCallback::GnssSvInfo> sv_info_vec;
358 aidl_gnss_cb_->sv_info_list_cbq_.retrieve(sv_info_vec, gnss_sv_info_list_timeout);
359 for (uint32_t iSv = 0; iSv < sv_info_vec.size(); iSv++) {
360 auto& gnss_sv = sv_info_vec[iSv];
361 if ((gnss_sv.svFlag & (uint32_t)IGnssCallback::GnssSvFlags::USED_IN_FIX) &&
362 (gnss_sv.constellation != GnssConstellationType::UNKNOWN) &&
363 (gnss_sv.constellation != GnssConstellationType::GPS)) {
364 // found a non-GPS constellation
365 constellation_to_blocklist = gnss_sv.constellation;
366 break;
367 }
368 }
369 if (constellation_to_blocklist != GnssConstellationType::UNKNOWN) {
370 break;
371 }
372 }
373
374 if (constellation_to_blocklist == GnssConstellationType::UNKNOWN) {
375 ALOGI("No non-GPS constellations found, constellation blocklist test less effective.");
376 // Proceed functionally to blocklist something.
377 constellation_to_blocklist = GnssConstellationType::GLONASS;
378 }
379
380 return constellation_to_blocklist;
Yu-Han Yang1e1a6762020-09-30 17:01:53 -0700381}
Yu-Han Yang19a32b62022-04-27 09:57:01 -0700382
383void GnssHalTest::checkGnssMeasurementClockFields(const GnssData& measurement) {
384 Utils::checkElapsedRealtime(measurement.elapsedRealtime);
385 ASSERT_TRUE(measurement.clock.gnssClockFlags >= 0 &&
386 measurement.clock.gnssClockFlags <=
387 (GnssClock::HAS_LEAP_SECOND | GnssClock::HAS_TIME_UNCERTAINTY |
388 GnssClock::HAS_FULL_BIAS | GnssClock::HAS_BIAS |
389 GnssClock::HAS_BIAS_UNCERTAINTY | GnssClock::HAS_DRIFT |
390 GnssClock::HAS_DRIFT_UNCERTAINTY));
391}
392
393void GnssHalTest::checkGnssMeasurementFlags(const GnssMeasurement& measurement) {
394 ASSERT_TRUE(measurement.flags >= 0 &&
395 measurement.flags <=
396 (GnssMeasurement::HAS_SNR | GnssMeasurement::HAS_CARRIER_FREQUENCY |
397 GnssMeasurement::HAS_CARRIER_CYCLES | GnssMeasurement::HAS_CARRIER_PHASE |
398 GnssMeasurement::HAS_CARRIER_PHASE_UNCERTAINTY |
399 GnssMeasurement::HAS_AUTOMATIC_GAIN_CONTROL |
400 GnssMeasurement::HAS_FULL_ISB | GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY |
401 GnssMeasurement::HAS_SATELLITE_ISB |
402 GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY |
403 GnssMeasurement::HAS_SATELLITE_PVT |
404 GnssMeasurement::HAS_CORRELATION_VECTOR));
405}
406
407void GnssHalTest::checkGnssMeasurementFields(const GnssMeasurement& measurement,
408 const GnssData& data) {
409 checkGnssMeasurementFlags(measurement);
410 // Verify CodeType is valid.
411 ASSERT_NE(measurement.signalType.codeType, "");
412 // Verify basebandCn0DbHz is valid.
413 ASSERT_TRUE(measurement.basebandCN0DbHz > 0.0 && measurement.basebandCN0DbHz <= 65.0);
414
415 if (((measurement.flags & GnssMeasurement::HAS_FULL_ISB) > 0) &&
416 ((measurement.flags & GnssMeasurement::HAS_FULL_ISB_UNCERTAINTY) > 0) &&
417 ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB) > 0) &&
418 ((measurement.flags & GnssMeasurement::HAS_SATELLITE_ISB_UNCERTAINTY) > 0)) {
419 GnssConstellationType referenceConstellation =
420 data.clock.referenceSignalTypeForIsb.constellation;
421 double carrierFrequencyHz = data.clock.referenceSignalTypeForIsb.carrierFrequencyHz;
422 std::string codeType = data.clock.referenceSignalTypeForIsb.codeType;
423
424 ASSERT_TRUE(referenceConstellation >= GnssConstellationType::UNKNOWN &&
425 referenceConstellation <= GnssConstellationType::IRNSS);
426 ASSERT_TRUE(carrierFrequencyHz > 0);
427 ASSERT_NE(codeType, "");
428
429 ASSERT_TRUE(std::abs(measurement.fullInterSignalBiasNs) < 1.0e6);
430 ASSERT_TRUE(measurement.fullInterSignalBiasUncertaintyNs >= 0);
431 ASSERT_TRUE(std::abs(measurement.satelliteInterSignalBiasNs) < 1.0e6);
432 ASSERT_TRUE(measurement.satelliteInterSignalBiasUncertaintyNs >= 0);
433 }
434}
435
436void GnssHalTest::startMeasurementWithInterval(
437 int intervalMs, const sp<IGnssMeasurementInterface>& iGnssMeasurement,
438 sp<GnssMeasurementCallbackAidl>& callback) {
439 ALOGD("Start requesting measurement at interval of %d millis.", intervalMs);
440 IGnssMeasurementInterface::Options options;
441 options.intervalMs = intervalMs;
442 auto status = iGnssMeasurement->setCallbackWithOptions(callback, options);
443 ASSERT_TRUE(status.isOk());
444}
445
446void GnssHalTest::collectMeasurementIntervals(const sp<GnssMeasurementCallbackAidl>& callback,
447 const int numMeasurementEvents,
448 const int timeoutSeconds,
449 std::vector<int>& deltasMs) {
450 int64_t lastElapsedRealtimeMillis = 0;
451 for (int i = 0; i < numMeasurementEvents; i++) {
452 GnssData lastGnssData;
453 ASSERT_TRUE(callback->gnss_data_cbq_.retrieve(lastGnssData, timeoutSeconds));
454 EXPECT_EQ(callback->gnss_data_cbq_.calledCount(), i + 1);
455 ASSERT_TRUE(lastGnssData.measurements.size() > 0);
456
457 // Validity check GnssData fields
458 checkGnssMeasurementClockFields(lastGnssData);
459 for (const auto& measurement : lastGnssData.measurements) {
460 checkGnssMeasurementFields(measurement, lastGnssData);
461 }
462
463 long currentElapsedRealtimeMillis = lastGnssData.elapsedRealtime.timestampNs * 1e-6;
464 if (lastElapsedRealtimeMillis != 0) {
465 deltasMs.push_back(currentElapsedRealtimeMillis - lastElapsedRealtimeMillis);
466 }
467 lastElapsedRealtimeMillis = currentElapsedRealtimeMillis;
468 }
469}
470
471void GnssHalTest::assertMeanAndStdev(int intervalMs, std::vector<int>& deltasMs) {
472 double mean = computeMean(deltasMs);
473 double stdev = computeStdev(mean, deltasMs);
474 EXPECT_TRUE(std::abs(mean - intervalMs) <= intervalMs * ALLOWED_MEAN_ERROR_RATIO)
475 << "Test failed, because the mean of intervals is " << mean
476 << " millis. The test requires that abs(" << mean << " - " << intervalMs
477 << ") <= " << intervalMs * ALLOWED_MEAN_ERROR_RATIO
478 << " millis, when the requested interval is " << intervalMs << " millis.";
479
480 double maxStdev = std::max(MIN_STDEV_MS, intervalMs * ALLOWED_STDEV_ERROR_RATIO);
481 EXPECT_TRUE(stdev <= maxStdev)
482 << "Test failed, because the stdev of intervals is " << stdev
483 << " millis, which must be <= " << maxStdev
484 << " millis, when the requested interval is " << intervalMs << " millis.";
485 ALOGD("Mean of interval deltas in millis: %.1lf", mean);
486 ALOGD("Stdev of interval deltas in millis: %.1lf", stdev);
487}