add dynamic dev

Author: chenx-dust

src/hhd/controller/physical/imu.py

@@ -238,59 +238,6 @@ def prepare_dev(
     return DeviceInfo(dev, axis_arr, sensor_dir, target_freqs, min_freqs)
 
 
-def set_powersave(dev: DeviceInfo, state: bool, update_trigger: bool):
-    freqs = dev.min_freqs if state else dev.freqs
-
-    write_sysfs(dev.sysfs, "buffer/enable", 0)
-    for a, f in freqs.items():
-        if (
-            a
-            and f
-            and os.path.isfile(os.path.join(dev.sysfs, f"in_{a}_sampling_frequency"))
-        ):
-            try:
-                write_sysfs(dev.sysfs, f"in_{a}_sampling_frequency", f)
-                logger.info(
-                    f"Set {'powersave' if state else 'normal'} frequency {f} for {a}"
-                )
-            except Exception as e:
-                logger.error(
-                    f"Could not set {'powersave' if state else 'normal'} frequency for {a}:\n{e}"
-                )
-
-    if not update_trigger:
-        return
-
-    # Find trigger
-    trig = None
-    for fn in os.listdir("/sys/bus/iio/devices"):
-        if not fn.startswith("trigger"):
-            continue
-        with open(os.path.join("/sys/bus/iio/devices", fn, "name"), "r") as f:
-            if f.read().strip() == "hhd":
-                trig = fn
-                break
-
-    write_sysfs(dev.sysfs, "buffer/enable", 1)
-
-    if not trig:
-        return
-
-    freq = next(iter([f for f in freqs if f]), None)
-    if not freq:
-        return
-
-    try:
-        write_sysfs(os.path.dirname(trig), "sampling_frequency", freq)
-        logger.info(
-            f"Set {'powersave' if state else 'normal'} trigger frequency {freq}"
-        )
-    except Exception as e:
-        logger.error(
-            f"Could not set {'powersave' if state else 'normal'} trigger frequency:\n{e}"
-        )
-
-
 def close_dev(dev: DeviceInfo):
     write_sysfs(dev.sysfs, "buffer/enable", 0)
 
@@ -368,16 +315,18 @@ def close(self, exit: bool):
         return True
 
     def consume(self, events: Sequence[Event]) -> None:
-        if not self.dev:
-            return
-
         powersave = None
         for e in events:
             if e["type"] == "configuration" and e["code"] == "imu_powersave":
                 powersave = bool(e["value"])
 
         if powersave is not None:
-            set_powersave(self.dev, powersave, self.update_trigger)
+            logger.info("IMU powersave: %s", powersave)
+            if powersave and self.dev:
+                self.close(False)
+            elif not powersave and not self.dev:
+                self.open()
+            
 
     def produce(self, fds: Sequence[int]) -> Sequence[Event]:
         if self.fd not in fds or not self.dev:

src/hhd/controller/virtual/sd/__init__.py

@@ -317,7 +317,7 @@ def consume(self, events: Sequence[Event]):
 
         # To fix gyro to mouse in latest steam
         # only send updates when gyro sends a timestamp
-        send = not self.sync_gyro
+        send = not self.sync_gyro or not self.gyro_enabled
         curr = time.perf_counter()
 
         new_rep = bytearray(self.report)
@@ -384,7 +384,7 @@ def consume(self, events: Sequence[Event]):
 
         # If the IMU breaks, smoothly re-enable the controller
         failover = self.last_imu + MAX_IMU_SYNC_DELAY < curr
-        if self.sync_gyro and failover and not self.imu_failed:
+        if self.gyro_enabled and self.sync_gyro and failover and not self.imu_failed:
             self.imu_failed = True
             logger.error(
                 f"IMU Did not send information for {MAX_IMU_SYNC_DELAY}s. Disabling Gyro Sync."

src/hhd/device/ayaneo/base.py

@@ -565,6 +565,7 @@ def controller_loop(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -573,14 +574,18 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         prepare(d_xinput)
         if motion and d_imu:
             start_imu = True
             if dconf.get("hrtimer", False):
                 start_imu = d_timer.open()
             if start_imu:
-                prepare(d_imu)
+                prepare_dynamic(d_imu)
         prepare(d_kbd_1)
         if d_kbd_2:
             prepare(d_kbd_2)
@@ -602,14 +607,22 @@ def prepare(m):
         logger.info("Emulated controller launched, have fun!")
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
-                to_run.add(id(fd_to_dev[f]))
+                to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))
 

src/hhd/device/claw/base.py

@@ -525,6 +525,7 @@ def controller_loop(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -533,6 +534,10 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         prepare(d_xinput)
         prepare(d_volume_btn)
@@ -548,14 +553,22 @@ def prepare(m):
         switch_to_dinput = None
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
-                to_run.add(id(fd_to_dev[f]))
+                to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))
 

