1 files changed, 83 insertions, 4 deletions

diff --git a/src/bt.cc b/src/bt.cc
index e3c12d9..e59555d 100644
--- a/src/bt.cc
+++ b/src/bt.cc
@@ -368,6 +368,10 @@ class AdapterProxy : public BaseProxy, public Adapter {
     {sdbus::PropertyName{"Discoverable"}, 3},
     {sdbus::PropertyName{"Pairable"}, 4},
     {sdbus::PropertyName{"Pairing"}, 5},
+    {sdbus::PropertyName{"Connectable"}, 6},
+    {sdbus::PropertyName{"Powered"}, 7},
+    {sdbus::PropertyName{"DiscoverableTimeout"}, 8},
+    {sdbus::PropertyName{"PairableTimeout"}, 9},
   };
 
  public:
@@ -399,20 +403,71 @@ class AdapterProxy : public BaseProxy, public Adapter {
   }
 
   [[nodiscard]]
+  uint32_t discoverable_timeout_seconds() const override {
+    return discoverable_timeout_;
+  }
+
+  [[nodiscard]]
   bool pairable() const override {
     return pairable_;
   }
 
   [[nodiscard]]
+  uint32_t pairable_timeout_seconds() const override {
+    return pairable_timeout_;
+  }
+
+  [[nodiscard]]
   bool pairing() const override {
     return pairing_;
   }
 
   [[nodiscard]]
+  bool powered() const override {
+    return powered_;
+  }
+
+  [[nodiscard]]
+  bool connectable() const override {
+    return connectable_;
+  }
+
+  [[nodiscard]]
   std::vector<Device*> devices() const override {
     return manager_.get_devices(getProxy().getObjectPath());
   }
 
+  void set_discoverable(bool discoverable) override {
+    if (discoverable == discoverable_)
+      return;
+
+    SetAsync(kAdapterInterface, sdbus::PropertyName{"Discoverable"},
+             sdbus::Variant{discoverable},
+             [this](std::optional<sdbus::Error> err) {
+               set_callback(std::move(err));
+             });
+  }
+
+  void set_discoverable_timeout_seconds(uint32_t seconds) override {
+    if (discoverable_timeout_ == seconds)
+      return;
+
+    SetAsync(kAdapterInterface, sdbus::PropertyName{"DiscoverableTimeout"},
+             sdbus::Variant{seconds}, [this](std::optional<sdbus::Error> err) {
+               set_callback(std::move(err));
+             });
+  }
+
+  void set_pairable_timeout_seconds(uint32_t seconds) override {
+    if (pairable_timeout_ == seconds)
+      return;
+
+    SetAsync(kAdapterInterface, sdbus::PropertyName{"PairableTimeout"},
+             sdbus::Variant{seconds}, [this](std::optional<sdbus::Error> err) {
+               set_callback(std::move(err));
+             });
+  }
+
  private:
   void update(size_t field, sdbus::Variant const& value) override {
     switch (field) {
@@ -430,16 +485,35 @@ class AdapterProxy : public BaseProxy, public Adapter {
         break;
       case 4:
         pairable_ = value.get<bool>();
-        manager_.logger().dbg(std::format("pairable: {}", pairable_));
         break;
       case 5:
         pairing_ = value.get<bool>();
         break;
+      case 6:
+        connectable_ = value.get<bool>();
+        break;
+      case 7:
+        powered_ = value.get<bool>();
+        break;
+      case 8:
+        discoverable_timeout_ = value.get<uint32_t>();
+        break;
+      case 9:
+        pairable_timeout_ = value.get<uint32_t>();
+        break;
       default:
         std::unreachable();
     }
   }
 
+  void set_callback(std::optional<sdbus::Error> err) {
+    if (err.has_value()) {
+      manager_.logger().warn(std::format("Failed to set property: {} {}",
+                                         std::string(err->getName()),
+                                         err->getMessage()));
+    }
+  }
+
   void notify_updated() override {
     manager_.update_adapter(getProxy().getObjectPath());
   }
@@ -451,6 +525,10 @@ class AdapterProxy : public BaseProxy, public Adapter {
   bool discoverable_{false};
   bool pairable_{false};
   bool pairing_{false};
+  bool connectable_{false};
+  bool powered_{false};
+  uint32_t discoverable_timeout_{180};
+  uint32_t pairable_timeout_{0};
 };
 
 class AgentManagerProxy {
@@ -914,16 +992,17 @@ class ManagerImpl : public Manager, public IManager, looper::Hook {
     auto cfg_adapter = cfg_.get("bluetooth.adapter");
     if (cfg_adapter.has_value()) {
       for (auto const& pair : adapters_) {
-        if (pair.second->address() == cfg_adapter.value()) {
+        if (pair.second->address() == cfg_adapter.value() &&
+            pair.second->powered()) {
           primary_adapter_ = pair.first;
           delegate_.new_adapter(pair.second.get());
           return;
         }
       }
     } else {
-      // Pick first (map is sorted) that is pairable.
+      // Pick first (map is sorted) that is pairable and powered.
       for (auto const& pair : adapters_) {
-        if (pair.second->pairable()) {
+        if (pair.second->powered() && pair.second->pairable()) {
           primary_adapter_ = pair.first;
           delegate_.new_adapter(pair.second.get());
           return;