Merge "Run VTS HWC tests on the AIDL repo itself." into main
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 6c694d3..33b41ce 100755
--- a/compatibility_matrices/bump.py
+++ b/compatibility_matrices/bump.py
@@ -60,6 +60,7 @@
self.copy_matrix()
self.edit_android_bp()
self.bump_libvintf()
+ self.bump_libvts_vintf()
def bump_kernel_configs(self):
check_call([
@@ -154,6 +155,20 @@
}} break;"""),
" "*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 add_lines_above(file, pattern, lines):
with open(file, 'r+') as f:
@@ -168,6 +183,16 @@
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__)
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/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..9669443 100644
--- a/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
+++ b/graphics/composer/aidl/vts/VtsHalGraphicsComposer3_TargetTest.cpp
@@ -22,8 +22,8 @@
#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 <aidl/android/hardware/graphics/composer3/OutputType.h>
#include <android-base/properties.h>
#include <android/binder_process.h>
#include <android/hardware/graphics/composer3/ComposerClientReader.h>
@@ -43,8 +43,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 +54,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 +62,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();
@@ -139,21 +140,21 @@
return version;
}
- const VtsDisplay& getPrimaryDisplay() const { return mDisplays[0]; }
+ const DisplayWrapper& getPrimaryDisplay() const { return mDisplays[0]; }
int64_t getPrimaryDisplayId() const { return getPrimaryDisplay().getDisplayId(); }
int64_t getInvalidDisplayId() const { return mComposerClient->getInvalidDisplayId(); }
- VtsDisplay& getEditablePrimaryDisplay() { return mDisplays[0]; }
+ DisplayWrapper& 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;
};
@@ -248,7 +249,6 @@
GTEST_SUCCEED() << "getReadbackBufferAttributes is not supported";
return;
}
-
ASSERT_TRUE(status.isOk());
}
@@ -512,7 +512,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 +526,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 +552,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);
@@ -1315,7 +1315,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);
@@ -1495,7 +1495,8 @@
static_cast<uint32_t>(getPrimaryDisplay().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);
@@ -1526,7 +1527,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());
@@ -1544,7 +1545,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());
@@ -1557,8 +1558,8 @@
sp<::android::Fence> presentAndGetFence(
std::optional<ClockMonotonicTimestamp> expectedPresentTime,
- std::optional<int64_t> displayIdOpt = {},
- int32_t frameIntervalNs = VtsComposerClient::kNoFrameIntervalNs) {
+ std::optional<int> displayIdOpt = {},
+ int32_t frameIntervalNs = ComposerClientWrapper::kNoFrameIntervalNs) {
const auto displayId = displayIdOpt.value_or(getPrimaryDisplayId());
auto& writer = getWriter(displayId);
writer.validateDisplay(displayId, expectedPresentTime, frameIntervalNs);
@@ -1588,7 +1589,7 @@
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] =
@@ -1623,7 +1624,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);
@@ -1750,8 +1751,8 @@
}
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] =
@@ -1781,7 +1782,7 @@
}
}
- 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);
@@ -1943,14 +1944,14 @@
TEST_P(GraphicsComposerAidlCommandTest, ValidDisplay) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
}
TEST_P(GraphicsComposerAidlCommandTest, AcceptDisplayChanges) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.acceptDisplayChanges(getPrimaryDisplayId());
execute();
}
@@ -1958,7 +1959,7 @@
TEST_P(GraphicsComposerAidlCommandTest, PresentDisplay) {
auto& writer = getWriter(getPrimaryDisplayId());
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.presentDisplay(getPrimaryDisplayId());
execute();
}
@@ -1998,7 +1999,7 @@
/*acquireFence*/ -1);
writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
if (!mReader.takeChangedCompositionTypes(getPrimaryDisplayId()).empty()) {
GTEST_SUCCEED() << "Composition change requested, skipping test";
@@ -2041,7 +2042,7 @@
configureLayer(getPrimaryDisplay(), layer, Composition::CURSOR, displayFrame, cropRect);
writer.setLayerDataspace(getPrimaryDisplayId(), layer, Dataspace::UNKNOWN);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
@@ -2057,7 +2058,7 @@
writer.setLayerCursorPosition(getPrimaryDisplayId(), layer, /*x*/ 0, /*y*/ 0);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
writer.presentDisplay(getPrimaryDisplayId());
execute();
}
@@ -2228,7 +2229,7 @@
}
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] =
@@ -2258,7 +2259,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());
@@ -2509,7 +2510,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 +2569,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;
@@ -2755,7 +2756,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
@@ -2859,7 +2860,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 +2918,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)) {
@@ -2980,7 +2981,7 @@
lock.unlock();
writer.validateDisplay(displayId, ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute(writer, reader);
threads.emplace_back([this, displayId, &readers, &readersMutex]() {
@@ -3115,7 +3116,7 @@
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;
@@ -3155,7 +3156,7 @@
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);
@@ -3171,7 +3172,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,7 +3203,7 @@
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);
@@ -3214,7 +3215,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;
@@ -3411,7 +3412,7 @@
/*acquireFence*/ -1);
writer.setLayerLuts(getPrimaryDisplayId(), layer, luts);
writer.validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
- VtsComposerClient::kNoFrameIntervalNs);
+ ComposerClientWrapper::kNoFrameIntervalNs);
execute();
const auto errors = mReader.takeErrors();
if (errors.size() == 1 && errors[0].errorCode == IComposerClient::EX_UNSUPPORTED) {
diff --git a/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp b/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
index 7ef445e..9d90440 100644
--- a/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
+++ b/security/rkp/aidl/vts/functional/VtsRemotelyProvisionedComponentTests.cpp
@@ -270,13 +270,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