Merge changes I9bd12ff0,Ic842a341 into main
* changes:
Enable framework during vts test
Stop framework during vts test
diff --git a/audio/aidl/default/CapEngineConfigXmlConverter.cpp b/audio/aidl/default/CapEngineConfigXmlConverter.cpp
index 20fbca4..14d27f2 100644
--- a/audio/aidl/default/CapEngineConfigXmlConverter.cpp
+++ b/audio/aidl/default/CapEngineConfigXmlConverter.cpp
@@ -52,6 +52,7 @@
static constexpr const char* gOutputDevicesParameter = "selected_output_devices";
static constexpr const char* gOutputDeviceAddressParameter = "device_address";
static constexpr const char* gStrategyPrefix = "vx_";
+static constexpr const char* gLegacyStrategyPrefix = "STRATEGY_";
static constexpr const char* gLegacyOutputDevicePrefix = "AUDIO_DEVICE_OUT_";
static constexpr const char* gLegacyInputDevicePrefix = "AUDIO_DEVICE_IN_";
static constexpr const char* gLegacyStreamPrefix = "AUDIO_STREAM_";
@@ -159,6 +160,17 @@
}
return strategyId;
}
+ pos = stringToken.find(gLegacyStrategyPrefix);
+ if (pos != std::string::npos) {
+ std::string legacyStrategyIdLiteral = stringToken.substr(pos);
+ const auto legacyStrategies = getLegacyProductStrategyMap();
+ if (const auto& it = legacyStrategies.find(legacyStrategyIdLiteral);
+ it != legacyStrategies.end()) {
+ return it->second;
+ }
+ LOG(ERROR) << "Invalid legacy strategy " << stringToken << " from path " << path;
+ return unexpected(BAD_VALUE);
+ }
}
return unexpected(BAD_VALUE);
}
diff --git a/audio/aidl/default/EngineConfigXmlConverter.cpp b/audio/aidl/default/EngineConfigXmlConverter.cpp
index d945b17..78deb64 100644
--- a/audio/aidl/default/EngineConfigXmlConverter.cpp
+++ b/audio/aidl/default/EngineConfigXmlConverter.cpp
@@ -59,20 +59,6 @@
static constexpr char kCapEngineConfigFileName[] =
"/parameter-framework/Settings/Policy/PolicyConfigurableDomains.xml";
-void EngineConfigXmlConverter::initProductStrategyMap() {
-#define STRATEGY_ENTRY(name) {"STRATEGY_" #name, static_cast<int>(AudioProductStrategyType::name)}
-
- mProductStrategyMap = {STRATEGY_ENTRY(MEDIA),
- STRATEGY_ENTRY(PHONE),
- STRATEGY_ENTRY(SONIFICATION),
- STRATEGY_ENTRY(SONIFICATION_RESPECTFUL),
- STRATEGY_ENTRY(DTMF),
- STRATEGY_ENTRY(ENFORCED_AUDIBLE),
- STRATEGY_ENTRY(TRANSMITTED_THROUGH_SPEAKER),
- STRATEGY_ENTRY(ACCESSIBILITY)};
-#undef STRATEGY_ENTRY
-}
-
ConversionResult<int> EngineConfigXmlConverter::convertProductStrategyNameToAidl(
const std::string& xsdcProductStrategyName) {
const auto [it, success] = mProductStrategyMap.insert(
@@ -242,7 +228,7 @@
}
void EngineConfigXmlConverter::init() {
- initProductStrategyMap();
+ mProductStrategyMap = getLegacyProductStrategyMap();
if (getXsdcConfig()->hasProductStrategies()) {
mAidlEngineConfig.productStrategies = VALUE_OR_FATAL(
(convertWrappedCollectionToAidl<eng_xsd::ProductStrategies,
diff --git a/audio/aidl/default/Stream.cpp b/audio/aidl/default/Stream.cpp
index 4525f6a..c138095 100644
--- a/audio/aidl/default/Stream.cpp
+++ b/audio/aidl/default/Stream.cpp
@@ -704,44 +704,7 @@
LOG(ERROR) << __func__ << ": Worker start error: " << mWorker->getError();
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
}
- if (auto flags = getContext().getFlags();
- (flags.getTag() == AudioIoFlags::Tag::input &&
- isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::input>(),
- AudioInputFlags::FAST)) ||
- (flags.getTag() == AudioIoFlags::Tag::output &&
- (isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
- AudioOutputFlags::FAST) ||
- isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
- AudioOutputFlags::SPATIALIZER)))) {
- // FAST workers should be run with a SCHED_FIFO scheduler, however the host process
- // might be lacking the capability to request it, thus a failure to set is not an error.
- pid_t workerTid = mWorker->getTid();
- if (workerTid > 0) {
- constexpr int32_t kRTPriorityMin = 1; // SchedulingPolicyService.PRIORITY_MIN (Java).
- constexpr int32_t kRTPriorityMax = 3; // SchedulingPolicyService.PRIORITY_MAX (Java).
- int priorityBoost = kRTPriorityMax;
- if (flags.getTag() == AudioIoFlags::Tag::output &&
- isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
- AudioOutputFlags::SPATIALIZER)) {
- const int32_t sptPrio =
- property_get_int32("audio.spatializer.priority", kRTPriorityMin);
- if (sptPrio >= kRTPriorityMin && sptPrio <= kRTPriorityMax) {
- priorityBoost = sptPrio;
- } else {
- LOG(WARNING) << __func__ << ": invalid spatializer priority: " << sptPrio;
- return ndk::ScopedAStatus::ok();
- }
- }
- struct sched_param param = {
- .sched_priority = priorityBoost,
- };
- if (sched_setscheduler(workerTid, SCHED_FIFO | SCHED_RESET_ON_FORK, ¶m) != 0) {
- PLOG(WARNING) << __func__ << ": failed to set FIFO scheduler and priority";
- }
- } else {
- LOG(WARNING) << __func__ << ": invalid worker tid: " << workerTid;
- }
- }
+ setWorkerThreadPriority(mWorker->getTid());
getContext().getCommandMQ()->setErrorHandler(
fmqErrorHandler<StreamContext::CommandMQ::Error>("CommandMQ"));
getContext().getReplyMQ()->setErrorHandler(
@@ -830,6 +793,42 @@
}
}
+void StreamCommonImpl::setWorkerThreadPriority(pid_t workerTid) {
+ // FAST workers should be run with a SCHED_FIFO scheduler, however the host process
+ // might be lacking the capability to request it, thus a failure to set is not an error.
+ if (auto flags = getContext().getFlags();
+ (flags.getTag() == AudioIoFlags::Tag::input &&
+ isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::input>(),
+ AudioInputFlags::FAST)) ||
+ (flags.getTag() == AudioIoFlags::Tag::output &&
+ (isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
+ AudioOutputFlags::FAST) ||
+ isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
+ AudioOutputFlags::SPATIALIZER)))) {
+ constexpr int32_t kRTPriorityMin = 1; // SchedulingPolicyService.PRIORITY_MIN (Java).
+ constexpr int32_t kRTPriorityMax = 3; // SchedulingPolicyService.PRIORITY_MAX (Java).
+ int priorityBoost = kRTPriorityMax;
+ if (flags.getTag() == AudioIoFlags::Tag::output &&
+ isBitPositionFlagSet(flags.template get<AudioIoFlags::Tag::output>(),
+ AudioOutputFlags::SPATIALIZER)) {
+ const int32_t sptPrio =
+ property_get_int32("audio.spatializer.priority", kRTPriorityMin);
+ if (sptPrio >= kRTPriorityMin && sptPrio <= kRTPriorityMax) {
+ priorityBoost = sptPrio;
+ } else {
+ LOG(WARNING) << __func__ << ": invalid spatializer priority: " << sptPrio;
+ return;
+ }
+ }
+ struct sched_param param = {
+ .sched_priority = priorityBoost,
+ };
+ if (sched_setscheduler(workerTid, SCHED_FIFO | SCHED_RESET_ON_FORK, ¶m) != 0) {
+ PLOG(WARNING) << __func__ << ": failed to set FIFO scheduler and priority";
+ }
+ }
+}
+
void StreamCommonImpl::stopAndJoinWorker() {
stopWorker();
LOG(DEBUG) << __func__ << ": joining the worker thread...";
diff --git a/audio/aidl/default/XsdcConversion.cpp b/audio/aidl/default/XsdcConversion.cpp
index b42d7f5..5845903 100644
--- a/audio/aidl/default/XsdcConversion.cpp
+++ b/audio/aidl/default/XsdcConversion.cpp
@@ -816,4 +816,23 @@
}
return aidlCurvePoint;
}
+
+/**
+ * The hard coded id must be in sync with policy.h definition of legacy strategy ids.
+ */
+std::unordered_map<std::string, int> getLegacyProductStrategyMap() {
+#define STRATEGY_ENTRY(name, id) {"STRATEGY_" #name, static_cast<int>(id)}
+
+ return {STRATEGY_ENTRY(MEDIA, 5),
+ STRATEGY_ENTRY(PHONE, 0),
+ STRATEGY_ENTRY(SONIFICATION, 1),
+ STRATEGY_ENTRY(SONIFICATION_RESPECTFUL, 4),
+ STRATEGY_ENTRY(DTMF, 6),
+ STRATEGY_ENTRY(ENFORCED_AUDIBLE, 2),
+ STRATEGY_ENTRY(CALL_ASSISTANT, 7),
+ STRATEGY_ENTRY(TRANSMITTED_THROUGH_SPEAKER,8),
+ STRATEGY_ENTRY(ACCESSIBILITY, 3)};
+#undef STRATEGY_ENTRY
+}
+
} // namespace aidl::android::hardware::audio::core::internal
diff --git a/audio/aidl/default/alsa/StreamAlsa.cpp b/audio/aidl/default/alsa/StreamAlsa.cpp
index c77bfca..114c4c0 100644
--- a/audio/aidl/default/alsa/StreamAlsa.cpp
+++ b/audio/aidl/default/alsa/StreamAlsa.cpp
@@ -23,9 +23,12 @@
#include <Utils.h>
#include <audio_utils/clock.h>
#include <error/expected_utils.h>
+#include <media/AidlConversionCppNdk.h>
#include "core-impl/StreamAlsa.h"
+using aidl::android::hardware::audio::common::getChannelCount;
+
namespace aidl::android::hardware::audio::core {
StreamAlsa::StreamAlsa(StreamContext* context, const Metadata& metadata, int readWriteRetries)
@@ -41,6 +44,34 @@
cleanupWorker();
}
+::android::NBAIO_Format StreamAlsa::getPipeFormat() const {
+ const audio_format_t audioFormat = VALUE_OR_FATAL(
+ aidl2legacy_AudioFormatDescription_audio_format_t(getContext().getFormat()));
+ const int channelCount = getChannelCount(getContext().getChannelLayout());
+ return ::android::Format_from_SR_C(getContext().getSampleRate(), channelCount, audioFormat);
+}
+
+::android::sp<::android::MonoPipe> StreamAlsa::makeSink(bool writeCanBlock) {
+ const ::android::NBAIO_Format format = getPipeFormat();
+ auto sink = ::android::sp<::android::MonoPipe>::make(mBufferSizeFrames, format, writeCanBlock);
+ const ::android::NBAIO_Format offers[1] = {format};
+ size_t numCounterOffers = 0;
+ ssize_t index = sink->negotiate(offers, 1, nullptr, numCounterOffers);
+ LOG_IF(FATAL, index != 0) << __func__ << ": Negotiation for the sink failed, index = " << index;
+ return sink;
+}
+
+::android::sp<::android::MonoPipeReader> StreamAlsa::makeSource(::android::MonoPipe* pipe) {
+ const ::android::NBAIO_Format format = getPipeFormat();
+ const ::android::NBAIO_Format offers[1] = {format};
+ auto source = ::android::sp<::android::MonoPipeReader>::make(pipe);
+ size_t numCounterOffers = 0;
+ ssize_t index = source->negotiate(offers, 1, nullptr, numCounterOffers);
+ LOG_IF(FATAL, index != 0) << __func__
+ << ": Negotiation for the source failed, index = " << index;
+ return source;
+}
+
::android::status_t StreamAlsa::init() {
return mConfig.has_value() ? ::android::OK : ::android::NO_INIT;
}
@@ -64,7 +95,7 @@
}
::android::status_t StreamAlsa::standby() {
- mAlsaDeviceProxies.clear();
+ teardownIo();
return ::android::OK;
}
@@ -74,6 +105,8 @@
return ::android::OK;
}
decltype(mAlsaDeviceProxies) alsaDeviceProxies;
+ decltype(mSources) sources;
+ decltype(mSinks) sinks;
for (const auto& device : getDeviceProfiles()) {
if ((device.direction == PCM_OUT && mIsInput) ||
(device.direction == PCM_IN && !mIsInput)) {
@@ -95,11 +128,29 @@
return ::android::NO_INIT;
}
alsaDeviceProxies.push_back(std::move(proxy));
+ auto sink = makeSink(mIsInput); // Do not block the writer when it is on our thread.
+ if (sink != nullptr) {
+ sinks.push_back(sink);
+ } else {
+ return ::android::NO_INIT;
+ }
+ if (auto source = makeSource(sink.get()); source != nullptr) {
+ sources.push_back(source);
+ } else {
+ return ::android::NO_INIT;
+ }
}
if (alsaDeviceProxies.empty()) {
return ::android::NO_INIT;
}
mAlsaDeviceProxies = std::move(alsaDeviceProxies);
+ mSources = std::move(sources);
+ mSinks = std::move(sinks);
+ mIoThreadIsRunning = true;
+ for (size_t i = 0; i < mAlsaDeviceProxies.size(); ++i) {
+ mIoThreads.emplace_back(mIsInput ? &StreamAlsa::inputIoThread : &StreamAlsa::outputIoThread,
+ this, i);
+ }
return ::android::OK;
}
@@ -112,15 +163,30 @@
const size_t bytesToTransfer = frameCount * mFrameSizeBytes;
unsigned maxLatency = 0;
if (mIsInput) {
- // For input case, only support single device.
- proxy_read_with_retries(mAlsaDeviceProxies[0].get(), buffer, bytesToTransfer,
- mReadWriteRetries);
- maxLatency = proxy_get_latency(mAlsaDeviceProxies[0].get());
+ const size_t i = 0; // For the input case, only support a single device.
+ LOG(VERBOSE) << __func__ << ": reading from sink " << i;
+ ssize_t framesRead = mSources[i]->read(buffer, frameCount);
+ LOG_IF(FATAL, framesRead < 0) << "Error reading from the pipe: " << framesRead;
+ if (ssize_t framesMissing = static_cast<ssize_t>(frameCount) - framesRead;
+ framesMissing > 0) {
+ LOG(WARNING) << __func__ << ": incomplete data received, inserting " << framesMissing
+ << " frames of silence";
+ memset(static_cast<char*>(buffer) + framesRead * mFrameSizeBytes, 0,
+ framesMissing * mFrameSizeBytes);
+ }
+ maxLatency = proxy_get_latency(mAlsaDeviceProxies[i].get());
} else {
alsa::applyGain(buffer, mGain, bytesToTransfer, mConfig.value().format, mConfig->channels);
- for (auto& proxy : mAlsaDeviceProxies) {
- proxy_write_with_retries(proxy.get(), buffer, bytesToTransfer, mReadWriteRetries);
- maxLatency = std::max(maxLatency, proxy_get_latency(proxy.get()));
+ for (size_t i = 0; i < mAlsaDeviceProxies.size(); ++i) {
+ LOG(VERBOSE) << __func__ << ": writing into sink " << i;
+ ssize_t framesWritten = mSinks[i]->write(buffer, frameCount);
+ LOG_IF(FATAL, framesWritten < 0) << "Error writing into the pipe: " << framesWritten;
+ if (ssize_t framesLost = static_cast<ssize_t>(frameCount) - framesWritten;
+ framesLost > 0) {
+ LOG(WARNING) << __func__ << ": sink " << i << " incomplete data sent, dropping "
+ << framesLost << " frames";
+ }
+ maxLatency = std::max(maxLatency, proxy_get_latency(mAlsaDeviceProxies[i].get()));
}
}
*actualFrameCount = frameCount;
@@ -164,7 +230,7 @@
}
void StreamAlsa::shutdown() {
- mAlsaDeviceProxies.clear();
+ teardownIo();
}
ndk::ScopedAStatus StreamAlsa::setGain(float gain) {
@@ -172,4 +238,80 @@
return ndk::ScopedAStatus::ok();
}
+void StreamAlsa::inputIoThread(size_t idx) {
+#if defined(__ANDROID__)
+ setWorkerThreadPriority(pthread_gettid_np(pthread_self()));
+ const std::string threadName = (std::string("in_") + std::to_string(idx)).substr(0, 15);
+ pthread_setname_np(pthread_self(), threadName.c_str());
+#endif
+ const size_t bufferSize = mBufferSizeFrames * mFrameSizeBytes;
+ std::vector<char> buffer(bufferSize);
+ while (mIoThreadIsRunning) {
+ if (int ret = proxy_read_with_retries(mAlsaDeviceProxies[idx].get(), &buffer[0], bufferSize,
+ mReadWriteRetries);
+ ret == 0) {
+ size_t bufferFramesWritten = 0;
+ while (bufferFramesWritten < mBufferSizeFrames) {
+ if (!mIoThreadIsRunning) return;
+ ssize_t framesWrittenOrError =
+ mSinks[idx]->write(&buffer[0], mBufferSizeFrames - bufferFramesWritten);
+ if (framesWrittenOrError >= 0) {
+ bufferFramesWritten += framesWrittenOrError;
+ } else {
+ LOG(WARNING) << __func__ << "[" << idx
+ << "]: Error while writing into the pipe: "
+ << framesWrittenOrError;
+ }
+ }
+ } else {
+ // Errors when the stream is being stopped are expected.
+ LOG_IF(WARNING, mIoThreadIsRunning)
+ << __func__ << "[" << idx << "]: Error reading from ALSA: " << ret;
+ }
+ }
+}
+
+void StreamAlsa::outputIoThread(size_t idx) {
+#if defined(__ANDROID__)
+ setWorkerThreadPriority(pthread_gettid_np(pthread_self()));
+ const std::string threadName = (std::string("out_") + std::to_string(idx)).substr(0, 15);
+ pthread_setname_np(pthread_self(), threadName.c_str());
+#endif
+ const size_t bufferSize = mBufferSizeFrames * mFrameSizeBytes;
+ std::vector<char> buffer(bufferSize);
+ while (mIoThreadIsRunning) {
+ ssize_t framesRead = mSources[idx]->read(&buffer[0], mBufferSizeFrames);
+ if (framesRead > 0) {
+ int ret = proxy_write_with_retries(mAlsaDeviceProxies[idx].get(), &buffer[0],
+ framesRead * mFrameSizeBytes, mReadWriteRetries);
+ // Errors when the stream is being stopped are expected.
+ LOG_IF(WARNING, ret != 0 && mIoThreadIsRunning)
+ << __func__ << "[" << idx << "]: Error writing into ALSA: " << ret;
+ }
+ }
+}
+
+void StreamAlsa::teardownIo() {
+ mIoThreadIsRunning = false;
+ if (mIsInput) {
+ LOG(DEBUG) << __func__ << ": shutting down pipes";
+ for (auto& sink : mSinks) {
+ sink->shutdown(true);
+ }
+ }
+ LOG(DEBUG) << __func__ << ": stopping PCM streams";
+ for (const auto& proxy : mAlsaDeviceProxies) {
+ proxy_stop(proxy.get());
+ }
+ LOG(DEBUG) << __func__ << ": joining threads";
+ for (auto& thread : mIoThreads) {
+ if (thread.joinable()) thread.join();
+ }
+ mIoThreads.clear();
+ LOG(DEBUG) << __func__ << ": closing PCM devices";
+ mAlsaDeviceProxies.clear();
+ mSources.clear();
+ mSinks.clear();
+}
+
} // namespace aidl::android::hardware::audio::core
diff --git a/audio/aidl/default/alsa/Utils.h b/audio/aidl/default/alsa/Utils.h
index a97ea10..53dcfd0 100644
--- a/audio/aidl/default/alsa/Utils.h
+++ b/audio/aidl/default/alsa/Utils.h
@@ -48,8 +48,8 @@
public:
DeviceProxy(); // Constructs a "null" proxy.
explicit DeviceProxy(const DeviceProfile& deviceProfile);
- alsa_device_profile* getProfile() { return mProfile.get(); }
- alsa_device_proxy* get() { return mProxy.get(); }
+ alsa_device_profile* getProfile() const { return mProfile.get(); }
+ alsa_device_proxy* get() const { return mProxy.get(); }
private:
static void alsaProxyDeleter(alsa_device_proxy* proxy);
diff --git a/audio/aidl/default/include/core-impl/Stream.h b/audio/aidl/default/include/core-impl/Stream.h
index 8297fc5..304f9b7 100644
--- a/audio/aidl/default/include/core-impl/Stream.h
+++ b/audio/aidl/default/include/core-impl/Stream.h
@@ -475,6 +475,7 @@
// the destructor in order to stop and join the worker thread in the case when the client
// has not called 'IStreamCommon::close' method.
void cleanupWorker();
+ void setWorkerThreadPriority(pid_t workerTid);
void stopAndJoinWorker();
void stopWorker();
diff --git a/audio/aidl/default/include/core-impl/StreamAlsa.h b/audio/aidl/default/include/core-impl/StreamAlsa.h
index 8bdf208..7e0f0ac 100644
--- a/audio/aidl/default/include/core-impl/StreamAlsa.h
+++ b/audio/aidl/default/include/core-impl/StreamAlsa.h
@@ -16,9 +16,14 @@
#pragma once
+#include <atomic>
#include <optional>
+#include <thread>
#include <vector>
+#include <media/nbaio/MonoPipe.h>
+#include <media/nbaio/MonoPipeReader.h>
+
#include "Stream.h"
#include "alsa/Utils.h"
@@ -57,11 +62,24 @@
const bool mIsInput;
const std::optional<struct pcm_config> mConfig;
const int mReadWriteRetries;
- // All fields below are only used on the worker thread.
- std::vector<alsa::DeviceProxy> mAlsaDeviceProxies;
private:
+ ::android::NBAIO_Format getPipeFormat() const;
+ ::android::sp<::android::MonoPipe> makeSink(bool writeCanBlock);
+ ::android::sp<::android::MonoPipeReader> makeSource(::android::MonoPipe* pipe);
+ void inputIoThread(size_t idx);
+ void outputIoThread(size_t idx);
+ void teardownIo();
+
std::atomic<float> mGain = 1.0;
+
+ // All fields below are only used on the worker thread.
+ std::vector<alsa::DeviceProxy> mAlsaDeviceProxies;
+ // Only 'libnbaio_mono' is vendor-accessible, thus no access to the multi-reader Pipe.
+ std::vector<::android::sp<::android::MonoPipe>> mSinks;
+ std::vector<::android::sp<::android::MonoPipeReader>> mSources;
+ std::vector<std::thread> mIoThreads;
+ std::atomic<bool> mIoThreadIsRunning = false; // used by all threads
};
} // namespace aidl::android::hardware::audio::core
diff --git a/audio/aidl/default/include/core-impl/XsdcConversion.h b/audio/aidl/default/include/core-impl/XsdcConversion.h
index f00206b..b298eee 100644
--- a/audio/aidl/default/include/core-impl/XsdcConversion.h
+++ b/audio/aidl/default/include/core-impl/XsdcConversion.h
@@ -64,4 +64,5 @@
const engineconfiguration::Stream& xsdStreamType);
ConversionResult<int32_t> convertAudioFlagsToAidl(
const std::vector<engineconfiguration::FlagType>& xsdcFlagTypeVec);
+std::unordered_map<std::string, int> getLegacyProductStrategyMap();
} // namespace aidl::android::hardware::audio::core::internal
diff --git a/audio/aidl/vts/EffectHelper.h b/audio/aidl/vts/EffectHelper.h
index 754a08f..5c75e48 100644
--- a/audio/aidl/vts/EffectHelper.h
+++ b/audio/aidl/vts/EffectHelper.h
@@ -520,9 +520,10 @@
<< "The input(buffer) size must be greater than or equal to nPointFFT";
bufferMag.resize(binOffsets.size());
std::vector<float> fftInput(nPointFFT);
- PFFFT_Setup* inputHandle = pffft_new_setup(nPointFFT, PFFFT_REAL);
+ pffft::detail::PFFFT_Setup* inputHandle =
+ pffft_new_setup(nPointFFT, pffft::detail::PFFFT_REAL);
pffft_transform_ordered(inputHandle, buffer.data(), fftInput.data(), nullptr,
- PFFFT_FORWARD);
+ pffft::detail::PFFFT_FORWARD);
pffft_destroy_setup(inputHandle);
for (size_t i = 0; i < binOffsets.size(); i++) {
size_t k = binOffsets[i];
diff --git a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
index 1e6f186..70790c4 100644
--- a/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
+++ b/audio/aidl/vts/VtsHalDynamicsProcessingTest.cpp
@@ -1254,6 +1254,7 @@
SKIP_TEST_IF_DATA_UNSUPPORTED(mDescriptor.common.flags);
ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput, 1.0, kSamplingFrequency,
mChannelLayout));
+ mInputDb = calculateDb(mInput);
}
void TearDown() override { TearDownDynamicsProcessingEffect(); }
@@ -1276,11 +1277,11 @@
void fillMbcBandConfig(std::vector<DynamicsProcessing::MbcBandConfig>& cfgs, int channelIndex,
float threshold, float ratio, float noiseGate, float expanderRatio,
- int bandIndex, int cutoffFreqHz) {
- cfgs.push_back(createMbcBandConfig(
- channelIndex, bandIndex, static_cast<float>(cutoffFreqHz), kDefaultAttackTime,
- kDefaultReleaseTime, ratio, threshold, kDefaultKneeWidth, noiseGate, expanderRatio,
- kDefaultPreGainDb, kDefaultPostGainDb));
+ int bandIndex, int cutoffFreqHz, float preGain, float postGain) {
+ cfgs.push_back(createMbcBandConfig(channelIndex, bandIndex,
+ static_cast<float>(cutoffFreqHz), kDefaultAttackTime,
+ kDefaultReleaseTime, ratio, threshold, kDefaultKneeWidth,
+ noiseGate, expanderRatio, preGain, postGain));
}
void getMagnitudeValue(const std::vector<float>& output, std::vector<float>& bufferMag) {
@@ -1291,10 +1292,9 @@
void validateOutput(const std::vector<float>& output, float threshold, float ratio,
size_t bandIndex) {
- float inputDb = calculateDb(mInput);
std::vector<float> outputMag(mBinOffsets.size());
EXPECT_NO_FATAL_FAILURE(getMagnitudeValue(output, outputMag));
- if (threshold >= inputDb || ratio == 1) {
+ if (threshold >= mInputDb || ratio == 1) {
std::vector<float> inputMag(mBinOffsets.size());
EXPECT_NO_FATAL_FAILURE(getMagnitudeValue(mInput, inputMag));
for (size_t i = 0; i < inputMag.size(); i++) {
@@ -1315,10 +1315,11 @@
for (size_t i = 0; i < cutoffFreqHz.size(); i++) {
for (int channelIndex = 0; channelIndex < mChannelCount; channelIndex++) {
fillMbcBandConfig(mCfgs, channelIndex, threshold, ratio, kDefaultNoiseGateDb,
- kDefaultExpanderRatio, i, cutoffFreqHz[i]);
+ kDefaultExpanderRatio, i, cutoffFreqHz[i], kDefaultPreGainDb,
+ kDefaultPostGainDb);
fillMbcBandConfig(mCfgs, channelIndex, kDefaultThresholdDb, kDefaultRatio,
kDefaultNoiseGateDb, kDefaultExpanderRatio, i ^ 1,
- cutoffFreqHz[i ^ 1]);
+ cutoffFreqHz[i ^ 1], kDefaultPreGainDb, kDefaultPostGainDb);
}
ASSERT_NO_FATAL_FAILURE(setMbcParamsAndProcess(output));
@@ -1347,6 +1348,8 @@
static constexpr float kDefaultExpanderRatio = 1;
static constexpr float kDefaultRatio = 1;
static constexpr float kBinWidth = (float)kSamplingFrequency / kNPointFFT;
+ // Full scale sine wave with 100 Hz and 1000 Hz frequency is -6 dB
+ static constexpr float kFullScaleDb = -6;
std::vector<int> mTestFrequencies = {100, 1000};
// Calculating normalizing factor by dividing the number of FFT points by half and the number of
// test frequencies. The normalization accounts for the FFT splitting the signal into positive
@@ -1357,6 +1360,7 @@
std::vector<DynamicsProcessing::ChannelConfig> mChannelConfig;
std::vector<int> mBinOffsets;
std::vector<float> mInput;
+ float mInputDb;
};
TEST_P(DynamicsProcessingMbcBandConfigDataTest, IncreasingThreshold) {
@@ -1379,6 +1383,31 @@
}
}
+TEST_P(DynamicsProcessingMbcBandConfigDataTest, IncreasingPostGain) {
+ std::vector<float> postGainDbValues = {-55, -30, 0, 30, 55};
+ std::vector<float> output(mInput.size());
+ for (float postGainDb : postGainDbValues) {
+ float amplitude = 1.0 / (pow(10, postGainDb / 20));
+ ASSERT_NO_FATAL_FAILURE(generateSineWave(mTestFrequencies, mInput, amplitude,
+ kSamplingFrequency, mChannelLayout));
+ mInputDb = calculateDb(mInput);
+ EXPECT_NEAR(mInputDb, kFullScaleDb - postGainDb, kToleranceDb);
+ cleanUpMbcConfig();
+ for (int i = 0; i < mChannelCount; i++) {
+ fillMbcBandConfig(mCfgs, i, kDefaultThresholdDb, kDefaultRatio, kDefaultNoiseGateDb,
+ kDefaultExpanderRatio, 0 /*band index*/, 2000 /*cutoffFrequency*/,
+ kDefaultPreGainDb, postGainDb);
+ }
+ EXPECT_NO_FATAL_FAILURE(setMbcParamsAndProcess(output));
+ if (!isAllParamsValid()) {
+ continue;
+ }
+ float outputDb = calculateDb(output, kStartIndex);
+ EXPECT_NEAR(outputDb, mInputDb + postGainDb, kToleranceDb)
+ << "PostGain: " << postGainDb << ", OutputDb: " << outputDb;
+ }
+}
+
INSTANTIATE_TEST_SUITE_P(DynamicsProcessingTest, DynamicsProcessingMbcBandConfigDataTest,
testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(
IFactory::descriptor, getEffectTypeUuidDynamicsProcessing())),
diff --git a/audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp b/audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp
index ff84f9d..d093ffe 100644
--- a/audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp
+++ b/audio/effect/all-versions/vts/functional/VtsHalAudioEffectTargetTest.cpp
@@ -39,6 +39,7 @@
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/ServiceManagement.h>
+#include <hwbinder/IPCThreadState.h>
using ::android::sp;
using ::android::hardware::hidl_handle;
@@ -205,6 +206,11 @@
void TearDown() override {
effect.clear();
effectsFactory.clear();
+ // Ensure all pending binder transactions are completed before proceeding.
+ android::hardware::IPCThreadState::self()->flushCommands();
+ // Add a delay to allow the binder destruction to propagate and ensure
+ // the remote objects are properly cleaned up.
+ usleep(100 * 1000);
}
protected:
diff --git a/automotive/can/1.0/default/libnetdevice/can.cpp b/automotive/can/1.0/default/libnetdevice/can.cpp
index 9cf0253..32d899b 100644
--- a/automotive/can/1.0/default/libnetdevice/can.cpp
+++ b/automotive/can/1.0/default/libnetdevice/can.cpp
@@ -80,7 +80,7 @@
{
auto linkinfo = req.addNested(IFLA_LINKINFO);
- req.addBuffer(IFLA_INFO_KIND, "can");
+ req.add(IFLA_INFO_KIND, "can");
{
auto infodata = req.addNested(IFLA_INFO_DATA);
/* For CAN FD, it would require to add IFLA_CAN_DATA_BITTIMING
diff --git a/automotive/can/1.0/default/libnetdevice/include/libnetdevice/libnetdevice.h b/automotive/can/1.0/default/libnetdevice/include/libnetdevice/libnetdevice.h
index 15ff491..04d1e0a 100644
--- a/automotive/can/1.0/default/libnetdevice/include/libnetdevice/libnetdevice.h
+++ b/automotive/can/1.0/default/libnetdevice/include/libnetdevice/libnetdevice.h
@@ -161,6 +161,15 @@
bool del(std::string_view dev);
/**
+ * Rename interface.
+ *
+ * \param from the name of the interface to rename from
+ * \param to the name of the interface to rename to
+ * \return true in case of success, false otherwise
+ */
+bool rename(std::string_view from, std::string_view to);
+
+/**
* Fetches interface's hardware address.
*
* \param ifname Interface name
diff --git a/automotive/can/1.0/default/libnetdevice/libnetdevice.cpp b/automotive/can/1.0/default/libnetdevice/libnetdevice.cpp
index 9bb1a57..f149c45 100644
--- a/automotive/can/1.0/default/libnetdevice/libnetdevice.cpp
+++ b/automotive/can/1.0/default/libnetdevice/libnetdevice.cpp
@@ -126,6 +126,10 @@
req->ifa_prefixlen = prefixlen;
req->ifa_flags = IFA_F_SECONDARY;
req->ifa_index = nametoindex(ifname);
+ if (req->ifa_index == 0) {
+ LOG(ERROR) << "Interface " << ifname << " doesn't exist";
+ return false;
+ }
auto addrn = inetAddr(addr);
req.add(IFLA_ADDRESS, addrn);
@@ -141,7 +145,7 @@
{
auto linkinfo = req.addNested(IFLA_LINKINFO);
- req.addBuffer(IFLA_INFO_KIND, type);
+ req.add(IFLA_INFO_KIND, type);
}
nl::Socket sock(NETLINK_ROUTE);
@@ -156,6 +160,20 @@
return sock.send(req) && sock.receiveAck(req);
}
+bool rename(std::string_view from, std::string_view to) {
+ nl::MessageFactory<ifinfomsg> req(RTM_SETLINK);
+ req.add(IFLA_IFNAME, to);
+
+ req->ifi_index = nametoindex(from);
+ if (req->ifi_index == 0) {
+ LOG(ERROR) << "Interface " << from << " doesn't exist";
+ return false;
+ }
+
+ nl::Socket sock(NETLINK_ROUTE);
+ return sock.send(req) && sock.receiveAck(req);
+}
+
std::optional<hwaddr_t> getHwAddr(std::string_view ifname) {
auto ifr = ifreqs::fromName(ifname);
if (!ifreqs::send(SIOCGIFHWADDR, ifr)) return std::nullopt;
diff --git a/automotive/can/1.0/default/libnetdevice/vlan.cpp b/automotive/can/1.0/default/libnetdevice/vlan.cpp
index e5b5a61..570545e 100644
--- a/automotive/can/1.0/default/libnetdevice/vlan.cpp
+++ b/automotive/can/1.0/default/libnetdevice/vlan.cpp
@@ -39,7 +39,7 @@
{
auto linkinfo = req.addNested(IFLA_LINKINFO);
- req.addBuffer(IFLA_INFO_KIND, "vlan");
+ req.add(IFLA_INFO_KIND, "vlan");
{
auto linkinfo = req.addNested(IFLA_INFO_DATA);
diff --git a/automotive/can/1.0/default/libnl++/include/libnl++/MessageFactory.h b/automotive/can/1.0/default/libnl++/include/libnl++/MessageFactory.h
index f65f055..058b2cb 100644
--- a/automotive/can/1.0/default/libnl++/include/libnl++/MessageFactory.h
+++ b/automotive/can/1.0/default/libnl++/include/libnl++/MessageFactory.h
@@ -23,6 +23,7 @@
#include <linux/netlink.h>
#include <string>
+#include <type_traits>
namespace android::nl {
@@ -109,25 +110,21 @@
*/
template <class A>
void add(nlattrtype_t type, const A& attr) {
- addInternal(type, &attr, sizeof(attr));
+ static_assert(std::is_pod_v<A>, "POD type required");
+ add(type, &attr, sizeof(attr));
}
- // It will always send the last null character, otherwise use addBuffer
- // variant instead
template <>
void add(nlattrtype_t type, const std::string& s) {
- addInternal(type, s.c_str(), s.size() + 1);
+ add(type, s.c_str(), s.size());
}
- void addBuffer(nlattrtype_t type, const std::string_view& s) {
- addInternal(type, s.data(), s.size());
- }
+ void add(nlattrtype_t type, std::string_view s) { add(type, s.data(), s.size()); }
/** Guard class to frame nested attributes. \see addNested(nlattrtype_t). */
class [[nodiscard]] NestedGuard {
public:
- NestedGuard(MessageFactory& req, nlattrtype_t type)
- : mReq(req), mAttr(req.addInternal(type)) {}
+ NestedGuard(MessageFactory& req, nlattrtype_t type) : mReq(req), mAttr(req.add(type)) {}
~NestedGuard() { closeNested(&mReq.mMessage.header, mAttr); }
private:
@@ -148,7 +145,7 @@
* MessageFactory<ifinfomsg> req(RTM_NEWLINK, NLM_F_REQUEST);
* {
* auto linkinfo = req.addNested(IFLA_LINKINFO);
- * req.addBuffer(IFLA_INFO_KIND, "can");
+ * req.add(IFLA_INFO_KIND, "can");
* {
* auto infodata = req.addNested(IFLA_INFO_DATA);
* req.add(IFLA_CAN_BITTIMING, bitTimingStruct);
@@ -164,7 +161,7 @@
Message mMessage = {};
bool mIsGood = true;
- nlattr* addInternal(nlattrtype_t type, const void* data = nullptr, size_t len = 0) {
+ nlattr* add(nlattrtype_t type, const void* data = nullptr, size_t len = 0) {
if (!mIsGood) return nullptr;
auto attr = MessageFactoryBase::add(&mMessage.header, sizeof(mMessage), type, data, len);
if (attr == nullptr) mIsGood = false;
diff --git a/automotive/vehicle/aidl/impl/3/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp b/automotive/vehicle/aidl/impl/3/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
index f6098ca..0dd5e9f 100644
--- a/automotive/vehicle/aidl/impl/3/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
+++ b/automotive/vehicle/aidl/impl/3/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
@@ -223,7 +223,8 @@
return status;
}
- const SetValueResult& result = getSetValueResults().back();
+ std::vector<SetValueResult> resultVector = getSetValueResults();
+ const SetValueResult& result = resultVector.back();
if (result.requestId != 0) {
ALOGE("request ID mismatch, got %" PRId64 ", expect 0", result.requestId);
@@ -245,7 +246,8 @@
return unexpected(status);
}
- const GetValueResult& result = getGetValueResults().back();
+ std::vector<GetValueResult> resultVector = getGetValueResults();
+ const GetValueResult& result = resultVector.back();
if (result.requestId != 0) {
ALOGE("request ID mismatch, got %" PRId64 ", expect 0", result.requestId);
return unexpected(StatusCode::INTERNAL_ERROR);
@@ -277,7 +279,7 @@
mCv.notify_all();
}
- const std::vector<SetValueResult>& getSetValueResults() {
+ std::vector<SetValueResult> getSetValueResults() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mSetValueResults;
}
@@ -291,7 +293,7 @@
mCv.notify_all();
}
- const std::vector<GetValueResult>& getGetValueResults() {
+ std::vector<GetValueResult> getGetValueResults() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mGetValueResults;
}
@@ -309,7 +311,7 @@
mCv.notify_all();
}
- const std::vector<VehiclePropValue>& getChangedProperties() {
+ std::vector<VehiclePropValue> getChangedProperties() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mChangedProperties;
}
diff --git a/automotive/vehicle/aidl/impl/3/vhal/Android.bp b/automotive/vehicle/aidl/impl/3/vhal/Android.bp
index a648fd4..22ea23d 100644
--- a/automotive/vehicle/aidl/impl/3/vhal/Android.bp
+++ b/automotive/vehicle/aidl/impl/3/vhal/Android.bp
@@ -47,6 +47,7 @@
cc_library {
name: "DefaultVehicleHal-V3",
vendor: true,
+ host_supported: true,
defaults: [
"VehicleHalDefaults-V3",
],
diff --git a/automotive/vehicle/aidl/impl/current/default_config/config/DefaultProperties.json b/automotive/vehicle/aidl/impl/current/default_config/config/DefaultProperties.json
index 86ac92e..f71dead 100644
--- a/automotive/vehicle/aidl/impl/current/default_config/config/DefaultProperties.json
+++ b/automotive/vehicle/aidl/impl/current/default_config/config/DefaultProperties.json
@@ -2549,57 +2549,49 @@
"property": "VehicleProperty::HVAC_TEMPERATURE_SET",
"defaultValue": {
"floatValues": [
- 17.0
+ 18.5
]
},
"areas": [
{
"areaId": "Constants::SEAT_1_LEFT",
- "minFloatValue": 16.0,
- "maxFloatValue": 28.0
+ "minFloatValue": 17.5,
+ "maxFloatValue": 32.5
},
{
"areaId": "Constants::SEAT_1_RIGHT",
- "minFloatValue": 16.0,
- "maxFloatValue": 28.0
+ "minFloatValue": 17.5,
+ "maxFloatValue": 32.5
},
{
"areaId": "Constants::SEAT_2_LEFT",
- "minFloatValue": 16.0,
- "maxFloatValue": 28.0
+ "minFloatValue": 17.5,
+ "maxFloatValue": 32.5
},
{
"areaId": "Constants::SEAT_2_RIGHT",
- "minFloatValue": 16.0,
- "maxFloatValue": 28.0
+ "minFloatValue": 17.5,
+ "maxFloatValue": 32.5
},
{
"areaId": "Constants::SEAT_2_CENTER",
- "minFloatValue": 16.0,
- "maxFloatValue": 28.0
+ "minFloatValue": 17.5,
+ "maxFloatValue": 32.5
}
],
"comment":
"minFloatValue and maxFloatValue in area config should match corresponding values in configArray",
"configArray": [
- 160,
- 280,
+ 175,
+ 325,
5,
- 608,
- 824,
- 9
+ 600,
+ 900,
+ 10
]
},
{
- "property": "VehicleProperty::HVAC_TEMPERATURE_VALUE_SUGGESTION",
- "defaultValue": {
- "floatValues": [
- 66.19999694824219,
- "VehicleUnit::FAHRENHEIT",
- 19.0,
- 66.2
- ]
- }
+ "property": "VehicleProperty::HVAC_TEMPERATURE_VALUE_SUGGESTION"
},
{
"property": "VehicleProperty::ENV_OUTSIDE_TEMPERATURE",
diff --git a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
index a097135..df5c2a3 100644
--- a/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
+++ b/automotive/vehicle/aidl/impl/current/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp
@@ -223,7 +223,8 @@
return status;
}
- const SetValueResult& result = getSetValueResults().back();
+ std::vector<SetValueResult> resultVector = getSetValueResults();
+ const SetValueResult& result = resultVector.back();
if (result.requestId != 0) {
ALOGE("request ID mismatch, got %" PRId64 ", expect 0", result.requestId);
@@ -245,7 +246,8 @@
return unexpected(status);
}
- const GetValueResult& result = getGetValueResults().back();
+ std::vector<GetValueResult> resultVector = getGetValueResults();
+ const GetValueResult& result = resultVector.back();
if (result.requestId != 0) {
ALOGE("request ID mismatch, got %" PRId64 ", expect 0", result.requestId);
return unexpected(StatusCode::INTERNAL_ERROR);
@@ -277,7 +279,7 @@
mCv.notify_all();
}
- const std::vector<SetValueResult>& getSetValueResults() {
+ std::vector<SetValueResult> getSetValueResults() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mSetValueResults;
}
@@ -291,7 +293,7 @@
mCv.notify_all();
}
- const std::vector<GetValueResult>& getGetValueResults() {
+ std::vector<GetValueResult> getGetValueResults() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mGetValueResults;
}
@@ -309,7 +311,7 @@
mCv.notify_all();
}
- const std::vector<VehiclePropValue>& getChangedProperties() {
+ std::vector<VehiclePropValue> getChangedProperties() {
std::scoped_lock<std::mutex> lockGuard(mLock);
return mChangedProperties;
}
@@ -3064,8 +3066,8 @@
TEST_F(FakeVehicleHardwareTest, GetPropertyWithPropertyNameAreaName) {
auto result = getHardware()->dump({"--get", "HVAC_TEMPERATURE_SET", "-a", "ROW_1_LEFT"});
- // Default value is 17
- ASSERT_THAT(result.buffer, ContainsRegex("17"));
+ // Default value is 18.5
+ ASSERT_THAT(result.buffer, ContainsRegex("18.5"));
getHardware()->dump({"--set", "HVAC_TEMPERATURE_SET", "-a", "ROW_1_LEFT", "-f", "22"});
result = getHardware()->dump({"--get", "HVAC_TEMPERATURE_SET", "-a", "ROW_1_LEFT"});
@@ -3680,7 +3682,7 @@
.areaId = HVAC_ALL,
.value.floatValues = {0, 0, 0, 0},
};
- status = setValue(floatArraySizeFive);
+ status = setValue(invalidUnit);
EXPECT_EQ(status, StatusCode::INVALID_ARG);
clearChangedProperties();
@@ -3924,9 +3926,9 @@
{minTempInFahrenheit +
incrementInFahrenheit * 2.5f,
FAHRENHEIT,
- minTempInCelsius + incrementInCelsius * 2,
+ minTempInCelsius + incrementInCelsius * 3,
minTempInFahrenheit +
- incrementInFahrenheit * 2},
+ incrementInFahrenheit * 3},
},
},
},
diff --git a/automotive/vehicle/aidl/impl/current/vhal/Android.bp b/automotive/vehicle/aidl/impl/current/vhal/Android.bp
index 8764eff..cfc2b34 100644
--- a/automotive/vehicle/aidl/impl/current/vhal/Android.bp
+++ b/automotive/vehicle/aidl/impl/current/vhal/Android.bp
@@ -47,6 +47,7 @@
cc_library {
name: "DefaultVehicleHal",
vendor: true,
+ host_supported: true,
defaults: [
"VehicleHalDefaults",
],
diff --git a/biometrics/common/util/CancellationSignal.cpp b/biometrics/common/util/CancellationSignal.cpp
index 7888838..2bfc39e 100644
--- a/biometrics/common/util/CancellationSignal.cpp
+++ b/biometrics/common/util/CancellationSignal.cpp
@@ -22,10 +22,13 @@
namespace aidl::android::hardware::biometrics {
CancellationSignal::CancellationSignal(std::promise<void>&& cancellationPromise)
- : mCancellationPromise(std::move(cancellationPromise)) {}
+ : mCancellationPromise(std::move(cancellationPromise)), isSet(false) {}
ndk::ScopedAStatus CancellationSignal::cancel() {
- mCancellationPromise.set_value();
+ if (!isSet) {
+ mCancellationPromise.set_value();
+ isSet = true;
+ }
return ndk::ScopedAStatus::ok();
}
diff --git a/biometrics/common/util/include/util/CancellationSignal.h b/biometrics/common/util/include/util/CancellationSignal.h
index be77e29..d5a9a1d 100644
--- a/biometrics/common/util/include/util/CancellationSignal.h
+++ b/biometrics/common/util/include/util/CancellationSignal.h
@@ -30,6 +30,7 @@
private:
std::promise<void> mCancellationPromise;
+ bool isSet;
};
// Returns whether the given cancellation future is ready, i.e. whether the operation corresponding
diff --git a/bluetooth/aidl/Android.bp b/bluetooth/aidl/Android.bp
index 0daecf7..4ee2f49 100644
--- a/bluetooth/aidl/Android.bp
+++ b/bluetooth/aidl/Android.bp
@@ -16,13 +16,6 @@
srcs: ["android/hardware/bluetooth/*.aidl"],
stability: "vintf",
backend: {
- cpp: {
- // FIXME should this be disabled?
- // prefer NDK backend which can be used anywhere
- // If you disable this, you also need to delete the C++
- // translate code.
- enabled: true,
- },
rust: {
enabled: true,
},
@@ -44,5 +37,4 @@
},
],
frozen: true,
-
}
diff --git a/bluetooth/aidl/default/Android.bp b/bluetooth/aidl/default/Android.bp
index 3f4ba99..d3f6364 100644
--- a/bluetooth/aidl/default/Android.bp
+++ b/bluetooth/aidl/default/Android.bp
@@ -2,81 +2,62 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
-cc_defaults {
- name: "android.hardware.bluetooth-service-build-defaults",
- cflags: [
- "-Wall",
- "-Wextra",
- ],
- shared_libs: [
- "android.hardware.bluetooth-V1-ndk",
- "libbase",
- "libbinder_ndk",
- "libcutils",
- "libhidlbase",
- "liblog",
- "libutils",
- ],
- static_libs: [
- "android.hardware.bluetooth.async",
- "android.hardware.bluetooth.hci",
- ],
-}
-
cc_library_static {
name: "libbluetoothhcihalimpl",
vendor_available: true,
host_supported: true,
- defaults: ["android.hardware.bluetooth-service-build-defaults"],
srcs: [
"BluetoothHci.cpp",
"net_bluetooth_mgmt.cpp",
],
-}
-
-cc_binary {
- name: "android.hardware.bluetooth-service.default",
- relative_install_path: "hw",
- init_rc: ["bluetooth-service-default.rc"],
- vintf_fragments: [":manifest_android.hardware.bluetooth-service.default.xml"],
- vendor: true,
- defaults: ["android.hardware.bluetooth-service-build-defaults"],
- srcs: [
- "service.cpp",
+ cflags: [
+ "-Wall",
+ "-Wextra",
],
- shared_libs: [
- "android.hardware.bluetooth-V1-ndk",
- "libbase",
- "libbinder_ndk",
- "libhidlbase",
- "libutils",
- "liblog",
- ],
- static_libs: [
- "libbluetoothhcihalimpl",
- ],
-}
-
-cc_fuzz {
- name: "android.hardware.bluetooth-service.default_fuzzer",
- host_supported: true,
- defaults: ["service_fuzzer_defaults"],
- srcs: [
- "test/fuzzer.cpp",
+ header_libs: [
+ "libbluetooth_offload_hal_headers",
],
static_libs: [
"android.hardware.bluetooth.async",
"android.hardware.bluetooth.hci",
- "android.hardware.bluetooth-V1-ndk",
- "libbluetoothhcihalimpl",
- "liblog",
],
- fuzz_config: {
- componentid: 27441,
- cc: [
- "mylesgw@google.com",
- ],
- },
+ shared_libs: [
+ "libbase",
+ "libcutils",
+ "liblog",
+ "libutils",
+ ],
+}
+
+rust_binary {
+ name: "android.hardware.bluetooth-service.default",
+ crate_name: "bluetooth_hci_hal_server",
+ relative_install_path: "hw",
+ init_rc: ["bluetooth-service-default.rc"],
+ vintf_fragments: [":manifest_android.hardware.bluetooth-service.default.xml"],
+ vendor: true,
+ prefer_rlib: true,
+ srcs: ["main.rs"],
+ rustlibs: [
+ "android.hardware.bluetooth-V1-rust",
+ "libbluetooth_offload_hal",
+ "libbluetooth_offload_leaudio_hci",
+ "libbinder_rs",
+ "liblogger",
+ "liblog_rust",
+ ],
+ static_libs: [
+ "android.hardware.bluetooth.async",
+ "android.hardware.bluetooth.hci",
+ "libbluetoothhcihalimpl",
+ ],
+ shared_libs: [
+ "libbase",
+ "libc++",
+ "libcutils",
+ "liblog",
+ "libutils",
+ ],
}
filegroup {
diff --git a/bluetooth/aidl/default/BluetoothHci.cpp b/bluetooth/aidl/default/BluetoothHci.cpp
index a247cb0..bcdb67e 100644
--- a/bluetooth/aidl/default/BluetoothHci.cpp
+++ b/bluetooth/aidl/default/BluetoothHci.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2022 The Android Open Source Project
+ * Copyright 2024 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,18 +16,20 @@
#define LOG_TAG "android.hardware.bluetooth.service.default"
-#include "BluetoothHci.h"
-
#include <cutils/properties.h>
#include <fcntl.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <poll.h>
+#include <hal/ffi.h>
#include <string.h>
-#include <sys/uio.h>
#include <termios.h>
+#include <future>
+#include <memory>
+#include <vector>
+
+#include "async_fd_watcher.h"
+#include "h4_protocol.h"
#include "log/log.h"
+#include "net_bluetooth_mgmt.h"
namespace {
int SetTerminalRaw(int fd) {
@@ -44,12 +46,9 @@
using namespace ::android::hardware::bluetooth::hci;
using namespace ::android::hardware::bluetooth::async;
-using aidl::android::hardware::bluetooth::Status;
namespace aidl::android::hardware::bluetooth::impl {
-void OnDeath(void* cookie);
-
std::optional<std::string> GetSystemProperty(const std::string& property) {
std::array<char, PROPERTY_VALUE_MAX> value_array{0};
auto value_len = property_get(property.c_str(), value_array.data(), nullptr);
@@ -63,302 +62,298 @@
return str.compare(0, prefix.length(), prefix) == 0;
}
-class BluetoothDeathRecipient {
+class Hal {
public:
- BluetoothDeathRecipient(BluetoothHci* hci) : mHci(hci) {}
-
- void LinkToDeath(const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
- mCb = cb;
- clientDeathRecipient_ = AIBinder_DeathRecipient_new(OnDeath);
- auto linkToDeathReturnStatus = AIBinder_linkToDeath(
- mCb->asBinder().get(), clientDeathRecipient_, this /* cookie */);
- LOG_ALWAYS_FATAL_IF(linkToDeathReturnStatus != STATUS_OK,
- "Unable to link to death recipient");
+ Hal(const std::string& dev_path = "/dev/hvc5") {
+ char property_bytes[PROPERTY_VALUE_MAX];
+ property_get("vendor.ser.bt-uart", property_bytes, dev_path.c_str());
+ mDevPath = std::string(property_bytes);
}
- void UnlinkToDeath(const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
- LOG_ALWAYS_FATAL_IF(cb != mCb, "Unable to unlink mismatched pointers");
+ static void Initialize(void* instance,
+ const struct hal_callbacks* callbacks) {
+ static_cast<Hal*>(instance)->Initialize(callbacks);
}
- void serviceDied() {
- if (mCb != nullptr && !AIBinder_isAlive(mCb->asBinder().get())) {
- ALOGE("Bluetooth remote service has died");
- } else {
- ALOGE("BluetoothDeathRecipient::serviceDied called but service not dead");
- return;
- }
- {
- std::lock_guard<std::mutex> guard(mHasDiedMutex);
- has_died_ = true;
- }
- mHci->close();
+ static void Close(void* instance) { static_cast<Hal*>(instance)->Close(); }
+
+ static void SendCommand(void* instance, const uint8_t* data, size_t len) {
+ static_cast<Hal*>(instance)->SendCommand(
+ std::vector<uint8_t>(data, data + len));
}
- BluetoothHci* mHci;
- std::shared_ptr<IBluetoothHciCallbacks> mCb;
- AIBinder_DeathRecipient* clientDeathRecipient_;
- bool getHasDied() {
- std::lock_guard<std::mutex> guard(mHasDiedMutex);
- return has_died_;
+
+ static void SendAcl(void* instance, const uint8_t* data, size_t len) {
+ static_cast<Hal*>(instance)->SendAcl(
+ std::vector<uint8_t>(data, data + len));
+ }
+
+ static void SendSco(void* instance, const uint8_t* data, size_t len) {
+ static_cast<Hal*>(instance)->SendSco(
+ std::vector<uint8_t>(data, data + len));
+ }
+
+ static void SendIso(void* instance, const uint8_t* data, size_t len) {
+ static_cast<Hal*>(instance)->SendIso(
+ std::vector<uint8_t>(data, data + len));
}
private:
- std::mutex mHasDiedMutex;
- bool has_died_{false};
-};
-
-void OnDeath(void* cookie) {
- auto* death_recipient = static_cast<BluetoothDeathRecipient*>(cookie);
- death_recipient->serviceDied();
-}
-
-BluetoothHci::BluetoothHci(const std::string& dev_path) {
- char property_bytes[PROPERTY_VALUE_MAX];
- property_get("vendor.ser.bt-uart", property_bytes, dev_path.c_str());
- mDevPath = std::string(property_bytes);
- mDeathRecipient = std::make_shared<BluetoothDeathRecipient>(this);
-}
-
-int BluetoothHci::getFdFromDevPath() {
- int fd = open(mDevPath.c_str(), O_RDWR);
- if (fd < 0) {
- ALOGE("Could not connect to bt: %s (%s)", mDevPath.c_str(),
- strerror(errno));
+ int getFdFromDevPath() {
+ int fd = open(mDevPath.c_str(), O_RDWR);
+ if (fd < 0) {
+ ALOGE("Could not connect to bt: %s (%s)", mDevPath.c_str(),
+ strerror(errno));
+ return fd;
+ }
+ if (int ret = SetTerminalRaw(fd) < 0) {
+ ALOGI("Could not make %s a raw terminal %d(%s)", mDevPath.c_str(), ret,
+ strerror(errno));
+ }
return fd;
}
- if (int ret = SetTerminalRaw(fd) < 0) {
- ALOGI("Could not make %s a raw terminal %d(%s)", mDevPath.c_str(), ret,
- strerror(errno));
- }
- return fd;
-}
-void BluetoothHci::reset() {
- // Send a reset command and wait until the command complete comes back.
+ void reset() {
+ // Send a reset command and wait until the command complete comes back.
- std::vector<uint8_t> reset = {0x03, 0x0c, 0x00};
+ std::vector<uint8_t> reset = {0x03, 0x0c, 0x00};
- auto resetPromise = std::make_shared<std::promise<void>>();
- auto resetFuture = resetPromise->get_future();
+ auto resetPromise = std::make_shared<std::promise<void>>();
+ auto resetFuture = resetPromise->get_future();
- mH4 = std::make_shared<H4Protocol>(
- mFd,
- [](const std::vector<uint8_t>& raw_command) {
- ALOGI("Discarding %d bytes with command type",
- static_cast<int>(raw_command.size()));
- },
- [](const std::vector<uint8_t>& raw_acl) {
- ALOGI("Discarding %d bytes with acl type",
- static_cast<int>(raw_acl.size()));
- },
- [](const std::vector<uint8_t>& raw_sco) {
- ALOGI("Discarding %d bytes with sco type",
- static_cast<int>(raw_sco.size()));
- },
- [resetPromise](const std::vector<uint8_t>& raw_event) {
- std::vector<uint8_t> reset_complete = {0x0e, 0x04, 0x01,
- 0x03, 0x0c, 0x00};
- bool valid = raw_event.size() == 6 &&
- raw_event[0] == reset_complete[0] &&
- raw_event[1] == reset_complete[1] &&
- // Don't compare the number of packets field.
- raw_event[3] == reset_complete[3] &&
- raw_event[4] == reset_complete[4] &&
- raw_event[5] == reset_complete[5];
- if (valid) {
- resetPromise->set_value();
- } else {
- ALOGI("Discarding %d bytes with event type",
- static_cast<int>(raw_event.size()));
- }
- },
- [](const std::vector<uint8_t>& raw_iso) {
- ALOGI("Discarding %d bytes with iso type",
- static_cast<int>(raw_iso.size()));
- },
- [this]() {
- ALOGI("HCI socket device disconnected while waiting for reset");
- mFdWatcher.StopWatchingFileDescriptors();
- });
- mFdWatcher.WatchFdForNonBlockingReads(mFd,
- [this](int) { mH4->OnDataReady(); });
+ mH4 = std::make_shared<H4Protocol>(
+ mFd,
+ [](const std::vector<uint8_t>& raw_command) {
+ ALOGI("Discarding %d bytes with command type",
+ static_cast<int>(raw_command.size()));
+ },
+ [](const std::vector<uint8_t>& raw_acl) {
+ ALOGI("Discarding %d bytes with acl type",
+ static_cast<int>(raw_acl.size()));
+ },
+ [](const std::vector<uint8_t>& raw_sco) {
+ ALOGI("Discarding %d bytes with sco type",
+ static_cast<int>(raw_sco.size()));
+ },
+ [resetPromise](const std::vector<uint8_t>& raw_event) {
+ std::vector<uint8_t> reset_complete = {0x0e, 0x04, 0x01,
+ 0x03, 0x0c, 0x00};
+ bool valid = raw_event.size() == 6 &&
+ raw_event[0] == reset_complete[0] &&
+ raw_event[1] == reset_complete[1] &&
+ // Don't compare the number of packets field.
+ raw_event[3] == reset_complete[3] &&
+ raw_event[4] == reset_complete[4] &&
+ raw_event[5] == reset_complete[5];
+ if (valid) {
+ resetPromise->set_value();
+ } else {
+ ALOGI("Discarding %d bytes with event type",
+ static_cast<int>(raw_event.size()));
+ }
+ },
+ [](const std::vector<uint8_t>& raw_iso) {
+ ALOGI("Discarding %d bytes with iso type",
+ static_cast<int>(raw_iso.size()));
+ },
+ [this]() {
+ ALOGI("HCI socket device disconnected while waiting for reset");
+ mFdWatcher.StopWatchingFileDescriptors();
+ });
+ mFdWatcher.WatchFdForNonBlockingReads(mFd,
+ [this](int) { mH4->OnDataReady(); });
- ndk::ScopedAStatus result = send(PacketType::COMMAND, reset);
- if (!result.isOk()) {
- ALOGE("Error sending reset command");
- }
- auto status = resetFuture.wait_for(std::chrono::seconds(1));
- mFdWatcher.StopWatchingFileDescriptors();
- if (status == std::future_status::ready) {
- ALOGI("HCI Reset successful");
- } else {
- ALOGE("HCI Reset Response not received in one second");
- }
-
- resetPromise.reset();
-}
-
-ndk::ScopedAStatus BluetoothHci::initialize(
- const std::shared_ptr<IBluetoothHciCallbacks>& cb) {
- ALOGI(__func__);
-
- if (cb == nullptr) {
- ALOGE("cb == nullptr! -> Unable to call initializationComplete(ERR)");
- return ndk::ScopedAStatus::fromServiceSpecificError(STATUS_BAD_VALUE);
- }
-
- HalState old_state = HalState::READY;
- {
- std::lock_guard<std::mutex> guard(mStateMutex);
- if (mState != HalState::READY) {
- old_state = mState;
+ if (!send(PacketType::COMMAND, reset)) {
+ ALOGE("Error sending reset command");
+ }
+ auto status = resetFuture.wait_for(std::chrono::seconds(1));
+ mFdWatcher.StopWatchingFileDescriptors();
+ if (status == std::future_status::ready) {
+ ALOGI("HCI Reset successful");
} else {
- mState = HalState::INITIALIZING;
+ ALOGE("HCI Reset Response not received in one second");
}
+
+ resetPromise.reset();
}
- if (old_state != HalState::READY) {
- ALOGE("initialize: Unexpected State %d", static_cast<int>(old_state));
- close();
- cb->initializationComplete(Status::ALREADY_INITIALIZED);
- return ndk::ScopedAStatus::ok();
- }
+ void Initialize(const struct hal_callbacks* callbacks) {
+ ALOGI(__func__);
- mCb = cb;
- management_.reset(new NetBluetoothMgmt);
- mFd = management_->openHci();
- if (mFd < 0) {
- management_.reset();
+ HalState old_state = HalState::READY;
+ {
+ std::lock_guard<std::mutex> guard(mStateMutex);
+ if (mState != HalState::READY) {
+ old_state = mState;
+ } else {
+ mState = HalState::INITIALIZING;
+ }
+ }
- ALOGI("Unable to open Linux interface, trying default path.");
- mFd = getFdFromDevPath();
+ if (old_state != HalState::READY) {
+ ALOGE("initialize: Unexpected State %d", static_cast<int>(old_state));
+ Close();
+ callbacks->initialization_complete(callbacks->handle,
+ STATUS_ALREADY_INITIALIZED);
+ return;
+ }
+
+ mCallbacks = std::make_unique<struct hal_callbacks>(*callbacks);
+ management_.reset(new NetBluetoothMgmt);
+ mFd = management_->openHci();
if (mFd < 0) {
+ management_.reset();
+
+ ALOGI("Unable to open Linux interface, trying default path.");
+ mFd = getFdFromDevPath();
+ if (mFd < 0) {
+ mState = HalState::READY;
+ mCallbacks->initialization_complete(mCallbacks->handle,
+ STATUS_UNABLE_TO_OPEN_INTERFACE);
+ return;
+ }
+ }
+
+ // TODO: HCI Reset on emulators since the bluetooth controller
+ // cannot be powered on/off during the HAL setup; and the stack
+ // might received spurious packets/events during boottime.
+ // Proper solution would be to use bt-virtio or vsock to better
+ // control the link to rootcanal and the controller lifetime.
+ const std::string kBoardProperty = "ro.product.board";
+ const std::string kCuttlefishBoard = "cutf";
+ auto board_name = GetSystemProperty(kBoardProperty);
+ if (board_name.has_value() &&
+ (starts_with(board_name.value(), "cutf") ||
+ starts_with(board_name.value(), "goldfish"))) {
+ reset();
+ }
+
+ mH4 = std::make_shared<H4Protocol>(
+ mFd,
+ [](const std::vector<uint8_t>& /* raw_command */) {
+ LOG_ALWAYS_FATAL("Unexpected command!");
+ },
+ [this](const std::vector<uint8_t>& raw_acl) {
+ mCallbacks->acl_received(mCallbacks->handle, raw_acl.data(),
+ raw_acl.size());
+ },
+ [this](const std::vector<uint8_t>& raw_sco) {
+ mCallbacks->sco_received(mCallbacks->handle, raw_sco.data(),
+ raw_sco.size());
+ },
+ [this](const std::vector<uint8_t>& raw_event) {
+ mCallbacks->event_received(mCallbacks->handle, raw_event.data(),
+ raw_event.size());
+ },
+ [this](const std::vector<uint8_t>& raw_iso) {
+ mCallbacks->iso_received(mCallbacks->handle, raw_iso.data(),
+ raw_iso.size());
+ },
+ [this]() {
+ ALOGI("HCI socket device disconnected");
+ mFdWatcher.StopWatchingFileDescriptors();
+ });
+ mFdWatcher.WatchFdForNonBlockingReads(mFd,
+ [this](int) { mH4->OnDataReady(); });
+
+ {
+ std::lock_guard<std::mutex> guard(mStateMutex);
+ mState = HalState::ONE_CLIENT;
+ }
+
+ ALOGI("initialization complete");
+ mCallbacks->initialization_complete(mCallbacks->handle, STATUS_SUCCESS);
+ }
+
+ void Close() {
+ ALOGI(__func__);
+ {
+ std::lock_guard<std::mutex> guard(mStateMutex);
+ if (mState != HalState::ONE_CLIENT) {
+ LOG_ALWAYS_FATAL_IF(mState == HalState::INITIALIZING,
+ "mState is INITIALIZING");
+ ALOGI("Already closed");
+ return;
+ }
+ mCallbacks.reset();
+ mState = HalState::CLOSING;
+ }
+
+ mFdWatcher.StopWatchingFileDescriptors();
+
+ if (management_) {
+ management_->closeHci();
+ } else {
+ ::close(mFd);
+ }
+
+ {
+ std::lock_guard<std::mutex> guard(mStateMutex);
mState = HalState::READY;
- cb->initializationComplete(Status::UNABLE_TO_OPEN_INTERFACE);
- return ndk::ScopedAStatus::ok();
+ mH4 = nullptr;
}
}
- mDeathRecipient->LinkToDeath(mCb);
-
- // TODO: HCI Reset on emulators since the bluetooth controller
- // cannot be powered on/off during the HAL setup; and the stack
- // might received spurious packets/events during boottime.
- // Proper solution would be to use bt-virtio or vsock to better
- // control the link to rootcanal and the controller lifetime.
- const std::string kBoardProperty = "ro.product.board";
- const std::string kCuttlefishBoard = "cutf";
- auto board_name = GetSystemProperty(kBoardProperty);
- if (board_name.has_value() && (
- starts_with(board_name.value(), "cutf") ||
- starts_with(board_name.value(), "goldfish"))) {
- reset();
+ void SendCommand(const std::vector<uint8_t>& data) {
+ send(PacketType::COMMAND, data);
+ }
+ void SendAcl(const std::vector<uint8_t>& data) {
+ send(PacketType::ACL_DATA, data);
+ }
+ void SendSco(const std::vector<uint8_t>& data) {
+ send(PacketType::SCO_DATA, data);
+ }
+ void SendIso(const std::vector<uint8_t>& data) {
+ send(PacketType::ISO_DATA, data);
}
- mH4 = std::make_shared<H4Protocol>(
- mFd,
- [](const std::vector<uint8_t>& /* raw_command */) {
- LOG_ALWAYS_FATAL("Unexpected command!");
- },
- [this](const std::vector<uint8_t>& raw_acl) {
- mCb->aclDataReceived(raw_acl);
- },
- [this](const std::vector<uint8_t>& raw_sco) {
- mCb->scoDataReceived(raw_sco);
- },
- [this](const std::vector<uint8_t>& raw_event) {
- mCb->hciEventReceived(raw_event);
- },
- [this](const std::vector<uint8_t>& raw_iso) {
- mCb->isoDataReceived(raw_iso);
- },
- [this]() {
- ALOGI("HCI socket device disconnected");
- mFdWatcher.StopWatchingFileDescriptors();
- });
- mFdWatcher.WatchFdForNonBlockingReads(mFd,
- [this](int) { mH4->OnDataReady(); });
-
- {
- std::lock_guard<std::mutex> guard(mStateMutex);
- mState = HalState::ONE_CLIENT;
- }
- ALOGI("initialization complete");
- auto status = mCb->initializationComplete(Status::SUCCESS);
- if (!status.isOk()) {
- if (!mDeathRecipient->getHasDied()) {
- ALOGE("Error sending init callback, but no death notification");
+ bool send(PacketType type, const std::vector<uint8_t>& v) {
+ if (v.empty()) {
+ ALOGE("Packet is empty, no data was found to be sent");
+ return false;
}
- close();
- return ndk::ScopedAStatus::fromServiceSpecificError(
- STATUS_FAILED_TRANSACTION);
- }
- return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus BluetoothHci::close() {
- ALOGI(__func__);
- {
std::lock_guard<std::mutex> guard(mStateMutex);
- if (mState != HalState::ONE_CLIENT) {
- LOG_ALWAYS_FATAL_IF(mState == HalState::INITIALIZING,
- "mState is INITIALIZING");
- ALOGI("Already closed");
- return ndk::ScopedAStatus::ok();
+ if (mH4 == nullptr) {
+ ALOGE("Illegal State");
+ return false;
}
- mState = HalState::CLOSING;
+
+ mH4->Send(type, v);
+ return true;
}
- mFdWatcher.StopWatchingFileDescriptors();
+ std::unique_ptr<struct hal_callbacks> mCallbacks;
+ std::string mDevPath;
+ int mFd{-1};
+ ::android::hardware::bluetooth::async::AsyncFdWatcher mFdWatcher;
+ std::shared_ptr<::android::hardware::bluetooth::hci::H4Protocol> mH4;
+ std::unique_ptr<NetBluetoothMgmt> management_{};
- if (management_) {
- management_->closeHci();
- } else {
- ::close(mFd);
- }
-
- {
- std::lock_guard<std::mutex> guard(mStateMutex);
- mState = HalState::READY;
- mH4 = nullptr;
- }
- return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus BluetoothHci::sendHciCommand(
- const std::vector<uint8_t>& packet) {
- return send(PacketType::COMMAND, packet);
-}
-
-ndk::ScopedAStatus BluetoothHci::sendAclData(
- const std::vector<uint8_t>& packet) {
- return send(PacketType::ACL_DATA, packet);
-}
-
-ndk::ScopedAStatus BluetoothHci::sendScoData(
- const std::vector<uint8_t>& packet) {
- return send(PacketType::SCO_DATA, packet);
-}
-
-ndk::ScopedAStatus BluetoothHci::sendIsoData(
- const std::vector<uint8_t>& packet) {
- return send(PacketType::ISO_DATA, packet);
-}
-
-ndk::ScopedAStatus BluetoothHci::send(PacketType type,
- const std::vector<uint8_t>& v) {
- if (v.empty()) {
- ALOGE("Packet is empty, no data was found to be sent");
- return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
- }
-
- std::lock_guard<std::mutex> guard(mStateMutex);
- if (mH4 == nullptr) {
- return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
- }
-
- mH4->Send(type, v);
- return ndk::ScopedAStatus::ok();
-}
+ // Don't close twice or open before close is complete
+ std::mutex mStateMutex;
+ enum class HalState {
+ READY,
+ INITIALIZING,
+ ONE_CLIENT,
+ CLOSING,
+ } mState{HalState::READY};
+};
} // namespace aidl::android::hardware::bluetooth::impl
+
+extern "C" {
+
+using namespace aidl::android::hardware::bluetooth::impl;
+
+struct hal_interface hal_new() {
+ return (struct hal_interface){
+ .handle = new Hal(),
+ .initialize = &Hal::Initialize,
+ .close = &Hal::Close,
+ .send_command = &Hal::SendCommand,
+ .send_acl = &Hal::SendAcl,
+ .send_sco = &Hal::SendSco,
+ .send_iso = &Hal::SendIso,
+ };
+}
+}
diff --git a/bluetooth/aidl/default/BluetoothHci.h b/bluetooth/aidl/default/BluetoothHci.h
deleted file mode 100644
index 477cc5c..0000000
--- a/bluetooth/aidl/default/BluetoothHci.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <aidl/android/hardware/bluetooth/BnBluetoothHci.h>
-#include <aidl/android/hardware/bluetooth/IBluetoothHciCallbacks.h>
-
-#include <future>
-#include <string>
-
-#include "async_fd_watcher.h"
-#include "h4_protocol.h"
-#include "net_bluetooth_mgmt.h"
-
-namespace aidl::android::hardware::bluetooth::impl {
-
-class BluetoothDeathRecipient;
-
-// This Bluetooth HAL implementation connects with a serial port at dev_path_.
-class BluetoothHci : public BnBluetoothHci {
- public:
- BluetoothHci(const std::string& dev_path = "/dev/hvc5");
-
- ndk::ScopedAStatus initialize(
- const std::shared_ptr<IBluetoothHciCallbacks>& cb) override;
-
- ndk::ScopedAStatus sendHciCommand(
- const std::vector<uint8_t>& packet) override;
-
- ndk::ScopedAStatus sendAclData(const std::vector<uint8_t>& packet) override;
-
- ndk::ScopedAStatus sendScoData(const std::vector<uint8_t>& packet) override;
-
- ndk::ScopedAStatus sendIsoData(const std::vector<uint8_t>& packet) override;
-
- ndk::ScopedAStatus close() override;
-
- static void OnPacketReady();
-
- static BluetoothHci* get();
-
- private:
- int mFd{-1};
- std::shared_ptr<IBluetoothHciCallbacks> mCb = nullptr;
-
- std::shared_ptr<::android::hardware::bluetooth::hci::H4Protocol> mH4;
-
- std::shared_ptr<BluetoothDeathRecipient> mDeathRecipient;
-
- std::string mDevPath;
-
- ::android::hardware::bluetooth::async::AsyncFdWatcher mFdWatcher;
-
- int getFdFromDevPath();
- [[nodiscard]] ndk::ScopedAStatus send(
- ::android::hardware::bluetooth::hci::PacketType type,
- const std::vector<uint8_t>& packet);
- std::unique_ptr<NetBluetoothMgmt> management_{};
-
- // Send a reset command and discard all packets until a reset is received.
- void reset();
-
- // Don't close twice or open before close is complete
- std::mutex mStateMutex;
- enum class HalState {
- READY,
- INITIALIZING,
- ONE_CLIENT,
- CLOSING,
- } mState{HalState::READY};
-};
-
-} // namespace aidl::android::hardware::bluetooth::impl
diff --git a/bluetooth/aidl/default/main.rs b/bluetooth/aidl/default/main.rs
new file mode 100644
index 0000000..b30162a
--- /dev/null
+++ b/bluetooth/aidl/default/main.rs
@@ -0,0 +1,58 @@
+// Copyright 2024, The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use android_hardware_bluetooth::aidl::android::hardware::bluetooth::IBluetoothHci::{
+ self,
+ IBluetoothHci as _
+};
+use android_hardware_bluetooth::binder;
+use bluetooth_offload_hal::{ HciHalProxy, CInterface };
+use bluetooth_offload_leaudio_hci::LeAudioModuleBuilder;
+use log;
+use std::panic;
+
+fn new_hal() -> CInterface {
+ extern "C" { fn hal_new() -> CInterface; }
+ unsafe { hal_new() }
+}
+
+fn main() {
+ logger::init(
+ logger::Config::default()
+ .with_max_level(log::LevelFilter::Debug)
+ .with_tag_on_device("android.hardware.bluetooth"),
+ );
+
+ panic::set_hook(Box::new(|panic_info| {
+ log::error!("{}", panic_info);
+ }));
+
+ log::info!("Bluetooth HAL starting up");
+
+ binder::ProcessState::set_thread_pool_max_thread_count(0);
+ binder::ProcessState::start_thread_pool();
+
+ binder::add_service(
+ &format!("{}/default", IBluetoothHci::BpBluetoothHci::get_descriptor()),
+ IBluetoothHci::BnBluetoothHci::new_binder(
+ HciHalProxy::new(
+ vec![ Box::new(LeAudioModuleBuilder {}) ],
+ new_hal()
+ ),
+ binder::BinderFeatures::default(),
+ ).as_binder()
+ ).expect("Failed to register service");
+
+ binder::ProcessState::join_thread_pool();
+}
diff --git a/bluetooth/aidl/default/service.cpp b/bluetooth/aidl/default/service.cpp
deleted file mode 100644
index ef4b884..0000000
--- a/bluetooth/aidl/default/service.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "aidl.android.hardware.bluetooth.service.default"
-
-#include <aidl/android/hardware/bluetooth/IBluetoothHci.h>
-#include <android/binder_manager.h>
-#include <android/binder_process.h>
-#include <hidl/HidlSupport.h>
-#include <hidl/HidlTransportSupport.h>
-
-#include "BluetoothHci.h"
-
-using ::aidl::android::hardware::bluetooth::impl::BluetoothHci;
-using ::android::hardware::configureRpcThreadpool;
-using ::android::hardware::joinRpcThreadpool;
-
-int main(int /* argc */, char** /* argv */) {
- ALOGI("Bluetooth HAL starting");
- if (!ABinderProcess_setThreadPoolMaxThreadCount(0)) {
- ALOGI("failed to set thread pool max thread count");
- return 1;
- }
-
- std::shared_ptr<BluetoothHci> service =
- ndk::SharedRefBase::make<BluetoothHci>();
- std::string instance = std::string() + BluetoothHci::descriptor + "/default";
- auto result =
- AServiceManager_addService(service->asBinder().get(), instance.c_str());
- if (result == STATUS_OK) {
- ABinderProcess_joinThreadPool();
- } else {
- ALOGE("Could not register as a service!");
- }
- return 0;
-}
diff --git a/bluetooth/aidl/default/test/fuzzer.cpp b/bluetooth/aidl/default/test/fuzzer.cpp
deleted file mode 100644
index e7a1eef..0000000
--- a/bluetooth/aidl/default/test/fuzzer.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2022 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <fuzzbinder/libbinder_ndk_driver.h>
-#include <fuzzer/FuzzedDataProvider.h>
-
-#include "BluetoothHci.h"
-
-using aidl::android::hardware::bluetooth::impl::BluetoothHci;
-using android::fuzzService;
-using ndk::SharedRefBase;
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
- auto service = SharedRefBase::make<BluetoothHci>();
-
- fuzzService(service->asBinder().get(), FuzzedDataProvider(data, size));
-
- return 0;
-}
diff --git a/compatibility_matrices/bump.py b/compatibility_matrices/bump.py
index 33b41ce..bbc4a11 100755
--- a/compatibility_matrices/bump.py
+++ b/compatibility_matrices/bump.py
@@ -14,9 +14,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-"""
-Creates the next compatibility matrix.
-"""
+"""Creates the next compatibility matrix."""
import argparse
import os
@@ -27,199 +25,354 @@
def check_call(*args, **kwargs):
- print(args)
- subprocess.check_call(*args, **kwargs)
+ print(args)
+ subprocess.check_call(*args, **kwargs)
def check_output(*args, **kwargs):
- print(args)
- return subprocess.check_output(*args, **kwargs)
+ print(args)
+ return subprocess.check_output(*args, **kwargs)
class Bump(object):
- def __init__(self, cmdline_args):
- self.top = pathlib.Path(os.environ["ANDROID_BUILD_TOP"])
- self.interfaces_dir = self.top / "hardware/interfaces"
+ def __init__(self, cmdline_args):
+ self.top = pathlib.Path(os.environ["ANDROID_BUILD_TOP"])
+ self.interfaces_dir = self.top / "hardware/interfaces"
- self.current_level = cmdline_args.current_level
- self.current_letter = cmdline_args.current_letter
- self.current_version = cmdline_args.platform_version
- self.next_version = cmdline_args.next_platform_version
- self.current_module_name = f"framework_compatibility_matrix.{self.current_level}.xml"
- self.current_xml = self.interfaces_dir / f"compatibility_matrices/compatibility_matrix.{self.current_level}.xml"
- self.device_module_name = "framework_compatibility_matrix.device.xml"
+ self.current_level = cmdline_args.current_level
+ self.current_letter = cmdline_args.current_letter
+ self.current_version = cmdline_args.platform_version
+ self.next_version = cmdline_args.next_platform_version
+ self.current_module_name = (
+ f"framework_compatibility_matrix.{self.current_level}.xml"
+ )
+ self.current_xml = (
+ self.interfaces_dir
+ / f"compatibility_matrices/compatibility_matrix.{self.current_level}.xml"
+ )
+ self.device_module_name = "framework_compatibility_matrix.device.xml"
- self.next_level = cmdline_args.next_level
- self.next_letter = cmdline_args.next_letter
- self.next_module_name = f"framework_compatibility_matrix.{self.next_level}.xml"
- self.next_xml = self.interfaces_dir / f"compatibility_matrices/compatibility_matrix.{self.next_level}.xml"
+ self.next_level = cmdline_args.next_level
+ self.next_letter = cmdline_args.next_letter
+ self.current_sdk = cmdline_args.current_sdk
+ self.next_sdk = cmdline_args.next_sdk
+ self.next_module_name = (
+ f"framework_compatibility_matrix.{self.next_level}.xml"
+ )
+ self.next_xml = (
+ self.interfaces_dir
+ / f"compatibility_matrices/compatibility_matrix.{self.next_level}.xml"
+ )
- def run(self):
- self.bump_kernel_configs()
- self.copy_matrix()
- self.edit_android_bp()
- self.bump_libvintf()
- self.bump_libvts_vintf()
+ def run(self):
+ self.bump_kernel_configs()
+ self.copy_matrix()
+ self.edit_android_bp()
+ self.bump_libvintf()
+ self.bump_libvts_vintf()
+ self.bump_cuttlefish()
- def bump_kernel_configs(self):
- check_call([
- self.top / "kernel/configs/tools/bump.py",
- self.current_letter.lower(),
- self.next_letter.lower(),
- ])
+ def bump_kernel_configs(self):
+ check_call([
+ self.top / "kernel/configs/tools/bump.py",
+ self.current_letter.lower(),
+ self.next_letter.lower(),
+ ])
- def copy_matrix(self):
- with open(self.current_xml) as f_current, open(self.next_xml, "w") as f_next:
- f_next.write(f_current.read().replace(f"level=\"{self.current_level}\"", f"level=\"{self.next_level}\""))
+ def copy_matrix(self):
+ with open(self.current_xml) as f_current, open(
+ self.next_xml, "w"
+ ) as f_next:
+ f_next.write(
+ f_current.read().replace(
+ f'level="{self.current_level}"', f'level="{self.next_level}"'
+ )
+ )
- def edit_android_bp(self):
- android_bp = self.interfaces_dir / "compatibility_matrices/Android.bp"
+ def edit_android_bp(self):
+ android_bp = self.interfaces_dir / "compatibility_matrices/Android.bp"
- with open(android_bp, "r+") as f:
- if self.next_module_name not in f.read():
- f.seek(0, 2) # end of file
- f.write("\n")
- f.write(
- textwrap.dedent(f"""\
+ with open(android_bp, "r+") as f:
+ if self.next_module_name not in f.read():
+ f.seek(0, 2) # end of file
+ f.write("\n")
+ f.write(textwrap.dedent(f"""\
vintf_compatibility_matrix {{
name: "{self.next_module_name}",
}}
"""))
- next_kernel_configs = check_output(
- """grep -rh name: | sed -E 's/^.*"(.*)".*/\\1/g'""",
- cwd=self.top / "kernel/configs" /
- self.next_letter.lower(),
- text=True,
- shell=True,
- ).splitlines()
- print(next_kernel_configs)
+ next_kernel_configs = check_output(
+ """grep -rh name: | sed -E 's/^.*"(.*)".*/\\1/g'""",
+ cwd=self.top / "kernel/configs" / self.next_letter.lower(),
+ text=True,
+ shell=True,
+ ).splitlines()
+ print(next_kernel_configs)
- check_call([
- "bpmodify", "-w", "-m", self.next_module_name, "-property", "stem",
- "-str", self.next_xml.name, android_bp
- ])
+ check_call([
+ "bpmodify",
+ "-w",
+ "-m",
+ self.next_module_name,
+ "-property",
+ "stem",
+ "-str",
+ self.next_xml.name,
+ android_bp,
+ ])
- check_call([
- "bpmodify", "-w", "-m", self.next_module_name, "-property", "srcs",
- "-a",
- self.next_xml.relative_to(android_bp.parent), android_bp
- ])
+ check_call([
+ "bpmodify",
+ "-w",
+ "-m",
+ self.next_module_name,
+ "-property",
+ "srcs",
+ "-a",
+ self.next_xml.relative_to(android_bp.parent),
+ android_bp,
+ ])
- check_call([
- "bpmodify", "-w", "-m", self.next_module_name, "-property",
- "kernel_configs", "-a", " ".join(next_kernel_configs), android_bp
- ])
+ check_call([
+ "bpmodify",
+ "-w",
+ "-m",
+ self.next_module_name,
+ "-property",
+ "kernel_configs",
+ "-a",
+ " ".join(next_kernel_configs),
+ android_bp,
+ ])
- # Replace the phony module's product_variables entry to add the new FCM
- # to the development targets (trunk* configs).
- lines = []
- with open(android_bp) as f:
- for line in f:
- if f" \"{self.current_module_name}\",\n" in line:
- lines.append(f" \"{self.next_module_name}\",\n")
- else:
- lines.append(line)
+ # Replace the phony module's product_variables entry to add the new FCM
+ # to the development targets (trunk* configs).
+ lines = []
+ with open(android_bp) as f:
+ for line in f:
+ if f' "{self.current_module_name}",\n' in line:
+ lines.append(f' "{self.next_module_name}",\n')
+ else:
+ lines.append(line)
- with open(android_bp, "w") as f:
- f.write("".join(lines))
+ with open(android_bp, "w") as f:
+ f.write("".join(lines))
- def bump_libvintf(self):
- if not self.current_version:
- print("Skip libvintf update...")
- return
- try:
- check_call(["grep", "-h",
- f"{self.next_letter.upper()} = {self.next_level}",
- f"{self.top}/system/libvintf/include/vintf/Level.h"])
- except subprocess.CalledProcessError:
- print("Adding new API level to libvintf")
- add_lines_above(f"{self.top}/system/libvintf/analyze_matrix/analyze_matrix.cpp",
- " case Level::UNSPECIFIED:",
- textwrap.indent(textwrap.dedent(f"""\
+ def bump_libvintf(self):
+ if not self.current_version:
+ print("Skip libvintf update...")
+ return
+ try:
+ check_call([
+ "grep",
+ "-h",
+ f"{self.next_letter.upper()} = {self.next_level}",
+ f"{self.top}/system/libvintf/include/vintf/Level.h",
+ ])
+ except subprocess.CalledProcessError:
+ print("Adding new API level to libvintf")
+ add_lines_above(
+ f"{self.top}/system/libvintf/analyze_matrix/analyze_matrix.cpp",
+ " case Level::UNSPECIFIED:",
+ textwrap.indent(
+ textwrap.dedent(
+ f"""\
case Level::{self.next_letter.upper()}:
- return "Android {self.next_version} ({self.next_letter.upper()})";"""),
- " "*2))
- add_lines_above(f"{self.top}/system/libvintf/include/vintf/Level.h",
- " // To add new values:",
- f" {self.next_letter.upper()} = {self.next_level},")
- add_lines_above(f"{self.top}/system/libvintf/include/vintf/Level.h",
- " Level::UNSPECIFIED,",
- f" Level::{self.next_letter.upper()},")
- add_lines_above(f"{self.top}/system/libvintf/RuntimeInfo.cpp",
- " // Add more levels above this line.",
- textwrap.indent(textwrap.dedent(f"""\
+ return "Android {self.next_version} ({self.next_letter.upper()})";"""
+ ),
+ " " * 2,
+ ),
+ )
+ add_lines_above(
+ f"{self.top}/system/libvintf/include/vintf/Level.h",
+ " // To add new values:",
+ f" {self.next_letter.upper()} = {self.next_level},",
+ )
+ add_lines_above(
+ f"{self.top}/system/libvintf/include/vintf/Level.h",
+ " Level::UNSPECIFIED,",
+ f" Level::{self.next_letter.upper()},",
+ )
+ add_lines_above(
+ f"{self.top}/system/libvintf/RuntimeInfo.cpp",
+ " // Add more levels above this line.",
+ textwrap.indent(
+ textwrap.dedent(f"""\
case {self.next_version}: {{
ret = Level::{self.next_letter.upper()};
}} break;"""),
- " "*3))
+ " " * 3,
+ ),
+ )
- def bump_libvts_vintf(self):
- if not self.current_version:
- print("Skip libvts_vintf update...")
- return
- try:
- check_call(["grep", "-h",
- f"{self.next_level}, Level::{self.next_letter.upper()}",
- f"{self.top}/test/vts-testcase/hal/treble/vintf/libvts_vintf_test_common/common.cpp"])
- print("libvts_vintf is already up-to-date")
- except subprocess.CalledProcessError:
- print("Adding new API level to libvts_vintf")
- add_lines_below(f"{self.top}/test/vts-testcase/hal/treble/vintf/libvts_vintf_test_common/common.cpp",
- f" {{{self.current_level}, Level::{self.current_letter.upper()}}},",
- f" {{{self.next_level}, Level::{self.next_letter.upper()}}},\n")
+ def bump_libvts_vintf(self):
+ if not self.current_version:
+ print("Skip libvts_vintf update...")
+ return
+ try:
+ check_call([
+ "grep",
+ "-h",
+ f"{self.next_level}, Level::{self.next_letter.upper()}",
+ f"{self.top}/test/vts-testcase/hal/treble/vintf/libvts_vintf_test_common/common.cpp",
+ ])
+ print("libvts_vintf is already up-to-date")
+ except subprocess.CalledProcessError:
+ print("Adding new API level to libvts_vintf")
+ add_lines_below(
+ f"{self.top}/test/vts-testcase/hal/treble/vintf/libvts_vintf_test_common/common.cpp",
+ f" {{{self.current_level},"
+ f" Level::{self.current_letter.upper()}}},",
+ f" {{{self.next_level},"
+ f" Level::{self.next_letter.upper()}}},\n",
+ )
-def add_lines_above(file, pattern, lines):
- with open(file, 'r+') as f:
- text = f.read()
- split_text = re.split(rf"\n{pattern}\n", text)
- if len(split_text) != 2:
- # Only one pattern must be found, otherwise the source must be
- # changed unexpectedly.
- raise Exception(
- f'Pattern "{pattern}" not found or multiple patterns found in {file}')
- f.seek(0)
- f.write(f"\n{lines}\n{pattern}\n".join(split_text))
- f.truncate()
-
-def add_lines_below(file, pattern, lines):
- final_lines = []
- with open(file, 'r+') as f:
+ def bump_cuttlefish(self):
+ if not self.next_sdk:
+ print("Skip Cuttlefish update...")
+ return
+ cf_mk_file = f"{self.top}/device/google/cuttlefish/shared/device.mk"
+ try:
+ check_call([
+ "grep",
+ "-h",
+ f"PRODUCT_SHIPPING_API_LEVEL := {self.next_sdk}",
+ cf_mk_file,
+ ])
+ print("Cuttlefish is already up-to-date")
+ except subprocess.CalledProcessError:
+ print("Bumping Cuttlefish to the next SHIPPING_API_LEVEL")
+ final_lines = []
+ with open(cf_mk_file, "r+") as f:
for line in f:
- final_lines.append(line)
- if pattern in line:
- final_lines.append(lines)
+ if f"PRODUCT_SHIPPING_API_LEVEL := {self.current_sdk}" in line:
+ final_lines.append(
+ f"PRODUCT_SHIPPING_API_LEVEL := {self.next_sdk}\n"
+ )
+ elif line.startswith("PRODUCT_SHIPPING_API_LEVEL :="):
+ # this is the previous SDK level.
+ final_lines.append(
+ f"PRODUCT_SHIPPING_API_LEVEL := {self.current_sdk}\n"
+ )
+ else:
+ final_lines.append(line)
f.seek(0)
f.write("".join(final_lines))
f.truncate()
+ final_lines = []
+ with open(
+ f"{self.top}/device/google/cuttlefish/shared/config/previous_manifest.xml",
+ "r+",
+ ) as f:
+ for line in f:
+ if "target-level=" in line:
+ final_lines.append(
+ '<manifest version="1.0" type="device"'
+ f' target-level="{self.current_level}">\n'
+ )
+ else:
+ final_lines.append(line)
+ f.seek(0)
+ f.write("".join(final_lines))
+ f.truncate()
+
+ final_lines = []
+ with open(
+ f"{self.top}/device/google/cuttlefish/shared/config/manifest.xml", "r+"
+ ) as f:
+ for line in f:
+ if "target-level=" in line:
+ final_lines.append(
+ '<manifest version="1.0" type="device"'
+ f' target-level="{self.next_level}">\n'
+ )
+ else:
+ final_lines.append(line)
+ f.seek(0)
+ f.write("".join(final_lines))
+ f.truncate()
+
+
+def add_lines_above(file, pattern, lines):
+ with open(file, "r+") as f:
+ text = f.read()
+ split_text = re.split(rf"\n{pattern}\n", text)
+ if len(split_text) != 2:
+ # Only one pattern must be found, otherwise the source must be
+ # changed unexpectedly.
+ raise Exception(
+ f'Pattern "{pattern}" not found or multiple patterns found in {file}'
+ )
+ f.seek(0)
+ f.write(f"\n{lines}\n{pattern}\n".join(split_text))
+ f.truncate()
+
+
+def add_lines_below(file, pattern, lines):
+ final_lines = []
+ with open(file, "r+") as f:
+ for line in f:
+ final_lines.append(line)
+ if pattern in line:
+ final_lines.append(lines)
+ f.seek(0)
+ f.write("".join(final_lines))
+ f.truncate()
+
def main():
- parser = argparse.ArgumentParser(description=__doc__)
- parser.add_argument("current_level",
- type=str,
- help="VINTF level of the current version (e.g. 202404)")
- parser.add_argument("next_level",
- type=str,
- help="VINTF level of the next version (e.g. 202504)")
- parser.add_argument("current_letter",
- type=str,
- help="Letter of the API level of the current version (e.g. b)")
- parser.add_argument("next_letter",
- type=str,
- help="Letter of the API level of the next version (e.g. c)")
- parser.add_argument("platform_version",
- type=str,
- nargs="?",
- help="Current Android release version number (e.g. 16)")
- parser.add_argument("next_platform_version",
- type=str,
- nargs="?",
- help="Next Android release version number number (e.g. 17)")
- cmdline_args = parser.parse_args()
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument(
+ "current_level",
+ type=str,
+ help="VINTF level of the current version (e.g. 202404)",
+ )
+ parser.add_argument(
+ "next_level",
+ type=str,
+ help="VINTF level of the next version (e.g. 202504)",
+ )
+ parser.add_argument(
+ "current_letter",
+ type=str,
+ help="Letter of the API level of the current version (e.g. b)",
+ )
+ parser.add_argument(
+ "next_letter",
+ type=str,
+ help="Letter of the API level of the next version (e.g. c)",
+ )
+ parser.add_argument(
+ "platform_version",
+ type=str,
+ nargs="?",
+ help="Current Android release version number (e.g. 16)",
+ )
+ parser.add_argument(
+ "next_platform_version",
+ type=str,
+ nargs="?",
+ help="Next Android release version number number (e.g. 17)",
+ )
+ parser.add_argument(
+ "current_sdk",
+ type=str,
+ nargs="?",
+ help="Version of the current SDK API level (e.g. 36)",
+ )
+ parser.add_argument(
+ "next_sdk",
+ type=str,
+ nargs="?",
+ help="Version of the next SDK API level(e.g. 37)",
+ )
- Bump(cmdline_args).run()
+ cmdline_args = parser.parse_args()
+
+ Bump(cmdline_args).run()
if __name__ == "__main__":
- main()
+ main()
diff --git a/compatibility_matrices/finalize.py b/compatibility_matrices/finalize.py
index ae048ea..1938278 100755
--- a/compatibility_matrices/finalize.py
+++ b/compatibility_matrices/finalize.py
@@ -14,8 +14,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
-"""
-Finalizes the current compatibility matrix and allows `next` targets to
+"""Finalizes the current compatibility matrix and allows `next` targets to
+
use the new FCM.
"""
@@ -28,52 +28,59 @@
def check_call(*args, **kwargs):
- print(args)
- subprocess.check_call(*args, **kwargs)
+ print(args)
+ subprocess.check_call(*args, **kwargs)
+
def check_output(*args, **kwargs):
- print(args)
- return subprocess.check_output(*args, **kwargs)
+ print(args)
+ return subprocess.check_output(*args, **kwargs)
+
class Bump(object):
- def __init__(self, cmdline_args):
- self.top = pathlib.Path(os.environ["ANDROID_BUILD_TOP"])
- self.interfaces_dir = self.top / "hardware/interfaces"
+ def __init__(self, cmdline_args):
+ self.top = pathlib.Path(os.environ["ANDROID_BUILD_TOP"])
+ self.interfaces_dir = self.top / "hardware/interfaces"
- self.current_level = cmdline_args.current_level
- self.current_module_name = f"framework_compatibility_matrix.{self.current_level}.xml"
- self.device_module_name = "framework_compatibility_matrix.device.xml"
+ self.current_level = cmdline_args.current_level
+ self.current_module_name = (
+ f"framework_compatibility_matrix.{self.current_level}.xml"
+ )
+ self.device_module_name = "framework_compatibility_matrix.device.xml"
- def run(self):
- self.edit_android_bp()
+ def run(self):
+ self.edit_android_bp()
- def edit_android_bp(self):
- android_bp = self.interfaces_dir / "compatibility_matrices/Android.bp"
+ def edit_android_bp(self):
+ android_bp = self.interfaces_dir / "compatibility_matrices/Android.bp"
- # update the SYSTEM_MATRIX_DEPS variable to unconditionally include the
- # latests FCM. This adds the file to `next` configs so releasing devices
- # can use the latest interfaces.
- lines = []
- with open(android_bp) as f:
- for line in f:
- if f" \"{self.device_module_name}\",\n" in line:
- lines.append(f" \"{self.current_module_name}\",\n")
+ # update the SYSTEM_MATRIX_DEPS variable to unconditionally include the
+ # latests FCM. This adds the file to `next` configs so releasing devices
+ # can use the latest interfaces.
+ lines = []
+ with open(android_bp) as f:
+ for line in f:
+ if f' "{self.device_module_name}",\n' in line:
+ lines.append(f' "{self.current_module_name}",\n')
- lines.append(line)
+ lines.append(line)
- with open(android_bp, "w") as f:
- f.write("".join(lines))
+ with open(android_bp, "w") as f:
+ f.write("".join(lines))
+
def main():
- parser = argparse.ArgumentParser(description=__doc__)
- parser.add_argument("current_level",
- type=str,
- help="VINTF level of the current version (e.g. 202404)")
- cmdline_args = parser.parse_args()
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument(
+ "current_level",
+ type=str,
+ help="VINTF level of the current version (e.g. 202404)",
+ )
+ cmdline_args = parser.parse_args()
- Bump(cmdline_args).run()
+ Bump(cmdline_args).run()
if __name__ == "__main__":
- main()
+ main()
diff --git a/contexthub/aidl/vts/VtsAidlHalContextHubTargetTest.cpp b/contexthub/aidl/vts/VtsAidlHalContextHubTargetTest.cpp
index d7859d9..900e6c9 100644
--- a/contexthub/aidl/vts/VtsAidlHalContextHubTargetTest.cpp
+++ b/contexthub/aidl/vts/VtsAidlHalContextHubTargetTest.cpp
@@ -72,17 +72,30 @@
constexpr int64_t kDefaultHubId = 1;
class TestEndpointCallback;
+
class ContextHubAidl : public testing::TestWithParam<std::tuple<std::string, int32_t>> {
public:
void SetUp() override {
mContextHub = android::waitForDeclaredService<IContextHub>(
String16(std::get<0>(GetParam()).c_str()));
ASSERT_NE(mContextHub, nullptr);
- mEndpointCb = sp<TestEndpointCallback>::make();
}
uint32_t getHubId() { return std::get<1>(GetParam()); }
+ void testSettingChanged(Setting setting);
+
+ sp<IContextHub> mContextHub;
+};
+
+class ContextHubEndpointAidl : public testing::TestWithParam<std::string> {
+ public:
+ void SetUp() override {
+ mContextHub = android::waitForDeclaredService<IContextHub>(String16(GetParam().c_str()));
+ ASSERT_NE(mContextHub, nullptr);
+ mEndpointCb = sp<TestEndpointCallback>::make();
+ }
+
Status registerHub(int64_t id, sp<IEndpointCommunication>* hubInterface) {
HubInfo info;
info.hubId = id;
@@ -103,17 +116,15 @@
return true;
}
- void testSettingChanged(Setting setting);
-
sp<IContextHub> mContextHub;
sp<TestEndpointCallback> mEndpointCb;
sp<IEndpointCommunication> mHubInterface;
};
-class ContextHubAidlWithTestMode : public ContextHubAidl {
+class ContextHubEndpointAidlWithTestMode : public ContextHubEndpointAidl {
public:
void SetUp() override {
- ContextHubAidl::SetUp();
+ ContextHubEndpointAidl::SetUp();
// Best effort enable test mode - this may not be supported on older HALS, so we
// ignore the return value.
@@ -122,11 +133,11 @@
void TearDown() override {
mContextHub->setTestMode(/* enable= */ false);
- ContextHubAidl::TearDown();
+ ContextHubEndpointAidl::TearDown();
}
};
-TEST_P(ContextHubAidl, TestGetHubs) {
+TEST_P(ContextHubEndpointAidl, TestGetHubs) {
std::vector<ContextHubInfo> hubs;
ASSERT_TRUE(mContextHub->getContextHubs(&hubs).isOk());
@@ -149,7 +160,7 @@
}
}
-TEST_P(ContextHubAidl, TestEnableTestMode) {
+TEST_P(ContextHubEndpointAidl, TestEnableTestMode) {
Status status = mContextHub->setTestMode(true);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
@@ -159,7 +170,7 @@
}
}
-TEST_P(ContextHubAidl, TestDisableTestMode) {
+TEST_P(ContextHubEndpointAidl, TestDisableTestMode) {
Status status = mContextHub->setTestMode(false);
if (status.exceptionCode() == Status::EX_UNSUPPORTED_OPERATION ||
status.transactionError() == android::UNKNOWN_TRANSACTION) {
@@ -585,7 +596,7 @@
bool mWasOnEndpointSessionOpenCompleteCalled = false;
};
-TEST_P(ContextHubAidlWithTestMode, RegisterHub) {
+TEST_P(ContextHubEndpointAidlWithTestMode, RegisterHub) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -604,7 +615,7 @@
EXPECT_TRUE(status.isOk());
}
-TEST_P(ContextHubAidlWithTestMode, RegisterEndpoint) {
+TEST_P(ContextHubEndpointAidlWithTestMode, RegisterEndpoint) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -625,7 +636,7 @@
}
}
-TEST_P(ContextHubAidlWithTestMode, RegisterEndpointSameNameFailure) {
+TEST_P(ContextHubEndpointAidlWithTestMode, RegisterEndpointSameNameFailure) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -655,7 +666,7 @@
EXPECT_FALSE(mHubInterface->registerEndpoint(endpointInfo2).isOk());
}
-TEST_P(ContextHubAidlWithTestMode, RegisterEndpointSameIdFailure) {
+TEST_P(ContextHubEndpointAidlWithTestMode, RegisterEndpointSameIdFailure) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -685,7 +696,7 @@
EXPECT_FALSE(mHubInterface->registerEndpoint(endpointInfo2).isOk());
}
-TEST_P(ContextHubAidlWithTestMode, UnregisterEndpoint) {
+TEST_P(ContextHubEndpointAidlWithTestMode, UnregisterEndpoint) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -708,7 +719,7 @@
EXPECT_TRUE(mHubInterface->unregisterEndpoint(endpointInfo).isOk());
}
-TEST_P(ContextHubAidlWithTestMode, UnregisterEndpointNonexistent) {
+TEST_P(ContextHubEndpointAidlWithTestMode, UnregisterEndpointNonexistent) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -729,7 +740,7 @@
}
}
-TEST_P(ContextHubAidlWithTestMode, OpenEndpointSessionInvalidRange) {
+TEST_P(ContextHubEndpointAidlWithTestMode, OpenEndpointSessionInvalidRange) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -775,7 +786,7 @@
.isOk());
}
-TEST_P(ContextHubAidlWithTestMode, OpenEndpointSessionAndSendMessageEchoesBack) {
+TEST_P(ContextHubEndpointAidlWithTestMode, OpenEndpointSessionAndSendMessageEchoesBack) {
if (!registerDefaultHub()) {
GTEST_SKIP() << "Not supported -> old API; or not implemented";
}
@@ -845,9 +856,17 @@
INSTANTIATE_TEST_SUITE_P(ContextHub, ContextHubAidl, testing::ValuesIn(generateContextHubMapping()),
PrintGeneratedTest);
-GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubAidlWithTestMode);
-INSTANTIATE_TEST_SUITE_P(ContextHub, ContextHubAidlWithTestMode,
- testing::ValuesIn(generateContextHubMapping()), PrintGeneratedTest);
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubEndpointAidl);
+INSTANTIATE_TEST_SUITE_P(
+ ContextHub, ContextHubEndpointAidl,
+ testing::ValuesIn(android::getAidlHalInstanceNames(IContextHub::descriptor)),
+ android::PrintInstanceNameToString);
+
+GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubEndpointAidlWithTestMode);
+INSTANTIATE_TEST_SUITE_P(
+ ContextHub, ContextHubEndpointAidlWithTestMode,
+ testing::ValuesIn(android::getAidlHalInstanceNames(IContextHub::descriptor)),
+ android::PrintInstanceNameToString);
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(ContextHubTransactionTest);
INSTANTIATE_TEST_SUITE_P(ContextHub, ContextHubTransactionTest,
diff --git a/graphics/allocator/aidl/vts/VtsHalGraphicsAllocatorAidl_TargetTest.cpp b/graphics/allocator/aidl/vts/VtsHalGraphicsAllocatorAidl_TargetTest.cpp
index 0430ea7..22ad5f0 100644
--- a/graphics/allocator/aidl/vts/VtsHalGraphicsAllocatorAidl_TargetTest.cpp
+++ b/graphics/allocator/aidl/vts/VtsHalGraphicsAllocatorAidl_TargetTest.cpp
@@ -162,11 +162,19 @@
}
private:
- BufferDescriptor createDescriptor(const BufferDescriptorInfo& descriptorInfo) {
- BufferDescriptor descriptor;
+ std::optional<BufferDescriptor> createDescriptor(const BufferDescriptorInfo& descriptorInfo,
+ bool raise_failure) {
+ std::optional<BufferDescriptor> descriptor;
mMapper4->createDescriptor(
convert(descriptorInfo), [&](const auto& tmpError, const auto& tmpDescriptor) {
- ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";
+ if (raise_failure) {
+ ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";
+ }
+
+ if (tmpError != Error::NONE) {
+ return;
+ }
+
descriptor = tmpDescriptor;
});
@@ -174,19 +182,24 @@
}
public:
- std::unique_ptr<BufferHandle> allocate(const BufferDescriptorInfo& descriptorInfo) {
+ std::unique_ptr<BufferHandle> allocate(const BufferDescriptorInfo& descriptorInfo,
+ bool raise_failure = true) {
AllocationResult result;
::ndk::ScopedAStatus status;
if (mIAllocatorVersion >= 2) {
status = mAllocator->allocate2(descriptorInfo, 1, &result);
} else {
- auto descriptor = createDescriptor(descriptorInfo);
+ auto descriptor = createDescriptor(descriptorInfo, raise_failure);
+ if (!descriptor.has_value()) {
+ return nullptr;
+ }
+
if (::testing::Test::HasFatalFailure()) {
return nullptr;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- status = mAllocator->allocate(descriptor, 1, &result);
+ status = mAllocator->allocate(descriptor.value(), 1, &result);
#pragma clang diagnostic pop // deprecation
}
if (!status.isOk()) {
@@ -380,7 +393,7 @@
.reservedSize = 0,
};
const bool supported = isSupported(info);
- auto buffer = allocate(info);
+ auto buffer = allocate(info, /*raise_failure=*/supported);
if (!supported) {
ASSERT_EQ(nullptr, buffer.get())
<< "Allocation succeeded, but IMapper::isSupported was false";
@@ -422,7 +435,7 @@
.reservedSize = 0,
};
const bool supported = isSupported(info);
- auto buffer = allocate(info);
+ auto buffer = allocate(info, /*raise_failure=*/supported);
if (!supported) {
ASSERT_EQ(nullptr, buffer.get())
<< "Allocation succeeded, but IMapper::isSupported was false";
@@ -480,4 +493,4 @@
[](auto info) -> std::string {
std::string name = std::to_string(info.index) + "/" + std::get<1>(info.param).name;
return Sanitize(name);
- });
\ No newline at end of file
+ });
diff --git a/graphics/composer/TEST_MAPPING b/graphics/composer/TEST_MAPPING
new file mode 100644
index 0000000..8513c9a
--- /dev/null
+++ b/graphics/composer/TEST_MAPPING
@@ -0,0 +1,12 @@
+{
+ "presubmit": [
+ {
+ "name": "VtsHalGraphicsComposer3_TargetTest"
+ }
+ ],
+ "desktop-presubmit": [
+ {
+ "name": "VtsHalGraphicsComposer3_TargetTest"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
index 2196530..da6001a 100644
--- a/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
+++ b/graphics/composer/aidl/include/android/hardware/graphics/composer3/ComposerClientReader.h
@@ -270,7 +270,7 @@
for (auto& [layerId, luts] : displayLuts.layerLuts) {
if (luts.pfd.get() >= 0) {
data.layerLuts.push_back(
- {layerId, Luts{ndk::ScopedFileDescriptor(luts.pfd.release()), luts.offsets,
+ {layerId, Luts{ndk::ScopedFileDescriptor(dup(luts.pfd.get())), luts.offsets,
luts.lutProperties}});
}
}
diff --git a/graphics/composer/aidl/libhwc_aidl_test/Android.bp b/graphics/composer/aidl/libhwc_aidl_test/Android.bp
new file mode 100644
index 0000000..1955fcf
--- /dev/null
+++ b/graphics/composer/aidl/libhwc_aidl_test/Android.bp
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2025, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package {
+ default_team: "trendy_team_android_core_graphics_stack",
+ // See: http://go/android-license-faq
+ // A large-scale-change added 'default_applicable_licenses' to import
+ // all of the 'license_kinds' from "hardware_interfaces_license"
+ // to get the below license kinds:
+ // SPDX-license-identifier-Apache-2.0
+}
+
+cc_library_static {
+ name: "libhwc_aidl_test",
+ export_include_dirs: ["include"],
+ defaults: [
+ "use_libaidlvintf_gtest_helper_static",
+ "librenderengine_deps",
+ "android.hardware.graphics.common-ndk_static",
+ "android.hardware.graphics.composer3-ndk_static",
+ ],
+ srcs: [
+ "ComposerClientWrapper.cpp",
+ "GraphicsComposerCallback.cpp",
+ "Readback.cpp",
+ "RenderEngine.cpp",
+ ],
+ shared_libs: [
+ "libEGL",
+ "libGLESv2",
+ "libbinder_ndk",
+ "libbinder",
+ "libfmq",
+ "libbase",
+ "libsync",
+ "libui",
+ "libgui",
+ ],
+ header_libs: [
+ "android.hardware.graphics.composer3-command-buffer",
+ ],
+ static_libs: [
+ "android.hardware.graphics.common@1.2",
+ "android.hardware.common-V2-ndk",
+ "android.hardware.common.fmq-V1-ndk",
+ "libaidlcommonsupport",
+ "libarect",
+ "libbase",
+ "libfmq",
+ "libgtest",
+ "librenderengine",
+ "libsync",
+ "libsurfaceflinger_common",
+ ],
+ cflags: [
+ "-Wconversion",
+ ],
+}
diff --git a/graphics/composer/aidl/vts/VtsComposerClient.cpp b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
similarity index 65%
rename from graphics/composer/aidl/vts/VtsComposerClient.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
index f09482c..8af1fc3 100644
--- a/graphics/composer/aidl/vts/VtsComposerClient.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/ComposerClientWrapper.cpp
@@ -14,19 +14,19 @@
* limitations under the License.
*/
-#include "VtsComposerClient.h"
+#include "ComposerClientWrapper.h"
#include <aidlcommonsupport/NativeHandle.h>
#include <android-base/logging.h>
#include <log/log_main.h>
#undef LOG_TAG
-#define LOG_TAG "VtsComposerClient"
+#define LOG_TAG "ComposerClientWrapper"
using namespace std::chrono_literals;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
-VtsComposerClient::VtsComposerClient(const std::string& name) {
+ComposerClientWrapper::ComposerClientWrapper(const std::string& name) {
SpAIBinder binder(AServiceManager_waitForService(name.c_str()));
ALOGE_IF(binder == nullptr, "Could not initialize the service binder");
if (binder != nullptr) {
@@ -43,7 +43,7 @@
}
}
-ScopedAStatus VtsComposerClient::createClient() {
+ScopedAStatus ComposerClientWrapper::createClient() {
if (mComposer == nullptr) {
ALOGE("IComposer not initialized");
return ScopedAStatus::fromServiceSpecificError(IComposerClient::INVALID_CONFIGURATION);
@@ -62,11 +62,11 @@
return mComposerClient->registerCallback(mComposerCallback);
}
-bool VtsComposerClient::tearDown(ComposerClientWriter* writer) {
+bool ComposerClientWrapper::tearDown(ComposerClientWriter* writer) {
return verifyComposerCallbackParams() && destroyAllLayers(writer);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getInterfaceVersion() const {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getInterfaceVersion() const {
int32_t version = 1;
if (!mComposerClient) {
return {ScopedAStatus{nullptr}, version};
@@ -75,7 +75,7 @@
return {std::move(status), version};
}
-std::pair<ScopedAStatus, VirtualDisplay> VtsComposerClient::createVirtualDisplay(
+std::pair<ScopedAStatus, VirtualDisplay> ComposerClientWrapper::createVirtualDisplay(
int32_t width, int32_t height, PixelFormat pixelFormat, int32_t bufferSlotCount) {
VirtualDisplay outVirtualDisplay;
auto status = mComposerClient->createVirtualDisplay(width, height, pixelFormat, bufferSlotCount,
@@ -87,7 +87,7 @@
outVirtualDisplay};
}
-ScopedAStatus VtsComposerClient::destroyVirtualDisplay(int64_t display) {
+ScopedAStatus ComposerClientWrapper::destroyVirtualDisplay(int64_t display) {
auto status = mComposerClient->destroyVirtualDisplay(display);
if (!status.isOk()) {
return status;
@@ -96,9 +96,9 @@
return status;
}
-std::pair<ScopedAStatus, int64_t> VtsComposerClient::createLayer(int64_t display,
- int32_t bufferSlotCount,
- ComposerClientWriter* writer) {
+std::pair<ScopedAStatus, int64_t> ComposerClientWrapper::createLayer(int64_t display,
+ int32_t bufferSlotCount,
+ ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
int64_t layer = mNextLayerHandle++;
writer->setLayerLifecycleBatchCommandType(display, layer,
@@ -116,8 +116,8 @@
return {addLayerToDisplayResources(display, outLayer), outLayer};
}
-ScopedAStatus VtsComposerClient::destroyLayer(int64_t display, int64_t layer,
- ComposerClientWriter* writer) {
+ScopedAStatus ComposerClientWrapper::destroyLayer(int64_t display, int64_t layer,
+ ComposerClientWriter* writer) {
if (mSupportsBatchedCreateLayer) {
writer->setLayerLifecycleBatchCommandType(display, layer,
LayerLifecycleBatchCommandType::DESTROY);
@@ -132,27 +132,27 @@
return ScopedAStatus::ok();
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getActiveConfig(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getActiveConfig(int64_t display) {
int32_t outConfig;
return {mComposerClient->getActiveConfig(display, &outConfig), outConfig};
}
-ScopedAStatus VtsComposerClient::setActiveConfig(VtsDisplay* vtsDisplay, int32_t config) {
- auto status = mComposerClient->setActiveConfig(vtsDisplay->getDisplayId(), config);
+ScopedAStatus ComposerClientWrapper::setActiveConfig(DisplayWrapper* display, int32_t config) {
+ auto status = mComposerClient->setActiveConfig(display->getDisplayId(), config);
if (!status.isOk()) {
return status;
}
- return updateDisplayProperties(vtsDisplay, config);
+ return updateDisplayProperties(display, config);
}
-ScopedAStatus VtsComposerClient::setPeakRefreshRateConfig(VtsDisplay* vtsDisplay) {
- const auto displayId = vtsDisplay->getDisplayId();
+ScopedAStatus ComposerClientWrapper::setPeakRefreshRateConfig(DisplayWrapper* display) {
+ const auto displayId = display->getDisplayId();
auto [activeStatus, activeConfig] = getActiveConfig(displayId);
EXPECT_TRUE(activeStatus.isOk());
- auto peakDisplayConfig = vtsDisplay->getDisplayConfig(activeConfig);
+ auto peakDisplayConfig = display->getDisplayConfig(activeConfig);
auto peakConfig = activeConfig;
- const auto displayConfigs = vtsDisplay->getDisplayConfigs();
+ const auto displayConfigs = display->getDisplayConfigs();
for (const auto [config, displayConfig] : displayConfigs) {
if (displayConfig.configGroup == peakDisplayConfig.configGroup &&
displayConfig.vsyncPeriod < peakDisplayConfig.vsyncPeriod) {
@@ -160,10 +160,10 @@
peakConfig = config;
}
}
- return setActiveConfig(vtsDisplay, peakConfig);
+ return setActiveConfig(display, peakConfig);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayAttribute(
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getDisplayAttribute(
int64_t display, int32_t config, DisplayAttribute displayAttribute) {
int32_t outDisplayAttribute;
return {mComposerClient->getDisplayAttribute(display, config, displayAttribute,
@@ -171,58 +171,59 @@
outDisplayAttribute};
}
-ScopedAStatus VtsComposerClient::setPowerMode(int64_t display, PowerMode powerMode) {
+ScopedAStatus ComposerClientWrapper::setPowerMode(int64_t display, PowerMode powerMode) {
return mComposerClient->setPowerMode(display, powerMode);
}
-ScopedAStatus VtsComposerClient::setVsync(int64_t display, bool enable) {
+ScopedAStatus ComposerClientWrapper::setVsync(int64_t display, bool enable) {
return mComposerClient->setVsyncEnabled(display, enable);
}
-void VtsComposerClient::setVsyncAllowed(bool isAllowed) {
+void ComposerClientWrapper::setVsyncAllowed(bool isAllowed) {
mComposerCallback->setVsyncAllowed(isAllowed);
}
-std::pair<ScopedAStatus, std::vector<float>> VtsComposerClient::getDataspaceSaturationMatrix(
+std::pair<ScopedAStatus, std::vector<float>> ComposerClientWrapper::getDataspaceSaturationMatrix(
Dataspace dataspace) {
std::vector<float> outMatrix;
return {mComposerClient->getDataspaceSaturationMatrix(dataspace, &outMatrix), outMatrix};
}
-std::pair<ScopedAStatus, std::vector<CommandResultPayload>> VtsComposerClient::executeCommands(
+std::pair<ScopedAStatus, std::vector<CommandResultPayload>> ComposerClientWrapper::executeCommands(
const std::vector<DisplayCommand>& commands) {
std::vector<CommandResultPayload> outResultPayload;
return {mComposerClient->executeCommands(commands, &outResultPayload),
std::move(outResultPayload)};
}
-std::optional<VsyncPeriodChangeTimeline> VtsComposerClient::takeLastVsyncPeriodChangeTimeline() {
+std::optional<VsyncPeriodChangeTimeline>
+ComposerClientWrapper::takeLastVsyncPeriodChangeTimeline() {
return mComposerCallback->takeLastVsyncPeriodChangeTimeline();
}
-ScopedAStatus VtsComposerClient::setContentType(int64_t display, ContentType contentType) {
+ScopedAStatus ComposerClientWrapper::setContentType(int64_t display, ContentType contentType) {
return mComposerClient->setContentType(display, contentType);
}
std::pair<ScopedAStatus, VsyncPeriodChangeTimeline>
-VtsComposerClient::setActiveConfigWithConstraints(VtsDisplay* vtsDisplay, int32_t config,
- const VsyncPeriodChangeConstraints& constraints) {
+ComposerClientWrapper::setActiveConfigWithConstraints(
+ DisplayWrapper* display, int32_t config, const VsyncPeriodChangeConstraints& constraints) {
VsyncPeriodChangeTimeline outTimeline;
- auto status = mComposerClient->setActiveConfigWithConstraints(
- vtsDisplay->getDisplayId(), config, constraints, &outTimeline);
+ auto status = mComposerClient->setActiveConfigWithConstraints(display->getDisplayId(), config,
+ constraints, &outTimeline);
if (!status.isOk()) {
return {std::move(status), outTimeline};
}
- return {updateDisplayProperties(vtsDisplay, config), outTimeline};
+ return {updateDisplayProperties(display, config), outTimeline};
}
-std::pair<ScopedAStatus, std::vector<DisplayCapability>> VtsComposerClient::getDisplayCapabilities(
- int64_t display) {
+std::pair<ScopedAStatus, std::vector<DisplayCapability>>
+ComposerClientWrapper::getDisplayCapabilities(int64_t display) {
std::vector<DisplayCapability> outCapabilities;
return {mComposerClient->getDisplayCapabilities(display, &outCapabilities), outCapabilities};
}
-ScopedAStatus VtsComposerClient::dumpDebugInfo() {
+ScopedAStatus ComposerClientWrapper::dumpDebugInfo() {
int pipefds[2];
if (pipe(pipefds) < 0) {
return ScopedAStatus::fromServiceSpecificError(IComposer::EX_NO_RESOURCES);
@@ -234,76 +235,79 @@
return ScopedAStatus::fromStatus(status);
}
-std::pair<ScopedAStatus, DisplayIdentification> VtsComposerClient::getDisplayIdentificationData(
+std::pair<ScopedAStatus, DisplayIdentification> ComposerClientWrapper::getDisplayIdentificationData(
int64_t display) {
DisplayIdentification outDisplayIdentification;
return {mComposerClient->getDisplayIdentificationData(display, &outDisplayIdentification),
outDisplayIdentification};
}
-std::pair<ScopedAStatus, HdrCapabilities> VtsComposerClient::getHdrCapabilities(int64_t display) {
+std::pair<ScopedAStatus, HdrCapabilities> ComposerClientWrapper::getHdrCapabilities(
+ int64_t display) {
HdrCapabilities outHdrCapabilities;
return {mComposerClient->getHdrCapabilities(display, &outHdrCapabilities), outHdrCapabilities};
}
std::pair<ScopedAStatus, std::vector<PerFrameMetadataKey>>
-VtsComposerClient::getPerFrameMetadataKeys(int64_t display) {
+ComposerClientWrapper::getPerFrameMetadataKeys(int64_t display) {
std::vector<PerFrameMetadataKey> outPerFrameMetadataKeys;
return {mComposerClient->getPerFrameMetadataKeys(display, &outPerFrameMetadataKeys),
outPerFrameMetadataKeys};
}
-std::pair<ScopedAStatus, ReadbackBufferAttributes> VtsComposerClient::getReadbackBufferAttributes(
- int64_t display) {
+std::pair<ScopedAStatus, ReadbackBufferAttributes>
+ComposerClientWrapper::getReadbackBufferAttributes(int64_t display) {
ReadbackBufferAttributes outReadbackBufferAttributes;
return {mComposerClient->getReadbackBufferAttributes(display, &outReadbackBufferAttributes),
outReadbackBufferAttributes};
}
-ScopedAStatus VtsComposerClient::setReadbackBuffer(int64_t display, const native_handle_t* buffer,
- const ScopedFileDescriptor& releaseFence) {
+ScopedAStatus ComposerClientWrapper::setReadbackBuffer(int64_t display,
+ const native_handle_t* buffer,
+ const ScopedFileDescriptor& releaseFence) {
return mComposerClient->setReadbackBuffer(display, ::android::dupToAidl(buffer), releaseFence);
}
-std::pair<ScopedAStatus, ScopedFileDescriptor> VtsComposerClient::getReadbackBufferFence(
+std::pair<ScopedAStatus, ScopedFileDescriptor> ComposerClientWrapper::getReadbackBufferFence(
int64_t display) {
ScopedFileDescriptor outReleaseFence;
return {mComposerClient->getReadbackBufferFence(display, &outReleaseFence),
std::move(outReleaseFence)};
}
-std::pair<ScopedAStatus, std::vector<ColorMode>> VtsComposerClient::getColorModes(int64_t display) {
+std::pair<ScopedAStatus, std::vector<ColorMode>> ComposerClientWrapper::getColorModes(
+ int64_t display) {
std::vector<ColorMode> outColorModes;
return {mComposerClient->getColorModes(display, &outColorModes), outColorModes};
}
-std::pair<ScopedAStatus, std::vector<RenderIntent>> VtsComposerClient::getRenderIntents(
+std::pair<ScopedAStatus, std::vector<RenderIntent>> ComposerClientWrapper::getRenderIntents(
int64_t display, ColorMode colorMode) {
std::vector<RenderIntent> outRenderIntents;
return {mComposerClient->getRenderIntents(display, colorMode, &outRenderIntents),
outRenderIntents};
}
-ScopedAStatus VtsComposerClient::setColorMode(int64_t display, ColorMode colorMode,
- RenderIntent renderIntent) {
+ScopedAStatus ComposerClientWrapper::setColorMode(int64_t display, ColorMode colorMode,
+ RenderIntent renderIntent) {
return mComposerClient->setColorMode(display, colorMode, renderIntent);
}
std::pair<ScopedAStatus, DisplayContentSamplingAttributes>
-VtsComposerClient::getDisplayedContentSamplingAttributes(int64_t display) {
+ComposerClientWrapper::getDisplayedContentSamplingAttributes(int64_t display) {
DisplayContentSamplingAttributes outAttributes;
return {mComposerClient->getDisplayedContentSamplingAttributes(display, &outAttributes),
outAttributes};
}
-ScopedAStatus VtsComposerClient::setDisplayedContentSamplingEnabled(
+ScopedAStatus ComposerClientWrapper::setDisplayedContentSamplingEnabled(
int64_t display, bool isEnabled, FormatColorComponent formatColorComponent,
int64_t maxFrames) {
return mComposerClient->setDisplayedContentSamplingEnabled(display, isEnabled,
formatColorComponent, maxFrames);
}
-std::pair<ScopedAStatus, DisplayContentSample> VtsComposerClient::getDisplayedContentSample(
+std::pair<ScopedAStatus, DisplayContentSample> ComposerClientWrapper::getDisplayedContentSample(
int64_t display, int64_t maxFrames, int64_t timestamp) {
DisplayContentSample outDisplayContentSample;
return {mComposerClient->getDisplayedContentSample(display, maxFrames, timestamp,
@@ -311,14 +315,14 @@
outDisplayContentSample};
}
-std::pair<ScopedAStatus, DisplayConnectionType> VtsComposerClient::getDisplayConnectionType(
+std::pair<ScopedAStatus, DisplayConnectionType> ComposerClientWrapper::getDisplayConnectionType(
int64_t display) {
DisplayConnectionType outDisplayConnectionType;
return {mComposerClient->getDisplayConnectionType(display, &outDisplayConnectionType),
outDisplayConnectionType};
}
-std::pair<ScopedAStatus, std::vector<int32_t>> VtsComposerClient::getDisplayConfigs(
+std::pair<ScopedAStatus, std::vector<int32_t>> ComposerClientWrapper::getDisplayConfigs(
int64_t display) {
std::vector<int32_t> outConfigs;
if (!getDisplayConfigurationSupported()) {
@@ -336,132 +340,131 @@
}
std::pair<ScopedAStatus, std::vector<DisplayConfiguration>>
-VtsComposerClient::getDisplayConfigurations(int64_t display) {
+ComposerClientWrapper::getDisplayConfigurations(int64_t display) {
std::vector<DisplayConfiguration> outConfigs;
return {mComposerClient->getDisplayConfigurations(display, kMaxFrameIntervalNs, &outConfigs),
outConfigs};
}
-ScopedAStatus VtsComposerClient::notifyExpectedPresent(int64_t display,
- ClockMonotonicTimestamp expectedPresentTime,
- int frameIntervalNs) {
+ScopedAStatus ComposerClientWrapper::notifyExpectedPresent(
+ int64_t display, ClockMonotonicTimestamp expectedPresentTime, int frameIntervalNs) {
return mComposerClient->notifyExpectedPresent(display, expectedPresentTime, frameIntervalNs);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getDisplayVsyncPeriod(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getDisplayVsyncPeriod(int64_t display) {
int32_t outVsyncPeriodNanos;
return {mComposerClient->getDisplayVsyncPeriod(display, &outVsyncPeriodNanos),
outVsyncPeriodNanos};
}
-ScopedAStatus VtsComposerClient::setAutoLowLatencyMode(int64_t display, bool isEnabled) {
+ScopedAStatus ComposerClientWrapper::setAutoLowLatencyMode(int64_t display, bool isEnabled) {
return mComposerClient->setAutoLowLatencyMode(display, isEnabled);
}
-std::pair<ScopedAStatus, std::vector<ContentType>> VtsComposerClient::getSupportedContentTypes(
+std::pair<ScopedAStatus, std::vector<ContentType>> ComposerClientWrapper::getSupportedContentTypes(
int64_t display) {
std::vector<ContentType> outContentTypes;
return {mComposerClient->getSupportedContentTypes(display, &outContentTypes), outContentTypes};
}
std::pair<ScopedAStatus, std::optional<DisplayDecorationSupport>>
-VtsComposerClient::getDisplayDecorationSupport(int64_t display) {
+ComposerClientWrapper::getDisplayDecorationSupport(int64_t display) {
std::optional<DisplayDecorationSupport> outSupport;
return {mComposerClient->getDisplayDecorationSupport(display, &outSupport), outSupport};
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getMaxVirtualDisplayCount() {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getMaxVirtualDisplayCount() {
int32_t outMaxVirtualDisplayCount;
return {mComposerClient->getMaxVirtualDisplayCount(&outMaxVirtualDisplayCount),
outMaxVirtualDisplayCount};
}
-std::pair<ScopedAStatus, std::string> VtsComposerClient::getDisplayName(int64_t display) {
+std::pair<ScopedAStatus, std::string> ComposerClientWrapper::getDisplayName(int64_t display) {
std::string outDisplayName;
return {mComposerClient->getDisplayName(display, &outDisplayName), outDisplayName};
}
-ScopedAStatus VtsComposerClient::setClientTargetSlotCount(int64_t display,
- int32_t bufferSlotCount) {
+ScopedAStatus ComposerClientWrapper::setClientTargetSlotCount(int64_t display,
+ int32_t bufferSlotCount) {
return mComposerClient->setClientTargetSlotCount(display, bufferSlotCount);
}
-std::pair<ScopedAStatus, std::vector<Capability>> VtsComposerClient::getCapabilities() {
+std::pair<ScopedAStatus, std::vector<Capability>> ComposerClientWrapper::getCapabilities() {
std::vector<Capability> outCapabilities;
return {mComposer->getCapabilities(&outCapabilities), outCapabilities};
}
-ScopedAStatus VtsComposerClient::setBootDisplayConfig(int64_t display, int32_t config) {
+ScopedAStatus ComposerClientWrapper::setBootDisplayConfig(int64_t display, int32_t config) {
return mComposerClient->setBootDisplayConfig(display, config);
}
-ScopedAStatus VtsComposerClient::clearBootDisplayConfig(int64_t display) {
+ScopedAStatus ComposerClientWrapper::clearBootDisplayConfig(int64_t display) {
return mComposerClient->clearBootDisplayConfig(display);
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getPreferredBootDisplayConfig(
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getPreferredBootDisplayConfig(
int64_t display) {
int32_t outConfig;
return {mComposerClient->getPreferredBootDisplayConfig(display, &outConfig), outConfig};
}
std::pair<ScopedAStatus, std::vector<common::HdrConversionCapability>>
-VtsComposerClient::getHdrConversionCapabilities() {
+ComposerClientWrapper::getHdrConversionCapabilities() {
std::vector<common::HdrConversionCapability> hdrConversionCapability;
return {mComposerClient->getHdrConversionCapabilities(&hdrConversionCapability),
hdrConversionCapability};
}
-std::pair<ScopedAStatus, common::Hdr> VtsComposerClient::setHdrConversionStrategy(
+std::pair<ScopedAStatus, common::Hdr> ComposerClientWrapper::setHdrConversionStrategy(
const common::HdrConversionStrategy& conversionStrategy) {
common::Hdr preferredHdrOutputType;
return {mComposerClient->setHdrConversionStrategy(conversionStrategy, &preferredHdrOutputType),
preferredHdrOutputType};
}
-std::pair<ScopedAStatus, common::Transform> VtsComposerClient::getDisplayPhysicalOrientation(
+std::pair<ScopedAStatus, common::Transform> ComposerClientWrapper::getDisplayPhysicalOrientation(
int64_t display) {
common::Transform outDisplayOrientation;
return {mComposerClient->getDisplayPhysicalOrientation(display, &outDisplayOrientation),
outDisplayOrientation};
}
-std::pair<ScopedAStatus, composer3::OverlayProperties> VtsComposerClient::getOverlaySupport() {
+std::pair<ScopedAStatus, composer3::OverlayProperties> ComposerClientWrapper::getOverlaySupport() {
OverlayProperties properties;
return {mComposerClient->getOverlaySupport(&properties), properties};
}
-ScopedAStatus VtsComposerClient::setIdleTimerEnabled(int64_t display, int32_t timeoutMs) {
+ScopedAStatus ComposerClientWrapper::setIdleTimerEnabled(int64_t display, int32_t timeoutMs) {
return mComposerClient->setIdleTimerEnabled(display, timeoutMs);
}
-int32_t VtsComposerClient::getVsyncIdleCount() {
+int32_t ComposerClientWrapper::getVsyncIdleCount() {
return mComposerCallback->getVsyncIdleCount();
}
-int64_t VtsComposerClient::getVsyncIdleTime() {
+int64_t ComposerClientWrapper::getVsyncIdleTime() {
return mComposerCallback->getVsyncIdleTime();
}
-ndk::ScopedAStatus VtsComposerClient::setRefreshRateChangedCallbackDebugEnabled(int64_t display,
- bool enabled) {
+ndk::ScopedAStatus ComposerClientWrapper::setRefreshRateChangedCallbackDebugEnabled(int64_t display,
+ bool enabled) {
mComposerCallback->setRefreshRateChangedDebugDataEnabledCallbackAllowed(enabled);
return mComposerClient->setRefreshRateChangedCallbackDebugEnabled(display, enabled);
}
std::vector<RefreshRateChangedDebugData>
-VtsComposerClient::takeListOfRefreshRateChangedDebugData() {
+ComposerClientWrapper::takeListOfRefreshRateChangedDebugData() {
return mComposerCallback->takeListOfRefreshRateChangedDebugData();
}
-int64_t VtsComposerClient::getInvalidDisplayId() {
+int64_t ComposerClientWrapper::getInvalidDisplayId() {
// returns an invalid display id (one that has not been registered to a
// display. Currently assuming that a device will never have close to
// std::numeric_limit<uint64_t>::max() displays registered while running tests
int64_t id = std::numeric_limits<int64_t>::max();
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
+ std::vector<int64_t> displayIds = mComposerCallback->getDisplays();
while (id > 0) {
- if (std::none_of(displays.begin(), displays.end(),
+ if (std::none_of(displayIds.begin(), displayIds.end(),
[id](const auto& display) { return id == display; })) {
return id;
}
@@ -475,86 +478,87 @@
return id;
}
-std::pair<ScopedAStatus, std::vector<VtsDisplay>> VtsComposerClient::getDisplays() {
+std::pair<ScopedAStatus, std::vector<DisplayWrapper>> ComposerClientWrapper::getDisplays() {
while (true) {
// Sleep for a small period of time to allow all built-in displays
// to post hotplug events
std::this_thread::sleep_for(5ms);
- std::vector<int64_t> displays = mComposerCallback->getDisplays();
- if (displays.empty()) {
+ std::vector<int64_t> displayIds = mComposerCallback->getDisplays();
+ if (displayIds.empty()) {
continue;
}
- std::vector<VtsDisplay> vtsDisplays;
- vtsDisplays.reserve(displays.size());
- for (int64_t display : displays) {
- auto vtsDisplay = VtsDisplay{display};
+ std::vector<DisplayWrapper> displays;
+ displays.reserve(displayIds.size());
+ for (int64_t displayId : displayIds) {
+ auto display = DisplayWrapper{displayId};
if (getDisplayConfigurationSupported()) {
- auto [status, configs] = getDisplayConfigurations(display);
+ auto [status, configs] = getDisplayConfigurations(displayId);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to get the DisplayConfigs "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
- addDisplayConfigs(&vtsDisplay, configs);
+ addDisplayConfigs(&display, configs);
} else {
- auto [status, configs] = getDisplayConfigs(display);
+ auto [status, configs] = getDisplayConfigs(displayId);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to get the configs "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
for (int config : configs) {
- status = addDisplayConfigLegacy(&vtsDisplay, config);
+ status = addDisplayConfigLegacy(&display, config);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, failed to add config "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
}
}
- auto activeConfig = getActiveConfig(display);
+ auto activeConfig = getActiveConfig(displayId);
if (!activeConfig.first.isOk()) {
ALOGE("Unable to get the displays for test, failed to get active config "
- "for display %" PRId64,
- display);
- return {std::move(activeConfig.first), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(activeConfig.first), displays};
}
- auto status = updateDisplayProperties(&vtsDisplay, activeConfig.second);
+ auto status = updateDisplayProperties(&display, activeConfig.second);
if (!status.isOk()) {
ALOGE("Unable to get the displays for test, "
"failed to update the properties "
- "for display %" PRId64,
- display);
- return {std::move(status), vtsDisplays};
+ "for displayId %" PRId64,
+ displayId);
+ return {std::move(status), displays};
}
- vtsDisplays.emplace_back(vtsDisplay);
- addDisplayToDisplayResources(display, /*isVirtual*/ false);
+ displays.emplace_back(display);
+ addDisplayToDisplayResources(displayId, /*isVirtual*/ false);
}
- return {ScopedAStatus::ok(), vtsDisplays};
+ return {ScopedAStatus::ok(), displays};
}
}
-void VtsComposerClient::addDisplayConfigs(VtsDisplay* vtsDisplay,
- const std::vector<DisplayConfiguration>& configs) {
+void ComposerClientWrapper::addDisplayConfigs(DisplayWrapper* display,
+ const std::vector<DisplayConfiguration>& configs) {
for (const auto& config : configs) {
- vtsDisplay->addDisplayConfig(config.configId,
- {config.vsyncPeriod, config.configGroup, config.vrrConfig});
+ display->addDisplayConfig(config.configId,
+ {config.vsyncPeriod, config.configGroup, config.vrrConfig});
}
}
-ScopedAStatus VtsComposerClient::addDisplayConfigLegacy(VtsDisplay* vtsDisplay, int32_t config) {
+ScopedAStatus ComposerClientWrapper::addDisplayConfigLegacy(DisplayWrapper* display,
+ int32_t config) {
const auto vsyncPeriod =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::VSYNC_PERIOD);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::VSYNC_PERIOD);
const auto configGroup =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::CONFIG_GROUP);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::CONFIG_GROUP);
if (vsyncPeriod.first.isOk() && configGroup.first.isOk()) {
- vtsDisplay->addDisplayConfig(config, {vsyncPeriod.second, configGroup.second});
+ display->addDisplayConfig(config, {vsyncPeriod.second, configGroup.second});
return ScopedAStatus::ok();
}
@@ -563,13 +567,14 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_CONFIG);
}
-ScopedAStatus VtsComposerClient::updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config) {
+ScopedAStatus ComposerClientWrapper::updateDisplayProperties(DisplayWrapper* display,
+ int32_t config) {
if (getDisplayConfigurationSupported()) {
- auto [status, configs] = getDisplayConfigurations(vtsDisplay->getDisplayId());
+ auto [status, configs] = getDisplayConfigurations(display->getDisplayId());
if (status.isOk()) {
for (const auto& displayConfig : configs) {
if (displayConfig.configId == config) {
- vtsDisplay->setDimensions(displayConfig.width, displayConfig.height);
+ display->setDimensions(displayConfig.width, displayConfig.height);
return ScopedAStatus::ok();
}
}
@@ -577,11 +582,11 @@
LOG(ERROR) << "Failed to update display property with DisplayConfig";
} else {
const auto width =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::WIDTH);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::WIDTH);
const auto height =
- getDisplayAttribute(vtsDisplay->getDisplayId(), config, DisplayAttribute::HEIGHT);
+ getDisplayAttribute(display->getDisplayId(), config, DisplayAttribute::HEIGHT);
if (width.first.isOk() && height.first.isOk()) {
- vtsDisplay->setDimensions(width.second, height.second);
+ display->setDimensions(width.second, height.second);
return ScopedAStatus::ok();
}
@@ -591,7 +596,7 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_CONFIG);
}
-ScopedAStatus VtsComposerClient::addDisplayToDisplayResources(int64_t display, bool isVirtual) {
+ScopedAStatus ComposerClientWrapper::addDisplayToDisplayResources(int64_t display, bool isVirtual) {
if (mDisplayResources.insert({display, DisplayResource(isVirtual)}).second) {
return ScopedAStatus::ok();
}
@@ -600,7 +605,7 @@
return ScopedAStatus::fromServiceSpecificError(IComposerClient::EX_BAD_DISPLAY);
}
-ScopedAStatus VtsComposerClient::addLayerToDisplayResources(int64_t display, int64_t layer) {
+ScopedAStatus ComposerClientWrapper::addLayerToDisplayResources(int64_t display, int64_t layer) {
auto resource = mDisplayResources.find(display);
if (resource == mDisplayResources.end()) {
resource = mDisplayResources.insert({display, DisplayResource(false)}).first;
@@ -613,14 +618,14 @@
return ScopedAStatus::ok();
}
-void VtsComposerClient::removeLayerFromDisplayResources(int64_t display, int64_t layer) {
+void ComposerClientWrapper::removeLayerFromDisplayResources(int64_t display, int64_t layer) {
auto resource = mDisplayResources.find(display);
if (resource != mDisplayResources.end()) {
resource->second.layers.erase(layer);
}
}
-bool VtsComposerClient::verifyComposerCallbackParams() {
+bool ComposerClientWrapper::verifyComposerCallbackParams() {
bool isValid = true;
if (mComposerCallback != nullptr) {
if (mComposerCallback->getInvalidHotplugCount() != 0) {
@@ -651,14 +656,14 @@
return isValid;
}
-bool VtsComposerClient::getDisplayConfigurationSupported() const {
+bool ComposerClientWrapper::getDisplayConfigurationSupported() const {
auto [status, interfaceVersion] = getInterfaceVersion();
EXPECT_TRUE(status.isOk());
// getDisplayConfigurations api is supported starting interface version 3
return interfaceVersion >= 3;
}
-bool VtsComposerClient::destroyAllLayers(ComposerClientWriter* writer) {
+bool ComposerClientWrapper::destroyAllLayers(ComposerClientWriter* writer) {
std::unordered_map<int64_t, DisplayResource> physicalDisplays;
while (!mDisplayResources.empty()) {
const auto& it = mDisplayResources.begin();
@@ -691,15 +696,16 @@
return true;
}
-std::pair<ScopedAStatus, int32_t> VtsComposerClient::getMaxLayerPictureProfiles(int64_t display) {
+std::pair<ScopedAStatus, int32_t> ComposerClientWrapper::getMaxLayerPictureProfiles(
+ int64_t display) {
int32_t outMaxProfiles = 0;
return {mComposerClient->getMaxLayerPictureProfiles(display, &outMaxProfiles), outMaxProfiles};
}
-std::pair<ScopedAStatus, std::vector<Luts>> VtsComposerClient::getLuts(
+std::pair<ScopedAStatus, std::vector<Luts>> ComposerClientWrapper::getLuts(
int64_t display, const std::vector<Buffer>& buffers) {
std::vector<Luts> outLuts;
return {mComposerClient->getLuts(display, buffers, &outLuts), std::move(outLuts)};
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/GraphicsComposerCallback.cpp b/graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
similarity index 97%
rename from graphics/composer/aidl/vts/GraphicsComposerCallback.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
index 1f7972c..ba16348 100644
--- a/graphics/composer/aidl/vts/GraphicsComposerCallback.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/GraphicsComposerCallback.cpp
@@ -23,7 +23,7 @@
#undef LOG_TAG
#define LOG_TAG "GraphicsComposerCallback"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
void GraphicsComposerCallback::setVsyncAllowed(bool allowed) {
std::scoped_lock lock(mMutex);
@@ -219,4 +219,4 @@
return ::ndk::ScopedAStatus::ok();
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/ReadbackVts.cpp b/graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
similarity index 97%
rename from graphics/composer/aidl/vts/ReadbackVts.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
index b45c8c0..2aded73 100644
--- a/graphics/composer/aidl/vts/ReadbackVts.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/Readback.cpp
@@ -14,14 +14,12 @@
* limitations under the License.
*/
-#include "ReadbackVts.h"
+#include "Readback.h"
#include <aidl/android/hardware/graphics/common/BufferUsage.h>
-#include <cmath>
-#include "RenderEngineVts.h"
-#include "renderengine/ExternalTexture.h"
+#include "RenderEngine.h"
#include "renderengine/impl/ExternalTexture.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
const std::vector<ColorMode> ReadbackHelper::colorModes = {ColorMode::SRGB, ColorMode::DISPLAY_P3};
const std::vector<Dataspace> ReadbackHelper::dataspaces = {common::Dataspace::SRGB,
@@ -344,8 +342,9 @@
}
}
-ReadbackBuffer::ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client,
- int32_t width, int32_t height, common::PixelFormat pixelFormat,
+ReadbackBuffer::ReadbackBuffer(int64_t display,
+ const std::shared_ptr<ComposerClientWrapper>& client, int32_t width,
+ int32_t height, common::PixelFormat pixelFormat,
common::Dataspace dataspace)
: mComposerClient(client) {
mDisplay = display;
@@ -427,7 +426,7 @@
return layerSettings;
}
-TestBufferLayer::TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
+TestBufferLayer::TestBufferLayer(const std::shared_ptr<ComposerClientWrapper>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format,
ComposerClientWriter& writer, Composition composition)
@@ -513,4 +512,4 @@
writer.setLayerCompositionType(mDisplay, mLayer, Composition::CLIENT);
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/RenderEngineVts.cpp b/graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
similarity index 96%
rename from graphics/composer/aidl/vts/RenderEngineVts.cpp
rename to graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
index 8f8b5fd..6715ea4 100644
--- a/graphics/composer/aidl/vts/RenderEngineVts.cpp
+++ b/graphics/composer/aidl/libhwc_aidl_test/RenderEngine.cpp
@@ -14,10 +14,10 @@
* limitations under the License.
*/
-#include "RenderEngineVts.h"
+#include "RenderEngine.h"
#include "renderengine/impl/ExternalTexture.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::DisplaySettings;
using ::android::renderengine::LayerSettings;
@@ -115,4 +115,4 @@
ASSERT_EQ(::android::OK, mGraphicBuffer->unlock());
}
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/VtsComposerClient.h b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
similarity index 90%
rename from graphics/composer/aidl/vts/VtsComposerClient.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
index f0dbe57..22dd888 100644
--- a/graphics/composer/aidl/vts/VtsComposerClient.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/ComposerClientWrapper.h
@@ -46,17 +46,17 @@
using aidl::android::hardware::graphics::common::Rect;
using namespace ::ndk;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
-class VtsDisplay;
+class DisplayWrapper;
/**
* A wrapper to IComposerClient.
* This wrapper manages the IComposerClient instance and manages the resources for
* the tests with respect to the IComposerClient calls.
*/
-class VtsComposerClient {
+class ComposerClientWrapper {
public:
- VtsComposerClient(const std::string& name);
+ ComposerClientWrapper(const std::string& name);
ScopedAStatus createClient();
@@ -77,9 +77,9 @@
std::pair<ScopedAStatus, int32_t> getActiveConfig(int64_t display);
- ScopedAStatus setActiveConfig(VtsDisplay* vtsDisplay, int32_t config);
+ ScopedAStatus setActiveConfig(DisplayWrapper* display, int32_t config);
- ScopedAStatus setPeakRefreshRateConfig(VtsDisplay* vtsDisplay);
+ ScopedAStatus setPeakRefreshRateConfig(DisplayWrapper* display);
std::pair<ScopedAStatus, int32_t> getDisplayAttribute(int64_t display, int32_t config,
DisplayAttribute displayAttribute);
@@ -100,7 +100,7 @@
ScopedAStatus setContentType(int64_t display, ContentType contentType);
std::pair<ScopedAStatus, VsyncPeriodChangeTimeline> setActiveConfigWithConstraints(
- VtsDisplay* vtsDisplay, int32_t config,
+ DisplayWrapper* display, int32_t config,
const VsyncPeriodChangeConstraints& constraints);
std::pair<ScopedAStatus, std::vector<DisplayCapability>> getDisplayCapabilities(
@@ -190,7 +190,7 @@
int64_t getInvalidDisplayId();
- std::pair<ScopedAStatus, std::vector<VtsDisplay>> getDisplays();
+ std::pair<ScopedAStatus, std::vector<DisplayWrapper>> getDisplays();
std::pair<ScopedAStatus, OverlayProperties> getOverlaySupport();
@@ -207,10 +207,10 @@
static constexpr int32_t kNoFrameIntervalNs = 0;
private:
- void addDisplayConfigs(VtsDisplay*, const std::vector<DisplayConfiguration>&);
- ScopedAStatus addDisplayConfigLegacy(VtsDisplay*, int32_t config);
+ void addDisplayConfigs(DisplayWrapper*, const std::vector<DisplayConfiguration>&);
+ ScopedAStatus addDisplayConfigLegacy(DisplayWrapper*, int32_t config);
bool getDisplayConfigurationSupported() const;
- ScopedAStatus updateDisplayProperties(VtsDisplay* vtsDisplay, int32_t config);
+ ScopedAStatus updateDisplayProperties(DisplayWrapper* display, int32_t config);
ScopedAStatus addDisplayToDisplayResources(int64_t display, bool isVirtual);
@@ -223,7 +223,7 @@
bool verifyComposerCallbackParams();
// Keep track of displays and layers. When a test fails/ends,
- // the VtsComposerClient::tearDown should be called from the
+ // the ComposerClientWrapper::tearDown should be called from the
// test tearDown to clean up the resources for the test.
struct DisplayResource {
DisplayResource(bool isVirtual_) : isVirtual(isVirtual_) {}
@@ -240,9 +240,10 @@
std::atomic<int64_t> mNextLayerHandle = 1;
};
-class VtsDisplay {
+class DisplayWrapper {
public:
- VtsDisplay(int64_t displayId) : mDisplayId(displayId), mDisplayWidth(0), mDisplayHeight(0) {}
+ DisplayWrapper(int64_t displayId)
+ : mDisplayId(displayId), mDisplayWidth(0), mDisplayHeight(0) {}
int64_t getDisplayId() const { return mDisplayId; }
@@ -299,9 +300,8 @@
std::stringstream ss;
if (displayConfig.vrrConfigOpt) {
ss << "{Config " << config << ": vsyncPeriod " << displayConfig.vsyncPeriod
- << ", minFrameIntervalNs " << vrrConfigOpt->minFrameIntervalNs << "}";
- }
- else {
+ << ", minFrameIntervalNs " << vrrConfigOpt->minFrameIntervalNs << "}";
+ } else {
ss << "{Config " << config << ": vsyncPeriod " << displayConfig.vsyncPeriod << "}";
}
return ss.str();
@@ -315,4 +315,4 @@
int32_t mDisplayHeight;
std::unordered_map<int32_t, DisplayConfig> mDisplayConfigs;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/GraphicsComposerCallback.h b/graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
similarity index 95%
rename from graphics/composer/aidl/vts/GraphicsComposerCallback.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
index 97f8e2b..ff379b7 100644
--- a/graphics/composer/aidl/vts/GraphicsComposerCallback.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/GraphicsComposerCallback.h
@@ -20,7 +20,7 @@
#include <mutex>
#include <vector>
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
class GraphicsComposerCallback : public BnComposerCallback {
public:
@@ -93,4 +93,4 @@
int32_t mHdcpLevelChangedCount GUARDED_BY(mMutex) = 0;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/ReadbackVts.h b/graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
similarity index 90%
rename from graphics/composer/aidl/vts/ReadbackVts.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
index c04e37a..9fdb4d3 100644
--- a/graphics/composer/aidl/vts/ReadbackVts.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/Readback.h
@@ -24,12 +24,11 @@
#include <renderengine/RenderEngine.h>
#include <ui/GraphicBuffer.h>
#include <memory>
-#include "GraphicsComposerCallback.h"
-#include "VtsComposerClient.h"
+#include "ComposerClientWrapper.h"
using aidl::android::hardware::graphics::composer3::Luts;
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::LayerSettings;
using common::Dataspace;
@@ -53,7 +52,7 @@
class TestLayer {
public:
- TestLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
+ TestLayer(const std::shared_ptr<ComposerClientWrapper>& client, int64_t display,
ComposerClientWriter& writer)
: mDisplay(display) {
const auto& [status, layer] = client->createLayer(display, kBufferSlotCount, &writer);
@@ -63,7 +62,7 @@
// ComposerClient will take care of destroying layers, no need to explicitly
// call destroyLayers here
- virtual ~TestLayer(){};
+ virtual ~TestLayer() {};
virtual void write(ComposerClientWriter& writer);
virtual LayerSettings toRenderEngineLayerSettings();
@@ -114,7 +113,7 @@
class TestColorLayer : public TestLayer {
public:
- TestColorLayer(const std::shared_ptr<VtsComposerClient>& client, int64_t display,
+ TestColorLayer(const std::shared_ptr<ComposerClientWrapper>& client, int64_t display,
ComposerClientWriter& writer)
: TestLayer{client, display, writer} {}
@@ -130,7 +129,7 @@
class TestBufferLayer : public TestLayer {
public:
- TestBufferLayer(const std::shared_ptr<VtsComposerClient>& client,
+ TestBufferLayer(const std::shared_ptr<ComposerClientWrapper>& client,
TestRenderEngine& renderEngine, int64_t display, uint32_t width,
uint32_t height, common::PixelFormat format, ComposerClientWriter& writer,
Composition composition = Composition::DEVICE);
@@ -206,8 +205,9 @@
class ReadbackBuffer {
public:
- ReadbackBuffer(int64_t display, const std::shared_ptr<VtsComposerClient>& client, int32_t width,
- int32_t height, common::PixelFormat pixelFormat, common::Dataspace dataspace);
+ ReadbackBuffer(int64_t display, const std::shared_ptr<ComposerClientWrapper>& client,
+ int32_t width, int32_t height, common::PixelFormat pixelFormat,
+ common::Dataspace dataspace);
void setReadbackBuffer();
@@ -224,7 +224,7 @@
Dataspace mDataspace;
int64_t mDisplay;
::android::sp<::android::GraphicBuffer> mGraphicBuffer;
- std::shared_ptr<VtsComposerClient> mComposerClient;
+ std::shared_ptr<ComposerClientWrapper> mComposerClient;
::android::Rect mAccessRegion;
native_handle_t mBufferHandle;
@@ -232,4 +232,4 @@
::android::sp<::android::GraphicBuffer> allocateBuffer();
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/RenderEngineVts.h b/graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
similarity index 91%
rename from graphics/composer/aidl/vts/RenderEngineVts.h
rename to graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
index 6553720..6b8b82f 100644
--- a/graphics/composer/aidl/vts/RenderEngineVts.h
+++ b/graphics/composer/aidl/libhwc_aidl_test/include/RenderEngine.h
@@ -23,9 +23,9 @@
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
#include <ui/Region.h>
-#include "ReadbackVts.h"
+#include "Readback.h"
-namespace aidl::android::hardware::graphics::composer3::vts {
+namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test {
using ::android::renderengine::DisplaySettings;
using ::android::renderengine::ExternalTexture;
@@ -60,4 +60,4 @@
DisplaySettings mDisplaySettings;
};
-} // namespace aidl::android::hardware::graphics::composer3::vts
+} // namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test
diff --git a/graphics/composer/aidl/vts/Android.bp b/graphics/composer/aidl/vts/Android.bp
index 61c2593..cf9c6d7 100644
--- a/graphics/composer/aidl/vts/Android.bp
+++ b/graphics/composer/aidl/vts/Android.bp
@@ -36,28 +36,19 @@
srcs: [
"VtsHalGraphicsComposer3_TargetTest.cpp",
"VtsHalGraphicsComposer3_ReadbackTest.cpp",
- "GraphicsComposerCallback.cpp",
- "ReadbackVts.cpp",
- "RenderEngineVts.cpp",
- "VtsComposerClient.cpp",
],
-
shared_libs: [
"libEGL",
- "libGLESv1_CM",
"libGLESv2",
"libbinder_ndk",
"libbinder",
- "libfmq",
"libbase",
"libsync",
"libui",
"libgui",
- "libhidlbase",
"libprocessgroup",
- "libvndksupport",
- "server_configurable_flags",
"libtracing_perfetto",
+ "server_configurable_flags",
],
header_libs: [
"android.hardware.graphics.composer3-command-buffer",
@@ -66,19 +57,17 @@
"android.hardware.graphics.common@1.2",
"android.hardware.common-V2-ndk",
"android.hardware.common.fmq-V1-ndk",
- "android.hardware.drm.common-V1-ndk",
"libaidlcommonsupport",
"libarect",
"libbase",
- "libfmq",
"libgmock",
"libgtest",
- "libmath",
+ "libhwc_aidl_test",
"librenderengine",
- "libshaders",
"libsync",
- "libtonemap",
"libsurfaceflinger_common",
+ "libshaders",
+ "libtonemap",
],
cflags: [
"-Wconversion",
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
index 6883cdb..dff044d 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_ReadbackTest.cpp
@@ -27,14 +27,16 @@
#include <ui/GraphicBuffer.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
+#include "ComposerClientWrapper.h"
#include "GraphicsComposerCallback.h"
-#include "ReadbackVts.h"
-#include "RenderEngineVts.h"
-#include "VtsComposerClient.h"
+#include "Readback.h"
+#include "RenderEngine.h"
namespace aidl::android::hardware::graphics::composer3::vts {
namespace {
+using namespace ::aidl::android::hardware::graphics::composer3::libhwc_aidl_test;
+
using ::android::Rect;
using common::Dataspace;
using common::PixelFormat;
@@ -42,7 +44,7 @@
class GraphicsCompositionTestBase : public ::testing::Test {
protected:
void SetUpBase(const std::string& name) {
- mComposerClient = std::make_shared<VtsComposerClient>(name);
+ mComposerClient = std::make_shared<ComposerClientWrapper>(name);
ASSERT_TRUE(mComposerClient->createClient().isOk());
const auto& [status, displays] = mComposerClient->getDisplays();
@@ -97,7 +99,7 @@
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
- const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
+ const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
@@ -158,8 +160,8 @@
return false;
}
- std::shared_ptr<VtsComposerClient> mComposerClient;
- std::vector<VtsDisplay> mDisplays;
+ std::shared_ptr<ComposerClientWrapper> mComposerClient;
+ std::vector<DisplayWrapper> mDisplays;
// use the slot count usually set by SF
std::vector<ColorMode> mTestColorModes;
std::unique_ptr<ComposerClientWriter> mWriter;
@@ -226,7 +228,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
// if hwc cannot handle and asks for composition change,
// just succeed the test
@@ -286,7 +288,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
@@ -347,7 +349,7 @@
ASSERT_NO_FATAL_FAILURE(readbackBuffer.setReadbackBuffer());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
@@ -462,7 +464,7 @@
auto layer = std::make_shared<TestBufferLayer>(
mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
- getDisplayHeight(), PixelFormat::RGBA_FP16, *mWriter);
+ getDisplayHeight(), PixelFormat::RGBA_8888, *mWriter);
layer->setDisplayFrame({0, 0, getDisplayWidth(), getDisplayHeight()});
layer->setZOrder(10);
layer->setDataspace(ReadbackHelper::getDataspaceForColorMode(mode));
@@ -475,7 +477,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -512,7 +514,7 @@
clientDataspace, std::vector<common::Rect>(1, damage), 1.f);
layer->setToClientComposition(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
@@ -612,7 +614,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
// if hwc cannot handle and asks for composition change,
// just succeed the test
@@ -703,7 +705,7 @@
writeLayers({srgbLayer, displayP3Layer});
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -780,7 +782,7 @@
clientLayer->setZOrder(0);
clientLayer->write(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
@@ -813,7 +815,7 @@
clientDataspace, std::vector<common::Rect>(1, clientFrame), 1.f);
clientLayer->setToClientComposition(*mWriter);
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
ASSERT_TRUE(changedCompositionTypes.empty());
@@ -862,7 +864,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -891,7 +893,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
@@ -934,7 +936,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -999,7 +1001,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1060,7 +1062,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1083,7 +1085,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1149,7 +1151,7 @@
writeLayers(layers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED()
@@ -1285,7 +1287,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1331,7 +1333,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1372,7 +1374,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1457,7 +1459,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1504,7 +1506,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1551,7 +1553,7 @@
writeLayers(mLayers);
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED();
@@ -1646,7 +1648,7 @@
ASSERT_TRUE(mReader.takeErrors().empty());
mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
continue;
diff --git a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
index 6b43cc8..88e5cb5 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -22,7 +22,6 @@
#include <aidl/android/hardware/graphics/common/PixelFormat.h>
#include <aidl/android/hardware/graphics/common/Rect.h>
#include <aidl/android/hardware/graphics/composer3/Composition.h>
-#include <aidl/android/hardware/graphics/composer3/OutputType.h>
#include <aidl/android/hardware/graphics/composer3/IComposer.h>
#include <android-base/properties.h>
#include <android/binder_process.h>
@@ -34,7 +33,6 @@
#include <gtest/gtest.h>
#include <ui/Fence.h>
#include <ui/GraphicBuffer.h>
-#include <ui/PictureProfileHandle.h>
#include <ui/PixelFormat.h>
#include <algorithm>
#include <iterator>
@@ -43,8 +41,8 @@
#include <string>
#include <thread>
#include <unordered_map>
+#include "ComposerClientWrapper.h"
#include "GraphicsComposerCallback.h"
-#include "VtsComposerClient.h"
#undef LOG_TAG
#define LOG_TAG "VtsHalGraphicsComposer3_TargetTest"
@@ -54,6 +52,7 @@
namespace aidl::android::hardware::graphics::composer3::vts {
using namespace std::chrono_literals;
+using namespace aidl::android::hardware::graphics::composer3::libhwc_aidl_test;
using ::android::GraphicBuffer;
using ::android::sp;
@@ -61,7 +60,7 @@
class GraphicsComposerAidlTest : public ::testing::TestWithParam<std::string> {
protected:
void SetUp() override {
- mComposerClient = std::make_unique<VtsComposerClient>(GetParam());
+ mComposerClient = std::make_unique<ComposerClientWrapper>(GetParam());
ASSERT_TRUE(mComposerClient->createClient().isOk());
const auto& [status, displays] = mComposerClient->getDisplays();
@@ -124,36 +123,21 @@
[&](const Capability& activeCapability) { return activeCapability == capability; });
}
- bool hasDisplayCapability(int64_t displayId, DisplayCapability capability) {
- const auto& [status, capabilities] = mComposerClient->getDisplayCapabilities(displayId);
- EXPECT_TRUE(status.isOk());
- return std::any_of(capabilities.begin(), capabilities.end(),
- [&](const DisplayCapability& activeCapability) {
- return activeCapability == capability;
- });
- }
-
int getInterfaceVersion() {
const auto& [versionStatus, version] = mComposerClient->getInterfaceVersion();
EXPECT_TRUE(versionStatus.isOk());
return version;
}
- const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
-
- int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
-
int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
-
struct TestParameters {
nsecs_t delayForChange;
bool refreshMiss;
};
- std::unique_ptr<VtsComposerClient> mComposerClient;
- std::vector<VtsDisplay> mDisplays;
+ std::unique_ptr<ComposerClientWrapper> mComposerClient;
+ std::vector<DisplayWrapper> mDisplays;
// use the slot count usually set by SF
static constexpr uint32_t kBufferSlotCount = 64;
};
@@ -187,125 +171,145 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayIdentificationData) {
- const auto& [status0, displayIdentification0] =
- mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
- if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "Display identification data not supported, skipping test";
- return;
+ for (const auto& display : mDisplays) {
+ const auto& [status0, displayIdentification0] =
+ mComposerClient->getDisplayIdentificationData(display.getDisplayId());
+ if (!status0.isOk() && status0.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status0.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "Display identification data not supported, skipping test";
+ return;
+ }
+ ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
+ ASSERT_FALSE(displayIdentification0.data.empty());
+
+ constexpr size_t kEdidBlockSize = 128;
+ ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
+ << "EDID blob length is not a multiple of " << kEdidBlockSize;
+
+ const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
+ ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
+ displayIdentification0.data.begin()))
+ << "EDID blob doesn't start with the fixed EDID header";
+ ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
+ displayIdentification0.data.begin() + kEdidBlockSize,
+ static_cast<uint8_t>(0)))
+ << "EDID base block doesn't checksum";
+
+ const auto& [status1, displayIdentification1] =
+ mComposerClient->getDisplayIdentificationData(display.getDisplayId());
+ ASSERT_TRUE(status1.isOk());
+
+ ASSERT_EQ(displayIdentification0.port, displayIdentification1.port)
+ << "ports are not stable";
+ ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
+ std::equal(displayIdentification0.data.begin(),
+ displayIdentification0.data.end(),
+ displayIdentification1.data.begin()))
+ << "data is not stable";
}
- ASSERT_TRUE(status0.isOk()) << "failed to get display identification data";
- ASSERT_FALSE(displayIdentification0.data.empty());
-
- constexpr size_t kEdidBlockSize = 128;
- ASSERT_TRUE(displayIdentification0.data.size() % kEdidBlockSize == 0)
- << "EDID blob length is not a multiple of " << kEdidBlockSize;
-
- const uint8_t kEdidHeader[] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00};
- ASSERT_TRUE(std::equal(std::begin(kEdidHeader), std::end(kEdidHeader),
- displayIdentification0.data.begin()))
- << "EDID blob doesn't start with the fixed EDID header";
- ASSERT_EQ(0, std::accumulate(displayIdentification0.data.begin(),
- displayIdentification0.data.begin() + kEdidBlockSize,
- static_cast<uint8_t>(0)))
- << "EDID base block doesn't checksum";
-
- const auto& [status1, displayIdentification1] =
- mComposerClient->getDisplayIdentificationData(getPrimaryDisplayId());
- ASSERT_TRUE(status1.isOk());
-
- ASSERT_EQ(displayIdentification0.port, displayIdentification1.port) << "ports are not stable";
- ASSERT_TRUE(displayIdentification0.data.size() == displayIdentification1.data.size() &&
- std::equal(displayIdentification0.data.begin(), displayIdentification0.data.end(),
- displayIdentification1.data.begin()))
- << "data is not stable";
}
TEST_P(GraphicsComposerAidlTest, GetHdrCapabilities) {
- const auto& [status, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
- ASSERT_TRUE(status.isOk());
- EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(hdrCapabilities.maxLuminance >= hdrCapabilities.minLuminance);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetPerFrameMetadataKeys) {
- const auto& [status, keys] = mComposerClient->getPerFrameMetadataKeys(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
- return;
- }
+ for (const auto& display : mDisplays) {
+ const auto& [status, keys] =
+ mComposerClient->getPerFrameMetadataKeys(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "getPerFrameMetadataKeys is not supported";
+ return;
+ }
- ASSERT_TRUE(status.isOk());
- EXPECT_TRUE(keys.size() >= 0);
+ ASSERT_TRUE(status.isOk());
+ EXPECT_TRUE(keys.size() >= 0);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetReadbackBufferAttributes) {
- const auto& [status, _] = mComposerClient->getReadbackBufferAttributes(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
- return;
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] =
+ mComposerClient->getReadbackBufferAttributes(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
+ return;
+ }
+ ASSERT_TRUE(status.isOk());
}
-
- ASSERT_TRUE(status.isOk());
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents) {
- const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, modes] = mComposerClient->getColorModes(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (auto mode : modes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- EXPECT_TRUE(intentStatus.isOk());
- bool isHdr;
- switch (mode) {
- case ColorMode::BT2100_PQ:
- case ColorMode::BT2100_HLG:
- isHdr = true;
- break;
- default:
- isHdr = false;
- break;
+ for (auto mode : modes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk());
+ bool isHdr;
+ switch (mode) {
+ case ColorMode::BT2100_PQ:
+ case ColorMode::BT2100_HLG:
+ isHdr = true;
+ break;
+ default:
+ isHdr = false;
+ break;
+ }
+ RenderIntent requiredIntent =
+ isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
+
+ const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
+ EXPECT_NE(intents.cend(), iter);
}
- RenderIntent requiredIntent =
- isHdr ? RenderIntent::TONE_MAP_COLORIMETRIC : RenderIntent::COLORIMETRIC;
-
- const auto iter = std::find(intents.cbegin(), intents.cend(), requiredIntent);
- EXPECT_NE(intents.cend(), iter);
}
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadDisplay) {
- const auto& [status, modes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, modes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- for (auto mode : modes) {
- const auto& [intentStatus, _] =
- mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
+ for (auto mode : modes) {
+ const auto& [intentStatus, _] =
+ mComposerClient->getRenderIntents(getInvalidDisplayId(), mode);
- EXPECT_FALSE(intentStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
+ EXPECT_FALSE(intentStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(intentStatus, IComposerClient::EX_BAD_DISPLAY));
+ }
}
}
TEST_P(GraphicsComposerAidlTest, GetRenderIntents_BadParameter) {
- const auto& [status, _] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), static_cast<ColorMode>(-1));
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getRenderIntents(display.getDisplayId(),
+ static_cast<ColorMode>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetColorModes) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
- EXPECT_NE(colorModes.cend(), native);
+ const auto native = std::find(colorModes.cbegin(), colorModes.cend(), ColorMode::NATIVE);
+ EXPECT_NE(colorModes.cend(), native);
+ }
}
TEST_P(GraphicsComposerAidlTest, GetColorMode_BadDisplay) {
@@ -316,128 +320,145 @@
}
TEST_P(GraphicsComposerAidlTest, SetColorMode) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (auto mode : colorModes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+ for (auto mode : colorModes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ EXPECT_TRUE(intentStatus.isOk()) << "failed to get render intents";
- for (auto intent : intents) {
- const auto modeStatus =
- mComposerClient->setColorMode(getPrimaryDisplayId(), mode, intent);
- EXPECT_TRUE(modeStatus.isOk() ||
+ for (auto intent : intents) {
+ const auto modeStatus =
+ mComposerClient->setColorMode(display.getDisplayId(), mode, intent);
+ EXPECT_TRUE(
+ modeStatus.isOk() ||
(modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
- << "failed to set color mode";
+ << "failed to set color mode";
+ }
}
- }
- const auto modeStatus = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
- RenderIntent::COLORIMETRIC);
- EXPECT_TRUE(modeStatus.isOk() ||
- (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
- << "failed to set color mode";
+ const auto modeStatus = mComposerClient->setColorMode(
+ display.getDisplayId(), ColorMode::NATIVE, RenderIntent::COLORIMETRIC);
+ EXPECT_TRUE(modeStatus.isOk() ||
+ (modeStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ IComposerClient::EX_UNSUPPORTED == modeStatus.getServiceSpecificError()))
+ << "failed to set color mode";
+ }
}
TEST_P(GraphicsComposerAidlTest, SetColorMode_BadDisplay) {
- const auto& [status, colorModes] = mComposerClient->getColorModes(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, colorModes] = mComposerClient->getColorModes(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- for (auto mode : colorModes) {
- const auto& [intentStatus, intents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), mode);
- ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
+ for (auto mode : colorModes) {
+ const auto& [intentStatus, intents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), mode);
+ ASSERT_TRUE(intentStatus.isOk()) << "failed to get render intents";
- for (auto intent : intents) {
- auto const modeStatus =
- mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
+ for (auto intent : intents) {
+ auto const modeStatus =
+ mComposerClient->setColorMode(getInvalidDisplayId(), mode, intent);
- EXPECT_FALSE(modeStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
+ EXPECT_FALSE(modeStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(modeStatus, IComposerClient::EX_BAD_DISPLAY));
+ }
}
}
}
TEST_P(GraphicsComposerAidlTest, SetColorMode_BadParameter) {
- auto status = mComposerClient->setColorMode(getPrimaryDisplayId(), static_cast<ColorMode>(-1),
- RenderIntent::COLORIMETRIC);
+ for (const auto& display : mDisplays) {
+ auto status = mComposerClient->setColorMode(
+ display.getDisplayId(), static_cast<ColorMode>(-1), RenderIntent::COLORIMETRIC);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
- status = mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE,
- static_cast<RenderIntent>(-1));
+ status = mComposerClient->setColorMode(display.getDisplayId(), ColorMode::NATIVE,
+ static_cast<RenderIntent>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSamplingAttributes) {
int constexpr kInvalid = -1;
- const auto& [status, format] =
- mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, format] =
+ mComposerClient->getDisplayedContentSamplingAttributes(display.getDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
+
+ ASSERT_TRUE(status.isOk());
+ EXPECT_NE(kInvalid, static_cast<int>(format.format));
+ EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
+ EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
}
-
- ASSERT_TRUE(status.isOk());
- EXPECT_NE(kInvalid, static_cast<int>(format.format));
- EXPECT_NE(kInvalid, static_cast<int>(format.dataspace));
- EXPECT_NE(kInvalid, static_cast<int>(format.componentMask));
-};
+}
TEST_P(GraphicsComposerAidlTest, SetDisplayedContentSamplingEnabled) {
int constexpr kMaxFrames = 10;
FormatColorComponent enableAllComponents = FormatColorComponent::FORMAT_COMPONENT_0;
- auto status = mComposerClient->setDisplayedContentSamplingEnabled(
- getPrimaryDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
- }
- EXPECT_TRUE(status.isOk());
- status = mComposerClient->setDisplayedContentSamplingEnabled(
- getPrimaryDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ auto status = mComposerClient->setDisplayedContentSamplingEnabled(
+ display.getDisplayId(), /*isEnabled*/ true, enableAllComponents, kMaxFrames);
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
+ EXPECT_TRUE(status.isOk());
+
+ status = mComposerClient->setDisplayedContentSamplingEnabled(
+ display.getDisplayId(), /*isEnabled*/ false, enableAllComponents, kMaxFrames);
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayedContentSample) {
- const auto& [status, displayContentSamplingAttributes] =
- mComposerClient->getDisplayedContentSamplingAttributes(getPrimaryDisplayId());
- if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
- return;
- }
+ for (const auto& display : mDisplays) {
+ const auto& [status, displayContentSamplingAttributes] =
+ mComposerClient->getDisplayedContentSamplingAttributes(display.getDisplayId());
+ if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Sampling attributes aren't supported on this device, test skipped";
+ return;
+ }
- int64_t constexpr kMaxFrames = 10;
- int64_t constexpr kTimestamp = 0;
- const auto& [sampleStatus, displayContentSample] = mComposerClient->getDisplayedContentSample(
- getPrimaryDisplayId(), kMaxFrames, kTimestamp);
- if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
- SUCCEED() << "Device does not support optional extension. Test skipped";
- return;
- }
+ int64_t constexpr kMaxFrames = 10;
+ int64_t constexpr kTimestamp = 0;
+ const auto& [sampleStatus, displayContentSample] =
+ mComposerClient->getDisplayedContentSample(display.getDisplayId(), kMaxFrames,
+ kTimestamp);
+ if (!sampleStatus.isOk() && sampleStatus.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ sampleStatus.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
+ SUCCEED() << "Device does not support optional extension. Test skipped";
+ return;
+ }
- EXPECT_TRUE(sampleStatus.isOk());
- const std::vector<std::vector<int64_t>> histogram = {
- displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
- displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
+ EXPECT_TRUE(sampleStatus.isOk());
+ const std::vector<std::vector<int64_t>> histogram = {
+ displayContentSample.sampleComponent0, displayContentSample.sampleComponent1,
+ displayContentSample.sampleComponent2, displayContentSample.sampleComponent3};
- for (size_t i = 0; i < histogram.size(); i++) {
- const bool shouldHaveHistogram =
- static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
- EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
+ for (size_t i = 0; i < histogram.size(); i++) {
+ const bool shouldHaveHistogram =
+ static_cast<int>(displayContentSamplingAttributes.componentMask) & (1 << i);
+ EXPECT_EQ(shouldHaveHistogram, !histogram[i].empty());
+ }
}
}
@@ -512,7 +533,7 @@
VsyncPeriodChangeConstraints constraints;
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- auto invalidDisplay = VtsDisplay(getInvalidDisplayId());
+ auto invalidDisplay = DisplayWrapper(getInvalidDisplayId());
const auto& [status, timeline] = mComposerClient->setActiveConfigWithConstraints(
&invalidDisplay, /*config*/ 0, constraints);
@@ -526,7 +547,7 @@
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
const auto& [status, _] = mComposerClient->setActiveConfigWithConstraints(
&display, kInvalidConfigId, constraints);
@@ -552,7 +573,7 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
int32_t constexpr kInvalidConfigId = IComposerClient::INVALID_CONFIGURATION;
const auto& status =
mComposerClient->setBootDisplayConfig(display.getDisplayId(), kInvalidConfigId);
@@ -567,10 +588,14 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- EXPECT_TRUE(mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config).isOk());
+
+ for (const auto& display : mDisplays) {
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ for (const auto& config : configs) {
+ EXPECT_TRUE(
+ mComposerClient->setBootDisplayConfig(display.getDisplayId(), config).isOk());
+ }
}
}
@@ -590,7 +615,10 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId()).isOk());
+
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->clearBootDisplayConfig(display.getDisplayId()).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetPreferredBootDisplayConfig_BadDisplay) {
@@ -609,36 +637,42 @@
GTEST_SUCCEED() << "Boot Display Config not supported";
return;
}
- const auto& [status, preferredDisplayConfig] =
- mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
- const auto& [configStatus, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, preferredDisplayConfig] =
+ mComposerClient->getPreferredBootDisplayConfig(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- EXPECT_TRUE(configStatus.isOk());
- EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
+ const auto& [configStatus, configs] =
+ mComposerClient->getDisplayConfigs(display.getDisplayId());
+
+ EXPECT_TRUE(configStatus.isOk());
+ EXPECT_NE(configs.end(), std::find(configs.begin(), configs.end(), preferredDisplayConfig));
+ }
}
TEST_P(GraphicsComposerAidlTest, BootDisplayConfig_Unsupported) {
if (!hasCapability(Capability::BOOT_DISPLAY_CONFIG)) {
- const auto& [configStatus, config] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(configStatus.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [configStatus, config] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(configStatus.isOk());
- auto status = mComposerClient->setBootDisplayConfig(getPrimaryDisplayId(), config);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ auto status = mComposerClient->setBootDisplayConfig(display.getDisplayId(), config);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->getPreferredBootDisplayConfig(getPrimaryDisplayId()).first;
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->getPreferredBootDisplayConfig(display.getDisplayId()).first;
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->clearBootDisplayConfig(getPrimaryDisplayId());
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->clearBootDisplayConfig(display.getDisplayId());
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
@@ -670,22 +704,25 @@
return;
}
const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
- const auto& [status2, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
- const auto& hdrTypes = hdrCapabilities.types;
- for (auto conversionCapability : conversionCapabilities) {
- if (conversionCapability.outputType != common::Hdr::INVALID) {
- if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
- hdrTypes.end()) {
- continue;
+
+ for (const auto& display : mDisplays) {
+ const auto& [status2, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
+ const auto& hdrTypes = hdrCapabilities.types;
+ for (auto conversionCapability : conversionCapabilities) {
+ if (conversionCapability.outputType != common::Hdr::INVALID) {
+ if (std::find(hdrTypes.begin(), hdrTypes.end(), conversionCapability.outputType) ==
+ hdrTypes.end()) {
+ continue;
+ }
+ common::HdrConversionStrategy hdrConversionStrategy;
+ hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
+ conversionCapability.outputType);
+ const auto& [statusSet, preferredHdrOutputType] =
+ mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
+ EXPECT_TRUE(statusSet.isOk());
+ EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
}
- common::HdrConversionStrategy hdrConversionStrategy;
- hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::forceHdrConversion>(
- conversionCapability.outputType);
- const auto& [statusSet, preferredHdrOutputType] =
- mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
- EXPECT_TRUE(statusSet.isOk());
- EXPECT_EQ(common::Hdr::INVALID, preferredHdrOutputType);
}
}
}
@@ -696,24 +733,27 @@
return;
}
const auto& [status, conversionCapabilities] = mComposerClient->getHdrConversionCapabilities();
- const auto& [status2, hdrCapabilities] =
- mComposerClient->getHdrCapabilities(getPrimaryDisplayId());
- if (hdrCapabilities.types.size() <= 0) {
- return;
- }
- std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
- for (auto conversionCapability : conversionCapabilities) {
- if (conversionCapability.outputType != common::Hdr::INVALID) {
- autoHdrTypes.push_back(conversionCapability.outputType);
+
+ for (const auto& display : mDisplays) {
+ const auto& [status2, hdrCapabilities] =
+ mComposerClient->getHdrCapabilities(display.getDisplayId());
+ if (hdrCapabilities.types.size() <= 0) {
+ return;
}
+ std::vector<aidl::android::hardware::graphics::common::Hdr> autoHdrTypes;
+ for (auto conversionCapability : conversionCapabilities) {
+ if (conversionCapability.outputType != common::Hdr::INVALID) {
+ autoHdrTypes.push_back(conversionCapability.outputType);
+ }
+ }
+ common::HdrConversionStrategy hdrConversionStrategy;
+ hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
+ autoHdrTypes);
+ const auto& [statusSet, preferredHdrOutputType] =
+ mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
+ EXPECT_TRUE(statusSet.isOk());
+ EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
}
- common::HdrConversionStrategy hdrConversionStrategy;
- hdrConversionStrategy.set<common::HdrConversionStrategy::Tag::autoAllowedHdrTypes>(
- autoHdrTypes);
- const auto& [statusSet, preferredHdrOutputType] =
- mComposerClient->setHdrConversionStrategy(hdrConversionStrategy);
- EXPECT_TRUE(statusSet.isOk());
- EXPECT_NE(common::Hdr::INVALID, preferredHdrOutputType);
}
TEST_P(GraphicsComposerAidlTest, SetAutoLowLatencyMode_BadDisplay) {
@@ -852,11 +892,12 @@
return;
}
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
-
- EXPECT_TRUE(status.isOk());
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, nullptr);
+ EXPECT_TRUE(status.isOk());
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, nullptr).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, CreateLayer_BadDisplay) {
@@ -878,17 +919,19 @@
return;
}
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, nullptr);
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, nullptr);
+ EXPECT_TRUE(status.isOk());
- const auto& destroyStatus =
- mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
+ const auto& destroyStatus =
+ mComposerClient->destroyLayer(getInvalidDisplayId(), layer, nullptr);
- EXPECT_FALSE(destroyStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
- ASSERT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, nullptr).isOk());
+ EXPECT_FALSE(destroyStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(destroyStatus, IComposerClient::EX_BAD_DISPLAY));
+ ASSERT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, nullptr).isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, DestroyLayer_BadLayerError) {
@@ -897,11 +940,14 @@
return;
}
- // We haven't created any layers yet, so any id should be invalid
- const auto& status = mComposerClient->destroyLayer(getPrimaryDisplayId(), /*layer*/ 1, nullptr);
+ for (const auto& display : mDisplays) {
+ // We haven't created any layers yet, so any id should be invalid
+ const auto& status =
+ mComposerClient->destroyLayer(display.getDisplayId(), /*layer*/ 1, nullptr);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_LAYER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetActiveConfig_BadDisplay) {
@@ -912,8 +958,10 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayConfig) {
- const auto& [status, _] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayConfig_BadDisplay) {
@@ -924,15 +972,10 @@
}
TEST_P(GraphicsComposerAidlTest, GetDisplayName) {
- const auto& [status, _] = mComposerClient->getDisplayName(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
-}
-
-TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation_BadDisplay) {
- const auto& [status, _] = mComposerClient->getDisplayPhysicalOrientation(getInvalidDisplayId());
-
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_DISPLAY));
+ for (const auto& display : mDisplays) {
+ const auto& [status, _] = mComposerClient->getDisplayName(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDisplayPhysicalOrientation) {
@@ -943,197 +986,214 @@
Transform::ROT_270,
};
- const auto& [status, displayOrientation] =
- mComposerClient->getDisplayPhysicalOrientation(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ const auto& [status, displayOrientation] =
+ mComposerClient->getDisplayPhysicalOrientation(display.getDisplayId());
- EXPECT_TRUE(status.isOk());
- EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
- displayOrientation),
- allowedDisplayOrientations.end());
+ EXPECT_TRUE(status.isOk());
+ EXPECT_NE(std::find(allowedDisplayOrientations.begin(), allowedDisplayOrientations.end(),
+ displayOrientation),
+ allowedDisplayOrientations.end());
+ }
}
TEST_P(GraphicsComposerAidlTest, SetClientTargetSlotCount) {
- EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(
+ mComposerClient->setClientTargetSlotCount(display.getDisplayId(), kBufferSlotCount)
.isOk());
+ }
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfig) {
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ for (auto& display : mDisplays) {
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- auto display = getEditablePrimaryDisplay();
- EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
- const auto& [configStatus, config1] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(configStatus.isOk());
- EXPECT_EQ(config, config1);
+ for (const auto& config : configs) {
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [configStatus, config1] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(configStatus.isOk());
+ EXPECT_EQ(config, config1);
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetActiveConfigPowerCycle) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto& [status, configs] = mComposerClient->getDisplayConfigs(getPrimaryDisplayId());
- EXPECT_TRUE(status.isOk());
+ const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
+ EXPECT_TRUE(status.isOk());
- for (const auto& config : configs) {
- auto display = getEditablePrimaryDisplay();
- EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
- const auto& [config1Status, config1] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(config1Status.isOk());
- EXPECT_EQ(config, config1);
+ for (const auto& config : configs) {
+ EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config).isOk());
+ const auto& [config1Status, config1] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(config1Status.isOk());
+ EXPECT_EQ(config, config1);
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- const auto& [config2Status, config2] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
- EXPECT_TRUE(config2Status.isOk());
- EXPECT_EQ(config, config2);
+ EXPECT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ EXPECT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
+ const auto& [config2Status, config2] =
+ mComposerClient->getActiveConfig(display.getDisplayId());
+ EXPECT_TRUE(config2Status.isOk());
+ EXPECT_EQ(config, config2);
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeUnsupported) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- if (!isDozeSupported) {
- const auto& powerModeDozeStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE);
- EXPECT_FALSE(powerModeDozeStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(powerModeDozeStatus, IComposerClient::EX_UNSUPPORTED));
+ if (!isDozeSupported) {
+ const auto& powerModeDozeStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE);
+ EXPECT_FALSE(powerModeDozeStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeStatus,
+ IComposerClient::EX_UNSUPPORTED));
- const auto& powerModeDozeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
- }
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
+ }
- if (!isSuspendSupported) {
- const auto& powerModeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON_SUSPEND);
- EXPECT_FALSE(powerModeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
+ if (!isSuspendSupported) {
+ const auto& powerModeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON_SUSPEND);
+ EXPECT_FALSE(powerModeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
- const auto& powerModeDozeSuspendStatus =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::DOZE_SUSPEND);
- EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
- IComposerClient::EX_UNSUPPORTED));
+ const auto& powerModeDozeSuspendStatus =
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::DOZE_SUSPEND);
+ EXPECT_FALSE(powerModeDozeSuspendStatus.isOk());
+ EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(powerModeDozeSuspendStatus,
+ IComposerClient::EX_UNSUPPORTED));
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetVsyncEnabled) {
mComposerClient->setVsyncAllowed(true);
- EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), true).isOk());
- usleep(60 * 1000);
- EXPECT_TRUE(mComposerClient->setVsync(getPrimaryDisplayId(), false).isOk());
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), true).isOk());
+ usleep(60 * 1000);
+ EXPECT_TRUE(mComposerClient->setVsync(display.getDisplayId(), false).isOk());
+ }
mComposerClient->setVsyncAllowed(false);
}
TEST_P(GraphicsComposerAidlTest, SetPowerMode) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- std::vector<PowerMode> modes;
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::ON);
+ std::vector<PowerMode> modes;
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::ON);
- if (isSuspendSupported) {
- modes.push_back(PowerMode::ON_SUSPEND);
- }
+ if (isSuspendSupported) {
+ modes.push_back(PowerMode::ON_SUSPEND);
+ }
- if (isDozeSupported) {
- modes.push_back(PowerMode::DOZE);
- }
+ if (isDozeSupported) {
+ modes.push_back(PowerMode::DOZE);
+ }
- if (isSuspendSupported && isDozeSupported) {
- modes.push_back(PowerMode::DOZE_SUSPEND);
- }
+ if (isSuspendSupported && isDozeSupported) {
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ }
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
}
}
TEST_P(GraphicsComposerAidlTest, SetPowerModeVariations) {
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
- const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::DOZE) != capabilities.end();
- const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::SUSPEND) != capabilities.end();
+ const bool isDozeSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::DOZE) != capabilities.end();
+ const bool isSuspendSupported = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::SUSPEND) != capabilities.end();
- std::vector<PowerMode> modes;
+ std::vector<PowerMode> modes;
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::ON);
- modes.push_back(PowerMode::OFF);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- modes.push_back(PowerMode::OFF);
- modes.push_back(PowerMode::OFF);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- modes.push_back(PowerMode::ON);
- modes.push_back(PowerMode::ON);
- for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
- }
- modes.clear();
-
- if (isSuspendSupported) {
- modes.push_back(PowerMode::ON_SUSPEND);
- modes.push_back(PowerMode::ON_SUSPEND);
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::ON);
+ modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
- }
- if (isDozeSupported) {
- modes.push_back(PowerMode::DOZE);
- modes.push_back(PowerMode::DOZE);
+ modes.push_back(PowerMode::OFF);
+ modes.push_back(PowerMode::OFF);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
- }
- if (isSuspendSupported && isDozeSupported) {
- modes.push_back(PowerMode::DOZE_SUSPEND);
- modes.push_back(PowerMode::DOZE_SUSPEND);
+ modes.push_back(PowerMode::ON);
+ modes.push_back(PowerMode::ON);
for (auto mode : modes) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), mode).isOk());
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
}
modes.clear();
+
+ if (isSuspendSupported) {
+ modes.push_back(PowerMode::ON_SUSPEND);
+ modes.push_back(PowerMode::ON_SUSPEND);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
+
+ if (isDozeSupported) {
+ modes.push_back(PowerMode::DOZE);
+ modes.push_back(PowerMode::DOZE);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
+
+ if (isSuspendSupported && isDozeSupported) {
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ modes.push_back(PowerMode::DOZE_SUSPEND);
+ for (auto mode : modes) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), mode).isOk());
+ }
+ modes.clear();
+ }
}
}
@@ -1145,11 +1205,14 @@
}
TEST_P(GraphicsComposerAidlTest, SetPowerMode_BadParameter) {
- const auto& status =
- mComposerClient->setPowerMode(getPrimaryDisplayId(), static_cast<PowerMode>(-1));
+ for (const auto& display : mDisplays) {
+ const auto& status =
+ mComposerClient->setPowerMode(display.getDisplayId(), static_cast<PowerMode>(-1));
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlTest, GetDataspaceSaturationMatrix) {
@@ -1315,7 +1378,7 @@
const auto minFrameInterval = *min_element(frameIntervalPowerHints.cbegin(),
frameIntervalPowerHints.cend());
EXPECT_LE(minFrameInterval->frameIntervalNs,
- VtsComposerClient::kMaxFrameIntervalNs);
+ ComposerClientWrapper::kMaxFrameIntervalNs);
const auto maxFrameInterval = *max_element(frameIntervalPowerHints.cbegin(),
frameIntervalPowerHints.cend());
EXPECT_GE(maxFrameInterval->frameIntervalNs, vrrConfig.minFrameIntervalNs);
@@ -1419,9 +1482,11 @@
void TearDown() override {
ASSERT_FALSE(mDisplays.empty());
ASSERT_TRUE(mReader.takeErrors().empty());
- ASSERT_TRUE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
- ASSERT_TRUE(mComposerClient->tearDown(&getWriter(getPrimaryDisplayId())));
+ for (const auto& display : mDisplays) {
+ ASSERT_TRUE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
+ ASSERT_TRUE(mComposerClient->tearDown(&getWriter(display.getDisplayId())));
+ }
ASSERT_NO_FATAL_FAILURE(GraphicsComposerAidlTest::TearDown());
}
@@ -1490,12 +1555,13 @@
"VtsHalGraphicsComposer3_TargetTest");
}
- sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat) {
- return allocate(static_cast<uint32_t>(getPrimaryDisplay().getDisplayWidth()),
- static_cast<uint32_t>(getPrimaryDisplay().getDisplayHeight()), pixelFormat);
+ sp<GraphicBuffer> allocate(::android::PixelFormat pixelFormat, const DisplayWrapper& display) {
+ return allocate(static_cast<uint32_t>(display.getDisplayWidth()),
+ static_cast<uint32_t>(display.getDisplayHeight()), pixelFormat);
}
- void sendRefreshFrame(const VtsDisplay& display, const VsyncPeriodChangeTimeline* timeline) {
+ void sendRefreshFrame(const DisplayWrapper& display,
+ const VsyncPeriodChangeTimeline* timeline) {
if (timeline != nullptr) {
// Refresh time should be before newVsyncAppliedTimeNanos
EXPECT_LT(timeline->refreshTimeNanos, timeline->newVsyncAppliedTimeNanos);
@@ -1514,7 +1580,7 @@
mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
EXPECT_TRUE(status.isOk());
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -1526,7 +1592,7 @@
writer.setLayerDataspace(display.getDisplayId(), layer, common::Dataspace::UNKNOWN);
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1536,7 +1602,7 @@
}
{
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
@@ -1544,7 +1610,7 @@
writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
std::vector<Rect>(1, {0, 0, 10, 10}));
writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -1556,10 +1622,8 @@
}
sp<::android::Fence> presentAndGetFence(
- std::optional<ClockMonotonicTimestamp> expectedPresentTime,
- std::optional<int64_t> displayIdOpt = {},
- int32_t frameIntervalNs = VtsComposerClient::kNoFrameIntervalNs) {
- const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
+ std::optional<ClockMonotonicTimestamp> expectedPresentTime, int64_t displayId,
+ int32_t frameIntervalNs = ComposerClientWrapper::kNoFrameIntervalNs) {
auto& writer = getWriter(displayId);
writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
execute();
@@ -1577,18 +1641,17 @@
return sp<::android::Fence>::make(fenceOwner);
}
- int32_t getVsyncPeriod() {
- const auto& [status, activeConfig] =
- mComposerClient->getActiveConfig(getPrimaryDisplayId());
+ int32_t getVsyncPeriod(int64_t displayId) {
+ const auto& [status, activeConfig] = mComposerClient->getActiveConfig(displayId);
EXPECT_TRUE(status.isOk());
const auto& [vsyncPeriodStatus, vsyncPeriod] = mComposerClient->getDisplayAttribute(
- getPrimaryDisplayId(), activeConfig, DisplayAttribute::VSYNC_PERIOD);
+ displayId, activeConfig, DisplayAttribute::VSYNC_PERIOD);
EXPECT_TRUE(vsyncPeriodStatus.isOk());
return vsyncPeriod;
}
- int64_t createOnScreenLayer(const VtsDisplay& display,
+ int64_t createOnScreenLayer(const DisplayWrapper& display,
Composition composition = Composition::DEVICE) {
auto& writer = getWriter(display.getDisplayId());
const auto& [status, layer] =
@@ -1602,16 +1665,16 @@
return layer;
}
- void sendBufferUpdate(int64_t layer) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ void sendBufferUpdate(int64_t layer, int64_t displayId) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ auto& writer = getWriter(displayId);
+ writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
const sp<::android::Fence> presentFence =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, displayId);
presentFence->waitForever(LOG_TAG);
}
@@ -1623,7 +1686,7 @@
}
void Test_setActiveConfigWithConstraints(const TestParameters& params) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
EXPECT_TRUE(mComposerClient->setActiveConfig(&display, config1).isOk());
sendRefreshFrame(display, nullptr);
@@ -1707,51 +1770,56 @@
return;
}
- ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (const auto& display : mDisplays) {
+ ASSERT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto vsyncPeriod = getVsyncPeriod();
+ const auto vsyncPeriod = getVsyncPeriod(display.getDisplayId());
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- ASSERT_NE(nullptr, buffer2);
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer1);
+ ASSERT_NE(nullptr, buffer2);
- const auto layer = createOnScreenLayer(getPrimaryDisplay());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer1->handle,
- /*acquireFence*/ -1);
- const sp<::android::Fence> presentFence1 =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
- presentFence1->waitForever(LOG_TAG);
+ const auto layer = createOnScreenLayer(display);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer1->handle,
+ /*acquireFence*/ -1);
+ const sp<::android::Fence> presentFence1 =
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, display.getDisplayId());
+ presentFence1->waitForever(LOG_TAG);
- auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
- if (framesDelay.has_value()) {
- expectedPresentTime += *framesDelay * vsyncPeriod;
- }
-
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer2->handle,
- /*acquireFence*/ -1);
- const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
- if (!framesDelay.has_value()) {
- return ComposerClientWriter::kNoTimestamp;
- } else if (*framesDelay == 0) {
- return ClockMonotonicTimestamp{0};
+ auto expectedPresentTime = presentFence1->getSignalTime() + vsyncPeriod;
+ if (framesDelay.has_value()) {
+ expectedPresentTime += *framesDelay * vsyncPeriod;
}
- return ClockMonotonicTimestamp{expectedPresentTime};
- }();
- const sp<::android::Fence> presentFence2 = presentAndGetFence(setExpectedPresentTime);
- presentFence2->waitForever(LOG_TAG);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer2->handle,
+ /*acquireFence*/ -1);
+ const auto setExpectedPresentTime = [&]() -> std::optional<ClockMonotonicTimestamp> {
+ if (!framesDelay.has_value()) {
+ return ComposerClientWriter::kNoTimestamp;
+ } else if (*framesDelay == 0) {
+ return ClockMonotonicTimestamp{0};
+ }
+ return ClockMonotonicTimestamp{expectedPresentTime};
+ }();
- const auto actualPresentTime = presentFence2->getSignalTime();
- EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
+ const sp<::android::Fence> presentFence2 =
+ presentAndGetFence(setExpectedPresentTime, display.getDisplayId());
+ presentFence2->waitForever(LOG_TAG);
- ASSERT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ const auto actualPresentTime = presentFence2->getSignalTime();
+ EXPECT_GE(actualPresentTime, expectedPresentTime - vsyncPeriod / 2);
+
+ ASSERT_TRUE(
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
+ }
}
void forEachNotifyExpectedPresentConfig(
- std::function<void(VtsDisplay&, const DisplayConfiguration&)> func) {
- for (VtsDisplay& display : mDisplays) {
+ std::function<void(DisplayWrapper&, const DisplayConfiguration&)> func) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
const auto& [status, displayConfigurations] =
@@ -1777,11 +1845,11 @@
}
}
EXPECT_TRUE(
- mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
+ mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
}
}
- void configureLayer(const VtsDisplay& display, int64_t layer, Composition composition,
+ void configureLayer(const DisplayWrapper& display, int64_t layer, Composition composition,
const Rect& displayFrame, const FRect& cropRect) {
auto& writer = getWriter(display.getDisplayId());
writer.setLayerCompositionType(display.getDisplayId(), layer, composition);
@@ -1838,86 +1906,94 @@
};
TEST_P(GraphicsComposerAidlCommandTest, SetColorTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setColorTransform(getPrimaryDisplayId(), kIdentity.data());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setColorTransform(display.getDisplayId(), kIdentity.data());
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColorTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- writer.setLayerColorTransform(getPrimaryDisplayId(), layer, kIdentity.data());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ writer.setLayerColorTransform(display.getDisplayId(), layer, kIdentity.data());
+ execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "setLayerColorTransform is not supported";
- return;
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "setLayerColorTransform is not supported";
+ continue;
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetDisplayBrightness) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- const auto& [status, capabilities] =
- mComposerClient->getDisplayCapabilities(getPrimaryDisplayId());
- ASSERT_TRUE(status.isOk());
- bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
- DisplayCapability::BRIGHTNESS) != capabilities.end();
- auto& writer = getWriter(getPrimaryDisplayId());
- if (!brightnessSupport) {
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
+ for (const auto& display : mDisplays) {
+ const auto& [status, capabilities] =
+ mComposerClient->getDisplayCapabilities(display.getDisplayId());
+ ASSERT_TRUE(status.isOk());
+ bool brightnessSupport = std::find(capabilities.begin(), capabilities.end(),
+ DisplayCapability::BRIGHTNESS) != capabilities.end();
+ auto& writer = getWriter(display.getDisplayId());
+ if (!brightnessSupport) {
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
+ GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
+ continue;
+ }
+
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.0f, -1.f);
execute();
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_UNSUPPORTED, errors[0].errorCode);
- GTEST_SUCCEED() << "SetDisplayBrightness is not supported";
- return;
- }
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 0.5f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 0.5f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 1.0f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 1.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ -1.0f, -1.f);
+ execute();
+ EXPECT_TRUE(mReader.takeErrors().empty());
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -1.0f, -1.f);
- execute();
- EXPECT_TRUE(mReader.takeErrors().empty());
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ 2.0f, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
- }
-
- writer.setDisplayBrightness(getPrimaryDisplayId(), /*brightness*/ -2.0f, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ writer.setDisplayBrightness(display.getDisplayId(), /*brightness*/ 2.0f, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetClientTarget) {
- EXPECT_TRUE(mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kBufferSlotCount)
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(
+ mComposerClient->setClientTargetSlotCount(display.getDisplayId(), kBufferSlotCount)
.isOk());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setClientTarget(getPrimaryDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
- Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setClientTarget(display.getDisplayId(), /*slot*/ 0, nullptr, /*acquireFence*/ -1,
+ Dataspace::UNKNOWN, std::vector<Rect>(), 1.0f);
- execute();
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetOutputBuffer) {
@@ -1933,34 +2009,43 @@
kBufferSlotCount);
EXPECT_TRUE(displayStatus.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ // Use dimensions from the primary display
+ const DisplayWrapper& primary = mDisplays[0];
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, primary);
const auto handle = buffer->handle;
auto& writer = getWriter(display.display);
- writer.setOutputBuffer(display.display, /*slot*/ 0, handle, /*releaseFence*/ -1);
+ writer.setOutputBuffer(display.display, /*slot*/ 0, handle,
+ /*releaseFence*/ -1);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- writer.acceptDisplayChanges(getPrimaryDisplayId());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ writer.acceptDisplayChanges(display.getDisplayId());
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ writer.presentDisplay(display.getDisplayId());
+ execute();
+ }
}
/**
@@ -1971,264 +2056,282 @@
* surface damage have been set
*/
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplayNoLayerStateChanges) {
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
+ for (const auto& display : mDisplays) {
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
- const auto& [renderIntentsStatus, renderIntents] =
- mComposerClient->getRenderIntents(getPrimaryDisplayId(), ColorMode::NATIVE);
- EXPECT_TRUE(renderIntentsStatus.isOk());
- auto& writer = getWriter(getPrimaryDisplayId());
- for (auto intent : renderIntents) {
- EXPECT_TRUE(mComposerClient->setColorMode(getPrimaryDisplayId(), ColorMode::NATIVE, intent)
+ const auto& [renderIntentsStatus, renderIntents] =
+ mComposerClient->getRenderIntents(display.getDisplayId(), ColorMode::NATIVE);
+ EXPECT_TRUE(renderIntentsStatus.isOk());
+ auto& writer = getWriter(display.getDisplayId());
+ for (auto intent : renderIntents) {
+ EXPECT_TRUE(
+ mComposerClient->setColorMode(display.getDisplayId(), ColorMode::NATIVE, intent)
.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
- getPrimaryDisplay().getDisplayHeight()};
- FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
- (float)getPrimaryDisplay().getDisplayHeight()};
- configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle,
- /*acquireFence*/ -1);
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED() << "Composition change requested, skipping test";
- return;
+ Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
+ FRect cropRect{0, 0, (float)display.getDisplayWidth(),
+ (float)display.getDisplayHeight()};
+ configureLayer(display, layer, Composition::CURSOR, displayFrame, cropRect);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ GTEST_SUCCEED() << "Composition change requested, skipping test";
+ return;
+ }
+
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.presentDisplay(display.getDisplayId());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle2 = buffer2->handle;
+ ASSERT_NE(nullptr, handle2);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle2,
+ /*acquireFence*/ -1);
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer,
+ std::vector<Rect>(1, {0, 0, 10, 10}));
+ writer.presentDisplay(display.getDisplayId());
+ execute();
}
-
- ASSERT_TRUE(mReader.takeErrors().empty());
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle2 = buffer2->handle;
- ASSERT_NE(nullptr, handle2);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle2,
- /*acquireFence*/ -1);
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer,
- std::vector<Rect>(1, {0, 0, 10, 10}));
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCursorPosition) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
- Rect displayFrame{0, 0, getPrimaryDisplay().getDisplayWidth(),
- getPrimaryDisplay().getDisplayHeight()};
- FRect cropRect{0, 0, (float)getPrimaryDisplay().getDisplayWidth(),
- (float)getPrimaryDisplay().getDisplayHeight()};
- configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ Rect displayFrame{0, 0, display.getDisplayWidth(), display.getDisplayHeight()};
+ FRect cropRect{0, 0, (float)display.getDisplayWidth(), (float)display.getDisplayHeight()};
+ configureLayer(display, layer, Composition::CURSOR, displayFrame, cropRect);
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
- execute();
+ execute();
- if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
- GTEST_SUCCEED() << "Composition change requested, skipping test";
- return;
+ if (!mReader.takeChangedCompositionTypes(display.getDisplayId()).empty()) {
+ continue; // Skip this display if composition change requested
+ }
+ writer.presentDisplay(display.getDisplayId());
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ writer.setLayerCursorPosition(display.getDisplayId(), layer, /*x*/ 1, /*y*/ 1);
+ execute();
+
+ writer.setLayerCursorPosition(display.getDisplayId(), layer, /*x*/ 0, /*y*/ 0);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
}
- writer.presentDisplay(getPrimaryDisplayId());
- ASSERT_TRUE(mReader.takeErrors().empty());
-
- writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 1, /*y*/ 1);
- execute();
-
- writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- writer.presentDisplay(getPrimaryDisplayId());
- execute();
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBuffer) {
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ for (const auto& display : mDisplays) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle,
+ /*acquireFence*/ -1);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBufferMultipleTimes) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
- // Android platform code that clears all 3 buffer slots by setting all but the active buffer
- // slot to a placeholder buffer, and then restoring the active buffer.
+ // Setup 3 buffers in the buffer cache, with the last buffer being active. Then, emulate the
+ // Android platform code that clears all 3 buffer slots by setting all but the active buffer
+ // slot to a placeholder buffer, and then restoring the active buffer.
- // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
+ // This is used on HALs that don't support setLayerBufferSlotsToClear (version <= 3.1).
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- const auto handle1 = buffer1->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer1);
+ const auto handle1 = buffer1->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer2);
- const auto handle2 = buffer2->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer2);
+ const auto handle2 = buffer2->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer3);
- const auto handle3 = buffer3->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer3);
+ const auto handle3 = buffer3->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
- // and then restoring the current active buffer at the end
- auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
- ASSERT_NE(nullptr, clearSlotBuffer);
- auto clearSlotBufferHandle = clearSlotBuffer->handle;
+ // Older versions of the HAL clear all but the active buffer slot with a placeholder buffer,
+ // and then restoring the current active buffer at the end
+ auto clearSlotBuffer = allocate(1u, 1u, ::android::PIXEL_FORMAT_RGB_888);
+ ASSERT_NE(nullptr, clearSlotBuffer);
+ auto clearSlotBufferHandle = clearSlotBuffer->handle;
- // clear buffer slots 0 and 1 with new layer commands... and then...
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 0,
- clearSlotBufferHandle, /*acquireFence*/ -1);
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /* slot */ 1,
- clearSlotBufferHandle, /*acquireFence*/ -1);
- // ...reset the layer buffer to the current active buffer slot with a final new command
- writer.setLayerBufferWithNewCommand(getPrimaryDisplayId(), layer, /*slot*/ 2, nullptr,
- /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ // clear buffer slots 0 and 1 with new layer commands... and then...
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /* slot */ 0,
+ clearSlotBufferHandle, /*acquireFence*/ -1);
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /* slot */ 1,
+ clearSlotBufferHandle, /*acquireFence*/ -1);
+ // ...reset the layer buffer to the current active buffer slot with a final new command
+ writer.setLayerBufferWithNewCommand(display.getDisplayId(), layer, /*slot*/ 2, nullptr,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSurfaceDamage) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerSurfaceDamage(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerSurfaceDamage(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlockingRegion) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlockingRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlockingRegion(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerBlendMode) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::NONE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::NONE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::PREMULTIPLIED);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::PREMULTIPLIED);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBlendMode(getPrimaryDisplayId(), layer, BlendMode::COVERAGE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBlendMode(display.getDisplayId(), layer, BlendMode::COVERAGE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerColor) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerColor(getPrimaryDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerColor(display.getDisplayId(), layer, Color{1.0f, 1.0f, 1.0f, 1.0f});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerColor(getPrimaryDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerColor(display.getDisplayId(), layer, Color{0.0f, 0.0f, 0.0f, 0.0f});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerCompositionType) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CLIENT);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CLIENT);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::DEVICE);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::DEVICE);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::SOLID_COLOR);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::SOLID_COLOR);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerCompositionType(getPrimaryDisplayId(), layer, Composition::CURSOR);
- execute();
+ writer.setLayerCompositionType(display.getDisplayId(), layer, Composition::CURSOR);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, DisplayDecoration) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
auto& writer = getWriter(displayId);
const auto [layerStatus, layer] =
@@ -2239,7 +2342,7 @@
const auto format = (error.isOk() && support) ? support->format
: aidl::android::hardware::graphics::common::PixelFormat::RGBA_8888;
- const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format));
+ const auto decorBuffer = allocate(static_cast<::android::PixelFormat>(format), display);
ASSERT_NE(nullptr, decorBuffer);
if (::android::OK != decorBuffer->initCheck()) {
if (support) {
@@ -2258,7 +2361,7 @@
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, decorBuffer->handle,
/*acquireFence*/ -1);
writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (support) {
ASSERT_TRUE(mReader.takeErrors().empty());
@@ -2272,38 +2375,42 @@
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDataspace) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
-
- writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerDataspace(display.getDisplayId(), layer, Dataspace::UNKNOWN);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerDisplayFrame) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
-
- writer.setLayerDisplayFrame(getPrimaryDisplayId(), layer, Rect{0, 0, 1, 1});
- execute();
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ writer.setLayerDisplayFrame(display.getDisplayId(), layer, Rect{0, 0, 1, 1});
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPlaneAlpha) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 0.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 0.0f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerPlaneAlpha(getPrimaryDisplayId(), layer, /*alpha*/ 1.0f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerPlaneAlpha(display.getDisplayId(), layer, /*alpha*/ 1.0f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSidebandStream) {
@@ -2312,186 +2419,201 @@
return;
}
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- const auto handle = buffer->handle;
- ASSERT_NE(nullptr, handle);
+ for (const auto& display : mDisplays) {
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ const auto handle = buffer->handle;
+ ASSERT_NE(nullptr, handle);
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerSidebandStream(getPrimaryDisplayId(), layer, handle);
- execute();
+ writer.setLayerSidebandStream(display.getDisplayId(), layer, handle);
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerSourceCrop) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerSourceCrop(getPrimaryDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
- execute();
+ writer.setLayerSourceCrop(display.getDisplayId(), layer, FRect{0.0f, 0.0f, 1.0f, 1.0f});
+ execute();
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerTransform) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, static_cast<Transform>(0));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, static_cast<Transform>(0));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_H);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_H);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::FLIP_V);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::FLIP_V);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_90);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_90);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_180);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_180);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer, Transform::ROT_270);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer, Transform::ROT_270);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer,
- static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
- static_cast<int>(Transform::ROT_90)));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer,
+ static_cast<Transform>(static_cast<int>(Transform::FLIP_H) |
+ static_cast<int>(Transform::ROT_90)));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerTransform(getPrimaryDisplayId(), layer,
- static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
- static_cast<int>(Transform::ROT_90)));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerTransform(display.getDisplayId(), layer,
+ static_cast<Transform>(static_cast<int>(Transform::FLIP_V) |
+ static_cast<int>(Transform::ROT_90)));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerVisibleRegion) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- Rect empty{0, 0, 0, 0};
- Rect unit{0, 0, 1, 1};
+ Rect empty{0, 0, 0, 0};
+ Rect unit{0, 0, 1, 1};
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, empty));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, empty));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>(1, unit));
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>(1, unit));
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerVisibleRegion(getPrimaryDisplayId(), layer, std::vector<Rect>());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerVisibleRegion(display.getDisplayId(), layer, std::vector<Rect>());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerZOrder) {
- auto& writer = getWriter(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 10);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 10);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerZOrder(getPrimaryDisplayId(), layer, /*z*/ 0);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerZOrder(display.getDisplayId(), layer, /*z*/ 0);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetLayerPerFrameMetadata) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- /**
- * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
- * the D65 white point and the SRGB transfer functions.
- * Rendering Intent: Colorimetric
- * Primaries:
- * x y
- * green 0.265 0.690
- * blue 0.150 0.060
- * red 0.680 0.320
- * white (D65) 0.3127 0.3290
- */
+ /**
+ * DISPLAY_P3 is a color space that uses the DCI_P3 primaries,
+ * the D65 white point and the SRGB transfer functions.
+ * Rendering Intent: Colorimetric
+ * Primaries:
+ * x y
+ * green 0.265 0.690
+ * blue 0.150 0.060
+ * red 0.680 0.320
+ * white (D65) 0.3127 0.3290
+ */
- std::vector<PerFrameMetadata> aidlMetadata;
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
- aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
- aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
- aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
- aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
- aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
- writer.setLayerPerFrameMetadata(getPrimaryDisplayId(), layer, aidlMetadata);
- execute();
+ std::vector<PerFrameMetadata> aidlMetadata;
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_X, 0.680f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_RED_PRIMARY_Y, 0.320f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_X, 0.265f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_GREEN_PRIMARY_Y, 0.690f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_X, 0.150f});
+ aidlMetadata.push_back({PerFrameMetadataKey::DISPLAY_BLUE_PRIMARY_Y, 0.060f});
+ aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_X, 0.3127f});
+ aidlMetadata.push_back({PerFrameMetadataKey::WHITE_POINT_Y, 0.3290f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_LUMINANCE, 100.0f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MIN_LUMINANCE, 0.1f});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_CONTENT_LIGHT_LEVEL, 78.0});
+ aidlMetadata.push_back({PerFrameMetadataKey::MAX_FRAME_AVERAGE_LIGHT_LEVEL, 62.0});
+ writer.setLayerPerFrameMetadata(display.getDisplayId(), layer, aidlMetadata);
+ execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
- GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
- return;
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == EX_UNSUPPORTED_OPERATION) {
+ GTEST_SUCCEED() << "SetLayerPerFrameMetadata is not supported";
+ EXPECT_TRUE(
+ mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
}
-
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
}
TEST_P(GraphicsComposerAidlCommandTest, setLayerBrightness) {
- auto& writer = getWriter(getPrimaryDisplayId());
+ for (const auto& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.2f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 0.2f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 1.f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 1.f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, 0.f);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ writer.setLayerBrightness(display.getDisplayId(), layer, 0.f);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, -1.f);
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
- }
+ writer.setLayerBrightness(display.getDisplayId(), layer, -1.f);
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
- writer.setLayerBrightness(getPrimaryDisplayId(), layer, std::nanf(""));
- execute();
- {
- const auto errors = mReader.takeErrors();
- ASSERT_EQ(1, errors.size());
- EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ writer.setLayerBrightness(display.getDisplayId(), layer, std::nanf(""));
+ execute();
+ {
+ const auto errors = mReader.takeErrors();
+ ASSERT_EQ(1, errors.size());
+ EXPECT_EQ(IComposerClient::EX_BAD_PARAMETER, errors[0].errorCode);
+ }
}
}
@@ -2509,7 +2631,7 @@
}
TEST_P(GraphicsComposerAidlCommandTest, GetDisplayVsyncPeriod) {
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto& [status, configs] = mComposerClient->getDisplayConfigs(display.getDisplayId());
EXPECT_TRUE(status.isOk());
@@ -2568,7 +2690,7 @@
constraints.seamlessRequired = true;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
forEachTwoConfigs(display.getDisplayId(), [&](int32_t config1, int32_t config2) {
int32_t configGroup1 = display.getDisplayConfig(config1).configGroup;
int32_t configGroup2 = display.getDisplayConfig(config2).configGroup;
@@ -2598,77 +2720,86 @@
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Unsupported) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- const auto& status =
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_BadParameter) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ continue; // DisplayCapability::DISPLAY_IDLE_TIMER is not supported
+ }
- const auto& status =
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ -1);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ const auto& status =
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ -1);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_BAD_PARAMETER));
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Disable) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ continue; // DisplayCapability::DISPLAY_IDLE_TIMER is not supported
+ }
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
- std::this_thread::sleep_for(1s);
- EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
+ EXPECT_TRUE(
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0).isOk());
+ std::this_thread::sleep_for(1s);
+ EXPECT_EQ(0, mComposerClient->getVsyncIdleCount());
+ }
}
TEST_P(GraphicsComposerAidlCommandTest, SetIdleTimerEnabled_Timeout_2) {
- const bool hasDisplayIdleTimerSupport =
- hasDisplayCapability(getPrimaryDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
- if (!hasDisplayIdleTimerSupport) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
+ for (const DisplayWrapper& display : mDisplays) {
+ const bool hasDisplayIdleTimerSupport =
+ hasDisplayCapability(display.getDisplayId(), DisplayCapability::DISPLAY_IDLE_TIMER);
+ if (!hasDisplayIdleTimerSupport) {
+ GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
+ return;
+ }
+
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::ON).isOk());
+ EXPECT_TRUE(
+ mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 0).isOk());
+
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display);
+ ASSERT_NE(nullptr, buffer->handle);
+
+ const auto layer = createOnScreenLayer(display);
+ auto& writer = getWriter(display.getDisplayId());
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
+ auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
+ EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(display.getDisplayId(), /*timeout*/ 2000)
+ .isOk());
+
+ const sp<::android::Fence> presentFence =
+ presentAndGetFence(ComposerClientWriter::kNoTimestamp, display.getDisplayId());
+ presentFence->waitForever(LOG_TAG);
+
+ std::this_thread::sleep_for(3s);
+ if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
+ EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
+ }
+
+ EXPECT_TRUE(mComposerClient->setPowerMode(display.getDisplayId(), PowerMode::OFF).isOk());
}
-
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 0).isOk());
-
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer->handle);
-
- const auto layer = createOnScreenLayer(getPrimaryDisplay());
- auto& writer = getWriter(getPrimaryDisplayId());
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
- /*acquireFence*/ -1);
- int32_t vsyncIdleCount = mComposerClient->getVsyncIdleCount();
- auto earlyVsyncIdleTime = systemTime() + std::chrono::nanoseconds(2s).count();
- EXPECT_TRUE(
- mComposerClient->setIdleTimerEnabled(getPrimaryDisplayId(), /*timeout*/ 2000).isOk());
-
- const sp<::android::Fence> presentFence =
- presentAndGetFence(ComposerClientWriter::kNoTimestamp);
- presentFence->waitForever(LOG_TAG);
-
- std::this_thread::sleep_for(3s);
- if (vsyncIdleCount < mComposerClient->getVsyncIdleCount()) {
- EXPECT_GE(mComposerClient->getVsyncIdleTime(), earlyVsyncIdleTime);
- }
-
- EXPECT_TRUE(mComposerClient->setPowerMode(getPrimaryDisplayId(), PowerMode::OFF).isOk());
}
class GraphicsComposerAidlCommandV2Test : public GraphicsComposerAidlCommandTest {
@@ -2680,6 +2811,7 @@
}
}
};
+
/**
* Test Capability::SKIP_VALIDATE
*
@@ -2694,58 +2826,66 @@
}
TEST_P(GraphicsComposerAidlCommandV2Test, SetLayerBufferSlotsToClear) {
- auto& writer = getWriter(getPrimaryDisplayId());
- // Older HAL versions use a backwards compatible way of clearing buffer slots
- // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ // Older HAL versions use a backwards compatible way of clearing buffer slots
+ // HAL at version 1 or lower does not have LayerCommand::bufferSlotsToClear
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
- // setup 3 buffers in the buffer cache, with the last buffer being active
- // then emulate the Android platform code that clears all 3 buffer slots
+ // setup 3 buffers in the buffer cache, with the last buffer being active
+ // then emulate the Android platform code that clears all 3 buffer slots
- const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer1);
- const auto handle1 = buffer1->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, handle1, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer1 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer1);
+ const auto handle1 = buffer1->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, handle1,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer2);
- const auto handle2 = buffer2->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 1, handle2, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer2 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer2);
+ const auto handle2 = buffer2->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 1, handle2,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer3);
- const auto handle3 = buffer3->handle;
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 2, handle3, /*acquireFence*/ -1);
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ const auto buffer3 = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer3);
+ const auto handle3 = buffer3->handle;
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 2, handle3,
+ /*acquireFence*/ -1);
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
- // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
- // current active buffer's slot will be cleared, but still remain the active buffer and no
- // errors will occur.
- writer.setLayerBufferSlotsToClear(getPrimaryDisplayId(), layer, {0, 1, 2});
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ // Ensure we can clear all 3 buffer slots, even the active buffer - it is assumed the
+ // current active buffer's slot will be cleared, but still remain the active buffer and no
+ // errors will occur.
+ writer.setLayerBufferSlotsToClear(display.getDisplayId(), layer, {0, 1, 2});
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV2Test, SetRefreshRateChangedCallbackDebug_Unsupported) {
if (!hasCapability(Capability::REFRESH_RATE_CHANGED_CALLBACK_DEBUG)) {
- auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
- getPrimaryDisplayId(), /*enabled*/ true);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ for (const DisplayWrapper& display : mDisplays) {
+ auto status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
+ display.getDisplayId(), /*enabled*/ true);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
- status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(getPrimaryDisplayId(),
- /*enabled*/ false);
- EXPECT_FALSE(status.isOk());
- EXPECT_NO_FATAL_FAILURE(
- assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ status = mComposerClient->setRefreshRateChangedCallbackDebugEnabled(
+ display.getDisplayId(),
+ /*enabled*/ false);
+ EXPECT_FALSE(status.isOk());
+ EXPECT_NO_FATAL_FAILURE(
+ assertServiceSpecificError(status, IComposerClient::EX_UNSUPPORTED));
+ }
}
}
@@ -2755,7 +2895,7 @@
return;
}
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
// Enable the callback
@@ -2798,54 +2938,55 @@
return;
}
- auto display = getEditablePrimaryDisplay();
- const auto displayId = display.getDisplayId();
+ for (DisplayWrapper& display : mDisplays) {
+ const auto displayId = display.getDisplayId();
- if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
- GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
- return;
- }
-
- EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
- EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
-
- ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
- // Enable the callback
- ASSERT_TRUE(mComposerClient
- ->setRefreshRateChangedCallbackDebugEnabled(displayId,
- /*enabled*/ true)
- .isOk());
-
- const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
- return displayId == refreshRateChangedDebugData.display;
- };
-
- int retryCount = 3;
- do {
- // Wait for 1s so that we enter the idle state
- std::this_thread::sleep_for(1s);
- if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
- // DID NOT receive a callback, we are in the idle state.
- break;
+ if (!hasDisplayCapability(displayId, DisplayCapability::DISPLAY_IDLE_TIMER)) {
+ GTEST_SUCCEED() << "DisplayCapability::DISPLAY_IDLE_TIMER is not supported";
+ return;
}
- } while (--retryCount > 0);
- if (retryCount == 0) {
- GTEST_SUCCEED() << "Unable to enter the idle mode";
- return;
+ EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
+ EXPECT_TRUE(mComposerClient->setPeakRefreshRateConfig(&display).isOk());
+
+ ASSERT_TRUE(mComposerClient->setIdleTimerEnabled(displayId, /*timeoutMs*/ 500).isOk());
+ // Enable the callback
+ ASSERT_TRUE(mComposerClient
+ ->setRefreshRateChangedCallbackDebugEnabled(displayId,
+ /*enabled*/ true)
+ .isOk());
+
+ const auto displayFilter = [displayId](auto refreshRateChangedDebugData) {
+ return displayId == refreshRateChangedDebugData.display;
+ };
+
+ int retryCount = 3;
+ do {
+ // Wait for 1s so that we enter the idle state
+ std::this_thread::sleep_for(1s);
+ if (!checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter)) {
+ // DID NOT receive a callback, we are in the idle state.
+ break;
+ }
+ } while (--retryCount > 0);
+
+ if (retryCount == 0) {
+ GTEST_SUCCEED() << "Unable to enter the idle mode";
+ return;
+ }
+
+ // Send the REFRESH_RATE_INDICATOR update
+ ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
+ createOnScreenLayer(display, Composition::REFRESH_RATE_INDICATOR), displayId));
+ std::this_thread::sleep_for(1s);
+ EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
+ << "A callback should not be received for REFRESH_RATE_INDICATOR";
+
+ EXPECT_TRUE(mComposerClient
+ ->setRefreshRateChangedCallbackDebugEnabled(displayId,
+ /*enabled*/ false)
+ .isOk());
}
-
- // Send the REFRESH_RATE_INDICATOR update
- ASSERT_NO_FATAL_FAILURE(sendBufferUpdate(
- createOnScreenLayer(getPrimaryDisplay(), Composition::REFRESH_RATE_INDICATOR)));
- std::this_thread::sleep_for(1s);
- EXPECT_FALSE(checkIfCallbackRefreshRateChangedDebugEnabledReceived(displayFilter))
- << "A callback should not be received for REFRESH_RATE_INDICATOR";
-
- EXPECT_TRUE(mComposerClient
- ->setRefreshRateChangedCallbackDebugEnabled(displayId,
- /*enabled*/ false)
- .isOk());
}
TEST_P(GraphicsComposerAidlCommandV2Test,
@@ -2859,7 +3000,7 @@
constraints.seamlessRequired = false;
constraints.desiredTimeNanos = systemTime();
- for (VtsDisplay& display : mDisplays) {
+ for (DisplayWrapper& display : mDisplays) {
const auto displayId = display.getDisplayId();
EXPECT_TRUE(mComposerClient->setPowerMode(displayId, PowerMode::ON).isOk());
@@ -2917,7 +3058,7 @@
}
TEST_P(GraphicsComposerAidlCommandTest, MultiThreadedPresent) {
- std::vector<VtsDisplay*> displays;
+ std::vector<DisplayWrapper*> displays;
for (auto& display : mDisplays) {
if (hasDisplayCapability(display.getDisplayId(),
DisplayCapability::MULTI_THREADED_PRESENT)) {
@@ -2959,7 +3100,7 @@
const auto& [status, layer] =
mComposerClient->createLayer(displayId, kBufferSlotCount, &writer);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
ASSERT_EQ(::android::OK, buffer->initCheck());
ASSERT_NE(nullptr, buffer->handle);
@@ -2980,7 +3121,7 @@
lock.unlock();
writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute(writer, reader);
threads.emplace_back([this, displayId, &readers, &readersMutex]() {
@@ -3034,12 +3175,14 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, CreateBatchedCommand_BadDisplay) {
@@ -3063,15 +3206,18 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
- EXPECT_TRUE(mComposerClient->destroyLayer(getPrimaryDisplayId(), layer, &writer).isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ EXPECT_TRUE(mComposerClient->destroyLayer(display.getDisplayId(), layer, &writer).isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, DestroyBatchedCommand_BadDisplay) {
@@ -3079,20 +3225,23 @@
GTEST_SKIP() << "LAYER_LIFECYCLE_BATCH_COMMAND not supported by the implementation";
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [status, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(status.isOk());
- execute();
- ASSERT_TRUE(mReader.takeErrors().empty());
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [status, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
- auto& invalid_writer = getWriter(getInvalidDisplayId());
- invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
- LayerLifecycleBatchCommandType::DESTROY);
- execute();
- const auto errors = mReader.takeErrors();
- ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
+ EXPECT_TRUE(status.isOk());
+ execute();
+ ASSERT_TRUE(mReader.takeErrors().empty());
+
+ auto& invalid_writer = getWriter(getInvalidDisplayId());
+ invalid_writer.setLayerLifecycleBatchCommandType(getInvalidDisplayId(), layer,
+ LayerLifecycleBatchCommandType::DESTROY);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_DISPLAY);
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, NoCreateDestroyBatchedCommandIncorrectLayer) {
@@ -3101,13 +3250,15 @@
return;
}
- auto& writer = getWriter(getPrimaryDisplayId());
- int64_t layer = 5;
- writer.setLayerLifecycleBatchCommandType(getPrimaryDisplayId(), layer,
- LayerLifecycleBatchCommandType::DESTROY);
- execute();
- const auto errors = mReader.takeErrors();
- ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ int64_t layer = 5;
+ writer.setLayerLifecycleBatchCommandType(display.getDisplayId(), layer,
+ LayerLifecycleBatchCommandType::DESTROY);
+ execute();
+ const auto errors = mReader.takeErrors();
+ ASSERT_TRUE(errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_BAD_LAYER);
+ }
}
TEST_P(GraphicsComposerAidlCommandV3Test, notifyExpectedPresentTimeout) {
@@ -3115,13 +3266,13 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
const auto timeoutNs = config.vrrConfig->notifyExpectedPresentConfig->timeoutNs;
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3155,10 +3306,10 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3171,7 +3322,7 @@
auto lastPresentTimeNs = presentFence->getSignalTime();
auto vsyncPeriod = config.vsyncPeriod;
- int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
+ int32_t highestDivisor = ComposerClientWrapper::kMaxFrameIntervalNs / vsyncPeriod;
int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
float totalDivisorsPassed = 0.f;
@@ -3202,10 +3353,10 @@
GTEST_SUCCEED() << "Device has unreliable present fences capability, skipping";
return;
}
- forEachNotifyExpectedPresentConfig([&](VtsDisplay& display,
+ forEachNotifyExpectedPresentConfig([&](DisplayWrapper& display,
const DisplayConfiguration& config) {
const auto displayId = display.getDisplayId();
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer);
const auto layer = createOnScreenLayer(display);
auto& writer = getWriter(displayId);
@@ -3214,7 +3365,7 @@
auto minFrameIntervalNs = config.vrrConfig->minFrameIntervalNs;
auto vsyncPeriod = config.vsyncPeriod;
- int32_t highestDivisor = VtsComposerClient::kMaxFrameIntervalNs / vsyncPeriod;
+ int32_t highestDivisor = ComposerClientWrapper::kMaxFrameIntervalNs / vsyncPeriod;
int32_t lowestDivisor = minFrameIntervalNs / vsyncPeriod;
const auto headsUpNs = config.vrrConfig->notifyExpectedPresentConfig->headsUpNs;
float totalDivisorsPassed = 0.f;
@@ -3291,7 +3442,7 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
// TODO(b/337330263): Lookup profile IDs from MediaQualityManager
writer.setDisplayPictureProfileId(displayId, PictureProfileId(1));
@@ -3316,7 +3467,7 @@
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3342,7 +3493,7 @@
auto& writer = getWriter(displayId);
for (int profileId = 1; profileId <= maxProfiles + 1; ++profileId) {
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3362,7 +3513,7 @@
int64_t displayId = display.getDisplayId();
auto& writer = getWriter(displayId);
const auto layer = createOnScreenLayer(display);
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, displayId);
ASSERT_NE(nullptr, buffer->handle);
writer.setLayerBuffer(displayId, layer, /*slot*/ 0, buffer->handle,
/*acquireFence*/ -1);
@@ -3381,45 +3532,47 @@
}
TEST_P(GraphicsComposerAidlCommandV4Test, SetUnsupportedLayerLuts) {
- auto& writer = getWriter(getPrimaryDisplayId());
- const auto& [layerStatus, layer] =
- mComposerClient->createLayer(getPrimaryDisplayId(), kBufferSlotCount, &writer);
- EXPECT_TRUE(layerStatus.isOk());
- const auto& [status, properties] = mComposerClient->getOverlaySupport();
+ for (const DisplayWrapper& display : mDisplays) {
+ auto& writer = getWriter(display.getDisplayId());
+ const auto& [layerStatus, layer] =
+ mComposerClient->createLayer(display.getDisplayId(), kBufferSlotCount, &writer);
+ EXPECT_TRUE(layerStatus.isOk());
+ const auto& [status, properties] = mComposerClient->getOverlaySupport();
- // TODO (b/362319189): add Lut VTS enforcement
- if ((!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
- status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) ||
- (status.isOk() && !properties.lutProperties)) {
- int32_t size = 7;
- size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
- int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
- void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
- std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
- memcpy(ptr, buffers.data(), bufferSize);
- munmap(ptr, bufferSize);
- Luts luts;
- luts.offsets = {0};
- luts.lutProperties = {
- {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
- luts.pfd = ndk::ScopedFileDescriptor(fd);
+ // TODO (b/362319189): add Lut VTS enforcement
+ if ((!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
+ status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) ||
+ (status.isOk() && !properties.lutProperties)) {
+ int32_t size = 7;
+ size_t bufferSize = static_cast<size_t>(size) * sizeof(float);
+ int32_t fd = ashmem_create_region("lut_shared_mem", bufferSize);
+ void* ptr = mmap(nullptr, bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+ std::vector<float> buffers = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+ memcpy(ptr, buffers.data(), bufferSize);
+ munmap(ptr, bufferSize);
+ Luts luts;
+ luts.offsets = {0};
+ luts.lutProperties = {
+ {LutProperties::Dimension::ONE_D, size, {LutProperties::SamplingKey::RGB}}};
+ luts.pfd = ndk::ScopedFileDescriptor(fd);
- const auto layer = createOnScreenLayer(getPrimaryDisplayId());
- const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888);
- ASSERT_NE(nullptr, buffer->handle);
- writer.setLayerBuffer(getPrimaryDisplayId(), layer, /*slot*/ 0, buffer->handle,
- /*acquireFence*/ -1);
- writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
- writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
- execute();
- const auto errors = mReader.takeErrors();
- if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
- GTEST_SUCCEED() << "setLayerLuts is not supported";
- return;
+ const auto layer = createOnScreenLayer(display.getDisplayId());
+ const auto buffer = allocate(::android::PIXEL_FORMAT_RGBA_8888, display.getDisplayId());
+ ASSERT_NE(nullptr, buffer->handle);
+ writer.setLayerBuffer(display.getDisplayId(), layer, /*slot*/ 0, buffer->handle,
+ /*acquireFence*/ -1);
+ writer.setLayerLuts(display.getDisplayId(), layer, luts);
+ writer.validateDisplay(display.getDisplayId(), ComposerClientWriter::kNoTimestamp,
+ ComposerClientWrapper::kNoFrameIntervalNs);
+ execute();
+ const auto errors = mReader.takeErrors();
+ if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
+ GTEST_SUCCEED() << "setLayerLuts is not supported";
+ return;
+ }
+ // change to client composition
+ ASSERT_FALSE(mReader.takeChangedCompositionTypes(display.getDisplayId()).empty());
}
- // change to client composition
- ASSERT_FALSE(mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty());
}
}
diff --git a/nfc/aidl/vts/functional/VtsNfcBehaviorChangesTest.cpp b/nfc/aidl/vts/functional/VtsNfcBehaviorChangesTest.cpp
index a61f8ee..a0c9436 100644
--- a/nfc/aidl/vts/functional/VtsNfcBehaviorChangesTest.cpp
+++ b/nfc/aidl/vts/functional/VtsNfcBehaviorChangesTest.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include "nfc_api.h"
#define LOG_TAG "nfc_behavior_changes_test"
#include <aidl/Gtest.h>
@@ -21,6 +22,7 @@
#include <aidl/android/hardware/nfc/BnNfc.h>
#include <aidl/android/hardware/nfc/INfc.h>
#include <android-base/logging.h>
+#include <android-base/properties.h>
#include <android-base/stringprintf.h>
#include <android/binder_process.h>
#include <gtest/gtest.h>
@@ -43,9 +45,33 @@
static SyncEvent sNfaVsCommand; // event for VS commands
static SyncEvent sNfaEnableDisablePollingEvent;
static SyncEvent sNfaPowerChangeEvent;
+static std::vector<uint8_t> sCaps(0);
static bool sIsNfaEnabled;
static tNFA_STATUS sVSCmdStatus;
+static const int SET_PASSIVE_OBSERVER_TECH_TIMEOUT_MS = 15;
+
+static int get_vsr_api_level() {
+ int api_level =
+ ::android::base::GetIntProperty("ro.vendor.api_level", -1);
+ if (api_level != -1) {
+ return api_level;
+ }
+
+ api_level =
+ ::android::base::GetIntProperty("ro.board.api_level", -1);
+ if (api_level != -1) {
+ return api_level;
+ }
+
+ api_level =
+ ::android::base::GetIntProperty("ro.board.first_api_level", -1);
+ EXPECT_NE(api_level, -1) << "Could not find VSR API level.";
+
+ return api_level;
+
+}
+
static void nfaDeviceManagementCallback(uint8_t dmEvent, tNFA_DM_CBACK_DATA* eventData) {
LOG(DEBUG) << StringPrintf("%s: enter; event=0x%X", __func__, dmEvent);
@@ -119,6 +145,7 @@
case NCI_MSG_PROP_ANDROID: {
uint8_t android_sub_opcode = p_param[3];
switch (android_sub_opcode) {
+ case NCI_ANDROID_SET_PASSIVE_OBSERVER_TECH:
case NCI_ANDROID_PASSIVE_OBSERVE: {
if (param_len == 5) {
if ((p_param[0] & NCI_MT_MASK) == (NCI_MT_RSP << NCI_MT_SHIFT)) {
@@ -138,6 +165,12 @@
case NCI_ANDROID_POLLING_FRAME_NTF: {
// TODO
} break;
+ case NCI_ANDROID_GET_CAPS: {
+ sVSCmdStatus = p_param[4];
+ SyncEventGuard guard(sNfaVsCommand);
+ sCaps.assign(p_param + 8, p_param + param_len);
+ sNfaVsCommand.notifyOne();
+ } break;
default:
LOG(WARNING) << StringPrintf("Unknown Android sub opcode %x",
android_sub_opcode);
@@ -170,7 +203,7 @@
if (status == NFA_STATUS_OK) {
if (!sNfaVsCommand.wait(1000)) {
- LOG(WARNING) << "Timeout waiting for NFA VS command response";
+ LOG(WARNING) << "Timeout waiting for set observe mode command response";
return NFA_STATUS_TIMEOUT;
}
}
@@ -178,10 +211,64 @@
return status;
}
+/*
+ * Enable per-technology observe mode.
+ */
+tNFA_STATUS static nfaSetPassiveObserverTech(uint8_t tech_mask) {
+ tNFA_STATUS status = NFA_STATUS_FAILED;
+
+ uint8_t cmd[] = {NCI_ANDROID_SET_PASSIVE_OBSERVER_TECH, tech_mask};
+
+ status = NFA_SendVsCommand(NCI_MSG_PROP_ANDROID, sizeof(cmd), cmd, nfaVSCallback);
+
+ if (status == NFA_STATUS_OK) {
+ if (!sNfaVsCommand.wait(SET_PASSIVE_OBSERVER_TECH_TIMEOUT_MS)) {
+ LOG(WARNING) << "Timeout waiting for set observer tech command response";
+ return NFA_STATUS_TIMEOUT;
+ }
+ }
+
+ return status;
+}
+
+/*
+ * Get chipset capabilities.
+ */
+tNFA_STATUS static nfaGetCaps() {
+ LOG(ERROR) << "getting caps";
+ tNFA_STATUS status = NFA_STATUS_FAILED;
+
+ uint8_t cmd[] = {NCI_ANDROID_GET_CAPS};
+ status = NFA_SendVsCommand(NCI_MSG_PROP_ANDROID, sizeof(cmd), cmd, nfaVSCallback);
+
+ if (status == NFA_STATUS_OK) {
+ if (!sNfaVsCommand.wait(1000)) {
+ LOG(WARNING) << "Timeout waiting for GET_CAPS response";
+ return NFA_STATUS_TIMEOUT;
+ }
+ }
+
+ return status;
+}
+
+/*
+ * Get observe mode capabilities.
+ */
+uint8_t static getCapsPassiveObserverModeValue() {
+ return sCaps[2];
+}
+
class NfcBehaviorChanges : public testing::TestWithParam<std::string> {
- protected:
+protected:
void SetUp() override {
tNFA_STATUS status = NFA_STATUS_OK;
+ status = NFA_StartRfDiscovery();
+ ASSERT_EQ(status, NFA_STATUS_OK);
+ ASSERT_TRUE(sNfaEnableDisablePollingEvent.wait(1000)) << "Timeout starting RF discovery";
+ }
+
+ static void SetUpTestSuite() {
+ tNFA_STATUS status = NFA_STATUS_OK;
sIsNfaEnabled = false;
sVSCmdStatus = NFA_STATUS_OK;
@@ -204,21 +291,21 @@
}
ASSERT_TRUE(sIsNfaEnabled) << "Could not initialize NFC controller";
-
- status = NFA_StartRfDiscovery();
- ASSERT_EQ(status, NFA_STATUS_OK);
- ASSERT_TRUE(sNfaEnableDisablePollingEvent.wait(1000)) << "Timeout starting RF discovery";
}
};
/*
- * ObserveModeEnable:
+ * ObserveModeEnableDisable:
* Attempts to enable observe mode. Does not test Observe Mode functionality,
* but simply verifies that the enable command responds successfully.
*
* @VsrTest = GMS-VSR-3.2.8-001
*/
TEST_P(NfcBehaviorChanges, ObserveModeEnableDisable) {
+ if (get_vsr_api_level() < 202404) {
+ GTEST_SKIP() << "Skipping test for board API level < 202404";
+ }
+
tNFA_STATUS status = nfaObserveModeEnable(true);
ASSERT_EQ(status, NFA_STATUS_OK);
@@ -226,12 +313,78 @@
ASSERT_EQ(status, NFA_STATUS_OK);
}
+/*
+ * SetPassiveObserverTech_individualTechnologies:
+ * Verifies per-technology observe mode is supported as a capability. Then sets observe mode
+ * for each individual technology and verifies the command succeeds.
+ *
+ * @VsrTest = GMS-VSR-3.2.8-002
+ */
+TEST_P(NfcBehaviorChanges, SetPassiveObserverTech_individualTechnologies) {
+ if (get_vsr_api_level() < 202504) {
+ GTEST_SKIP() << "Skipping test for board API level < 202504";
+ }
+
+ tNFC_STATUS status = nfaGetCaps();
+ ASSERT_EQ(status, NFC_STATUS_OK);
+ ASSERT_EQ(getCapsPassiveObserverModeValue(), 0x2);
+
+ status = nfaSetPassiveObserverTech(NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_A);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+
+ status = nfaSetPassiveObserverTech(NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_B);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+
+ status = nfaSetPassiveObserverTech(NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_V);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+
+ status = nfaSetPassiveObserverTech(NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_F);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+}
+
+/*
+ * SetPassiveObserverTech_allExceptF:
+ * Verifies observe mode can be enabled for NFC-A, NFC-B, NFC-V, and disable for NFC-F.
+ *
+ * @VsrTest = GMS-VSR-3.2.8-002
+ */
+TEST_P(NfcBehaviorChanges, SetPassiveObserverTech_allExceptF) {
+ if (get_vsr_api_level() < 202504) {
+ GTEST_SKIP() << "Skipping test for board API level < 202504";
+ }
+
+ tNFC_STATUS status = nfaSetPassiveObserverTech(NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_A |
+ NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_B |
+ NCI_ANDROID_PASSIVE_OBSERVE_PARAM_ENABLE_V);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+}
+
+/*
+ * SetPassiveObserverTech_allOnAndOff:
+ * Verifies observe mode can be enabled and disabled for all technologies.
+ *
+ * @VsrTest = GMS-VSR-3.2.8-002
+ */
+TEST_P(NfcBehaviorChanges, SetPassiveObserverTech_allOnAndOff) {
+ LOG(ERROR) << "starting new test";
+ if (get_vsr_api_level() < 202504) {
+ GTEST_SKIP() << "Skipping test for board API level < 202504";
+ }
+
+ tNFC_STATUS status = nfaSetPassiveObserverTech(0x0F);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+
+ status = nfaSetPassiveObserverTech(0x00);
+ ASSERT_EQ(status, NFA_STATUS_OK);
+}
+
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NfcBehaviorChanges);
INSTANTIATE_TEST_SUITE_P(Nfc, NfcBehaviorChanges,
- testing::ValuesIn(::android::getAidlHalInstanceNames(INfc::descriptor)),
- ::android::PrintInstanceNameToString);
+ testing::ValuesIn(::android::getAidlHalInstanceNames(INfc::descriptor)),
+ ::android::PrintInstanceNameToString
+);
-int main(int argc, char** argv) {
+int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
ABinderProcess_startThreadPool();
std::system("/system/bin/svc nfc disable"); /* Turn off NFC service */
diff --git a/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp b/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
index 7ef445e..65e93c6 100644
--- a/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
+++ b/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
@@ -60,6 +60,10 @@
const string KEYMINT_STRONGBOX_INSTANCE_NAME =
"android.hardware.security.keymint.IKeyMintDevice/strongbox";
+constexpr std::string_view kVerifiedBootState = "ro.boot.verifiedbootstate";
+constexpr std::string_view kDeviceState = "ro.boot.vbmeta.device_state";
+constexpr std::string_view kDefaultValue = "";
+
#define INSTANTIATE_REM_PROV_AIDL_TEST(name) \
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(name); \
INSTANTIATE_TEST_SUITE_P( \
@@ -171,6 +175,37 @@
return nullptr;
}
+void unlockedBootloaderStatesImpliesNonNormalDiceChain(
+ const string& rpcInstanceName, std::shared_ptr<IRemotelyProvisionedComponent> rpc) {
+ auto challenge = randomBytes(MAX_CHALLENGE_SIZE);
+ bytevec csr;
+ auto status = rpc->generateCertificateRequestV2({} /* keysToSign */, challenge, &csr);
+ ASSERT_TRUE(status.isOk()) << status.getDescription();
+
+ auto isProper = isCsrWithProperDiceChain(csr, rpcInstanceName);
+ ASSERT_TRUE(isProper) << isProper.message();
+ if (!*isProper) {
+ GTEST_SKIP() << "Skipping test: Only a proper DICE chain has a mode set.";
+ }
+
+ auto nonNormalMode = hasNonNormalModeInDiceChain(csr, rpcInstanceName);
+ ASSERT_TRUE(nonNormalMode) << nonNormalMode.message();
+
+ auto deviceState = ::android::base::GetProperty(string(kDeviceState), string(kDefaultValue));
+ auto verifiedBootState =
+ ::android::base::GetProperty(string(kVerifiedBootState), string(kDefaultValue));
+
+ ASSERT_TRUE(!deviceState.empty());
+ ASSERT_TRUE(!verifiedBootState.empty());
+
+ ASSERT_EQ(deviceState != "locked" || verifiedBootState != "green", *nonNormalMode)
+ << kDeviceState << " = '" << deviceState << "' and " << kVerifiedBootState << " = '"
+ << verifiedBootState << "', but the DICE "
+ << " chain has a " << (*nonNormalMode ? "non-normal" : "normal") << " DICE mode."
+ << " Locked devices must report normal, and unlocked devices must report "
+ << " non-normal.";
+}
+
} // namespace
class VtsRemotelyProvisionedComponentTests : public testing::TestWithParam<std::string> {
@@ -270,13 +305,9 @@
*/
// @VsrTest = 7.1-003.001
TEST(NonParameterizedTests, equalUdsPubInDiceCertChainForRkpVmAndPrimaryKeyMintInstances) {
- int vendorApiLevel = get_vendor_api_level();
- if (vendorApiLevel < 202504 && !AServiceManager_isDeclared(RKPVM_INSTANCE_NAME.c_str())) {
+ if (!AServiceManager_isDeclared(RKPVM_INSTANCE_NAME.c_str())) {
GTEST_SKIP() << "The RKP VM (" << RKPVM_INSTANCE_NAME << ") is not present on this device.";
}
- if (vendorApiLevel >= 202504) {
- ASSERT_TRUE(AServiceManager_isDeclared(RKPVM_INSTANCE_NAME.c_str()));
- }
auto rkpVmRpc = getHandle<IRemotelyProvisionedComponent>(RKPVM_INSTANCE_NAME);
ASSERT_NE(rkpVmRpc, nullptr) << "The RKP VM (" << RKPVM_INSTANCE_NAME
@@ -349,7 +380,7 @@
* is not "green" if and only if the mode on at least one certificate in the DICE chain
* is non-normal.
*/
-TEST(NonParameterizedTests, unlockedBootloaderStatesImpliesNonnormalRkpVmDiceChain) {
+TEST(NonParameterizedTests, unlockedBootloaderStatesImpliesNonNormalRkpVmDiceChain) {
if (!AServiceManager_isDeclared(RKPVM_INSTANCE_NAME.c_str())) {
GTEST_SKIP() << "The RKP VM (" << RKPVM_INSTANCE_NAME << ") is not present on this device.";
}
@@ -363,32 +394,31 @@
GTEST_SKIP() << "The RKP VM is not supported on this system.";
}
- auto challenge = randomBytes(MAX_CHALLENGE_SIZE);
- bytevec csr;
- auto rkpVmStatus = rpc->generateCertificateRequestV2({} /* keysToSign */, challenge, &csr);
- ASSERT_TRUE(rkpVmStatus.isOk()) << status.getDescription();
+ unlockedBootloaderStatesImpliesNonNormalDiceChain(RKPVM_INSTANCE_NAME, rpc);
+}
- auto isProper = isCsrWithProperDiceChain(csr, RKPVM_INSTANCE_NAME);
- ASSERT_TRUE(isProper) << isProper.message();
- if (!*isProper) {
- GTEST_SKIP() << "Skipping test: Only a proper DICE chain has a mode set.";
+/**
+ * If trusty.security_vm.keymint.enabled is set to "true", then do the following.
+ *
+ * Check that ro.boot.vbmeta.device_state is not "locked" or ro.boot.verifiedbootstate
+ * is not "green" if and only if the mode on at least one certificate in the DICE chain
+ * is non-normal.
+ */
+TEST(NonParameterizedTests, unlockedBootloaderStatesImpliesNonNormalKeyMintInAVmDiceChain) {
+ if (::android::base::GetBoolProperty("trusty.security_vm.keymint.enabled", false)) {
+ GTEST_SKIP() << "The KeyMint (" << DEFAULT_INSTANCE_NAME
+ << ") instance is not inside a VM.";
}
- auto nonNormalMode = hasNonNormalModeInDiceChain(csr, RKPVM_INSTANCE_NAME);
- ASSERT_TRUE(nonNormalMode) << nonNormalMode.message();
+ auto rpc = getHandle<IRemotelyProvisionedComponent>(DEFAULT_INSTANCE_NAME);
+ ASSERT_NE(rpc, nullptr) << "The KeyMint (" << DEFAULT_INSTANCE_NAME
+ << ") instance RPC is unavailable.";
- auto deviceState = ::android::base::GetProperty("ro.boot.vbmeta.device_state", "");
- auto verifiedBootState = ::android::base::GetProperty("ro.boot.verifiedbootstate", "");
+ RpcHardwareInfo hardwareInfo;
+ auto status = rpc->getHardwareInfo(&hardwareInfo);
+ ASSERT_TRUE(status.isOk()) << status.getDescription();
- ASSERT_TRUE(!deviceState.empty());
- ASSERT_TRUE(!verifiedBootState.empty());
-
- ASSERT_EQ(deviceState != "locked" || verifiedBootState != "green", *nonNormalMode)
- << "ro.boot.vbmeta.device_state = '" << deviceState
- << "' and ro.boot.verifiedbootstate = '" << verifiedBootState << "', but the DICE "
- << " chain has a " << (*nonNormalMode ? "non-normal" : "normal") << " DICE mode."
- << " Locked devices must report normal, and unlocked devices must report "
- << " non-normal.";
+ unlockedBootloaderStatesImpliesNonNormalDiceChain(DEFAULT_INSTANCE_NAME, rpc);
}
using GetHardwareInfoTests = VtsRemotelyProvisionedComponentTests;
diff --git a/sensors/OWNERS b/sensors/OWNERS
index 5017a9a..b647f3b 100644
--- a/sensors/OWNERS
+++ b/sensors/OWNERS
@@ -1,3 +1,2 @@
# Bug component: 62965
-
-bduddie@google.com
+include platform/frameworks/native:/services/sensorservice/OWNERS
\ No newline at end of file
diff --git a/usb/OWNERS b/usb/OWNERS
index 647d626..0c73782 100644
--- a/usb/OWNERS
+++ b/usb/OWNERS
@@ -1,8 +1,8 @@
# Bug component: 175220
-anothermark@google.com
+vmartensson@google.com
+nkapron@google.com
febinthattil@google.com
-aprasath@google.com
+shubhankarm@google.com
albertccwang@google.com
-badhri@google.com
-kumarashishg@google.com
\ No newline at end of file
+badhri@google.com
\ No newline at end of file