fix(keyboard): track media key press state

Apps/Keyty/Sources/Keyty/Features/Settings/Keyboard/KeyboardSettingsPane+PreviewGroup.swift

@@ -167,10 +167,10 @@ extension KeyboardSettingsPane.PreviewGroup {
     private static func mediaKeySampleGroups() -> [[KeycapPreviewSample]] {
         [
             [
-                .media(.brightnessUp)
+                .media(.brightnessUp, isPressed: true)
             ],
             [
-                .media(.play)
+                .media(.play, isPressed: true)
             ],
         ]
     }

Apps/Keyty/Sources/Keyty/Features/Visualizers/Keyboard/KeyboardVisualizer.swift

@@ -96,7 +96,9 @@ final class KeyboardVisualizer {
             self.prepareForNextContentEvent()
 
             let keycap = KeycapItemFactory.mediaKeyItem(for: mediaKey, palette: self.visualizerSettings.palette)
-            self.eventCoordinator.handleStandalone(
+            self.eventCoordinator.handleMediaKey(
+                kind: mediaKey.kind,
+                isPressed: keycap.isPressed,
                 items: [keycap],
                 appendGroup: { self.visualizerWindow.appendGroup(with: $0) },
                 updateGroup: { group, items in self.visualizerWindow.updateGroup(group, with: items) }

Apps/Keyty/Sources/Keyty/Features/Visualizers/Keyboard/KeycapEventCoordinator.swift

@@ -13,17 +13,22 @@ protocol KeycapGroupItem {
 }
 
 final class KeycapEventCoordinator<GroupView: AnyObject, Item: KeycapGroupItem> {
+    private enum TrackedButtonIdentifier: Hashable {
+        case mouse(MouseEvent.Kind)
+        case media(MediaKeyEvent.Kind)
+    }
+
     private var pendingModifierGroup: GroupView?
     private var completedModifierGroup: GroupView?
     private var activeKeyGroups: [UInt16: GroupView] = [:]
-    private var activeMouseGroups: [MouseEvent.Kind: GroupView] = [:]
+    private var activeButtonGroups: [TrackedButtonIdentifier: GroupView] = [:]
     private var groupItems: [ObjectIdentifier: [Item]] = [:]
 
     func reset() {
         self.pendingModifierGroup = nil
         self.completedModifierGroup = nil
         self.activeKeyGroups.removeAll(keepingCapacity: true)
-        self.activeMouseGroups.removeAll(keepingCapacity: true)
+        self.activeButtonGroups.removeAll(keepingCapacity: true)
         self.groupItems.removeAll(keepingCapacity: true)
     }
 
@@ -35,7 +40,7 @@ final class KeycapEventCoordinator<GroupView: AnyObject, Item: KeycapGroupItem>
             self.completedModifierGroup = nil
         }
         self.activeKeyGroups = self.activeKeyGroups.filter { $0.value !== group }
-        self.activeMouseGroups = self.activeMouseGroups.filter { $0.value !== group }
+        self.activeButtonGroups = self.activeButtonGroups.filter { $0.value !== group }
         self.groupItems[ObjectIdentifier(group)] = nil
     }
 
@@ -130,17 +135,75 @@ final class KeycapEventCoordinator<GroupView: AnyObject, Item: KeycapGroupItem>
         items: [Item],
         appendGroup: ([Item]) -> GroupView,
         updateGroup: (GroupView, [Item]) -> Void
+    ) {
+        self.handleTrackedButton(
+            identifier: .mouse(kind),
+            isPressed: isPressed,
+            items: items,
+            appendGroup: appendGroup,
+            updateGroup: updateGroup
+        )
+    }
+
+    func handleStandalone(
+        items: [Item],
+        appendGroup: ([Item]) -> GroupView,
+        updateGroup: (GroupView, [Item]) -> Void
+    ) {
+        guard !items.isEmpty else { return }
+
+        if let pendingModifierGroup, self.canAbsorbIntoPendingChord(pendingModifierGroup) {
+            let merged = self.ordered(items: self.merged(items: items, into: self.storedItems(for: pendingModifierGroup)))
+            self.groupItems[ObjectIdentifier(pendingModifierGroup)] = merged
+            updateGroup(pendingModifierGroup, merged)
+            self.completedModifierGroup = pendingModifierGroup
+            return
+        }
+
+        let group = appendGroup(items)
+        self.groupItems[ObjectIdentifier(group)] = items
+    }
+
+    func handleMediaKey(
+        kind: MediaKeyEvent.Kind,
+        isPressed: Bool,
+        items: [Item],
+        appendGroup: ([Item]) -> GroupView,
+        updateGroup: (GroupView, [Item]) -> Void
+    ) {
+        self.handleTrackedButton(
+            identifier: .media(kind),
+            isPressed: isPressed,
+            items: items,
+            appendGroup: appendGroup,
+            updateGroup: updateGroup
+        )
+    }
+}
+
+// MARK: - Private API
+private extension KeycapEventCoordinator {
+    private func storedItems(for group: GroupView) -> [Item] {
+        self.groupItems[ObjectIdentifier(group)] ?? []
+    }
+
+    private func handleTrackedButton(
+        identifier: TrackedButtonIdentifier,
+        isPressed: Bool,
+        items: [Item],
+        appendGroup: ([Item]) -> GroupView,
+        updateGroup: (GroupView, [Item]) -> Void
     ) {
         guard !items.isEmpty else { return }
 
-        if let activeGroup = self.activeMouseGroups[kind] {
+        if let activeGroup = self.activeButtonGroups[identifier] {
             let merged = self.ordered(items: self.merged(items: items, into: self.storedItems(for: activeGroup)))
             self.groupItems[ObjectIdentifier(activeGroup)] = merged
             updateGroup(activeGroup, merged)
             self.pendingModifierGroup = activeGroup
             self.completedModifierGroup = activeGroup
             if !isPressed {
-                self.activeMouseGroups[kind] = nil
+                self.activeButtonGroups[identifier] = nil
             }
             return
         }
@@ -151,7 +214,7 @@ final class KeycapEventCoordinator<GroupView: AnyObject, Item: KeycapGroupItem>
             updateGroup(pendingModifierGroup, merged)
             self.completedModifierGroup = pendingModifierGroup
             if isPressed {
-                self.activeMouseGroups[kind] = pendingModifierGroup
+                self.activeButtonGroups[identifier] = pendingModifierGroup
             }
             return
         }
@@ -161,36 +224,10 @@ final class KeycapEventCoordinator<GroupView: AnyObject, Item: KeycapGroupItem>
         self.groupItems[ObjectIdentifier(group)] = orderedItems
         self.completedModifierGroup = group
         if isPressed {
-            self.activeMouseGroups[kind] = group
+            self.activeButtonGroups[identifier] = group
         }
     }
 
-    func handleStandalone(
-        items: [Item],
-        appendGroup: ([Item]) -> GroupView,
-        updateGroup: (GroupView, [Item]) -> Void
-    ) {
-        guard !items.isEmpty else { return }
-
-        if let pendingModifierGroup, self.canAbsorbIntoPendingChord(pendingModifierGroup) {
-            let merged = self.ordered(items: self.merged(items: items, into: self.storedItems(for: pendingModifierGroup)))
-            self.groupItems[ObjectIdentifier(pendingModifierGroup)] = merged
-            updateGroup(pendingModifierGroup, merged)
-            self.completedModifierGroup = pendingModifierGroup
-            return
-        }
-
-        let group = appendGroup(items)
-        self.groupItems[ObjectIdentifier(group)] = items
-    }
-}
-
-// MARK: - Private API
-private extension KeycapEventCoordinator {
-    private func storedItems(for group: GroupView) -> [Item] {
-        self.groupItems[ObjectIdentifier(group)] ?? []
-    }
-
     /// Only pure modifier previews can absorb later modifier-only updates.
     private func canAppendModifiers(to group: GroupView) -> Bool {
         let items = self.storedItems(for: group)

Apps/Keyty/Sources/Keyty/Features/Visualizers/Keyboard/KeycapItemFactory.swift

@@ -128,7 +128,7 @@ enum KeycapItemFactory {
     }
 
     static func mediaKeyItem(for mediaKey: MediaKeyEvent, palette: KeycapThemePalette) -> KeycapItem {
-        Self.mediaKeyItem(for: mediaKey.kind, isPressed: false, palette: palette)
+        Self.mediaKeyItem(for: mediaKey.kind, isPressed: mediaKey.isPressed, palette: palette)
     }
 
     static func mediaKeyItem(

Apps/Keyty/Sources/Keyty/Platform/Capture/CaptureController/CaptureController.swift

@@ -193,7 +193,7 @@ extension CaptureController: EventTapDelegate {
     }
 
     func eventTap(_ tap: EventTap, noteMediaKey mediaKey: MediaKeyEvent) {
-        guard self.isCapturing, mediaKey.isPressed, mediaKey.isRecognized else { return }
+        guard self.isCapturing, mediaKey.isRecognized else { return }
         self.eventProcessor.noteMediaKey(mediaKey)
     }
 

Apps/Keyty/Tests/KeytyTests/Features/Settings/Keyboard/KeyboardSettingsPreviewTests.swift

@@ -90,6 +90,16 @@ final class KeyboardSettingsPreviewTests: XCTestCase {
         ])
     }
 
+    func testMediaPreviewGroupsRenderPressedMediaKeys() {
+        let groups = KeyboardSettingsPane.PreviewGroup.previewGroups(settings: settings)
+        let mediaGroups = groups.filter { $0.category == .mediaKey }
+
+        XCTAssertEqual(mediaGroups.count, 2)
+        XCTAssertTrue(mediaGroups.allSatisfy { group in
+            group.items.allSatisfy(\.isPressed)
+        })
+    }
+
     func testPreviewGroupsFallBackToKeyboardCategoryOnly() {
         settings.onlyShowModifiedKeystrokes = true
         settings.showSpecialKeys = false