src/hhd/device/generic/base.py

@@ -208,6 +208,7 @@ def controller_loop(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -216,6 +217,10 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         if dtype == "tecno":
             d_kbd_2 = GenericGamepadHidraw(
@@ -241,7 +246,7 @@ def prepare(m):
             if dconf.get("hrtimer", False):
                 start_imu = d_timer.open()
             if start_imu:
-                prepare(d_imu)
+                prepare_dynamic(d_imu)
 
         if grab_at:
             prepare(d_volume_btn)
@@ -254,14 +259,22 @@ def prepare(m):
         logger.info("Emulated controller launched, have fun!")
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
-                to_run.add(id(fd_to_dev[f]))
+                to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))
 

src/hhd/device/gpd/win/base.py

@@ -327,6 +327,7 @@ def controller_loop(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -335,6 +336,10 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         if l4r4_enabled:
             kbd_fds = d_kbd_1.open()
@@ -348,7 +353,7 @@ def prepare(m):
                 if dconf.get("hrtimer", False):
                     start_imu = d_timer.open()
                 if start_imu:
-                    prepare(d_imu)
+                    prepare_dynamic(d_imu)
             except Exception as e:
                 motion = False
                 try:
@@ -369,16 +374,24 @@ def prepare(m):
         logger.info("Emulated controller launched, have fun!")
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
                 # skip kbd_1 to always run it
                 if f not in kbd_fds:
-                    to_run.add(id(fd_to_dev[f]))
+                    to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))
             evs.extend(d_kbd_1.produce(r))

src/hhd/device/legion_go/slim/base.py

@@ -340,6 +340,7 @@ def controller_loop_xinput(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -348,6 +349,10 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         prepare(d_xinput)
         prepare(d_shortcuts)
@@ -365,14 +370,22 @@ def prepare(m):
 
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
-                to_run.add(id(fd_to_dev[f]))
+                to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))
 

src/hhd/device/legion_go/tablet/base.py

@@ -337,6 +337,7 @@ def controller_loop_xinput(
     fds = []
     devs = []
     fd_to_dev = {}
+    dynamic_devs = []
 
     def prepare(m):
         devs.append(m)
@@ -345,6 +346,10 @@ def prepare(m):
         for f in fs:
             fd_to_dev[f] = m
 
+    def prepare_dynamic(m):
+        dynamic_devs.append(m)
+        m.open()
+
     try:
         prepare(d_xinput)
         prepare(d_shortcuts)
@@ -360,14 +365,22 @@ def prepare(m):
         logger.info("Emulated controller launched, have fun!")
         while not should_exit.is_set() and not updated.is_set():
             start = time.perf_counter()
+            # Add fds of dynamic devices
+            to_select = fds.copy()
+            fd_to_dev_all = fd_to_dev.copy()
+            for d in dynamic_devs:
+                if d.fd != -1:
+                    to_select.append(d.fd)
+                    fd_to_dev_all[d.fd] = d
+
             # Add timeout to call consumers a minimum amount of times per second
-            r, _, _ = select.select(fds, [], [], REPORT_DELAY_MAX)
+            r, _, _ = select.select(to_select, [], [], REPORT_DELAY_MAX)
             evs = []
             to_run = set()
             for f in r:
-                to_run.add(id(fd_to_dev[f]))
+                to_run.add(id(fd_to_dev_all[f]))
 
-            for d in devs:
+            for d in [*devs, *dynamic_devs]:
                 if id(d) in to_run:
                     evs.extend(d.produce(r))