Add VTS tests for measurementInterval, stopSvStatus, and stopNmea
Bug: 206670536
Test: atest VtsHalGnssTargetTest
Change-Id: Id597c772fbe63789cb394b2aa14faeb755196f64
diff --git a/gnss/aidl/default/Gnss.cpp b/gnss/aidl/default/Gnss.cpp
index 7855b51..cf2c90d 100644
--- a/gnss/aidl/default/Gnss.cpp
+++ b/gnss/aidl/default/Gnss.cpp
@@ -19,6 +19,7 @@
#include "Gnss.h"
#include <inttypes.h>
#include <log/log.h>
+#include <utils/Timers.h>
#include "AGnss.h"
#include "AGnssRil.h"
#include "DeviceFileReader.h"
@@ -28,7 +29,6 @@
#include "GnssConfiguration.h"
#include "GnssDebug.h"
#include "GnssGeofence.h"
-#include "GnssMeasurementInterface.h"
#include "GnssNavigationMessageInterface.h"
#include "GnssPsds.h"
#include "GnssVisibilityControl.h"
@@ -95,6 +95,9 @@
}
mIsActive = true;
+ mThreadBlocker.reset();
+ // notify measurement engine to update measurement interval
+ mGnssMeasurementInterface->setLocationEnabled(true);
this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
mThread = std::thread([this]() {
this->reportSvStatus();
@@ -102,8 +105,12 @@
std::this_thread::sleep_for(std::chrono::milliseconds(TTFF_MILLIS));
mFirstFixReceived = true;
}
- while (mIsActive == true) {
+ do {
+ if (!mIsActive) {
+ break;
+ }
this->reportSvStatus();
+ this->reportNmea();
auto currentLocation = getLocationFromHW();
mGnssPowerIndication->notePowerConsumption();
@@ -113,12 +120,29 @@
const auto location = Utils::getMockLocation();
this->reportLocation(location);
}
- std::this_thread::sleep_for(std::chrono::milliseconds(mMinIntervalMs));
- }
+ } while (mIsActive && mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMs)));
});
return ScopedAStatus::ok();
}
+ScopedAStatus Gnss::stop() {
+ ALOGD("stop");
+ mIsActive = false;
+ mGnssMeasurementInterface->setLocationEnabled(false);
+ this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_END);
+ mThreadBlocker.notify();
+ if (mThread.joinable()) {
+ mThread.join();
+ }
+ return ScopedAStatus::ok();
+}
+
+ScopedAStatus Gnss::close() {
+ ALOGD("close");
+ sGnssCallback = nullptr;
+ return ScopedAStatus::ok();
+}
+
void Gnss::reportLocation(const GnssLocation& location) const {
std::unique_lock<std::mutex> lock(mMutex);
if (sGnssCallback == nullptr) {
@@ -153,7 +177,6 @@
std::vector<GnssSvInfo> Gnss::filterBlocklistedSatellites(
std::vector<GnssSvInfo> gnssSvInfoList) const {
- ALOGD("filterBlocklistedSatellites");
for (uint32_t i = 0; i < gnssSvInfoList.size(); i++) {
if (mGnssConfiguration->isBlocklisted(gnssSvInfoList[i])) {
gnssSvInfoList[i].svFlag &= ~(uint32_t)IGnssCallback::GnssSvFlags::USED_IN_FIX;
@@ -174,14 +197,19 @@
}
}
-ScopedAStatus Gnss::stop() {
- ALOGD("stop");
- mIsActive = false;
- this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_END);
- if (mThread.joinable()) {
- mThread.join();
+void Gnss::reportNmea() const {
+ if (mIsNmeaActive) {
+ std::unique_lock<std::mutex> lock(mMutex);
+ if (sGnssCallback == nullptr) {
+ ALOGE("%s: sGnssCallback is null.", __func__);
+ return;
+ }
+ nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+ auto status = sGnssCallback->gnssNmeaCb(now, "$TEST,0,1,2,3,4,5");
+ if (!status.isOk()) {
+ ALOGE("%s: Unable to invoke callback", __func__);
+ }
}
- return ScopedAStatus::ok();
}
ScopedAStatus Gnss::startSvStatus() {
@@ -197,16 +225,12 @@
}
ScopedAStatus Gnss::startNmea() {
ALOGD("startNmea");
+ mIsNmeaActive = true;
return ScopedAStatus::ok();
}
ScopedAStatus Gnss::stopNmea() {
ALOGD("stopNmea");
- return ScopedAStatus::ok();
-}
-
-ScopedAStatus Gnss::close() {
- ALOGD("close");
- sGnssCallback = nullptr;
+ mIsNmeaActive = false;
return ScopedAStatus::ok();
}
@@ -249,7 +273,8 @@
ScopedAStatus Gnss::setPositionMode(const PositionModeOptions& options) {
ALOGD("setPositionMode. minIntervalMs:%d, lowPowerMode:%d", options.minIntervalMs,
(int)options.lowPowerMode);
- mMinIntervalMs = options.minIntervalMs;
+ mMinIntervalMs = std::max(1000, options.minIntervalMs);
+ mGnssMeasurementInterface->setLocationInterval(mMinIntervalMs);
return ScopedAStatus::ok();
}
@@ -283,8 +308,10 @@
ScopedAStatus Gnss::getExtensionGnssMeasurement(
std::shared_ptr<IGnssMeasurementInterface>* iGnssMeasurement) {
ALOGD("getExtensionGnssMeasurement");
-
- *iGnssMeasurement = SharedRefBase::make<GnssMeasurementInterface>();
+ if (mGnssMeasurementInterface == nullptr) {
+ mGnssMeasurementInterface = SharedRefBase::make<GnssMeasurementInterface>();
+ }
+ *iGnssMeasurement = mGnssMeasurementInterface;
return ScopedAStatus::ok();
}
diff --git a/gnss/aidl/default/Gnss.h b/gnss/aidl/default/Gnss.h
index 1489b4b..df10fc8 100644
--- a/gnss/aidl/default/Gnss.h
+++ b/gnss/aidl/default/Gnss.h
@@ -32,7 +32,9 @@
#include <mutex>
#include <thread>
#include "GnssConfiguration.h"
+#include "GnssMeasurementInterface.h"
#include "GnssPowerIndication.h"
+#include "Utils.h"
namespace aidl::android::hardware::gnss {
@@ -84,6 +86,7 @@
std::shared_ptr<GnssConfiguration> mGnssConfiguration;
std::shared_ptr<GnssPowerIndication> mGnssPowerIndication;
+ std::shared_ptr<GnssMeasurementInterface> mGnssMeasurementInterface;
private:
void reportLocation(const GnssLocation&) const;
@@ -93,14 +96,17 @@
std::vector<IGnssCallback::GnssSvInfo> gnssSvInfoList) const;
void reportGnssStatusValue(const IGnssCallback::GnssStatusValue gnssStatusValue) const;
std::unique_ptr<GnssLocation> getLocationFromHW();
+ void reportNmea() const;
static std::shared_ptr<IGnssCallback> sGnssCallback;
std::atomic<long> mMinIntervalMs;
std::atomic<bool> mIsActive;
std::atomic<bool> mIsSvStatusActive;
+ std::atomic<bool> mIsNmeaActive;
std::atomic<bool> mFirstFixReceived;
std::thread mThread;
+ ::android::hardware::gnss::common::ThreadBlocker mThreadBlocker;
mutable std::mutex mMutex;
};
diff --git a/gnss/aidl/default/GnssMeasurementInterface.cpp b/gnss/aidl/default/GnssMeasurementInterface.cpp
index 2c7241b..606de07 100644
--- a/gnss/aidl/default/GnssMeasurementInterface.cpp
+++ b/gnss/aidl/default/GnssMeasurementInterface.cpp
@@ -33,10 +33,11 @@
std::shared_ptr<IGnssMeasurementCallback> GnssMeasurementInterface::sCallback = nullptr;
-GnssMeasurementInterface::GnssMeasurementInterface() : mMinIntervalMillis(1000) {}
+GnssMeasurementInterface::GnssMeasurementInterface()
+ : mIntervalMs(1000), mLocationIntervalMs(1000), mFutures(std::vector<std::future<void>>()) {}
GnssMeasurementInterface::~GnssMeasurementInterface() {
- stop();
+ waitForStoppingThreads();
}
ndk::ScopedAStatus GnssMeasurementInterface::setCallback(
@@ -44,8 +45,10 @@
const bool enableCorrVecOutputs) {
ALOGD("setCallback: enableFullTracking: %d enableCorrVecOutputs: %d", (int)enableFullTracking,
(int)enableCorrVecOutputs);
- std::unique_lock<std::mutex> lock(mMutex);
- sCallback = callback;
+ {
+ std::unique_lock<std::mutex> lock(mMutex);
+ sCallback = callback;
+ }
if (mIsActive) {
ALOGW("GnssMeasurement callback already set. Resetting the callback...");
@@ -60,14 +63,16 @@
const std::shared_ptr<IGnssMeasurementCallback>& callback, const Options& options) {
ALOGD("setCallbackWithOptions: fullTracking:%d, corrVec:%d, intervalMs:%d",
(int)options.enableFullTracking, (int)options.enableCorrVecOutputs, options.intervalMs);
- std::unique_lock<std::mutex> lock(mMutex);
- sCallback = callback;
+ {
+ std::unique_lock<std::mutex> lock(mMutex);
+ sCallback = callback;
+ }
if (mIsActive) {
ALOGW("GnssMeasurement callback already set. Resetting the callback...");
stop();
}
- mMinIntervalMillis = options.intervalMs;
+ mIntervalMs = std::max(options.intervalMs, 1000);
start(options.enableCorrVecOutputs);
return ndk::ScopedAStatus::ok();
@@ -75,18 +80,35 @@
ndk::ScopedAStatus GnssMeasurementInterface::close() {
ALOGD("close");
- stop();
- std::unique_lock<std::mutex> lock(mMutex);
- sCallback = nullptr;
- mMinIntervalMillis = 1000;
+ if (mIsActive) {
+ stop();
+ }
+ {
+ std::unique_lock<std::mutex> lock(mMutex);
+ sCallback = nullptr;
+ }
+ mIntervalMs = 1000;
return ndk::ScopedAStatus::ok();
}
void GnssMeasurementInterface::start(const bool enableCorrVecOutputs) {
ALOGD("start");
+
+ if (mIsActive) {
+ ALOGD("restarting since measurement has started");
+ stop();
+ }
+ // Wait for stopping previous thread.
+ waitForStoppingThreads();
+
mIsActive = true;
+ mThreadBlocker.reset();
mThread = std::thread([this, enableCorrVecOutputs]() {
- while (mIsActive == true) {
+ int intervalMs;
+ do {
+ if (!mIsActive) {
+ break;
+ }
std::string rawMeasurementStr = "";
if (ReplayUtils::hasGnssDeviceFile() &&
ReplayUtils::isGnssRawMeasurement(
@@ -103,15 +125,19 @@
auto measurement = Utils::getMockMeasurement(enableCorrVecOutputs);
this->reportMeasurement(measurement);
}
- std::this_thread::sleep_for(std::chrono::milliseconds(mMinIntervalMillis));
- }
+ intervalMs =
+ (mLocationEnabled) ? std::min(mLocationIntervalMs, mIntervalMs) : mIntervalMs;
+ } while (mIsActive && mThreadBlocker.wait_for(std::chrono::milliseconds(intervalMs)));
});
- mThread.detach();
}
void GnssMeasurementInterface::stop() {
ALOGD("stop");
mIsActive = false;
+ mThreadBlocker.notify();
+ if (mThread.joinable()) {
+ mFutures.push_back(std::async(std::launch::async, [this] { mThread.join(); }));
+ }
}
void GnssMeasurementInterface::reportMeasurement(const GnssData& data) {
@@ -128,4 +154,21 @@
callbackCopy->gnssMeasurementCb(data);
}
+void GnssMeasurementInterface::setLocationInterval(const int intervalMs) {
+ mLocationIntervalMs = intervalMs;
+}
+
+void GnssMeasurementInterface::setLocationEnabled(const bool enabled) {
+ mLocationEnabled = enabled;
+}
+
+void GnssMeasurementInterface::waitForStoppingThreads() {
+ for (auto& future : mFutures) {
+ ALOGD("Stopping previous thread.");
+ future.wait();
+ ALOGD("Done stopping thread.");
+ }
+ mFutures.clear();
+}
+
} // namespace aidl::android::hardware::gnss
diff --git a/gnss/aidl/default/GnssMeasurementInterface.h b/gnss/aidl/default/GnssMeasurementInterface.h
index bf77806..bb08027 100644
--- a/gnss/aidl/default/GnssMeasurementInterface.h
+++ b/gnss/aidl/default/GnssMeasurementInterface.h
@@ -19,8 +19,10 @@
#include <aidl/android/hardware/gnss/BnGnssMeasurementCallback.h>
#include <aidl/android/hardware/gnss/BnGnssMeasurementInterface.h>
#include <atomic>
+#include <future>
#include <mutex>
#include <thread>
+#include "Utils.h"
namespace aidl::android::hardware::gnss {
@@ -35,15 +37,22 @@
ndk::ScopedAStatus setCallbackWithOptions(
const std::shared_ptr<IGnssMeasurementCallback>& callback,
const Options& options) override;
+ void setLocationInterval(const int intervalMs);
+ void setLocationEnabled(const bool enabled);
private:
void start(const bool enableCorrVecOutputs);
void stop();
void reportMeasurement(const GnssData&);
+ void waitForStoppingThreads();
- std::atomic<long> mMinIntervalMillis;
+ std::atomic<long> mIntervalMs;
+ std::atomic<long> mLocationIntervalMs;
std::atomic<bool> mIsActive;
+ std::atomic<bool> mLocationEnabled;
std::thread mThread;
+ std::vector<std::future<void>> mFutures;
+ ::android::hardware::gnss::common::ThreadBlocker mThreadBlocker;
// Guarded by mMutex
static std::shared_ptr<IGnssMeasurementCallback> sCallback;
diff --git a/gnss/aidl/default/GnssNavigationMessageInterface.cpp b/gnss/aidl/default/GnssNavigationMessageInterface.cpp
index 4bc859d..75b9624 100644
--- a/gnss/aidl/default/GnssNavigationMessageInterface.cpp
+++ b/gnss/aidl/default/GnssNavigationMessageInterface.cpp
@@ -32,7 +32,7 @@
GnssNavigationMessageInterface::GnssNavigationMessageInterface() : mMinIntervalMillis(1000) {}
GnssNavigationMessageInterface::~GnssNavigationMessageInterface() {
- stop();
+ waitForStoppingThreads();
}
ndk::ScopedAStatus GnssNavigationMessageInterface::setCallback(
@@ -46,7 +46,9 @@
ndk::ScopedAStatus GnssNavigationMessageInterface::close() {
ALOGD("close");
- stop();
+ if (mIsActive) {
+ stop();
+ }
std::unique_lock<std::mutex> lock(mMutex);
sCallback = nullptr;
return ndk::ScopedAStatus::ok();
@@ -54,9 +56,20 @@
void GnssNavigationMessageInterface::start() {
ALOGD("start");
+
+ if (mIsActive) {
+ ALOGD("restarting since nav msg has started");
+ stop();
+ }
+ // Wait for stopping previous thread.
+ waitForStoppingThreads();
+
mIsActive = true;
mThread = std::thread([this]() {
- while (mIsActive == true) {
+ do {
+ if (!mIsActive) {
+ break;
+ }
GnssNavigationMessage message = {
.svid = 19,
.type = GnssNavigationMessageType::GPS_L1CA,
@@ -66,15 +79,18 @@
.data = std::vector<uint8_t>(40, 0xF9),
};
this->reportMessage(message);
- std::this_thread::sleep_for(std::chrono::milliseconds(mMinIntervalMillis));
- }
+ } while (mIsActive &&
+ mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMillis)));
});
- mThread.detach();
}
void GnssNavigationMessageInterface::stop() {
ALOGD("stop");
mIsActive = false;
+ mThreadBlocker.notify();
+ if (mThread.joinable()) {
+ mFutures.push_back(std::async(std::launch::async, [this] { mThread.join(); }));
+ }
}
void GnssNavigationMessageInterface::reportMessage(const GnssNavigationMessage& message) {
@@ -91,4 +107,13 @@
callbackCopy->gnssNavigationMessageCb(message);
}
+void GnssNavigationMessageInterface::waitForStoppingThreads() {
+ for (auto& future : mFutures) {
+ ALOGD("Stopping previous thread.");
+ future.wait();
+ ALOGD("Done stopping thread.");
+ }
+ mFutures.clear();
+}
+
} // namespace aidl::android::hardware::gnss
diff --git a/gnss/aidl/default/GnssNavigationMessageInterface.h b/gnss/aidl/default/GnssNavigationMessageInterface.h
index 600b23a..b335348 100644
--- a/gnss/aidl/default/GnssNavigationMessageInterface.h
+++ b/gnss/aidl/default/GnssNavigationMessageInterface.h
@@ -18,7 +18,9 @@
#include <aidl/android/hardware/gnss/BnGnssNavigationMessageInterface.h>
#include <atomic>
+#include <future>
#include <thread>
+#include "Utils.h"
namespace aidl::android::hardware::gnss {
@@ -34,10 +36,13 @@
void start();
void stop();
void reportMessage(const IGnssNavigationMessageCallback::GnssNavigationMessage& message);
+ void waitForStoppingThreads();
std::atomic<long> mMinIntervalMillis;
std::atomic<bool> mIsActive;
std::thread mThread;
+ std::vector<std::future<void>> mFutures;
+ ::android::hardware::gnss::common::ThreadBlocker mThreadBlocker;
// Guarded by mMutex
static std::shared_ptr<IGnssNavigationMessageCallback> sCallback;