From 1bc2515a864e1e039c7381f5bd3df2ee151f43e8 Mon Sep 17 00:00:00 2001
From: Pierre Le Fevre <pierre.lefevre@netinsight.net>
Date: Fri, 12 Jun 2026 16:30:30 +0200
Subject: [PATCH] Support external trackpad

---
 MCT/API/GestureMonitor.swift | 92 +++++++++++++++++++++++++++++-------
 1 file changed, 74 insertions(+), 18 deletions(-)

diff --git a/MCT/API/GestureMonitor.swift b/MCT/API/GestureMonitor.swift
index 0118c6c..374572c 100644
--- a/MCT/API/GestureMonitor.swift
+++ b/MCT/API/GestureMonitor.swift
@@ -22,6 +22,8 @@ final class GestureMonitor {
     // MultitouchSupport state
     private var mtHandle: UnsafeMutableRawPointer?
     private var mtDevices: [UnsafeMutableRawPointer] = []
+    private var registeredDeviceCount = 0
+    private var deviceRefreshTimer: DispatchSourceTimer?
 
     // Three-finger swipe tracking
     private var threeFingerActive = false
@@ -57,6 +59,9 @@ final class GestureMonitor {
     ) -> Void
 
     // Resolved function pointers
+    private var fnCreateList: CreateListFn?
+    private var fnRegisterCallback: RegisterCallbackFn?
+    private var fnDeviceStart: DeviceStartFn?
     private var fnDeviceStop: DeviceStopFn?
     private var fnUnregisterCallback: UnregisterCallbackFn?
 
@@ -107,45 +112,96 @@ final class GestureMonitor {
         let stopSym = dlsym(handle, "MTDeviceStop")
         let unregSym = dlsym(handle, "MTUnregisterContactFrameCallback")
 
-        let createList = unsafeBitCast(createListSym, to: CreateListFn.self)
-        let registerCallback = unsafeBitCast(registerSym, to: RegisterCallbackFn.self)
-        let deviceStart = unsafeBitCast(startSym, to: DeviceStartFn.self)
+        fnCreateList = unsafeBitCast(createListSym, to: CreateListFn.self)
+        fnRegisterCallback = unsafeBitCast(registerSym, to: RegisterCallbackFn.self)
+        fnDeviceStart = unsafeBitCast(startSym, to: DeviceStartFn.self)
 
         if let s = stopSym { fnDeviceStop = unsafeBitCast(s, to: DeviceStopFn.self) }
         if let s = unregSym { fnUnregisterCallback = unsafeBitCast(s, to: UnregisterCallbackFn.self) }
 
-        // takeUnretainedValue — MTDeviceCreateList may not follow the Create Rule
-        let deviceList = createList().takeUnretainedValue()
-        log("device list obtained: \(CFArrayGetCount(deviceList)) device(s)")
-
-        let count = CFArrayGetCount(deviceList)
-        for i in 0..<count {
-            guard let device = CFArrayGetValueAtIndex(deviceList, i) else { continue }
-            let devicePtr = UnsafeMutableRawPointer(mutating: device)
-            registerCallback(devicePtr, mtTouchCallback)
-            let _ = deviceStart(devicePtr, 0)
-            mtDevices.append(devicePtr)
-            log("registered device \(i)")
-        }
-
-        log("MultitouchSupport started with \(count) device(s)")
+        refreshDevices(reason: "initial")
+        startDeviceRefreshTimer()
+        log("MultitouchSupport started with \(mtDevices.count) registered device(s)")
     }
 
     func stop() {
+        deviceRefreshTimer?.cancel()
+        deviceRefreshTimer = nil
+
         for device in mtDevices {
             fnUnregisterCallback?(device, mtTouchCallback)
             fnDeviceStop?(device)
         }
         mtDevices.removeAll()
+        registeredDeviceCount = 0
 
         if let h = mtHandle {
             dlclose(h)
             mtHandle = nil
         }
 
+        fnCreateList = nil
+        fnRegisterCallback = nil
+        fnDeviceStart = nil
+        fnDeviceStop = nil
+        fnUnregisterCallback = nil
+
         GestureMonitor.shared = nil
     }
 
+    private func startDeviceRefreshTimer() {
+        let timer = DispatchSource.makeTimerSource(queue: .main)
+        timer.schedule(deadline: .now() + 2.0, repeating: 5.0)
+        timer.setEventHandler { [weak self] in
+            self?.refreshDevices(reason: "poll")
+        }
+        timer.resume()
+        deviceRefreshTimer = timer
+    }
+
+    private func refreshDevices(reason: String) {
+        guard let createList = fnCreateList,
+              let registerCallback = fnRegisterCallback,
+              let deviceStart = fnDeviceStart else {
+            log("ERROR: refreshDevices called before MultitouchSupport symbols were resolved")
+            return
+        }
+
+        // takeUnretainedValue — MTDeviceCreateList may not follow the Create Rule.
+        let deviceList = createList().takeUnretainedValue()
+        let count = CFArrayGetCount(deviceList)
+
+        if reason != "initial" {
+            guard count != registeredDeviceCount else { return }
+
+            log("device count changed from \(registeredDeviceCount) to \(count); restarting MultitouchSupport")
+            start()
+            return
+        }
+
+        if reason == "initial" {
+            log("device list obtained: \(count) device(s)")
+        }
+
+        for i in 0..<count {
+            guard let device = CFArrayGetValueAtIndex(deviceList, i) else { continue }
+
+            let devicePtr = UnsafeMutableRawPointer(mutating: device)
+            let deviceID = UInt(bitPattern: devicePtr)
+            registerCallback(devicePtr, mtTouchCallback)
+            let startResult = deviceStart(devicePtr, 0)
+            mtDevices.append(devicePtr)
+
+            log(String(format: "registered device %d ptr=0x%llx startResult=%d reason=%@",
+                       i,
+                       UInt64(deviceID),
+                       startResult,
+                       reason))
+        }
+
+        registeredDeviceCount = mtDevices.count
+    }
+
     // MARK: - Touch handling
 
     fileprivate func handleTouches(
-- 
2.51.2