Snap for 13256841 from 1fda3ca6b608840e58a1e36014c784d21c76b977 to 25Q2-release
Change-Id: Id86f4ce661346cd54072a481866a5c801e95461c
diff --git a/camera/device/default/ExternalCameraDeviceSession.cpp b/camera/device/default/ExternalCameraDeviceSession.cpp
index abd5d7e..9c55ea9 100644
--- a/camera/device/default/ExternalCameraDeviceSession.cpp
+++ b/camera/device/default/ExternalCameraDeviceSession.cpp
@@ -1185,6 +1185,7 @@
if (numAttempt == MAX_RETRY) {
break;
}
+ numAttempt++;
if (ret < 0) {
ALOGW("%s: VIDIOC_STREAMON failed, wait 33ms and try again", __FUNCTION__);
usleep(IOCTL_RETRY_SLEEP_US); // sleep 100 ms and try again
diff --git a/gnss/aidl/default/Gnss.cpp b/gnss/aidl/default/Gnss.cpp
index 1fd21d8..a0510ce 100644
--- a/gnss/aidl/default/Gnss.cpp
+++ b/gnss/aidl/default/Gnss.cpp
@@ -91,6 +91,52 @@
if (!status.isOk()) {
ALOGE("%s: Unable to invoke callback.gnssSetSignalTypeCapabilitiesCb", __func__);
}
+
+ // In case when the setCallback() and close() calls are not balanced
+ mIsInitialized = false;
+ mIsActive = false;
+ mThreadBlocker.notify();
+ if (mThread.joinable()) {
+ mThread.join();
+ }
+
+ mIsInitialized = true;
+ mThreadBlocker.reset();
+ mThread = std::thread([this]() {
+ while (mIsInitialized) {
+ if (mIsActive) {
+ if (mReportedLocationCount == 0) {
+ if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
+ this->reportSvStatus();
+ }
+ if (!mFirstFixReceived) {
+ // Simulate the code start TTFF
+ std::this_thread::sleep_for(std::chrono::milliseconds(TTFF_MILLIS));
+ mFirstFixReceived = true;
+ }
+ }
+ if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
+ this->reportSvStatus();
+ }
+ this->reportNmea();
+
+ auto currentLocation = getLocationFromHW();
+ mGnssPowerIndication->notePowerConsumption();
+ if (currentLocation != nullptr) {
+ this->reportLocation(*currentLocation);
+ } else {
+ const auto location = Utils::getMockLocation();
+ this->reportLocation(location);
+ }
+ mReportedLocationCount += 1;
+ mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMs));
+ } else {
+ // Wait indefinitely until start() or close() is called
+ mThreadBlocker.wait();
+ }
+ }
+ });
+
return ScopedAStatus::ok();
}
@@ -104,48 +150,16 @@
}
ScopedAStatus Gnss::start() {
- ALOGD("start()");
+ ALOGD("start");
if (mIsActive) {
ALOGW("Gnss has started. Restarting...");
stop();
}
-
mIsActive = true;
- mThreadBlocker.reset();
// notify measurement engine to update measurement interval
mGnssMeasurementInterface->setLocationEnabled(true);
this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
- mThread = std::thread([this]() {
- if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
- this->reportSvStatus();
- }
- if (!mFirstFixReceived) {
- std::this_thread::sleep_for(std::chrono::milliseconds(TTFF_MILLIS));
- mFirstFixReceived = true;
- }
- int reportGnssCount = 0;
- do {
- if (!mIsActive) {
- ALOGD("Do not report location. mIsActive is false");
- break;
- }
- reportGnssCount += 1;
- if (!mGnssMeasurementEnabled || mMinIntervalMs <= mGnssMeasurementIntervalMs) {
- this->reportSvStatus();
- }
- this->reportNmea();
-
- auto currentLocation = getLocationFromHW();
- mGnssPowerIndication->notePowerConsumption();
- if (currentLocation != nullptr) {
- this->reportLocation(*currentLocation);
- } else {
- const auto location = Utils::getMockLocation();
- this->reportLocation(location);
- }
- } while (mIsActive && mThreadBlocker.wait_for(std::chrono::milliseconds(mMinIntervalMs)));
- ALOGD("reportGnssCount: %d", reportGnssCount);
- });
+ mThreadBlocker.notify();
return ScopedAStatus::ok();
}
@@ -154,16 +168,22 @@
mIsActive = false;
mGnssMeasurementInterface->setLocationEnabled(false);
this->reportGnssStatusValue(IGnssCallback::GnssStatusValue::SESSION_END);
+
+ int reportedLocationCount = mReportedLocationCount;
+ ALOGD("reportedLocationCount: %d", reportedLocationCount);
+ mReportedLocationCount = 0;
mThreadBlocker.notify();
- if (mThread.joinable()) {
- mThread.join();
- }
return ScopedAStatus::ok();
}
ScopedAStatus Gnss::close() {
ALOGD("close");
sGnssCallback = nullptr;
+ mIsInitialized = false;
+ mThreadBlocker.notify();
+ if (mThread.joinable()) {
+ mThread.join();
+ }
return ScopedAStatus::ok();
}
diff --git a/gnss/aidl/default/Gnss.h b/gnss/aidl/default/Gnss.h
index 56fe399..aea9eb9 100644
--- a/gnss/aidl/default/Gnss.h
+++ b/gnss/aidl/default/Gnss.h
@@ -110,10 +110,12 @@
std::atomic<long> mMinIntervalMs;
std::atomic<long> mGnssMeasurementIntervalMs;
std::atomic<bool> mIsActive;
+ std::atomic<bool> mIsInitialized;
std::atomic<bool> mIsSvStatusActive;
std::atomic<bool> mIsNmeaActive;
std::atomic<bool> mFirstFixReceived;
std::atomic<bool> mGnssMeasurementEnabled;
+ std::atomic<int> mReportedLocationCount;
std::shared_ptr<GnssLocation> mLastLocation;
std::thread mThread;
::android::hardware::gnss::common::ThreadBlocker mThreadBlocker;
diff --git a/gnss/common/utils/default/include/Utils.h b/gnss/common/utils/default/include/Utils.h
index 9be4a19..55960fd 100644
--- a/gnss/common/utils/default/include/Utils.h
+++ b/gnss/common/utils/default/include/Utils.h
@@ -61,9 +61,16 @@
template <class R, class P>
bool wait_for(std::chrono::duration<R, P> const& time) {
std::unique_lock<std::mutex> lock(m);
+ terminate = false;
return !cv.wait_for(lock, time, [&] { return terminate; });
}
+ void wait() {
+ std::unique_lock<std::mutex> lock(m);
+ terminate = false;
+ cv.wait(lock, [&] { return terminate; });
+ }
+
void notify() {
std::unique_lock<std::mutex> lock(m);
terminate = true;
diff --git a/sensors/aidl/vts/VtsAidlHalSensorsTargetTest.cpp b/sensors/aidl/vts/VtsAidlHalSensorsTargetTest.cpp
index b1590f9..77e2916 100644
--- a/sensors/aidl/vts/VtsAidlHalSensorsTargetTest.cpp
+++ b/sensors/aidl/vts/VtsAidlHalSensorsTargetTest.cpp
@@ -616,8 +616,18 @@
}
TEST_P(SensorsAidlTest, InjectSensorEventData) {
- std::vector<SensorInfo> sensors = getInjectEventSensors();
- if (sensors.size() == 0) {
+ std::vector<SensorInfo> sensorsAll = getInjectEventSensors();
+ std::vector<SensorInfo> sensors3d;
+
+ for (const auto& s : sensorsAll) {
+ if ((s.type == SensorType::ACCELEROMETER) || (s.type == SensorType::GYROSCOPE) ||
+ (s.type == SensorType::MAGNETIC_FIELD)) {
+ sensors3d.push_back(s);
+ }
+ }
+
+ // Here we only test for the sensors with vec3 data type
+ if (sensors3d.size() == 0) {
return;
}
@@ -645,7 +655,7 @@
Event::EventPayload::Vec3 data = {1, 2, 3, SensorStatus::ACCURACY_HIGH};
injectedEvent.payload.set<Event::EventPayload::Tag::vec3>(data);
- for (const auto& s : sensors) {
+ for (const auto& s : sensors3d) {
additionalInfoEvent.sensorHandle = s.sensorHandle;
ASSERT_TRUE(getSensors()->injectSensorData(additionalInfoEvent).isOk());
@@ -655,10 +665,10 @@
}
// Wait for events to be written back to the Event FMQ
- callback.waitForEvents(sensors, std::chrono::milliseconds(1000) /* timeout */);
+ callback.waitForEvents(sensors3d, std::chrono::milliseconds(1000) /* timeout */);
getEnvironment()->unregisterCallback();
- for (const auto& s : sensors) {
+ for (const auto& s : sensors3d) {
auto events = callback.getEvents(s.sensorHandle);
if (events.empty()) {
FAIL() << "Received no events";
diff --git a/uwb/aidl/vts/VtsHalUwbTargetTest.cpp b/uwb/aidl/vts/VtsHalUwbTargetTest.cpp
index 2b09f7e..c75160c 100644
--- a/uwb/aidl/vts/VtsHalUwbTargetTest.cpp
+++ b/uwb/aidl/vts/VtsHalUwbTargetTest.cpp
@@ -202,8 +202,26 @@
}
TEST_P(UwbAidl, ChipSendUciMessage_GetDeviceInfo) {
- const auto iuwb_chip = getAnyChipAndOpen();
+ std::promise<void> open_cb_promise;
+ std::future<void> open_cb_future{open_cb_promise.get_future()};
+ std::promise<void> init_cb_promise;
+ std::future<void> init_cb_future{init_cb_promise.get_future()};
+ std::shared_ptr<UwbClientCallback> callback = ndk::SharedRefBase::make<UwbClientCallback>(
+ [](auto /* data */) {},
+ [&init_cb_promise, &open_cb_promise](auto event, auto /* status */) {
+ if (event == UwbEvent::OPEN_CPLT) {
+ open_cb_promise.set_value();
+ }
+ if (event == UwbEvent::POST_INIT_CPLT) {
+ init_cb_promise.set_value();
+ }
+ });
+ std::chrono::milliseconds timeout{1000};
+ const auto iuwb_chip = getAnyChip();
+ EXPECT_TRUE(iuwb_chip->open(callback).isOk());
+ EXPECT_EQ(open_cb_future.wait_for(timeout), std::future_status::ready);
EXPECT_TRUE(iuwb_chip->coreInit().isOk());
+ EXPECT_EQ(init_cb_future.wait_for(timeout), std::future_status::ready);
std::vector<uint8_t> uciMessage = {0x20, 0x02, 0x00, 0x00}; /** CoreGetDeviceInfo */
int32_t* return_status = new int32_t;