Complete DeviceManager interface

src/ipcgull

@@ -1 +1 @@
-Subproject commit 73d837add44f7524603557ee1819610dcc4a3037
+Subproject commit 5f95b1111ea2f3a6f8e2f0d60ccae12aebaa1a90

src/logid/DeviceManager.cpp

@@ -19,6 +19,7 @@
 #include <thread>
 #include <sstream>
 #include <utility>
+#include <ipcgull/function.h>
 
 #include "DeviceManager.h"
 #include "Receiver.h"
@@ -50,8 +51,8 @@ DeviceManager::DeviceManager(std::shared_ptr<Configuration> config,
     _device_node (ipcgull::node::make_root("devices")),
     _receiver_node (ipcgull::node::make_root("receivers"))
 {
-    _ipc_devices = _root_node->make_interface<DevicesIPC>();
-    _ipc_receivers = _root_node->make_interface<ReceiversIPC>();
+    _ipc_devices = _root_node->make_interface<DevicesIPC>(this);
+    _ipc_receivers = _root_node->make_interface<ReceiversIPC>(this);
     _device_node->add_server(_server);
     _receiver_node->add_server(_server);
     _root_node->add_server(_server);
@@ -124,6 +125,7 @@ void DeviceManager::addDevice(std::string path)
         logPrintf(INFO, "Detected receiver at %s", path.c_str());
         auto receiver = Receiver::make(path, _self.lock());
         receiver->run();
+        std::lock_guard<std::mutex> lock(_map_lock);
         _receivers.emplace(path, receiver);
         _ipc_receivers->receiverAdded(receiver);
     } else {
@@ -132,12 +134,14 @@ void DeviceManager::addDevice(std::string path)
         if(defaultExists) {
             auto device = Device::make(path, hidpp::DefaultDevice,
                                        _self.lock());
+            std::lock_guard<std::mutex> lock(_map_lock);
             _devices.emplace(path,  device);
             _ipc_devices->deviceAdded(device);
         } else {
             try {
                 auto device = Device::make(path,
                         hidpp::CordedDevice, _self.lock());
+                std::lock_guard<std::mutex> lock(_map_lock);
                 _devices.emplace(path, device);
                 _ipc_devices->deviceAdded(device);
             } catch(hidpp10::Error &e) {
@@ -167,8 +171,14 @@ void DeviceManager::removeExternalDevice(const std::shared_ptr<Device> &d)
     _ipc_devices->deviceRemoved(d);
 }
 
+std::mutex& DeviceManager::mutex() const
+{
+    return _map_lock;
+}
+
 void DeviceManager::removeDevice(std::string path)
 {
+    std::lock_guard<std::mutex> lock(_map_lock);
     auto receiver = _receivers.find(path);
 
     if(receiver != _receivers.end()) {
@@ -185,55 +195,84 @@ void DeviceManager::removeDevice(std::string path)
     }
 }
 
-DeviceManager::DevicesIPC::DevicesIPC() : ipcgull::interface(
+DeviceManager::DevicesIPC::DevicesIPC(DeviceManager* manager) :
+ipcgull::interface(
         "pizza.pixl.LogiOps.Devices",
-        {},
+        {
+                {"Enumerate",{manager, &DeviceManager::listDevices,{"devices"}}}
+        },
         {},
         {
-                {"deviceAdded",
+                {"DeviceAdded",
                         ipcgull::make_signal<std::shared_ptr<Device>>(
                                 {"device"})},
-                {"deviceRemoved",
+                {"DeviceRemoved",
                         ipcgull::make_signal<std::shared_ptr<Device>>(
                                 {"device"})}
-        }
-        )
+        })
 {
 }
 
+std::vector<std::shared_ptr<Device>> DeviceManager::listDevices() const
+{
+    std::lock_guard<std::mutex> lock(_map_lock);
+    std::vector<std::shared_ptr<Device>> devices;
+    for(auto& x : _devices)
+        devices.emplace_back(x.second);
+    for(auto& x : _receivers) {
+        for(auto& d : x.second->devices())
+            devices.emplace_back(d.second);
+    }
+
+    return devices;
+}
+
+std::vector<std::shared_ptr<Receiver>> DeviceManager::listReceivers() const
+{
+    std::lock_guard<std::mutex> lock(_map_lock);
+    std::vector<std::shared_ptr<Receiver>> receivers;
+    for(auto& x : _receivers)
+        receivers.emplace_back(x.second);
+    return receivers;
+}
+
 void DeviceManager::DevicesIPC::deviceAdded(
         const std::shared_ptr<Device>& d) {
-    emit_signal("deviceAdded", d);
+    emit_signal("DeviceAdded", d);
 }
 
 void DeviceManager::DevicesIPC::deviceRemoved(
         const std::shared_ptr<Device>& d) {
-    emit_signal("deviceRemoved", d);
+    emit_signal("DeviceRemoved", d);
 }
 
-DeviceManager::ReceiversIPC::ReceiversIPC() : ipcgull::interface(
+DeviceManager::ReceiversIPC::ReceiversIPC(DeviceManager* manager) :
+ipcgull::interface(
         "pizza.pixl.LogiOps.Receivers",
-        {},
+        {
+                {"Enumerate",{manager, &DeviceManager::listReceivers,
+                              {"receivers"}}}
+            },
         {},
         {
-                {"receiverAdded",
+                {"ReceiverAdded",
                         ipcgull::make_signal<std::shared_ptr<Receiver>>(
-                                {"device"})},
-                {"receiverRemoved",
+                                {"receiver"})},
+                {"ReceiverRemoved",
                         ipcgull::make_signal<std::shared_ptr<Receiver>>(
-                                {"device"})}
+                                {"receiver"})}
         })
 {
 }
 
 void DeviceManager::ReceiversIPC::receiverAdded(
         const std::shared_ptr<Receiver>& r) {
-    emit_signal("receiverAdded", r);
+    emit_signal("ReceiverAdded", r);
 }
 
 void DeviceManager::ReceiversIPC::receiverRemoved(
         const std::shared_ptr<Receiver>& r) {
-    emit_signal("receiverRemoved", r);
+    emit_signal("ReceiverRemoved", r);
 }
 
 int DeviceManager::newDeviceNickname()

src/logid/DeviceManager.h

@@ -50,23 +50,29 @@ namespace logid
 
         void addExternalDevice(const std::shared_ptr<Device>& d);
         void removeExternalDevice(const std::shared_ptr<Device>& d);
+
+        std::mutex& mutex() const;
     protected:
         void addDevice(std::string path) final;
         void removeDevice(std::string path) final;
     private:
         class DevicesIPC : public ipcgull::interface {
         public:
-            DevicesIPC();
+            explicit DevicesIPC(DeviceManager* manager);
             void deviceAdded(const std::shared_ptr<Device>& d);
             void deviceRemoved(const std::shared_ptr<Device>& d);
         };
+        [[nodiscard]]
+        std::vector<std::shared_ptr<Device>> listDevices() const;
 
         class ReceiversIPC : public ipcgull::interface {
         public:
-            ReceiversIPC();
+            explicit ReceiversIPC(DeviceManager* manager);
             void receiverAdded(const std::shared_ptr<Receiver>& r);
             void receiverRemoved(const std::shared_ptr<Receiver>& r);
         };
+        [[nodiscard]]
+        std::vector<std::shared_ptr<Receiver>> listReceivers() const;
 
         friend class _DeviceManager;
         DeviceManager(std::shared_ptr<Configuration> config,
@@ -89,6 +95,8 @@ namespace logid
         std::map<std::string, std::shared_ptr<Device>> _devices;
         std::map<std::string, std::shared_ptr<Receiver>> _receivers;
 
+        mutable std::mutex _map_lock;
+
         friend class DeviceNickname;
         friend class ReceiverNickname;
 

src/logid/Receiver.cpp

@@ -73,6 +73,10 @@ Receiver::Receiver(const std::string& path,
 {
 }
 
+const Receiver::DeviceList& Receiver::devices() const {
+    return _devices;
+}
+
 Receiver::~Receiver()
 {
     if(auto manager = _manager.lock()) {
@@ -124,6 +128,7 @@ void Receiver::addDevice(hidpp::DeviceConnectionEvent event)
         }
 
         auto device = Device::make(this, event.index, manager);
+        std::lock_guard<std::mutex> manager_lock(manager->mutex());
         _devices.emplace(event.index, device);
         manager->addExternalDevice(device);
 
@@ -145,6 +150,9 @@ void Receiver::addDevice(hidpp::DeviceConnectionEvent event)
 void Receiver::removeDevice(hidpp::DeviceIndex index)
 {
     std::unique_lock<std::mutex> lock(_devices_change);
+    std::unique_lock<std::mutex> manager_lock;
+    if(auto manager = _manager.lock())
+        manager_lock = std::unique_lock<std::mutex>(manager->mutex());
     auto device = _devices.find(index);
     if(device != _devices.end()) {
         if(auto manager = _manager.lock())

src/logid/Receiver.h

@@ -42,6 +42,9 @@ namespace logid
         public ipcgull::object
     {
     public:
+        typedef std::map<backend::hidpp::DeviceIndex, std::shared_ptr<Device>>
+        DeviceList;
+
         ~Receiver();
 
         static std::shared_ptr<Receiver> make(
@@ -49,6 +52,8 @@ namespace logid
                 const std::shared_ptr<DeviceManager>& manager);
         const std::string& path() const;
         std::shared_ptr<backend::dj::Receiver> rawReceiver();
+
+        [[nodiscard]] const DeviceList& devices() const;
     protected:
         void addDevice(backend::hidpp::DeviceConnectionEvent event) override;
         void removeDevice(backend::hidpp::DeviceIndex index) override;
@@ -59,7 +64,7 @@ namespace logid
                  const std::shared_ptr<DeviceManager>& manager);
 
         std::mutex _devices_change;
-        std::map<backend::hidpp::DeviceIndex, std::shared_ptr<Device>> _devices;
+        DeviceList _devices;
         std::string _path;
         std::weak_ptr<DeviceManager> _manager;
 

src/logid/logid.cpp

@@ -159,7 +159,7 @@ int main(int argc, char** argv)
     std::shared_ptr<InputDevice> virtual_input;
 
     auto server = ipcgull::make_server("pizza.pixl.LogiOps",
-                                      "/pizza/pixl/logiops",
+                                      "/pizza/pixl/LogiOps",
                                       ipcgull::IPCGULL_USER);
 
     std::thread( [server]() {