drm_hwcomposer: Tidy-up DrmConnector class

Implement DrmConnector instantiation through CreateInstance() static method,
which helps to reduce complexity of DrmDevice::Init() function.

Move Connector-to-CRTC binding information to the DrmDevice class.

Move drm/DrmConnector.h to Normal clang-tidy checks list by fixing
clang-tidy findings.

Signed-off-by: Roman Stratiienko <roman.o.stratiienko@globallogic.com>

12 files changed, 224 insertions, 272 deletions

diff --git a/.ci/Makefile b/.ci/Makefile
index e8704da..d138968 100644
--- a/.ci/Makefile
+++ b/.ci/Makefile
@@ -28,9 +28,7 @@ TIDY_FILES_OVERRIDE := \
     drm/DrmMode.h:COARSE                                \
     drm/DrmDevice.h:COARSE                              \
     drm/DrmProperty.h:COARSE                            \
-    drm/DrmConnector.h:COARSE                           \
     drm/DrmUnique.h:FINE                                \
-    drm/DrmConnector.cpp:COARSE                         \
     drm/DrmDevice.cpp:COARSE                            \
     drm/DrmProperty.cpp:COARSE                          \
     drm/UEventListener.cpp:COARSE                       \
diff --git a/backend/BackendManager.cpp b/backend/BackendManager.cpp
index aadef36..4a735eb 100644
--- a/backend/BackendManager.cpp
+++ b/backend/BackendManager.cpp
@@ -51,13 +51,13 @@ int BackendManager::SetBackendForDisplay(HwcDisplay *display) {
   display->set_backend(GetBackendByName(backend_name));
   if (display->backend() == nullptr) {
     ALOGE("Failed to set backend '%s' for '%s' and driver '%s'",
-          backend_name.c_str(), display->connector()->name().c_str(),
+          backend_name.c_str(), display->connector()->GetName().c_str(),
           driver_name.c_str());
     return -EINVAL;
   }
 
   ALOGI("Backend '%s' for '%s' and driver '%s' was successfully set",
-        backend_name.c_str(), display->connector()->name().c_str(),
+        backend_name.c_str(), display->connector()->GetName().c_str(),
         driver_name.c_str());
 
   return 0;
diff --git a/compositor/DrmDisplayCompositor.cpp b/compositor/DrmDisplayCompositor.cpp
index 0cb1d39..c2db7fc 100644
--- a/compositor/DrmDisplayCompositor.cpp
+++ b/compositor/DrmDisplayCompositor.cpp
@@ -107,7 +107,7 @@ auto DrmDisplayCompositor::CommitFrame(AtomicCommitArgs &args) -> int {
   if (args.active) {
     new_frame_state.crtc_active_state = *args.active;
     if (!crtc->GetActiveProperty().AtomicSet(*pset, *args.active) ||
-        !connector->crtc_id_property().AtomicSet(*pset, crtc->GetId())) {
+        !connector->GetCrtcIdProperty().AtomicSet(*pset, crtc->GetId())) {
       return -EINVAL;
     }
   }
@@ -189,7 +189,7 @@ auto DrmDisplayCompositor::CommitFrame(AtomicCommitArgs &args) -> int {
     if (args.display_mode) {
       /* TODO(nobody): we still need this for synthetic vsync, remove after
        * vsync reworked */
-      connector->set_active_mode(*args.display_mode);
+      connector->SetActiveMode(*args.display_mode);
     }
 
     active_frame_state_ = std::move(new_frame_state);
@@ -229,9 +229,9 @@ auto DrmDisplayCompositor::ActivateDisplayUsingDPMS() -> int {
     return -ENODEV;
   }
 
-  if (connector->dpms_property()) {
-    drmModeConnectorSetProperty(drm->fd(), connector->id(),
-                                connector->dpms_property().id(),
+  if (connector->GetDpmsProperty()) {
+    drmModeConnectorSetProperty(drm->fd(), connector->GetId(),
+                                connector->GetDpmsProperty().id(),
                                 DRM_MODE_DPMS_ON);
   }
   return 0;
diff --git a/drm/DrmConnector.cpp b/drm/DrmConnector.cpp
index 7cbec95..5e00dd6 100644
--- a/drm/DrmConnector.cpp
+++ b/drm/DrmConnector.cpp
@@ -29,10 +29,12 @@
 #include "utils/log.h"
 
 #ifndef DRM_MODE_CONNECTOR_SPI
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define DRM_MODE_CONNECTOR_SPI 19
 #endif
 
 #ifndef DRM_MODE_CONNECTOR_USB
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
 #define DRM_MODE_CONNECTOR_USB 20
 #endif
 
@@ -40,62 +42,60 @@ namespace android {
 
 constexpr size_t kTypesCount = 21;
 
-DrmConnector::DrmConnector(DrmDevice *drm, drmModeConnectorPtr c,
-                           DrmEncoder *current_encoder,
-                           std::vector<DrmEncoder *> &possible_encoders)
-    : drm_(drm),
-      id_(c->connector_id),
-      encoder_(current_encoder),
-      display_(-1),
-      type_(c->connector_type),
-      type_id_(c->connector_type_id),
-      state_(c->connection),
-      mm_width_(c->mmWidth),
-      mm_height_(c->mmHeight),
-      possible_encoders_(possible_encoders) {
+static bool GetOptionalConnectorProperty(const DrmDevice &dev,
+                                         const DrmConnector &connector,
+                                         const char *prop_name,
+                                         DrmProperty *property) {
+  return dev.GetProperty(connector.GetId(), DRM_MODE_OBJECT_CONNECTOR,
+                         prop_name, property) == 0;
 }
 
-int DrmConnector::Init() {
-  int ret = drm_->GetConnectorProperty(*this, "DPMS", &dpms_property_);
-  if (ret) {
-    ALOGE("Could not get DPMS property\n");
-    return ret;
+static bool GetConnectorProperty(const DrmDevice &dev,
+                                 const DrmConnector &connector,
+                                 const char *prop_name, DrmProperty *property) {
+  if (!GetOptionalConnectorProperty(dev, connector, prop_name, property)) {
+    ALOGE("Could not get %s property\n", prop_name);
+    return false;
   }
-  ret = drm_->GetConnectorProperty(*this, "CRTC_ID", &crtc_id_property_);
-  if (ret) {
-    ALOGE("Could not get CRTC_ID property\n");
-    return ret;
+  return true;
+}
+
+auto DrmConnector::CreateInstance(DrmDevice &dev, uint32_t connector_id,
+                                  uint32_t index)
+    -> std::unique_ptr<DrmConnector> {
+  auto conn = MakeDrmModeConnectorUnique(dev.fd(), connector_id);
+  if (!conn) {
+    ALOGE("Failed to get connector %d", connector_id);
+    return {};
   }
-  UpdateEdidProperty();
-  if (writeback()) {
-    ret = drm_->GetConnectorProperty(*this, "WRITEBACK_PIXEL_FORMATS",
-                                     &writeback_pixel_formats_);
-    if (ret) {
-      ALOGE("Could not get WRITEBACK_PIXEL_FORMATS connector_id = %d\n", id_);
-      return ret;
-    }
-    ret = drm_->GetConnectorProperty(*this, "WRITEBACK_FB_ID",
-                                     &writeback_fb_id_);
-    if (ret) {
-      ALOGE("Could not get WRITEBACK_FB_ID connector_id = %d\n", id_);
-      return ret;
-    }
-    ret = drm_->GetConnectorProperty(*this, "WRITEBACK_OUT_FENCE_PTR",
-                                     &writeback_out_fence_);
-    if (ret) {
-      ALOGE("Could not get WRITEBACK_OUT_FENCE_PTR connector_id = %d\n", id_);
-      return ret;
-    }
+
+  auto c = std::unique_ptr<DrmConnector>(
+      new DrmConnector(std::move(conn), &dev, index));
+
+  if (!GetConnectorProperty(dev, *c, "DPMS", &c->dpms_property_) ||
+      !GetConnectorProperty(dev, *c, "CRTC_ID", &c->crtc_id_property_)) {
+    return {};
   }
-  return 0;
+
+  c->UpdateEdidProperty();
+
+  if (c->IsWriteback() &&
+      (!GetConnectorProperty(dev, *c, "WRITEBACK_PIXEL_FORMATS",
+                             &c->writeback_pixel_formats_) ||
+       !GetConnectorProperty(dev, *c, "WRITEBACK_FB_ID",
+                             &c->writeback_fb_id_) ||
+       !GetConnectorProperty(dev, *c, "WRITEBACK_OUT_FENCE_PTR",
+                             &c->writeback_out_fence_))) {
+    return {};
+  }
+
+  return c;
 }
 
 int DrmConnector::UpdateEdidProperty() {
-  int ret = drm_->GetConnectorProperty(*this, "EDID", &edid_property_);
-  if (ret) {
-    ALOGW("Could not get EDID property\n");
-  }
-  return ret;
+  return GetOptionalConnectorProperty(*drm_, *this, "EDID", &edid_property_)
+             ? 0
+             : -EINVAL;
 }
 
 auto DrmConnector::GetEdidBlob() -> DrmModePropertyBlobUnique {
@@ -105,7 +105,7 @@ auto DrmConnector::GetEdidBlob() -> DrmModePropertyBlobUnique {
     return {};
   }
 
-  std::tie(ret, blob_id) = edid_property().value();
+  std::tie(ret, blob_id) = GetEdidProperty().value();
   if (ret != 0) {
     return {};
   }
@@ -113,137 +113,79 @@ auto DrmConnector::GetEdidBlob() -> DrmModePropertyBlobUnique {
   return MakeDrmModePropertyBlobUnique(drm_->fd(), blob_id);
 }
 
-uint32_t DrmConnector::id() const {
-  return id_;
-}
-
-int DrmConnector::display() const {
-  return display_;
+bool DrmConnector::IsInternal() const {
+  auto type = connector_->connector_type;
+  return type == DRM_MODE_CONNECTOR_LVDS || type == DRM_MODE_CONNECTOR_eDP ||
+         type == DRM_MODE_CONNECTOR_DSI || type == DRM_MODE_CONNECTOR_VIRTUAL ||
+         type == DRM_MODE_CONNECTOR_DPI || type == DRM_MODE_CONNECTOR_SPI;
 }
 
-void DrmConnector::set_display(int display) {
-  display_ = display;
+bool DrmConnector::IsExternal() const {
+  auto type = connector_->connector_type;
+  return type == DRM_MODE_CONNECTOR_HDMIA ||
+         type == DRM_MODE_CONNECTOR_DisplayPort ||
+         type == DRM_MODE_CONNECTOR_DVID || type == DRM_MODE_CONNECTOR_DVII ||
+         type == DRM_MODE_CONNECTOR_VGA || type == DRM_MODE_CONNECTOR_USB;
 }
 
-bool DrmConnector::internal() const {
-  return type_ == DRM_MODE_CONNECTOR_LVDS || type_ == DRM_MODE_CONNECTOR_eDP ||
-         type_ == DRM_MODE_CONNECTOR_DSI ||
-         type_ == DRM_MODE_CONNECTOR_VIRTUAL ||
-         type_ == DRM_MODE_CONNECTOR_DPI || type_ == DRM_MODE_CONNECTOR_SPI;
-}
-
-bool DrmConnector::external() const {
-  return type_ == DRM_MODE_CONNECTOR_HDMIA ||
-         type_ == DRM_MODE_CONNECTOR_DisplayPort ||
-         type_ == DRM_MODE_CONNECTOR_DVID || type_ == DRM_MODE_CONNECTOR_DVII ||
-         type_ == DRM_MODE_CONNECTOR_VGA || type_ == DRM_MODE_CONNECTOR_USB;
-}
-
-bool DrmConnector::writeback() const {
+bool DrmConnector::IsWriteback() const {
 #ifdef DRM_MODE_CONNECTOR_WRITEBACK
-  return type_ == DRM_MODE_CONNECTOR_WRITEBACK;
+  return connector_->connector_type == DRM_MODE_CONNECTOR_WRITEBACK;
 #else
   return false;
 #endif
 }
 
-bool DrmConnector::valid_type() const {
-  return internal() || external() || writeback();
+bool DrmConnector::IsValid() const {
+  return IsInternal() || IsExternal() || IsWriteback();
 }
 
-std::string DrmConnector::name() const {
+std::string DrmConnector::GetName() const {
   constexpr std::array<const char *, kTypesCount> kNames =
       {"None",      "VGA",  "DVI-I",     "DVI-D",   "DVI-A", "Composite",
        "SVIDEO",    "LVDS", "Component", "DIN",     "DP",    "HDMI-A",
        "HDMI-B",    "TV",   "eDP",       "Virtual", "DSI",   "DPI",
        "Writeback", "SPI",  "USB"};
 
-  if (type_ < kTypesCount) {
+  if (connector_->connector_type < kTypesCount) {
     std::ostringstream name_buf;
-    name_buf << kNames[type_] << "-" << type_id_;
+    name_buf << kNames[connector_->connector_type] << "-"
+             << connector_->connector_type_id;
     return name_buf.str();
   }
 
-  ALOGE("Unknown type in connector %d, could not make his name", id_);
+  ALOGE("Unknown type in connector %d, could not make his name", GetId());
   return "None";
 }
 
 int DrmConnector::UpdateModes() {
-  drmModeConnectorPtr c = drmModeGetConnector(drm_->fd(), id_);
-  if (!c) {
-    ALOGE("Failed to get connector %d", id_);
+  auto conn = MakeDrmModeConnectorUnique(drm_->fd(), GetId());
+  if (!conn) {
+    ALOGE("Failed to get connector %d", GetId());
     return -ENODEV;
   }
-
-  state_ = c->connection;
+  connector_ = std::move(conn);
 
   modes_.clear();
-  for (int i = 0; i < c->count_modes; ++i) {
+  for (int i = 0; i < connector_->count_modes; ++i) {
     bool exists = false;
     for (const DrmMode &mode : modes_) {
-      if (mode == c->modes[i]) {
+      if (mode == connector_->modes[i]) {
         exists = true;
         break;
       }
     }
 
     if (!exists) {
-      modes_.emplace_back(DrmMode(&c->modes[i]));
+      modes_.emplace_back(DrmMode(&connector_->modes[i]));
     }
   }
 
   return 0;
 }
 
-const DrmMode &DrmConnector::active_mode() const {
-  return active_mode_;
-}
-
-void DrmConnector::set_active_mode(const DrmMode &mode) {
+void DrmConnector::SetActiveMode(DrmMode &mode) {
   active_mode_ = mode;
 }
 
-const DrmProperty &DrmConnector::dpms_property() const {
-  return dpms_property_;
-}
-
-const DrmProperty &DrmConnector::crtc_id_property() const {
-  return crtc_id_property_;
-}
-
-const DrmProperty &DrmConnector::edid_property() const {
-  return edid_property_;
-}
-
-const DrmProperty &DrmConnector::writeback_pixel_formats() const {
-  return writeback_pixel_formats_;
-}
-
-const DrmProperty &DrmConnector::writeback_fb_id() const {
-  return writeback_fb_id_;
-}
-
-const DrmProperty &DrmConnector::writeback_out_fence() const {
-  return writeback_out_fence_;
-}
-
-DrmEncoder *DrmConnector::encoder() const {
-  return encoder_;
-}
-
-void DrmConnector::set_encoder(DrmEncoder *encoder) {
-  encoder_ = encoder;
-}
-
-drmModeConnection DrmConnector::state() const {
-  return state_;
-}
-
-uint32_t DrmConnector::mm_width() const {
-  return mm_width_;
-}
-
-uint32_t DrmConnector::mm_height() const {
-  return mm_height_;
-}
 }  // namespace android
diff --git a/drm/DrmConnector.h b/drm/DrmConnector.h
index 2bcb543..5f8ba88 100644
--- a/drm/DrmConnector.h
+++ b/drm/DrmConnector.h
@@ -34,67 +34,95 @@ class DrmDevice;
 
 class DrmConnector {
  public:
-  DrmConnector(DrmDevice *drm, drmModeConnectorPtr c,
-               DrmEncoder *current_encoder,
-               std::vector<DrmEncoder *> &possible_encoders);
+  static auto CreateInstance(DrmDevice &dev, uint32_t connector_id,
+                             uint32_t index) -> std::unique_ptr<DrmConnector>;
+
   DrmConnector(const DrmProperty &) = delete;
   DrmConnector &operator=(const DrmProperty &) = delete;
 
-  int Init();
   int UpdateEdidProperty();
   auto GetEdidBlob() -> DrmModePropertyBlobUnique;
 
-  uint32_t id() const;
+  auto GetDev() const -> DrmDevice & {
+    return *drm_;
+  }
+
+  auto GetId() const {
+    return connector_->connector_id;
+  }
+
+  auto GetIndexInResArray() const {
+    return index_in_res_array_;
+  }
+
+  auto GetCurrentEncoderId() const {
+    return connector_->encoder_id;
+  }
+
+  auto SupportsEncoder(DrmEncoder &enc) const {
+    for (int i = 0; i < connector_->count_encoders; i++) {
+      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+      if (connector_->encoders[i] == enc.GetId()) {
+        return true;
+      }
+    }
 
-  int display() const;
-  void set_display(int display);
+    return false;
+  }
 
-  bool internal() const;
-  bool external() const;
-  bool writeback() const;
-  bool valid_type() const;
+  bool IsInternal() const;
+  bool IsExternal() const;
+  bool IsWriteback() const;
+  bool IsValid() const;
 
-  std::string name() const;
+  std::string GetName() const;
 
   int UpdateModes();
 
-  const std::vector<DrmMode> &modes() const {
+  auto &GetModes() const {
     return modes_;
   }
-  const DrmMode &active_mode() const;
-  void set_active_mode(const DrmMode &mode);
-
-  const DrmProperty &dpms_property() const;
-  const DrmProperty &crtc_id_property() const;
-  const DrmProperty &edid_property() const;
-  const DrmProperty &writeback_pixel_formats() const;
-  const DrmProperty &writeback_fb_id() const;
-  const DrmProperty &writeback_out_fence() const;
-
-  const std::vector<DrmEncoder *> &possible_encoders() const {
-    return possible_encoders_;
+
+  auto &GetActiveMode() const {
+    return active_mode_;
   }
-  DrmEncoder *encoder() const;
-  void set_encoder(DrmEncoder *encoder);
 
-  drmModeConnection state() const;
+  void SetActiveMode(DrmMode &mode);
 
-  uint32_t mm_width() const;
-  uint32_t mm_height() const;
+  auto &GetDpmsProperty() const {
+    return dpms_property_;
+  }
 
- private:
-  DrmDevice *drm_;
+  auto &GetCrtcIdProperty() const {
+    return crtc_id_property_;
+  }
+
+  auto &GetEdidProperty() const {
+    return edid_property_;
+  }
 
-  uint32_t id_;
-  DrmEncoder *encoder_;
-  int display_;
+  auto IsConnected() const {
+    return connector_->connection == DRM_MODE_CONNECTED;
+  }
 
-  uint32_t type_;
-  uint32_t type_id_;
-  drmModeConnection state_;
+  auto GetMmWidth() const {
+    return connector_->mmWidth;
+  }
 
-  uint32_t mm_width_;
-  uint32_t mm_height_;
+  auto GetMmHeight() const {
+    return connector_->mmHeight;
+  };
+
+ private:
+  DrmConnector(DrmModeConnectorUnique connector, DrmDevice *drm, uint32_t index)
+      : connector_(std::move(connector)),
+        drm_(drm),
+        index_in_res_array_(index){};
+
+  DrmModeConnectorUnique connector_;
+  DrmDevice *const drm_;
+
+  const uint32_t index_in_res_array_;
 
   DrmMode active_mode_;
   std::vector<DrmMode> modes_;
@@ -105,8 +133,6 @@ class DrmConnector {
   DrmProperty writeback_pixel_formats_;
   DrmProperty writeback_fb_id_;
   DrmProperty writeback_out_fence_;
-
-  std::vector<DrmEncoder *> possible_encoders_;
 };
 }  // namespace android
 
diff --git a/drm/DrmDevice.cpp b/drm/DrmDevice.cpp
index f5e3521..a6d2289 100644
--- a/drm/DrmDevice.cpp
+++ b/drm/DrmDevice.cpp
@@ -111,47 +111,28 @@ std::tuple<int, int> DrmDevice::Init(const char *path, int num_displays) {
     }
   }
 
-  for (int i = 0; !ret && i < res->count_connectors; ++i) {
-    auto c = MakeDrmModeConnectorUnique(fd(), res->connectors[i]);
-    if (!c) {
-      ALOGE("Failed to get connector %d", res->connectors[i]);
-      ret = -ENODEV;
-      break;
-    }
-
-    std::vector<DrmEncoder *> possible_encoders;
-    DrmEncoder *current_encoder = nullptr;
-    for (int j = 0; j < c->count_encoders; ++j) {
-      for (auto &encoder : encoders_) {
-        if (encoder->GetId() == c->encoders[j])
-          possible_encoders.push_back(encoder.get());
-        if (encoder->GetId() == c->encoder_id)
-          current_encoder = encoder.get();
-      }
-    }
-
-    std::unique_ptr<DrmConnector> conn(
-        new DrmConnector(this, c.get(), current_encoder, possible_encoders));
+  for (int i = 0; i < res->count_connectors; ++i) {
+    // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+    auto conn = DrmConnector::CreateInstance(*this, res->connectors[i], i);
 
-    ret = conn->Init();
-    if (ret) {
-      ALOGE("Init connector %d failed", res->connectors[i]);
-      break;
+    if (!conn) {
+      continue;
     }
 
-    if (conn->writeback())
+    if (conn->IsWriteback()) {
       writeback_connectors_.emplace_back(std::move(conn));
-    else
+    } else {
       connectors_.emplace_back(std::move(conn));
+    }
   }
 
   auto add_displays = [this, &num_displays](bool internal, bool connected) {
     for (auto &conn : connectors_) {
-      bool is_connected = conn->state() == DRM_MODE_CONNECTED;
-      if ((internal ? conn->internal() : conn->external()) &&
+      bool is_connected = conn->IsConnected();
+      if ((internal ? conn->IsInternal() : conn->IsExternal()) &&
           (connected ? is_connected : !is_connected)) {
-        conn->set_display(num_displays);
-        displays_[num_displays] = num_displays;
+        bound_connectors_[num_displays] = conn.get();
+        connectors_to_display_id_[conn.get()] = num_displays;
         ++num_displays;
       }
     }
@@ -187,23 +168,19 @@ std::tuple<int, int> DrmDevice::Init(const char *path, int num_displays) {
   for (auto &conn : connectors_) {
     ret = CreateDisplayPipe(conn.get());
     if (ret) {
-      ALOGE("Failed CreateDisplayPipe %d with %d", conn->id(), ret);
+      ALOGE("Failed CreateDisplayPipe %d with %d", conn->GetId(), ret);
       return std::make_tuple(ret, 0);
     }
   }
-  return std::make_tuple(ret, displays_.size());
+  return std::make_tuple(ret, bound_connectors_.size());
 }
 
 bool DrmDevice::HandlesDisplay(int display) const {
-  return displays_.find(display) != displays_.end();
+  return bound_connectors_.count(display) != 0;
 }
 
 DrmConnector *DrmDevice::GetConnectorForDisplay(int display) const {
-  for (const auto &conn : connectors_) {
-    if (conn->display() == display)
-      return conn.get();
-  }
-  return nullptr;
+  return bound_connectors_.at(display);
 }
 
 DrmCrtc *DrmDevice::GetCrtcForDisplay(int display) const {
@@ -246,11 +223,13 @@ int DrmDevice::TryEncoderForDisplay(int display, DrmEncoder *enc) {
 }
 
 int DrmDevice::CreateDisplayPipe(DrmConnector *connector) {
-  int display = connector->display();
+  int display = connectors_to_display_id_.at(connector);
   /* Try to use current setup first */
-  if (connector->encoder()) {
-    int ret = TryEncoderForDisplay(display, connector->encoder());
+  auto *enc0 = FindEncoderById(connector->GetCurrentEncoderId());
+  if (enc0 != nullptr && encoders_to_display_id_.count(enc0) == 0) {
+    int ret = TryEncoderForDisplay(display, enc0);
     if (!ret) {
+      encoders_to_display_id_[enc0] = display;
       return 0;
     }
 
@@ -260,10 +239,15 @@ int DrmDevice::CreateDisplayPipe(DrmConnector *connector) {
     }
   }
 
-  for (DrmEncoder *enc : connector->possible_encoders()) {
-    int ret = TryEncoderForDisplay(display, enc);
+  for (auto &enc : encoders_) {
+    if (!connector->SupportsEncoder(*enc) ||
+        encoders_to_display_id_.count(enc.get()) != 0) {
+      continue;
+    }
+
+    int ret = TryEncoderForDisplay(display, enc.get());
     if (!ret) {
-      connector->set_encoder(enc);
+      encoders_to_display_id_[enc.get()] = display;
       return 0;
     }
 
@@ -272,8 +256,7 @@ int DrmDevice::CreateDisplayPipe(DrmConnector *connector) {
       return ret;
     }
   }
-  ALOGE("Could not find a suitable encoder/crtc for display %d",
-        connector->display());
+  ALOGE("Could not find a suitable encoder/crtc for display %d", display);
   return -ENODEV;
 }
 
@@ -327,13 +310,6 @@ int DrmDevice::GetProperty(uint32_t obj_id, uint32_t obj_type,
   return found ? 0 : -ENOENT;
 }
 
-int DrmDevice::GetConnectorProperty(const DrmConnector &connector,
-                                    const char *prop_name,
-                                    DrmProperty *property) const {
-  return GetProperty(connector.id(), DRM_MODE_OBJECT_CONNECTOR, prop_name,
-                     property);
-}
-
 std::string DrmDevice::GetName() const {
   auto *ver = drmGetVersion(fd());
   if (!ver) {
diff --git a/drm/DrmDevice.h b/drm/DrmDevice.h
index 82b0f6a..cd87127 100644
--- a/drm/DrmDevice.h
+++ b/drm/DrmDevice.h
@@ -62,9 +62,6 @@ class DrmDevice {
   DrmConnector *GetConnectorForDisplay(int display) const;
   DrmCrtc *GetCrtcForDisplay(int display) const;
 
-  int GetConnectorProperty(const DrmConnector &connector, const char *prop_name,
-                           DrmProperty *property) const;
-
   std::string GetName() const;
 
   const std::vector<std::unique_ptr<DrmCrtc>> &crtcs() const;
@@ -95,6 +92,20 @@ class DrmDevice {
     return nullptr;
   }
 
+  auto FindEncoderById(uint32_t id) const -> DrmEncoder * {
+    for (const auto &enc : encoders_) {
+      if (enc->GetId() == id) {
+        return enc.get();
+      }
+    };
+
+    return nullptr;
+  }
+
+  auto GetDisplayId(DrmConnector *conn) {
+    return connectors_to_display_id_.at(conn);
+  }
+
   int GetProperty(uint32_t obj_id, uint32_t obj_type, const char *prop_name,
                   DrmProperty *property) const;
 
@@ -114,9 +125,11 @@ class DrmDevice {
 
   std::pair<uint32_t, uint32_t> min_resolution_;
   std::pair<uint32_t, uint32_t> max_resolution_;
-  std::map<int, int> displays_;
 
   std::map<int /*display*/, DrmCrtc *> bound_crtcs_;
+  std::map<int /*display*/, DrmConnector *> bound_connectors_;
+  std::map<DrmConnector *, int /*display*/> connectors_to_display_id_;
+  std::map<DrmEncoder *, int /*display*/> encoders_to_display_id_;
   std::map<DrmCrtc *, DrmEncoder *> bound_encoders_;
 
   bool HasAddFb2ModifiersSupport_{};
diff --git a/drm/VSyncWorker.cpp b/drm/VSyncWorker.cpp
index 0ac626e..3bcb4d0 100644
--- a/drm/VSyncWorker.cpp
+++ b/drm/VSyncWorker.cpp
@@ -87,11 +87,11 @@ int VSyncWorker::SyntheticWaitVBlank(int64_t *timestamp) {
 
   float refresh = 60.0F;  // Default to 60Hz refresh rate
   DrmConnector *conn = drm_->GetConnectorForDisplay(display_);
-  if (conn && conn->active_mode().v_refresh() != 0.0F)
-    refresh = conn->active_mode().v_refresh();
+  if (conn && conn->GetActiveMode().v_refresh() != 0.0F)
+    refresh = conn->GetActiveMode().v_refresh();
   else
     ALOGW("Vsync worker active with conn=%p refresh=%f\n", conn,
-          conn ? conn->active_mode().v_refresh() : 0.0F);
+          conn ? conn->GetActiveMode().v_refresh() : 0.0F);
 
   int64_t phased_timestamp = GetPhasedVSync(kOneSecondNs /
                                                 static_cast<int>(refresh),
diff --git a/hwc2_device/DrmHwcTwo.cpp b/hwc2_device/DrmHwcTwo.cpp
index 87cc238..698c1e5 100644
--- a/hwc2_device/DrmHwcTwo.cpp
+++ b/hwc2_device/DrmHwcTwo.cpp
@@ -165,42 +165,40 @@ void DrmHwcTwo::HandleDisplayHotplug(hwc2_display_t displayid, int state) {
 
 void DrmHwcTwo::HandleInitialHotplugState(DrmDevice *drmDevice) {
   for (const auto &conn : drmDevice->connectors()) {
-    int display_id = conn->display();
+    int display_id = drmDevice->GetDisplayId(conn.get());
     auto &display = displays_.at(display_id);
 
-    if (conn->state() != DRM_MODE_CONNECTED && !display.IsInHeadlessMode())
+    if (!conn->IsConnected() && !display.IsInHeadlessMode())
       continue;
-    HandleDisplayHotplug(conn->display(), display.IsInHeadlessMode()
-                                              ? DRM_MODE_CONNECTED
-                                              : conn->state());
+    HandleDisplayHotplug(display_id, display.IsInHeadlessMode()
+                                         ? 1
+                                         : (conn->IsConnected() ? 1 : 0));
   }
 }
 
 void DrmHwcTwo::HandleHotplugUEvent() {
   for (const auto &drm : resource_manager_.GetDrmDevices()) {
     for (const auto &conn : drm->connectors()) {
-      drmModeConnection old_state = conn->state();
-      drmModeConnection cur_state = conn->UpdateModes()
-                                        ? DRM_MODE_UNKNOWNCONNECTION
-                                        : conn->state();
+      int display_id = drm->GetDisplayId(conn.get());
 
+      bool old_state = conn->IsConnected();
+      bool cur_state = conn->UpdateModes() ? false : conn->IsConnected();
       if (cur_state == old_state)
         continue;
 
       ALOGI("%s event for connector %u on display %d",
-            cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", conn->id(),
-            conn->display());
+            cur_state == DRM_MODE_CONNECTED ? "Plug" : "Unplug", conn->GetId(),
+            display_id);
 
-      int display_id = conn->display();
       auto &display = displays_.at(display_id);
       display.ChosePreferredConfig();
-      if (cur_state != DRM_MODE_CONNECTED) {
+      if (cur_state) {
         display.ClearDisplay();
       }
 
       HandleDisplayHotplug(display_id, display.IsInHeadlessMode()
                                            ? DRM_MODE_CONNECTED
-                                           : cur_state);
+                                           : (cur_state ? 1 : 0));
     }
   }
 }
diff --git a/hwc2_device/HwcDisplay.cpp b/hwc2_device/HwcDisplay.cpp
index f18e00d..54cf867 100644
--- a/hwc2_device/HwcDisplay.cpp
+++ b/hwc2_device/HwcDisplay.cpp
@@ -69,7 +69,7 @@ std::string HwcDisplay::Dump() {
   }
 
   std::stringstream ss;
-  ss << "- Display on: " << connector_->name() << "\n"
+  ss << "- Display on: " << connector_->GetName() << "\n"
      << "  Flattening state: " << flattening_state_str << "\n"
      << "Statistics since system boot:\n"
      << DumpDelta(total_stats_) << "\n\n"
@@ -363,7 +363,7 @@ HWC2::Error HwcDisplay::GetDisplayConfigs(uint32_t *num_configs,
 
 HWC2::Error HwcDisplay::GetDisplayName(uint32_t *size, char *name) {
   std::ostringstream stream;
-  stream << "display-" << connector_->id();
+  stream << "display-" << connector_->GetId();
   std::string string = stream.str();
   size_t length = string.length();
   if (!name) {
@@ -715,9 +715,9 @@ HWC2::Error HwcDisplay::GetDisplayConnectionType(uint32_t *outType) {
   /* Primary display should be always internal,
    * otherwise SF will be unhappy and will crash
    */
-  if (connector_->internal() || handle_ == kPrimaryDisplay)
+  if (connector_->IsInternal() || handle_ == kPrimaryDisplay)
     *outType = static_cast<uint32_t>(HWC2::DisplayConnectionType::Internal);
-  else if (connector_->external())
+  else if (connector_->IsExternal())
     *outType = static_cast<uint32_t>(HWC2::DisplayConnectionType::External);
   else
     return HWC2::Error::BadConfig;
@@ -785,7 +785,7 @@ HWC2::Error HwcDisplay::GetDisplayIdentificationData(uint8_t *outPort,
   } else {
     *outDataSize = blob->length;
   }
-  *outPort = connector_->id();
+  *outPort = connector_->GetId();
 
   return HWC2::Error::None;
 }
diff --git a/hwc2_device/HwcDisplay.h b/hwc2_device/HwcDisplay.h
index 76456b7..3e8a548 100644
--- a/hwc2_device/HwcDisplay.h
+++ b/hwc2_device/HwcDisplay.h
@@ -209,8 +209,7 @@ class HwcDisplay {
    * https://source.android.com/devices/graphics/hotplug#handling-common-scenarios
    */
   bool IsInHeadlessMode() {
-    return handle_ == kPrimaryDisplay &&
-           connector_->state() != DRM_MODE_CONNECTED;
+    return handle_ == kPrimaryDisplay && !connector_->IsConnected();
   }
 
  private:
diff --git a/hwc2_device/HwcDisplayConfigs.cpp b/hwc2_device/HwcDisplayConfigs.cpp
index 16f1ed0..f6ccdb7 100644
--- a/hwc2_device/HwcDisplayConfigs.cpp
+++ b/hwc2_device/HwcDisplayConfigs.cpp
@@ -61,14 +61,14 @@ HWC2::Error HwcDisplayConfigs::Update(DrmConnector &connector) {
     return HWC2::Error::BadDisplay;
   }
 
-  if (connector.modes().empty()) {
+  if (connector.GetModes().empty()) {
     ALOGE("No modes reported by KMS");
     return HWC2::Error::BadDisplay;
   }
 
   hwc_configs.clear();
-  mm_width = connector.mm_width();
-  mm_height = connector.mm_height();
+  mm_width = connector.GetMmWidth();
+  mm_height = connector.GetMmHeight();
 
   preferred_config_id = 0;
   int preferred_config_group_id = 0;
@@ -77,7 +77,7 @@ HWC2::Error HwcDisplayConfigs::Update(DrmConnector &connector) {
   int last_group_id = 1;
 
   /* Group modes */
-  for (const auto &mode : connector.modes()) {
+  for (const auto &mode : connector.GetModes()) {
     /* Find group for the new mode or create new group */
     int group_found = 0;
     for (auto &hwc_config : hwc_configs) {