diff --git a/drm/DrmHwc.cpp b/drm/DrmHwc.cpp
index f32da1b..4020aba 100644
--- a/drm/DrmHwc.cpp
+++ b/drm/DrmHwc.cpp
@@ -172,25 +172,25 @@ void DrmHwc::NotifyDisplayLinkStatus(
                        DisplayStatus::kLinkTrainingFailed);
 }
 
-std::optional<hwc2_display_t> DrmHwc::CreateVirtualDisplay(uint32_t width,
-                                                           uint32_t height) {
+std::optional<DisplayHandle> DrmHwc::CreateVirtualDisplay(uint32_t width,
+                                                          uint32_t height) {
   ALOGI("Creating virtual display %dx%d", width, height);
 
   auto virtual_pipeline = resource_manager_.GetVirtualDisplayPipeline();
   if (!virtual_pipeline)
     return std::nullopt;
 
-  hwc2_display_t new_display_id = ++last_display_handle_;
-  auto disp = std::make_unique<HwcDisplay>(new_display_id,
+  DisplayHandle new_display_handle = ++last_display_handle_;
+  auto disp = std::make_unique<HwcDisplay>(new_display_handle,
                                            /* is_virtual */ true, this);
 
   disp->SetVirtualDisplayResolution(width, height);
   disp->SetPipeline(virtual_pipeline);
-  displays_[new_display_id] = std::move(disp);
-  return new_display_id;
+  displays_[new_display_handle] = std::move(disp);
+  return new_display_handle;
 }
 
-bool DrmHwc::DestroyVirtualDisplay(hwc2_display_t display) {
+bool DrmHwc::DestroyVirtualDisplay(DisplayHandle display) {
   ALOGI("Destroying virtual display %" PRIu64, display);
 
   if (displays_.count(display) == 0) {
@@ -218,10 +218,11 @@ bool DrmHwc::DestroyVirtualDisplay(hwc2_display_t display) {
   return true;
 }
 
-auto DrmHwc::PullCompositionStats() -> std::map<int64_t, CompositionStats> {
+auto DrmHwc::PullCompositionStats()
+    -> std::map<DisplayHandle, CompositionStats> {
   std::map<int64_t, CompositionStats> stats;
-  for (auto &[display_id, display] : displays_) {
-    stats[static_cast<int64_t>(display_id)] = display->total_stats();
+  for (auto &[display_handle, display] : displays_) {
+    stats[static_cast<int64_t>(display_handle)] = display->total_stats();
   }
   return stats;
 }
@@ -231,11 +232,12 @@ std::string DrmHwc::DumpState() {
 
   output << "-- drm_hwcomposer --\n\n";
 
-  auto callback = [this, &output](int64_t display_id,
+  auto callback = [this, &output](int64_t display_handle,
                                   const CompositionStats &stats,
                                   const CompositionStats &delta) {
-    auto *display = GetDisplay(display_id);
-    ALOGE_IF(display == nullptr, "Display %" PRIu64 " not found", display_id);
+    auto *display = GetDisplay(display_handle);
+    ALOGE_IF(display == nullptr, "Display %" PRIu64 " not found",
+             display_handle);
     if (display) {
       output << DumpDisplayStats(display, stats, delta);
     }
diff --git a/drm/DrmHwc.h b/drm/DrmHwc.h
index 1cb1a16..e187eb4 100644
--- a/drm/DrmHwc.h
+++ b/drm/DrmHwc.h
@@ -37,27 +37,28 @@ class DrmHwc : public PipelineToFrontendBindingInterface,
   };
 
   // Client Callback functions.:
-  virtual void SendVsyncEventToClient(hwc2_display_t displayid,
+  virtual void SendVsyncEventToClient(DisplayHandle display_handle,
                                       int64_t timestamp,
                                       uint32_t vsync_period) const = 0;
   virtual void SendVsyncPeriodTimingChangedEventToClient(
-      hwc2_display_t displayid, int64_t timestamp) const = 0;
-  virtual void SendRefreshEventToClient(uint64_t displayid) = 0;
-  virtual void SendHotplugEventToClient(hwc2_display_t displayid,
+      DisplayHandle display_handle, int64_t timestamp) const = 0;
+  virtual void SendRefreshEventToClient(DisplayHandle display_handle) = 0;
+  virtual void SendHotplugEventToClient(DisplayHandle display_handle,
                                         enum DisplayStatus display_status) = 0;
 
   // CompositionStatsProvider:
-  auto PullCompositionStats() -> std::map<int64_t, CompositionStats> override;
+  auto PullCompositionStats()
+      -> std::map<DisplayHandle, CompositionStats> override;
 
   std::string DumpState();
 
   // Virtual Display functions.
-  std::optional<hwc2_display_t> CreateVirtualDisplay(uint32_t width,
-                                                     uint32_t height);
-  bool DestroyVirtualDisplay(hwc2_display_t display);
+  std::optional<DisplayHandle> CreateVirtualDisplay(uint32_t width,
+                                                    uint32_t height);
+  bool DestroyVirtualDisplay(DisplayHandle display_handle);
   uint32_t GetMaxVirtualDisplayCount();
 
-  auto GetDisplay(hwc2_display_t display_handle) {
+  auto GetDisplay(DisplayHandle display_handle) {
     return displays_.count(display_handle) != 0
                ? displays_[display_handle].get()
                : nullptr;
@@ -67,9 +68,9 @@ class DrmHwc : public PipelineToFrontendBindingInterface,
     return resource_manager_;
   }
 
-  void ScheduleHotplugEvent(hwc2_display_t displayid,
+  void ScheduleHotplugEvent(DisplayHandle display_handle,
                             enum DisplayStatus display_status) {
-    deferred_hotplug_events_[displayid] = display_status;
+    deferred_hotplug_events_[display_handle] = display_status;
   }
 
   void DeinitDisplays();
@@ -90,14 +91,13 @@ class DrmHwc : public PipelineToFrontendBindingInterface,
 
  private:
   ResourceManager resource_manager_;
-  std::map<hwc2_display_t, std::unique_ptr<HwcDisplay>> displays_;
-  std::map<std::shared_ptr<DrmDisplayPipeline>, hwc2_display_t>
-      display_handles_;
+  std::map<DisplayHandle, std::unique_ptr<HwcDisplay>> displays_;
+  std::map<std::shared_ptr<DrmDisplayPipeline>, DisplayHandle> display_handles_;
 
-  std::map<hwc2_display_t, enum DisplayStatus> deferred_hotplug_events_;
-  std::vector<hwc2_display_t> displays_for_removal_list_;
+  std::map<DisplayHandle, enum DisplayStatus> deferred_hotplug_events_;
+  std::vector<DisplayHandle> displays_for_removal_list_;
 
-  uint32_t last_display_handle_ = kPrimaryDisplay;
+  DisplayHandle last_display_handle_ = kPrimaryDisplay;
   CompositionStatsTracker dump_stats_tracker_;
 };
 }  // namespace android
diff --git a/hwc2_device/DrmHwcTwo.cpp b/hwc2_device/DrmHwcTwo.cpp
index 4637f04..98af8c8 100644
--- a/hwc2_device/DrmHwcTwo.cpp
+++ b/hwc2_device/DrmHwcTwo.cpp
@@ -68,7 +68,7 @@ HWC2::Error DrmHwcTwo::RegisterCallback(int32_t descriptor,
   return HWC2::Error::None;
 }
 
-void DrmHwcTwo::SendHotplugEventToClient(hwc2_display_t displayid,
+void DrmHwcTwo::SendHotplugEventToClient(DisplayHandle display_handle,
                                          DisplayStatus display_status) {
   auto hc = hotplug_callback_;
 
@@ -76,31 +76,31 @@ void DrmHwcTwo::SendHotplugEventToClient(hwc2_display_t displayid,
     /* For some reason HWC Service will call HWC2 API in hotplug callback
      * handler. This is the reason we're using recursive mutex.
      */
-    hc.first(hc.second, displayid,
+    hc.first(hc.second, display_handle,
              display_status ? HWC2_CONNECTION_CONNECTED
                             : HWC2_CONNECTION_DISCONNECTED);
   }
 }
 
 void DrmHwcTwo::SendVsyncEventToClient(
-    hwc2_display_t displayid, int64_t timestamp,
+    DisplayHandle display_handle, int64_t timestamp,
     [[maybe_unused]] uint32_t vsync_period) const {
   /* vsync callback */
 #if __ANDROID_API__ > 29
   if (vsync_2_4_callback_.first != nullptr &&
       vsync_2_4_callback_.second != nullptr) {
-    vsync_2_4_callback_.first(vsync_2_4_callback_.second, displayid, timestamp,
-                              vsync_period);
+    vsync_2_4_callback_.first(vsync_2_4_callback_.second, display_handle,
+                              timestamp, vsync_period);
   } else
 #endif
       if (vsync_callback_.first != nullptr &&
           vsync_callback_.second != nullptr) {
-    vsync_callback_.first(vsync_callback_.second, displayid, timestamp);
+    vsync_callback_.first(vsync_callback_.second, display_handle, timestamp);
   }
 }
 
 void DrmHwcTwo::SendVsyncPeriodTimingChangedEventToClient(
-    [[maybe_unused]] hwc2_display_t displayid,
+    [[maybe_unused]] DisplayHandle display_handle,
     [[maybe_unused]] int64_t timestamp) const {
 #if __ANDROID_API__ > 29
   hwc_vsync_period_change_timeline_t timeline = {
@@ -111,15 +111,16 @@ void DrmHwcTwo::SendVsyncPeriodTimingChangedEventToClient(
   if (period_timing_changed_callback_.first != nullptr &&
       period_timing_changed_callback_.second != nullptr) {
     period_timing_changed_callback_
-        .first(period_timing_changed_callback_.second, displayid, &timeline);
+        .first(period_timing_changed_callback_.second, display_handle,
+               &timeline);
   }
 #endif
 }
 
-void DrmHwcTwo::SendRefreshEventToClient(hwc2_display_t displayid) {
+void DrmHwcTwo::SendRefreshEventToClient(DisplayHandle display_handle) {
   if (refresh_callback_.first != nullptr &&
       refresh_callback_.second != nullptr) {
-    refresh_callback_.first(refresh_callback_.second, displayid);
+    refresh_callback_.first(refresh_callback_.second, display_handle);
   }
 }
 
diff --git a/hwc2_device/DrmHwcTwo.h b/hwc2_device/DrmHwcTwo.h
index d87168d..bef88c6 100644
--- a/hwc2_device/DrmHwcTwo.h
+++ b/hwc2_device/DrmHwcTwo.h
@@ -31,12 +31,12 @@ class DrmHwcTwo : public DrmHwc {
                                hwc2_function_pointer_t function);
 
   // DrmHwc
-  void SendVsyncEventToClient(hwc2_display_t displayid, int64_t timestamp,
+  void SendVsyncEventToClient(DisplayHandle display_handle, int64_t timestamp,
                               uint32_t vsync_period) const override;
   void SendVsyncPeriodTimingChangedEventToClient(
-      hwc2_display_t displayid, int64_t timestamp) const override;
-  void SendRefreshEventToClient(uint64_t displayid) override;
-  void SendHotplugEventToClient(hwc2_display_t displayid,
+      DisplayHandle display_handle, int64_t timestamp) const override;
+  void SendRefreshEventToClient(DisplayHandle display_handle) override;
+  void SendHotplugEventToClient(DisplayHandle display_handle,
                                 DisplayStatus display_status) override;
 
   const std::string& RefreshStateDump();
diff --git a/hwc2_device/HwcDisplay.cpp b/hwc2_device/HwcDisplay.cpp
index 161cf23..e0f0f94 100644
--- a/hwc2_device/HwcDisplay.cpp
+++ b/hwc2_device/HwcDisplay.cpp
@@ -111,7 +111,7 @@ auto HwcDisplay::GetDisplayName() -> std::string {
   return stream.str();
 }
 
-HwcDisplay::HwcDisplay(hwc2_display_t handle, bool is_virtual, DrmHwc *hwc)
+HwcDisplay::HwcDisplay(DisplayHandle handle, bool is_virtual, DrmHwc *hwc)
     : hwc_(hwc), handle_(handle), is_virtual_(is_virtual), client_layer_(this) {
   // Create writeback layer for both virtual displays and potential readback
   // operations
@@ -491,7 +491,7 @@ void HwcDisplay::SetVsyncCallbacksEnabled(bool enabled) {
   std::optional<VSyncWorker::VsyncTimestampCallback> callback = std::nullopt;
   if (vsync_event_en_) {
     DrmHwc *hwc = hwc_;
-    hwc2_display_t id = handle_;
+    DisplayHandle id = handle_;
     // Callback will be called from the vsync thread.
     callback = [hwc, id](int64_t timestamp, uint32_t period_ns) {
       hwc->SendVsyncEventToClient(id, timestamp, period_ns);
diff --git a/hwc2_device/HwcDisplay.h b/hwc2_device/HwcDisplay.h
index e6e3e4e..ad17729 100644
--- a/hwc2_device/HwcDisplay.h
+++ b/hwc2_device/HwcDisplay.h
@@ -36,6 +36,8 @@
 
 namespace android {
 
+using DisplayHandle = int64_t;
+
 class Backend;
 class DrmHwc;
 
@@ -58,7 +60,7 @@ class HwcDisplay {
 
   enum DisplayType { kInternal, kExternal, kVirtual };
 
-  HwcDisplay(hwc2_display_t handle, bool is_virtual, DrmHwc *hwc);
+  HwcDisplay(DisplayHandle handle, bool is_virtual, DrmHwc *hwc);
   HwcDisplay(const HwcDisplay &) = delete;
   ~HwcDisplay();
 
@@ -248,7 +250,7 @@ class HwcDisplay {
   std::unique_ptr<VSyncWorker> vsync_worker_;
   bool vsync_event_en_{};
 
-  const hwc2_display_t handle_;
+  const DisplayHandle handle_;
   bool is_virtual_;
 
   std::map<ILayerId, HwcLayer> layers_;
diff --git a/hwc2_device/hwc2_device.cpp b/hwc2_device/hwc2_device.cpp
index 3382103..8a964c0 100644
--- a/hwc2_device/hwc2_device.cpp
+++ b/hwc2_device/hwc2_device.cpp
@@ -218,7 +218,7 @@ static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
         GetFuncName(__PRETTY_FUNCTION__).c_str());
   DrmHwcTwo *hwc = ToDrmHwcTwo(dev);
   const std::unique_lock lock(hwc->GetResMan().GetMainLock());
-  auto *display = hwc->GetDisplay(display_handle);
+  auto *display = hwc->GetDisplay(static_cast<DisplayHandle>(display_handle));
   if (display == nullptr)
     return static_cast<int32_t>(HWC2::Error::BadDisplay);
 
@@ -243,9 +243,9 @@ static void HookDevGetCapabilities(hwc2_device_t * /*dev*/, uint32_t *out_count,
   auto *ihwc = ToDrmHwcTwo(dev); \
   const std::unique_lock lock(ihwc->GetResMan().GetMainLock());
 
-#define GET_DISPLAY(display_id)                  \
-  auto *idisplay = ihwc->GetDisplay(display_id); \
-  if (!idisplay)                                 \
+#define GET_DISPLAY(display_handle)                  \
+  auto *idisplay = ihwc->GetDisplay(display_handle); \
+  if (!idisplay)                                     \
     return static_cast<int32_t>(HWC2::Error::BadDisplay);
 
 #define GET_LAYER(layer_id)                     \
@@ -305,15 +305,15 @@ static int32_t Dump(hwc2_device_t *device, uint32_t *out_size,
 
 static int32_t CreateVirtualDisplay(hwc2_device_t *device, uint32_t width,
                                     uint32_t height, int32_t * /*format*/,
-                                    hwc2_display_t *out_display_id) {
+                                    hwc2_display_t *out_display_handle) {
   ALOGV("CreateVirtualDisplay");
   LOCK_COMPOSER(device);
-  auto display_id = ihwc->CreateVirtualDisplay(width, height);
-  if (!display_id) {
+  auto display_handle = ihwc->CreateVirtualDisplay(width, height);
+  if (!display_handle) {
     return static_cast<int32_t>(HWC2::Error::Unsupported);
   }
 
-  *out_display_id = display_id.value();
+  *out_display_handle = display_handle.value();
   return 0;
 }
 
@@ -322,7 +322,7 @@ static int32_t DestroyVirtualDisplay(hwc2_device_t *device,
   ALOGV("DestroyVirtualDisplay");
   LOCK_COMPOSER(device);
   GET_DISPLAY(display);
-  if (!ihwc->DestroyVirtualDisplay(display)) {
+  if (!ihwc->DestroyVirtualDisplay(static_cast<DisplayHandle>(display))) {
     return static_cast<int32_t>(HWC2::Error::BadParameter);
   }
   return 0;
diff --git a/hwc3/CommandResultWriter.h b/hwc3/CommandResultWriter.h
index aae6817..3c0ccd7 100644
--- a/hwc3/CommandResultWriter.h
+++ b/hwc3/CommandResultWriter.h
@@ -32,11 +32,11 @@ struct DisplayChanges {
   std::optional<ChangedCompositionTypes> composition_changes;
   std::optional<DisplayRequest> display_request_changes;
 
-  void AddLayerCompositionChange(int64_t display_id, int64_t layer_id,
+  void AddLayerCompositionChange(int64_t display_handle, int64_t layer_id,
                                  Composition layer_composition) {
     if (!composition_changes) {
       composition_changes.emplace();
-      composition_changes->display = display_id;
+      composition_changes->display = display_handle;
     }
 
     ChangedCompositionLayer composition_change;
@@ -84,22 +84,23 @@ class CommandResultWriter {
     has_error_ = true;
   }
 
-  void AddPresentFence(int64_t display_id, ::android::base::unique_fd fence) {
+  void AddPresentFence(int64_t display_handle,
+                       ::android::base::unique_fd fence) {
     if (!fence.ok()) {
       return;
     }
 
     PresentFence present_fence;
     present_fence.fence = ::ndk::ScopedFileDescriptor(fence.release());
-    present_fence.display = display_id;
+    present_fence.display = display_handle;
     results_->emplace_back(std::move(present_fence));
   }
 
   void AddReleaseFence(
-      int64_t display_id,
+      int64_t display_handle,
       std::unordered_map<int64_t, ::android::base::unique_fd>& layer_fences) {
     ReleaseFences release_fences;
-    release_fences.display = display_id;
+    release_fences.display = display_handle;
     for (auto& [layer, fence] : layer_fences) {
       if (!fence.ok()) {
         continue;
@@ -124,10 +125,10 @@ class CommandResultWriter {
     }
   }
 
-  void AddPresentOrValidateResult(int64_t display_id,
+  void AddPresentOrValidateResult(int64_t display_handle,
                                   const PresentOrValidate::Result& pov_result) {
     PresentOrValidate pov_command;
-    pov_command.display = display_id;
+    pov_command.display = display_handle;
     pov_command.result = pov_result;
 
     results_->emplace_back(pov_command);
diff --git a/hwc3/ComposerClient.cpp b/hwc3/ComposerClient.cpp
index d14fd3e..82d64c6 100644
--- a/hwc3/ComposerClient.cpp
+++ b/hwc3/ComposerClient.cpp
@@ -51,6 +51,7 @@
 #include "hwc3/Utils.h"
 
 using ::android::DamageInfo;
+using ::android::DisplayHandle;
 using ::android::DstRectInfo;
 using ::android::HwcDisplay;
 using ::android::HwcDisplayConfig;
@@ -506,13 +507,13 @@ ComposerClient::~ComposerClient() {
   LOG(DEBUG) << "removed composer client";
 }
 
-ndk::ScopedAStatus ComposerClient::createLayer(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::createLayer(int64_t display_handle,
                                                int32_t /*buffer_slot_count*/,
                                                int64_t* layer_id) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
 
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -537,22 +538,22 @@ ndk::ScopedAStatus ComposerClient::createVirtualDisplay(
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
 
   // TODO: Format is currently not used in drm_hwcomposer.
-  std::optional<hwc2_display_t>
-      hwc2_display_id = hwc_->CreateVirtualDisplay(width, height);
-  if (!hwc2_display_id) {
+  std::optional<DisplayHandle>
+      display_handle = hwc_->CreateVirtualDisplay(width, height);
+  if (!display_handle) {
     return ToBinderStatus(hwc3::Error::kUnsupported);
   }
 
-  out_display->display = Hwc2DisplayToHwc3(hwc2_display_id.value());
+  out_display->display = display_handle.value();
   out_display->format = format_hint;
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::destroyLayer(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::destroyLayer(int64_t display_handle,
                                                 int64_t layer_id) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -564,26 +565,27 @@ ndk::ScopedAStatus ComposerClient::destroyLayer(int64_t display_id,
   return ToBinderStatus(hwc3::Error::kNone);
 }
 
-ndk::ScopedAStatus ComposerClient::destroyVirtualDisplay(int64_t display_id) {
+ndk::ScopedAStatus ComposerClient::destroyVirtualDisplay(
+    int64_t display_handle) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  auto* display = GetDisplay(display_id);
+  auto* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
-  if (!hwc_->DestroyVirtualDisplay(display_id)) {
+  if (!hwc_->DestroyVirtualDisplay(display_handle)) {
     return ToBinderStatus(hwc3::Error::kBadParameter);
   }
   return ndk::ScopedAStatus::ok();
 }
 
-::android::HwcDisplay* ComposerClient::GetDisplay(uint64_t display_id) {
-  return hwc_->GetDisplay(display_id);
+::android::HwcDisplay* ComposerClient::GetDisplay(int64_t display_handle) {
+  return hwc_->GetDisplay(static_cast<DisplayHandle>(display_handle));
 }
 
-void ComposerClient::DispatchLayerCommand(int64_t display_id,
+void ComposerClient::DispatchLayerCommand(int64_t display_handle,
                                           const LayerCommand& command) {
-  auto* display = GetDisplay(display_id);
+  auto* display = GetDisplay(display_handle);
   if (display == nullptr) {
     cmd_result_writer_->AddError(hwc3::Error::kBadDisplay);
     return;
@@ -696,8 +698,8 @@ void ComposerClient::DispatchLayerCommand(int64_t display_id,
 }
 
 void ComposerClient::ExecuteDisplayCommand(const DisplayCommand& command) {
-  const int64_t display_id = command.display;
-  HwcDisplay* display = hwc_->GetDisplay(display_id);
+  const int64_t display_handle = command.display;
+  HwcDisplay* display = hwc_->GetDisplay(display_handle);
   if (display == nullptr) {
     cmd_result_writer_->AddError(hwc3::Error::kBadDisplay);
     return;
@@ -752,7 +754,7 @@ void ComposerClient::ExecuteDisplayCommand(const DisplayCommand& command) {
     }
     cmd_result_writer_->AddChanges(changes);
     auto hwc3_display = DrmHwcThree::GetHwc3Display(*display);
-    hwc_->ClearMustValidateDisplay(display_id);
+    hwc_->ClearMustValidateDisplay(display_handle);
     hwc3_display->desired_present_time = AidlToPresentTimeNs(
         command.expectedPresentTime);
 
@@ -762,11 +764,11 @@ void ComposerClient::ExecuteDisplayCommand(const DisplayCommand& command) {
   if (command.presentOrValidateDisplay) {
     auto result = PresentOrValidate::Result::Validated;
     if (!display->NeedsClientLayerUpdate() && !changes.HasAnyChanges()) {
-      ALOGV("Skipping SF roundtrip for display %" PRId64, display_id);
+      ALOGV("Skipping SF roundtrip for display %" PRId64, display_handle);
       result = PresentOrValidate::Result::Presented;
       shall_present_now = true;
     }
-    cmd_result_writer_->AddPresentOrValidateResult(display_id, result);
+    cmd_result_writer_->AddPresentOrValidateResult(display_handle, result);
   }
 
   if (command.acceptDisplayChanges) {
@@ -775,7 +777,7 @@ void ComposerClient::ExecuteDisplayCommand(const DisplayCommand& command) {
 
   if (command.presentDisplay || shall_present_now) {
     auto hwc3_display = DrmHwcThree::GetHwc3Display(*display);
-    if (hwc_->GetMustValidateDisplay(display_id)) {
+    if (hwc_->GetMustValidateDisplay(display_handle)) {
       cmd_result_writer_->AddError(hwc3::Error::kNotValidated);
       return;
     }
@@ -793,13 +795,13 @@ void ComposerClient::ExecuteDisplayCommand(const DisplayCommand& command) {
 
     using ::android::base::unique_fd;
     cmd_result_writer_->AddPresentFence(  //
-        display_id, unique_fd(::android::DupFd(present_fence)));
+        display_handle, unique_fd(::android::DupFd(present_fence)));
 
     std::unordered_map<int64_t, unique_fd> hal_release_fences;
     for (const auto& [layer_id, release_fence] : release_fences) {
       hal_release_fences[layer_id] = unique_fd(::android::DupFd(release_fence));
     }
-    cmd_result_writer_->AddReleaseFence(display_id, hal_release_fences);
+    cmd_result_writer_->AddReleaseFence(display_handle, hal_release_fences);
   }
 }
 
@@ -818,11 +820,11 @@ ndk::ScopedAStatus ComposerClient::executeCommands(
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::getActiveConfig(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::getActiveConfig(int64_t display_handle,
                                                    int32_t* config_id) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -837,10 +839,10 @@ ndk::ScopedAStatus ComposerClient::getActiveConfig(int64_t display_id,
 }
 
 ndk::ScopedAStatus ComposerClient::getColorModes(
-    int64_t display_id, std::vector<AidlColorMode>* color_modes) {
+    int64_t display_handle, std::vector<AidlColorMode>* color_modes) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -867,11 +869,11 @@ ndk::ScopedAStatus ComposerClient::getDataspaceSaturationMatrix(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayAttribute(
-    int64_t display_id, int32_t config_id, DisplayAttribute attribute,
+    int64_t display_handle, int32_t config_id, DisplayAttribute attribute,
     int32_t* value) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -921,10 +923,10 @@ ndk::ScopedAStatus ComposerClient::getDisplayAttribute(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(
-    int64_t display_id, std::vector<DisplayCapability>* caps) {
+    int64_t display_handle, std::vector<DisplayCapability>* caps) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  if (GetDisplay(display_id) == nullptr) {
+  if (GetDisplay(display_handle) == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
 
@@ -937,10 +939,10 @@ ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayConfigs(
-    int64_t display_id, std::vector<int32_t>* out_configs) {
+    int64_t display_handle, std::vector<int32_t>* out_configs) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -953,10 +955,10 @@ ndk::ScopedAStatus ComposerClient::getDisplayConfigs(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayConnectionType(
-    int64_t display_id, DisplayConnectionType* type) {
+    int64_t display_handle, DisplayConnectionType* type) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -975,10 +977,10 @@ ndk::ScopedAStatus ComposerClient::getDisplayConnectionType(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayIdentificationData(
-    int64_t display_id, DisplayIdentification* id) {
+    int64_t display_handle, DisplayIdentification* id) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -991,11 +993,11 @@ ndk::ScopedAStatus ComposerClient::getDisplayIdentificationData(
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::getDisplayName(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::getDisplayName(int64_t display_handle,
                                                   std::string* name) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1005,10 +1007,10 @@ ndk::ScopedAStatus ComposerClient::getDisplayName(int64_t display_id,
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayVsyncPeriod(
-    int64_t display_id, int32_t* vsync_period) {
+    int64_t display_handle, int32_t* vsync_period) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1026,20 +1028,20 @@ ndk::ScopedAStatus ComposerClient::getDisplayVsyncPeriod(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayedContentSample(
-    int64_t /*display_id*/, int64_t /*max_frames*/, int64_t /*timestamp*/,
+    int64_t /*display_handle*/, int64_t /*max_frames*/, int64_t /*timestamp*/,
     DisplayContentSample* /*samples*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayedContentSamplingAttributes(
-    int64_t /*display_id*/, DisplayContentSamplingAttributes* /*attrs*/) {
+    int64_t /*display_handle*/, DisplayContentSamplingAttributes* /*attrs*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayPhysicalOrientation(
-    int64_t display_id, common::Transform* orientation) {
+    int64_t display_handle, common::Transform* orientation) {
   DEBUG_FUNC();
 
   if (orientation == nullptr) {
@@ -1048,7 +1050,7 @@ ndk::ScopedAStatus ComposerClient::getDisplayPhysicalOrientation(
   }
 
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1078,11 +1080,11 @@ ndk::ScopedAStatus ComposerClient::getDisplayPhysicalOrientation(
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::getHdrCapabilities(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::getHdrCapabilities(int64_t display_handle,
                                                       HdrCapabilities* caps) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1101,17 +1103,17 @@ ndk::ScopedAStatus ComposerClient::getMaxVirtualDisplayCount(int32_t* count) {
 }
 
 ndk::ScopedAStatus ComposerClient::getPerFrameMetadataKeys(
-    int64_t /*display_id*/, std::vector<PerFrameMetadataKey>* /*keys*/) {
+    int64_t /*display_handle*/, std::vector<PerFrameMetadataKey>* /*keys*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
 ndk::ScopedAStatus ComposerClient::getReadbackBufferAttributes(
-    int64_t display_id, ReadbackBufferAttributes* attrs) {
+    int64_t display_handle, ReadbackBufferAttributes* attrs) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
 
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1129,13 +1131,13 @@ ndk::ScopedAStatus ComposerClient::getReadbackBufferAttributes(
 }
 
 ndk::ScopedAStatus ComposerClient::getReadbackBufferFence(
-    int64_t display_id, ndk::ScopedFileDescriptor* acquire_fence) {
+    int64_t display_handle, ndk::ScopedFileDescriptor* acquire_fence) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
 
   *acquire_fence = ndk::ScopedFileDescriptor(-1);
 
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1143,7 +1145,7 @@ ndk::ScopedAStatus ComposerClient::getReadbackBufferFence(
   // Check if this display supports readback operations
   if (!display->IsWritebackSupported()) {
     ALOGI("ComposerClient: Display %" PRId64 " does not support readback",
-          display_id);
+          display_handle);
     return ToBinderStatus(hwc3::Error::kUnsupported);
   }
 
@@ -1163,11 +1165,11 @@ ndk::ScopedAStatus ComposerClient::getReadbackBufferFence(
 }
 
 ndk::ScopedAStatus ComposerClient::getRenderIntents(
-    int64_t display_id, AidlColorMode mode,
+    int64_t display_handle, AidlColorMode mode,
     std::vector<RenderIntent>* intents) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1184,10 +1186,10 @@ ndk::ScopedAStatus ComposerClient::getRenderIntents(
 }
 
 ndk::ScopedAStatus ComposerClient::getSupportedContentTypes(
-    int64_t display_id, std::vector<ContentType>* types) {
+    int64_t display_handle, std::vector<ContentType>* types) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1198,7 +1200,7 @@ ndk::ScopedAStatus ComposerClient::getSupportedContentTypes(
 }
 
 ndk::ScopedAStatus ComposerClient::getDisplayDecorationSupport(
-    int64_t /*display_id*/,
+    int64_t /*display_handle*/,
     std::optional<common::DisplayDecorationSupport>* /*support_struct*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
@@ -1213,7 +1215,7 @@ ndk::ScopedAStatus ComposerClient::registerCallback(
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::setActiveConfig(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setActiveConfig(int64_t display_handle,
                                                    int32_t config) {
   DEBUG_FUNC();
 
@@ -1222,17 +1224,17 @@ ndk::ScopedAStatus ComposerClient::setActiveConfig(int64_t display_id,
       .desiredTimeNanos = ::android::ResourceManager::GetTimeMonotonicNs(),
       .seamlessRequired = false,
   };
-  return setActiveConfigWithConstraints(display_id, config, constraints,
+  return setActiveConfigWithConstraints(display_handle, config, constraints,
                                         &timeline);
 }
 
 ndk::ScopedAStatus ComposerClient::setActiveConfigWithConstraints(
-    int64_t display_id, int32_t config,
+    int64_t display_handle, int32_t config,
     const VsyncPeriodChangeConstraints& constraints,
     VsyncPeriodChangeTimeline* timeline) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1294,29 +1296,29 @@ ndk::ScopedAStatus ComposerClient::setActiveConfigWithConstraints(
   }
 }
 
-ndk::ScopedAStatus ComposerClient::setBootDisplayConfig(int64_t /*display_id*/,
-                                                        int32_t /*config*/) {
+ndk::ScopedAStatus ComposerClient::setBootDisplayConfig(
+    int64_t /*display_handle*/, int32_t /*config*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
 ndk::ScopedAStatus ComposerClient::clearBootDisplayConfig(
-    int64_t /*display_id*/) {
+    int64_t /*display_handle*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
 ndk::ScopedAStatus ComposerClient::getPreferredBootDisplayConfig(
-    int64_t /*display_id*/, int32_t* /*config*/) {
+    int64_t /*display_handle*/, int32_t* /*config*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
-ndk::ScopedAStatus ComposerClient::setAutoLowLatencyMode(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setAutoLowLatencyMode(int64_t display_handle,
                                                          bool /*on*/) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1325,17 +1327,17 @@ ndk::ScopedAStatus ComposerClient::setAutoLowLatencyMode(int64_t display_id,
 }
 
 ndk::ScopedAStatus ComposerClient::setClientTargetSlotCount(
-    int64_t /*display_id*/, int32_t /*count*/) {
+    int64_t /*display_handle*/, int32_t /*count*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kNone);
 }
 
-ndk::ScopedAStatus ComposerClient::setColorMode(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setColorMode(int64_t display_handle,
                                                 AidlColorMode mode,
                                                 RenderIntent intent) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1354,11 +1356,11 @@ ndk::ScopedAStatus ComposerClient::setColorMode(int64_t display_id,
   return ToBinderStatus(hwc3::Error::kNone);
 }
 
-ndk::ScopedAStatus ComposerClient::setContentType(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setContentType(int64_t display_handle,
                                                   ContentType type) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1370,17 +1372,17 @@ ndk::ScopedAStatus ComposerClient::setContentType(int64_t display_id,
 }
 
 ndk::ScopedAStatus ComposerClient::setDisplayedContentSamplingEnabled(
-    int64_t /*display_id*/, bool /*enable*/,
+    int64_t /*display_handle*/, bool /*enable*/,
     FormatColorComponent /*componentMask*/, int64_t /*maxFrames*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
 
-ndk::ScopedAStatus ComposerClient::setPowerMode(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setPowerMode(int64_t display_handle,
                                                 PowerMode mode) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1406,12 +1408,12 @@ ndk::ScopedAStatus ComposerClient::setPowerMode(int64_t display_id,
 }
 
 ndk::ScopedAStatus ComposerClient::setReadbackBuffer(
-    int64_t display_id, const AidlNativeHandle& aidl_buffer,
+    int64_t display_handle, const AidlNativeHandle& aidl_buffer,
     const ndk::ScopedFileDescriptor& release_fence_in) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
 
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1463,11 +1465,11 @@ ndk::ScopedAStatus ComposerClient::setReadbackBuffer(
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::setVsyncEnabled(int64_t display_id,
+ndk::ScopedAStatus ComposerClient::setVsyncEnabled(int64_t display_handle,
                                                    bool enabled) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1476,8 +1478,8 @@ ndk::ScopedAStatus ComposerClient::setVsyncEnabled(int64_t display_id,
   return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus ComposerClient::setIdleTimerEnabled(int64_t /*display_id*/,
-                                                       int32_t /*timeout*/) {
+ndk::ScopedAStatus ComposerClient::setIdleTimerEnabled(
+    int64_t /*display_handle*/, int32_t /*timeout*/) {
   DEBUG_FUNC();
   return ToBinderStatus(hwc3::Error::kUnsupported);
 }
@@ -1510,11 +1512,11 @@ ndk::ScopedAStatus ComposerClient::setRefreshRateChangedCallbackDebugEnabled(
 #if __ANDROID_API__ >= 35
 
 ndk::ScopedAStatus ComposerClient::getDisplayConfigurations(
-    int64_t display_id, int32_t /*max_frame_interval_ns*/,
+    int64_t display_handle, int32_t /*max_frame_interval_ns*/,
     std::vector<DisplayConfiguration>* configurations) {
   DEBUG_FUNC();
   const std::unique_lock lock(hwc_->GetResMan().GetMainLock());
-  HwcDisplay* display = GetDisplay(display_id);
+  HwcDisplay* display = GetDisplay(display_handle);
   if (display == nullptr) {
     return ToBinderStatus(hwc3::Error::kBadDisplay);
   }
@@ -1569,8 +1571,8 @@ std::string ComposerClient::Dump() {
 }
 
 void ComposerClient::ExecuteSetDisplayClientTarget(
-    uint64_t display_id, const ClientTarget& command) {
-  auto* display = GetDisplay(display_id);
+    int64_t display_handle, const ClientTarget& command) {
+  auto* display = GetDisplay(display_handle);
   if (display == nullptr) {
     cmd_result_writer_->AddError(hwc3::Error::kBadDisplay);
     return;
@@ -1607,9 +1609,9 @@ void ComposerClient::ExecuteSetDisplayClientTarget(
   client_layer.SetLayerProperties(properties.value());
 }
 
-void ComposerClient::ExecuteSetDisplayOutputBuffer(uint64_t display_id,
+void ComposerClient::ExecuteSetDisplayOutputBuffer(int64_t display_handle,
                                                    const Buffer& buffer) {
-  auto* display = GetDisplay(display_id);
+  auto* display = GetDisplay(display_handle);
   if (display == nullptr) {
     cmd_result_writer_->AddError(hwc3::Error::kBadDisplay);
     return;
diff --git a/hwc3/ComposerClient.h b/hwc3/ComposerClient.h
index 1ddf476..350114c 100644
--- a/hwc3/ComposerClient.h
+++ b/hwc3/ComposerClient.h
@@ -168,20 +168,22 @@ class ComposerClient : public BnComposerClient {
   ::ndk::SpAIBinder createBinder() override;
 
  private:
-  hwc3::Error ImportLayerBuffer(int64_t display_id, int64_t layer_id,
+  hwc3::Error ImportLayerBuffer(int64_t display_handle, int64_t layer_id,
                                 const Buffer& buffer,
                                 ::android::HwcLayer::Buffer* out_buffer);
 
   // Layer commands
-  void DispatchLayerCommand(int64_t display_id, const LayerCommand& command);
+  void DispatchLayerCommand(int64_t display_handle,
+                            const LayerCommand& command);
 
   // Display commands
   void ExecuteDisplayCommand(const DisplayCommand& command);
-  void ExecuteSetDisplayClientTarget(uint64_t display_id,
+  void ExecuteSetDisplayClientTarget(int64_t display_handle,
                                      const ClientTarget& command);
-  void ExecuteSetDisplayOutputBuffer(uint64_t display_id, const Buffer& buffer);
+  void ExecuteSetDisplayOutputBuffer(int64_t display_handle,
+                                     const Buffer& buffer);
 
-  ::android::HwcDisplay* GetDisplay(uint64_t display_id);
+  ::android::HwcDisplay* GetDisplay(int64_t display_handle);
 
   std::unique_ptr<CommandResultWriter> cmd_result_writer_;
 
diff --git a/hwc3/DrmHwcThree.cpp b/hwc3/DrmHwcThree.cpp
index 74d3e50..660a14b 100644
--- a/hwc3/DrmHwcThree.cpp
+++ b/hwc3/DrmHwcThree.cpp
@@ -49,35 +49,38 @@ void DrmHwcThree::Init(std::shared_ptr<IComposerCallback> callback) {
 }
 
 void DrmHwcThree::SendVsyncPeriodTimingChangedEventToClient(
-    uint64_t display_id, int64_t timestamp) const {
+    ::android::DisplayHandle display_handle, int64_t timestamp) const {
   VsyncPeriodChangeTimeline timeline;
   timeline.newVsyncAppliedTimeNanos = timestamp;
   timeline.refreshRequired = false;
   timeline.refreshTimeNanos = 0;
 
   composer_callback_->onVsyncPeriodTimingChanged(static_cast<int64_t>(
-                                                     display_id),
+                                                     display_handle),
                                                  timeline);
 }
 
-void DrmHwcThree::SendRefreshEventToClient(uint64_t display_id) {
+void DrmHwcThree::SendRefreshEventToClient(
+    ::android::DisplayHandle display_handle) {
   {
     const std::scoped_lock lock(must_validate_lock_);
-    must_validate_.insert(display_id);
+    must_validate_.insert(display_handle);
   }
-  composer_callback_->onRefresh(static_cast<int64_t>(display_id));
+  composer_callback_->onRefresh(static_cast<int64_t>(display_handle));
 }
 
-void DrmHwcThree::SendVsyncEventToClient(uint64_t display_id, int64_t timestamp,
-                                         uint32_t vsync_period) const {
-  composer_callback_->onVsync(static_cast<int64_t>(display_id), timestamp,
+void DrmHwcThree::SendVsyncEventToClient(
+    ::android::DisplayHandle display_handle, int64_t timestamp,
+    uint32_t vsync_period) const {
+  composer_callback_->onVsync(static_cast<int64_t>(display_handle), timestamp,
                               static_cast<int32_t>(vsync_period));
 }
 
 #if __ANDROID_API__ >= 35
 
 void DrmHwcThree::SendHotplugEventToClient(
-    hwc2_display_t display_id, DrmHwc::DisplayStatus display_status) {
+    ::android::DisplayHandle display_handle,
+    DrmHwc::DisplayStatus display_status) {
   common::DisplayHotplugEvent event = common::DisplayHotplugEvent::DISCONNECTED;
   switch (display_status) {
     case DrmHwc::kDisconnected:
@@ -91,32 +94,37 @@ void DrmHwcThree::SendHotplugEventToClient(
       break;
   }
   if (event == common::DisplayHotplugEvent::DISCONNECTED) {
-    ClearMustValidateDisplay(display_id);
+    ClearMustValidateDisplay(display_handle);
   }
-  composer_callback_->onHotplugEvent(static_cast<int64_t>(display_id), event);
+  composer_callback_->onHotplugEvent(static_cast<int64_t>(display_handle),
+                                     event);
 }
 
 #else
 
 void DrmHwcThree::SendHotplugEventToClient(
-    hwc2_display_t display_id, DrmHwc::DisplayStatus display_status) {
+    ::android::DisplayHandle display_handle,
+    DrmHwc::DisplayStatus display_status) {
   bool connected = display_status != DrmHwc::kDisconnected;
   if (!connected) {
-    ClearMustValidateDisplay(display_id);
+    ClearMustValidateDisplay(display_handle);
   }
-  composer_callback_->onHotplug(static_cast<int64_t>(display_id), connected);
+  composer_callback_->onHotplug(static_cast<int64_t>(display_handle),
+                                connected);
 }
 
 #endif
 
-auto DrmHwcThree::GetMustValidateDisplay(uint64_t display_id) -> bool {
+auto DrmHwcThree::GetMustValidateDisplay(
+    ::android::DisplayHandle display_handle) -> bool {
   std::scoped_lock lock(must_validate_lock_);
-  return must_validate_.find(display_id) != must_validate_.end();
+  return must_validate_.find(display_handle) != must_validate_.end();
 }
 
-void DrmHwcThree::ClearMustValidateDisplay(uint64_t display_id) {
+void DrmHwcThree::ClearMustValidateDisplay(
+    ::android::DisplayHandle display_handle) {
   std::scoped_lock lock(must_validate_lock_);
-  must_validate_.erase(display_id);
+  must_validate_.erase(display_handle);
 }
 
 }  // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/hwc3/DrmHwcThree.h b/hwc3/DrmHwcThree.h
index bc263c2..22d8747 100644
--- a/hwc3/DrmHwcThree.h
+++ b/hwc3/DrmHwcThree.h
@@ -41,24 +41,28 @@ class DrmHwcThree : public ::android::DrmHwc {
   void Init(std::shared_ptr<IComposerCallback> callback);
 
   // DrmHwcInterface
-  void SendVsyncEventToClient(hwc2_display_t display_id, int64_t timestamp,
+  void SendVsyncEventToClient(::android::DisplayHandle display_handle,
+                              int64_t timestamp,
                               uint32_t vsync_period) const override;
   void SendVsyncPeriodTimingChangedEventToClient(
-      hwc2_display_t display_id, int64_t timestamp) const override;
-  void SendRefreshEventToClient(uint64_t display_id) override;
-  void SendHotplugEventToClient(hwc2_display_t display_id,
+      ::android::DisplayHandle display_handle,
+      int64_t timestamp) const override;
+  void SendRefreshEventToClient(
+      ::android::DisplayHandle display_handle) override;
+  void SendHotplugEventToClient(::android::DisplayHandle display_handle,
                                 DrmHwc::DisplayStatus display_status) override;
 
   static auto GetHwc3Display(::android::HwcDisplay& display)
       -> std::shared_ptr<Hwc3Display>;
 
-  auto GetMustValidateDisplay(uint64_t display_id) -> bool;
-  void ClearMustValidateDisplay(uint64_t display_id);
+  auto GetMustValidateDisplay(::android::DisplayHandle display_handle) -> bool;
+  void ClearMustValidateDisplay(::android::DisplayHandle display_handle);
 
  private:
   std::shared_ptr<IComposerCallback> composer_callback_;
 
   std::mutex must_validate_lock_;
-  std::set<uint64_t> must_validate_ GUARDED_BY(must_validate_lock_);
+  std::set<::android::DisplayHandle> must_validate_
+      GUARDED_BY(must_validate_lock_);
 };
 }  // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/stats/CompositionStats.cpp b/stats/CompositionStats.cpp
index 5e921b0..e964558 100644
--- a/stats/CompositionStats.cpp
+++ b/stats/CompositionStats.cpp
@@ -32,9 +32,9 @@ CompositionStats operator-(const CompositionStats& a,
 
 void CompositionStatsTracker::ReportStats(const Callback& callback) {
   auto new_stats = provider_->PullCompositionStats();
-  for (auto& [display_id, cumulative_stats] : new_stats) {
-    auto delta = cumulative_stats - previous_stats_[display_id];
-    callback(display_id, cumulative_stats, delta);
+  for (auto& [display_handle, cumulative_stats] : new_stats) {
+    auto delta = cumulative_stats - previous_stats_[display_handle];
+    callback(display_handle, cumulative_stats, delta);
   }
   previous_stats_ = new_stats;
 }
diff --git a/stats/CompositionStats.h b/stats/CompositionStats.h
index 44d9877..aa65c91 100644
--- a/stats/CompositionStats.h
+++ b/stats/CompositionStats.h
@@ -54,7 +54,7 @@ class CompositionStatsProvider {
 class CompositionStatsTracker {
  public:
   // Arguments are the display ID, the cumulative stats, and the stats delta.
-  using Callback = std::function<void(int64_t display_id,
+  using Callback = std::function<void(int64_t display_handle,
                                       const CompositionStats& cumulative,
                                       const CompositionStats& delta)>;
   explicit CompositionStatsTracker(CompositionStatsProvider* provider)
diff --git a/stats/CompositionStatsTest.cpp b/stats/CompositionStatsTest.cpp
index ffa8030..6ee2caf 100644
--- a/stats/CompositionStatsTest.cpp
+++ b/stats/CompositionStatsTest.cpp
@@ -106,10 +106,10 @@ class CompositionStatsTrackerTest : public ::testing::Test {
 
 // Initial call to ReportStats reports the same stats for cumulative and delta.
 TEST_F(CompositionStatsTrackerTest, ReportStatsInitialCall) {
-  const int64_t display_id = 1;
+  const int64_t display_handle = 1;
   CompositionStats current_stats = CreateStats(100);
   std::map<int64_t, CompositionStats> provider_result = {
-      {display_id, current_stats}};
+      {display_handle, current_stats}};
 
   StrictMock<MockStatsCallback> mock_callback;
 
@@ -118,16 +118,17 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsInitialCall) {
 
   // Expect that delta is same as cumulative.
   EXPECT_CALL(mock_callback,
-              Invoke(Eq(display_id), Eq(current_stats), Eq(current_stats)));
+              Invoke(Eq(display_handle), Eq(current_stats), Eq(current_stats)));
 
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }
 
 // Subsequent calls to ReportStats with no change in cumulative stats.
 TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallNoChange) {
-  const int64_t display_id = 1;
+  const int64_t display_handle = 1;
   CompositionStats stats = CreateStats(100);
-  std::map<int64_t, CompositionStats> provider_result = {{display_id, stats}};
+  std::map<int64_t, CompositionStats> provider_result = {
+      {display_handle, stats}};
   CompositionStats zero_delta = {};
 
   // Same provider result for both calls.
@@ -137,21 +138,24 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallNoChange) {
   StrictMock<MockStatsCallback> mock_callback;
 
   // Initial call.
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats), Eq(stats)));
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle), Eq(stats), Eq(stats)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 
   // Second call. Delta should be zero.
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats), Eq(zero_delta)));
+  EXPECT_CALL(mock_callback,
+              Invoke(Eq(display_handle), Eq(stats), Eq(zero_delta)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }
 
 // Test that the delta is reported as expected.
 TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallWithChange) {
-  const int64_t display_id = 1;
+  const int64_t display_handle = 1;
   CompositionStats stats1 = CreateStats(100);
   CompositionStats stats2 = CreateStats(150);
-  std::map<int64_t, CompositionStats> provider_result1 = {{display_id, stats1}};
-  std::map<int64_t, CompositionStats> provider_result2 = {{display_id, stats2}};
+  std::map<int64_t, CompositionStats> provider_result1 = {
+      {display_handle, stats1}};
+  std::map<int64_t, CompositionStats> provider_result2 = {
+      {display_handle, stats2}};
   CompositionStats expected_delta = stats2 - stats1;
 
   StrictMock<MockStatsCallback> mock_callback;
@@ -159,30 +163,31 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallWithChange) {
   // First call with the initial stats.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result1));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats1), Eq(stats1)));
+  EXPECT_CALL(mock_callback,
+              Invoke(Eq(display_handle), Eq(stats1), Eq(stats1)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 
   // Second call with updated stats and non-trivial delta.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result2));
   EXPECT_CALL(mock_callback,
-              Invoke(Eq(display_id), Eq(stats2), Eq(expected_delta)));
+              Invoke(Eq(display_handle), Eq(stats2), Eq(expected_delta)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }
 
 // Test that stats for multiple displays are reported correctly.
 TEST_F(CompositionStatsTrackerTest, ReportStatsMultipleDisplays) {
-  const int64_t display_id1 = 10;
-  const int64_t display_id2 = 20;
+  const int64_t display_handle1 = 10;
+  const int64_t display_handle2 = 20;
   CompositionStats display1_stats1 = CreateStats(100);
   CompositionStats display2_stats1 = CreateStats(200);
   CompositionStats display1_stats2 = CreateStats(110);
   CompositionStats display2_stats2 = CreateStats(250);
 
   std::map<int64_t, CompositionStats> provider_result1 =
-      {{display_id1, display1_stats1}, {display_id2, display2_stats1}};
+      {{display_handle1, display1_stats1}, {display_handle2, display2_stats1}};
   std::map<int64_t, CompositionStats> provider_result2 =
-      {{display_id1, display1_stats2}, {display_id2, display2_stats2}};
+      {{display_handle1, display1_stats2}, {display_handle2, display2_stats2}};
 
   CompositionStats display1_expected_delta1 = display1_stats1;
   CompositionStats display1_expected_delta2 = display1_stats2 - display1_stats1;
@@ -194,18 +199,18 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsMultipleDisplays) {
   // Initial call. Ordering between displays doesn't matter.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result1));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
                                     Eq(display1_expected_delta1)));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats1),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats1),
                                     Eq(display2_expected_delta1)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 
   // Updated call. Ordering between displays doesn't matter.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result2));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
                                     Eq(display1_expected_delta2)));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats2),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats2),
                                     Eq(display2_expected_delta2)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }
@@ -223,16 +228,16 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsEmptyResult) {
 
 // Display added in between calls to ReportStats.
 TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayAdded) {
-  const int64_t display_id1 = 10;
-  const int64_t display_id2 = 20;
+  const int64_t display_handle1 = 10;
+  const int64_t display_handle2 = 20;
   const CompositionStats display1_stats1 = CreateStats(100);
   const CompositionStats display1_stats2 = CreateStats(110);
   const CompositionStats display2_stats = CreateStats(50);
 
   std::map<int64_t, CompositionStats> provider_result1 = {
-      {display_id1, display1_stats1}};
+      {display_handle1, display1_stats1}};
   std::map<int64_t, CompositionStats> provider_result2 =
-      {{display_id1, display1_stats2}, {display_id2, display2_stats}};
+      {{display_handle1, display1_stats2}, {display_handle2, display2_stats}};
 
   const CompositionStats display1_expected_delta1 = display1_stats1;
   const CompositionStats display1_expected_delta2 = display1_stats2 -
@@ -244,32 +249,32 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayAdded) {
   // First call only contains display 1.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result1));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
                                     Eq(display1_expected_delta1)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 
   // Second call has both displays.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result2));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
                                     Eq(display1_expected_delta2)));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats),
                                     Eq(display2_expected_delta)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }
 
 // Display removed in between calls to ReportStats.
 TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayRemoved) {
-  const int64_t display_id1 = 10;
-  const int64_t display_id2 = 20;
+  const int64_t display_handle1 = 10;
+  const int64_t display_handle2 = 20;
   const CompositionStats display1_stats1 = CreateStats(100);
   const CompositionStats display2_stats = CreateStats(200);
   const CompositionStats display1_stats2 = CreateStats(110);
 
   std::map<int64_t, CompositionStats> provider_result1 =
-      {{display_id1, display1_stats1}, {display_id2, display2_stats}};
+      {{display_handle1, display1_stats1}, {display_handle2, display2_stats}};
   std::map<int64_t, CompositionStats> provider_result2 = {
-      {display_id1, display1_stats2}};
+      {display_handle1, display1_stats2}};
 
   const CompositionStats display1_expected_delta1 = display1_stats1;
   const CompositionStats display2_expected_delta = display2_stats;
@@ -281,17 +286,17 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayRemoved) {
   // Initial call has both displays.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result1));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
                                     Eq(display1_expected_delta1)));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats),
                                     Eq(display2_expected_delta)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 
   // Second call has only display 1. StrictMock will fail if Invoke is called
-  // for display_id2.
+  // for display_handle2.
   EXPECT_CALL(*mock_provider_, PullCompositionStats())
       .WillOnce(Return(provider_result2));
-  EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
+  EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
                                     Eq(display1_expected_delta2)));
   tracker_->ReportStats(mock_callback.AsStdFunction());
 }