Update InputManager

Author: ThomasFarstrike

docs/frameworks/input-manager.md

@@ -1,6 +1,6 @@
 # InputManager
 
-InputManager is a singleton framework that provides a unified API for managing input device interactions, including pointer/touch coordinates and focus management.
+InputManager is a singleton framework that provides a unified API for managing input device interactions, including pointer/touch coordinates, focus management, and input device registration.
 
 ## Overview
 
@@ -11,13 +11,16 @@ InputManager centralizes all input-related operations in a single class with cla
 - **Testable** - InputManager can be tested independently
 - **Focus Control** - Emulate focus on specific UI objects
 - **Pointer Access** - Get current touch/pointer coordinates
+- **Device Registration** - Register and query available input devices by type
 
 ## Architecture
 
 InputManager is implemented as a singleton using class variables and class methods:
 
 ```python
 class InputManager:
+    _registered_indevs = []  # List of registered input devices
+    
     @classmethod
     def pointer_xy(cls):
         """Get current pointer/touch coordinates."""
@@ -33,6 +36,25 @@ class InputManager:
     def emulate_focus_obj(cls, focusgroup, target):
         """Emulate setting focus to a specific object."""
         # ... implementation
+    
+    @classmethod
+    def register_indev(cls, indev):
+        """Register an input device for later querying."""
+        if indev and indev not in cls._registered_indevs:
+            cls._registered_indevs.append(indev)
+    
+    @classmethod
+    def list_indevs(cls):
+        """Get list of all registered input devices."""
+        return cls._registered_indevs
+    
+    @classmethod
+    def has_indev_type(cls, indev_type):
+        """Check if any registered input device has the specified type."""
+        for indev in cls._registered_indevs:
+            if indev.get_type() == indev_type:
+                return True
+        return False
 ```
 
 No instance creation is needed - all methods are class methods that operate on class variables.
@@ -100,6 +122,55 @@ if focusgroup:
     InputManager.emulate_focus_obj(focusgroup, my_button)
 ```
 
+#### `register_indev(indev)`
+Register an input device for later querying by type.
+
+This method is called by board initialization code to register available input devices. Apps can then query these devices without hardcoding hardware IDs.
+
+**Parameters:**
+- `indev` (lv.indev): The LVGL input device to register
+
+**Returns:** None
+
+**Example:**
+```python
+# In board initialization (e.g., fri3d_2024.py)
+indev = lv.indev_create()
+indev.set_type(lv.INDEV_TYPE.KEYPAD)
+indev.set_read_cb(keypad_read_cb)
+InputManager.register_indev(indev)
+```
+
+#### `list_indevs()`
+Get list of all registered input devices.
+
+**Returns:** list - List of registered LVGL input devices
+
+**Example:**
+```python
+devices = InputManager.list_indevs()
+for indev in devices:
+    print(f"Device type: {indev.get_type()}")
+```
+
+#### `has_indev_type(indev_type)`
+Check if any registered input device has the specified type.
+
+This is a convenience method for checking device capabilities without iterating through the device list.
+
+**Parameters:**
+- `indev_type` (int): LVGL input device type (e.g., `lv.INDEV_TYPE.KEYPAD`, `lv.INDEV_TYPE.POINTER`)
+
+**Returns:** bool - True if a device with the specified type is registered, False otherwise
+
+**Example:**
+```python
+if InputManager.has_indev_type(lv.INDEV_TYPE.KEYPAD):
+    print("Device has physical buttons")
+else:
+    print("Device is touch-only")
+```
+
 ## Practical Examples
 
 ### Touch Event Handling
@@ -161,6 +232,49 @@ def navigate_to_button(button):
         print(f"Focus moved to {button}")
 ```
 
+### Input Device Registration (Board Initialization)
+
+```python
+# In board initialization file (e.g., fri3d_2024.py)
+from mpos import InputManager
+import lvgl as lv
+
+# Create and configure input device
+indev = lv.indev_create()
+indev.set_type(lv.INDEV_TYPE.KEYPAD)
+indev.set_read_cb(keypad_read_cb)
+
+# Register with InputManager for app access
+InputManager.register_indev(indev)
+```
+
+### Querying Input Devices (App Code)
+
+```python
+from mpos import InputManager, Activity
+import lvgl as lv
+
+class MyGame(Activity):
+    def onCreate(self):
+        # Check if device has physical buttons
+        if InputManager.has_indev_type(lv.INDEV_TYPE.KEYPAD):
+            # Show button-based controls
+            self.show_button_controls()
+        else:
+            # Show touch-based controls
+            self.show_touch_controls()
+    
+    def show_button_controls(self):
+        """Display UI optimized for physical buttons."""
+        helptext = "Press A to start!\nY to reset, B to show FPS"
+        # ... setup button-based UI ...
+    
+    def show_touch_controls(self):
+        """Display UI optimized for touch."""
+        helptext = "Tap to start!\nTop left to reset, bottom left for FPS"
+        # ... setup touch-based UI ...
+```
+
 ## Implementation Details
 
 ### File Structure
@@ -227,6 +341,32 @@ focusgroup = lv.group_get_default()
 focusgroup.focus_next()
 ```
 
+### Device Registration Pattern
+
+InputManager uses a registration pattern to decouple hardware initialization from app code:
+
+**Board Initialization (Hardware Layer):**
+```python
+# fri3d_2024.py - knows about hardware
+InputManager.register_indev(keypad_indev)
+InputManager.register_indev(touch_indev)
+```
+
+**App Code (Application Layer):**
+```python
+# quasibird.py - doesn't know about hardware
+if InputManager.has_indev_type(lv.INDEV_TYPE.KEYPAD):
+    # Adapt UI for buttons
+else:
+    # Adapt UI for touch
+```
+
+This pattern provides:
+- **Hardware Abstraction** - Apps don't hardcode hardware IDs
+- **Flexibility** - New boards can register different devices
+- **Testability** - Apps can be tested with different device configurations
+- **Scalability** - Easy to add new input device types
+
 ## Related Frameworks
 
 - **[DisplayMetrics](display-metrics.md)** - Display properties and pointer coordinates (now uses InputManager)