Use metadata event value for followed output refresh

Author: bhack

src/mini_eq/routing.py

@@ -47,6 +47,7 @@
     PipeWireBackend,
     PipeWireNode,
     node_sample_rate,
+    parse_metadata_node_name,
 )
 from .pipewire_routes import PipeWireOutputPresetTarget
 from .pipewire_stream_router import PipeWireStreamRouter
@@ -68,6 +69,7 @@ def __init__(self, output_sink: str | None) -> None:
         self.engine_start_pending = False
         self.filter_node_id: int | None = None
         self.output_event_source_id = 0
+        self.pending_followed_output_sink: str | None = None
         self.output_object_added_handler_id = 0
         self.output_object_removed_handler_id = 0
         self.output_metadata_changed_handler_id = 0
@@ -321,6 +323,19 @@ def refresh_followed_output_sink(self) -> bool:
 
         return True
 
+    def refresh_followed_output_sink_from_event(self, sink_name: str | None) -> bool:
+        if not self.follow_default_output:
+            return False
+
+        if sink_name and self.is_valid_output_sink(sink_name) and self.get_sink(sink_name) is not None:
+            try:
+                self.switch_output_sink(sink_name, explicit=False)
+            except Exception as exc:
+                self.emit_status(f"default output follow warning: {exc}")
+            return True
+
+        return self.refresh_followed_output_sink()
+
     def schedule_output_event_refresh(self) -> None:
         if not getattr(self, "accept_output_events", False):
             return
@@ -355,6 +370,10 @@ def handle_output_metadata_changed(
     ) -> None:
         if subject == 0 and key in {DEFAULT_AUDIO_SINK_KEY, DEFAULT_CONFIGURED_AUDIO_SINK_KEY}:
             self.output_backend.remember_default_metadata_change(key, _value)
+            if getattr(self, "follow_default_output", False):
+                sink_name = parse_metadata_node_name(_value)
+                if sink_name and self.is_valid_output_sink(sink_name):
+                    self.pending_followed_output_sink = sink_name
             self.schedule_output_event_refresh()
 
     def handle_output_route_param_changed(self) -> None:
@@ -400,7 +419,12 @@ def on_output_event_idle(self) -> bool:
             return False
 
         self.invalidate_output_preset_target()
-        self.refresh_followed_output_sink()
+        pending_followed_output_sink = getattr(self, "pending_followed_output_sink", None)
+        self.pending_followed_output_sink = None
+        if pending_followed_output_sink is not None:
+            self.refresh_followed_output_sink_from_event(pending_followed_output_sink)
+        else:
+            self.refresh_followed_output_sink()
         self.refresh_output_route_param_monitor()
 
         if self.outputs_changed_callback is not None:

tests/test_mini_eq_routing.py

@@ -248,6 +248,67 @@ def test_output_metadata_change_schedules_one_refresh(monkeypatch: pytest.Monkey
     assert len(scheduled_callbacks) == 1
 
 
+def test_output_metadata_change_records_followed_sink_for_idle(monkeypatch: pytest.MonkeyPatch) -> None:
+    controller = routing.SystemWideEqController.__new__(routing.SystemWideEqController)
+    calls: list[object] = []
+
+    class FakeBackend:
+        def remember_default_metadata_change(self, key: str, value: str | None) -> bool:
+            calls.append(("remember", key, value))
+            return True
+
+    controller.accept_output_events = True
+    controller.follow_default_output = True
+    controller.output_event_source_id = 0
+    controller.pending_followed_output_sink = None
+    controller.output_backend = FakeBackend()
+    scheduled_callbacks: list[object] = []
+
+    monkeypatch.setattr(
+        routing.GLib,
+        "idle_add",
+        lambda callback: scheduled_callbacks.append(callback) or 321,
+    )
+
+    routing.SystemWideEqController.handle_output_metadata_changed(
+        controller,
+        None,
+        0,
+        pw_backend.DEFAULT_CONFIGURED_AUDIO_SINK_KEY,
+        "Spa:String:JSON",
+        '{"name":"hdmi"}',
+    )
+
+    assert calls == [("remember", pw_backend.DEFAULT_CONFIGURED_AUDIO_SINK_KEY, '{"name":"hdmi"}')]
+    assert controller.pending_followed_output_sink == "hdmi"
+    assert controller.output_event_source_id == 321
+    assert len(scheduled_callbacks) == 1
+
+
+def test_output_event_idle_uses_pending_followed_sink_before_metadata_refresh() -> None:
+    controller = routing.SystemWideEqController.__new__(routing.SystemWideEqController)
+    controller.accept_output_events = True
+    controller.output_event_source_id = 123
+    controller.pending_followed_output_sink = "hdmi"
+    controller.follow_default_output = True
+    controller.output_backend = FakeOutputBackend([make_node(1, "hdmi")])
+    controller._output_preset_target_sink = "speakers"
+    controller._output_preset_target = pw_routes.PipeWireOutputPresetTarget("speakers", None, ("speakers",))
+    calls: list[object] = []
+    controller.switch_output_sink = lambda sink_name, explicit: calls.append(("switch", sink_name, explicit))
+    controller.refresh_followed_output_sink = lambda: calls.append("refresh")
+    controller.refresh_output_route_param_monitor = lambda: calls.append("route-monitor")
+    controller.outputs_changed_callback = lambda: calls.append("outputs")
+
+    assert routing.SystemWideEqController.on_output_event_idle(controller) is False
+
+    assert controller.output_event_source_id == 0
+    assert controller.pending_followed_output_sink is None
+    assert controller._output_preset_target_sink is None
+    assert controller._output_preset_target is None
+    assert calls == [("switch", "hdmi", False), "route-monitor", "outputs"]
+
+
 def test_output_object_added_schedules_refresh_only_for_audio_sinks(monkeypatch: pytest.MonkeyPatch) -> None:
     controller = routing.SystemWideEqController.__new__(routing.SystemWideEqController)
     controller.accept_output_events = True