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