769 lines
24 KiB
Markdown
769 lines
24 KiB
Markdown
# Mikrofon-Monitor Implementation Plan
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** Mikrofon-Geräteänderungen erkennen, bei fehlendem konfiguriertem Mikrofon automatisch auf Standard-Mikrofon wechseln und den Nutzer per Toast und Tray-Tooltip benachrichtigen.
|
||
|
||
**Architecture:** Neues `whisper_local/microphone/` Paket mit `MicrophoneMonitor`-Protocol und `create_monitor()`-Factory (analog zu `whisper_local/media/`). Windows nutzt `IMMNotificationClient` via `comtypes` mit Fallback auf Polling; alle anderen Plattformen nutzen Polling (`asyncio.sleep(2.5)`). Benachrichtigungen laufen über `notify-py` (cross-platform) und `PystrayApp.set_warning()`.
|
||
|
||
**Tech Stack:** Python 3.13+, `sounddevice` (device listing), `comtypes` (Windows COM), `notify-py` (Toast), `pystray` (Tray-Tooltip), `pytest-asyncio` (Tests)
|
||
|
||
---
|
||
|
||
## Dateiübersicht
|
||
|
||
| Aktion | Datei | Zweck |
|
||
|--------|-------|-------|
|
||
| Erstellen | `whisper_local/microphone/__init__.py` | Protocol + Factory |
|
||
| Erstellen | `whisper_local/microphone/_poll.py` | Polling-Implementierung |
|
||
| Erstellen | `whisper_local/microphone/_win32.py` | Windows IMMNotificationClient |
|
||
| Erstellen | `whisper_local/tray/_notification.py` | notify-py Wrapper |
|
||
| Ändern | `whisper_local/tray/_tray.py` | `set_warning()` zu `PystrayApp` + `NoOpTray` |
|
||
| Ändern | `whisper_local/__main__.py` | Monitor-Integration in `App` |
|
||
| Ändern | `pyproject.toml` | `notify-py` + `comtypes` als Abhängigkeiten |
|
||
| Erstellen | `tests/test_microphone_monitor.py` | Tests für `PollMonitor` |
|
||
|
||
---
|
||
|
||
## Task 1: Abhängigkeiten + `_notification.py`
|
||
|
||
**Files:**
|
||
- Modify: `pyproject.toml`
|
||
- Create: `whisper_local/tray/_notification.py`
|
||
|
||
- [ ] **Schritt 1: Abhängigkeiten in `pyproject.toml` eintragen**
|
||
|
||
In der `dependencies`-Liste nach `"darkdetect>=0.8.0",` folgende Zeilen ergänzen:
|
||
|
||
```toml
|
||
"notify-py>=0.3.43",
|
||
"comtypes>=1.4.0; sys_platform == 'win32'",
|
||
```
|
||
|
||
- [ ] **Schritt 2: Lock-File aktualisieren**
|
||
|
||
```
|
||
uv lock
|
||
```
|
||
|
||
Erwartete Ausgabe: `Resolved N packages` ohne Fehler.
|
||
|
||
- [ ] **Schritt 3: `_notification.py` anlegen**
|
||
|
||
```python
|
||
# whisper_local/tray/_notification.py
|
||
"""Desktop-Benachrichtigungen via notify-py."""
|
||
import logging
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
_APP_NAME = "whisper-local"
|
||
|
||
|
||
def notify(title: str, message: str) -> None:
|
||
"""Zeigt eine Desktop-Benachrichtigung. Bei Fehler wird nur geloggt."""
|
||
try:
|
||
from notifypy import Notify
|
||
n = Notify()
|
||
n.application_name = _APP_NAME
|
||
n.title = title
|
||
n.message = message
|
||
n.send()
|
||
except Exception:
|
||
logger.warning("Benachrichtigung fehlgeschlagen: %s – %s", title, message)
|
||
```
|
||
|
||
- [ ] **Schritt 4: Importtest**
|
||
|
||
```
|
||
uv run python -c "from whisper_local.tray._notification import notify; print('OK')"
|
||
```
|
||
|
||
Erwartete Ausgabe: `OK`
|
||
|
||
- [ ] **Schritt 5: Committen**
|
||
|
||
```
|
||
git add pyproject.toml uv.lock whisper_local/tray/_notification.py
|
||
git commit -m "feat(notify): notify-py + _notification.py Wrapper"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 2: `MicrophoneMonitor` Protocol + Factory-Skeleton
|
||
|
||
**Files:**
|
||
- Create: `whisper_local/microphone/__init__.py`
|
||
|
||
- [ ] **Schritt 1: Paket anlegen**
|
||
|
||
```python
|
||
# whisper_local/microphone/__init__.py
|
||
"""Mikrofon-Geräteüberwachung — plattformspezifische Backends."""
|
||
import sys
|
||
from collections.abc import Awaitable, Callable
|
||
from typing import Protocol
|
||
|
||
|
||
class MicrophoneMonitor(Protocol):
|
||
on_device_added: Callable[[str], Awaitable[None]] | None
|
||
on_device_removed: Callable[[str], Awaitable[None]] | None
|
||
on_configured_missing: Callable[[], Awaitable[None]] | None
|
||
|
||
async def start(self) -> None: ...
|
||
def stop(self) -> None: ...
|
||
|
||
|
||
def create_monitor(configured_device: str | None) -> MicrophoneMonitor:
|
||
"""Erstellt den plattformspezifischen Mikrofon-Monitor."""
|
||
if sys.platform == "win32":
|
||
from whisper_local.microphone._win32 import Win32Monitor
|
||
return Win32Monitor(configured_device)
|
||
from whisper_local.microphone._poll import PollMonitor
|
||
return PollMonitor(configured_device)
|
||
```
|
||
|
||
- [ ] **Schritt 2: Importtest**
|
||
|
||
```
|
||
uv run python -c "from whisper_local.microphone import create_monitor; print('OK')"
|
||
```
|
||
|
||
Erwartete Ausgabe: `OK` (auf Windows schlägt das vorerst fehl, weil `_win32.py` noch nicht existiert — das ist OK, kommt in Task 5)
|
||
|
||
- [ ] **Schritt 3: Committen**
|
||
|
||
```
|
||
git add whisper_local/microphone/__init__.py
|
||
git commit -m "feat(microphone): Protocol + create_monitor() Factory-Skeleton"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 3: `PollMonitor` — Geräteerkennung (TDD)
|
||
|
||
**Files:**
|
||
- Create: `whisper_local/microphone/_poll.py`
|
||
- Create: `tests/test_microphone_monitor.py`
|
||
|
||
- [ ] **Schritt 1: Testdatei anlegen (schlägt zunächst fehl)**
|
||
|
||
```python
|
||
# tests/test_microphone_monitor.py
|
||
import asyncio
|
||
from unittest.mock import AsyncMock, patch
|
||
|
||
import pytest
|
||
|
||
from whisper_local.microphone._poll import PollMonitor
|
||
|
||
|
||
def _fake_devices(names: list[str]) -> list[dict]:
|
||
return [{"name": n, "max_input_channels": 1} for n in names]
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_on_device_added_fires_when_device_appears():
|
||
monitor = PollMonitor(configured_device=None, interval=0.05)
|
||
event = asyncio.Event()
|
||
added: list[str] = []
|
||
|
||
async def on_added(name: str) -> None:
|
||
added.append(name)
|
||
event.set()
|
||
|
||
monitor.on_device_added = on_added
|
||
call_count = 0
|
||
|
||
def fake_query():
|
||
nonlocal call_count
|
||
call_count += 1
|
||
if call_count == 1:
|
||
return _fake_devices(["Mic A"])
|
||
return _fake_devices(["Mic A", "Mic B"])
|
||
|
||
with patch("sounddevice.query_devices", side_effect=fake_query):
|
||
await monitor.start()
|
||
await asyncio.wait_for(event.wait(), timeout=1.0)
|
||
monitor.stop()
|
||
|
||
assert added == ["Mic B"]
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_on_device_removed_fires_when_device_disappears():
|
||
monitor = PollMonitor(configured_device=None, interval=0.05)
|
||
event = asyncio.Event()
|
||
removed: list[str] = []
|
||
|
||
async def on_removed(name: str) -> None:
|
||
removed.append(name)
|
||
event.set()
|
||
|
||
monitor.on_device_removed = on_removed
|
||
call_count = 0
|
||
|
||
def fake_query():
|
||
nonlocal call_count
|
||
call_count += 1
|
||
if call_count == 1:
|
||
return _fake_devices(["Mic A", "Mic B"])
|
||
return _fake_devices(["Mic A"])
|
||
|
||
with patch("sounddevice.query_devices", side_effect=fake_query):
|
||
await monitor.start()
|
||
await asyncio.wait_for(event.wait(), timeout=1.0)
|
||
monitor.stop()
|
||
|
||
assert removed == ["Mic B"]
|
||
```
|
||
|
||
- [ ] **Schritt 2: Tests ausführen — müssen FEHLSCHLAGEN**
|
||
|
||
```
|
||
uv run pytest tests/test_microphone_monitor.py -v
|
||
```
|
||
|
||
Erwartete Ausgabe: `ModuleNotFoundError: No module named 'whisper_local.microphone._poll'`
|
||
|
||
- [ ] **Schritt 3: `_poll.py` implementieren**
|
||
|
||
```python
|
||
# whisper_local/microphone/_poll.py
|
||
"""Polling-basierter Mikrofon-Monitor (cross-platform)."""
|
||
import asyncio
|
||
import logging
|
||
from collections.abc import Awaitable, Callable
|
||
|
||
import sounddevice as sd
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class PollMonitor:
|
||
def __init__(self, configured_device: str | None, interval: float = 2.5):
|
||
self.configured_device = configured_device
|
||
self.interval = interval
|
||
self.on_device_added: Callable[[str], Awaitable[None]] | None = None
|
||
self.on_device_removed: Callable[[str], Awaitable[None]] | None = None
|
||
self.on_configured_missing: Callable[[], Awaitable[None]] | None = None
|
||
self._task: asyncio.Task | None = None
|
||
self._known_devices: set[str] = set()
|
||
|
||
def _current_devices(self) -> set[str]:
|
||
try:
|
||
return {
|
||
dev["name"]
|
||
for dev in sd.query_devices()
|
||
if dev["max_input_channels"] > 0
|
||
}
|
||
except Exception:
|
||
logger.exception("Fehler beim Abfragen der Audiogeräte")
|
||
return self._known_devices.copy()
|
||
|
||
async def start(self) -> None:
|
||
self._known_devices = self._current_devices()
|
||
self._task = asyncio.create_task(self._loop())
|
||
|
||
def stop(self) -> None:
|
||
if self._task is not None:
|
||
self._task.cancel()
|
||
self._task = None
|
||
|
||
async def _loop(self) -> None:
|
||
while True:
|
||
await asyncio.sleep(self.interval)
|
||
current = self._current_devices()
|
||
added = current - self._known_devices
|
||
removed = self._known_devices - current
|
||
self._known_devices = current
|
||
|
||
for name in added:
|
||
if self.on_device_added:
|
||
await self.on_device_added(name)
|
||
|
||
for name in removed:
|
||
if self.on_device_removed:
|
||
await self.on_device_removed(name)
|
||
```
|
||
|
||
- [ ] **Schritt 4: Tests ausführen — müssen BESTEHEN**
|
||
|
||
```
|
||
uv run pytest tests/test_microphone_monitor.py -v
|
||
```
|
||
|
||
Erwartete Ausgabe:
|
||
```
|
||
PASSED tests/test_microphone_monitor.py::test_on_device_added_fires_when_device_appears
|
||
PASSED tests/test_microphone_monitor.py::test_on_device_removed_fires_when_device_disappears
|
||
```
|
||
|
||
- [ ] **Schritt 5: Committen**
|
||
|
||
```
|
||
git add whisper_local/microphone/_poll.py tests/test_microphone_monitor.py
|
||
git commit -m "feat(microphone): PollMonitor mit Geräteerkennung (TDD)"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 4: `PollMonitor` — sofortige Startprüfung (TDD)
|
||
|
||
**Files:**
|
||
- Modify: `whisper_local/microphone/_poll.py`
|
||
- Modify: `tests/test_microphone_monitor.py`
|
||
|
||
- [ ] **Schritt 1: Zwei neue Tests zur Testdatei hinzufügen** (nach den bestehenden Tests einfügen)
|
||
|
||
```python
|
||
@pytest.mark.asyncio
|
||
async def test_on_configured_missing_fires_immediately_at_start():
|
||
monitor = PollMonitor(configured_device="Headset USB", interval=99.0)
|
||
missing_called = asyncio.Event()
|
||
|
||
async def on_missing() -> None:
|
||
missing_called.set()
|
||
|
||
monitor.on_configured_missing = on_missing
|
||
|
||
with patch("sounddevice.query_devices", return_value=_fake_devices(["Mic A"])):
|
||
await monitor.start()
|
||
|
||
assert missing_called.is_set()
|
||
monitor.stop()
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_on_configured_missing_does_not_fire_when_device_present():
|
||
monitor = PollMonitor(configured_device="Headset USB", interval=99.0)
|
||
missing_mock = AsyncMock()
|
||
monitor.on_configured_missing = missing_mock
|
||
|
||
with patch("sounddevice.query_devices", return_value=_fake_devices(["Headset USB", "Mic A"])):
|
||
await monitor.start()
|
||
|
||
missing_mock.assert_not_called()
|
||
monitor.stop()
|
||
```
|
||
|
||
- [ ] **Schritt 2: Tests ausführen — die zwei neuen müssen FEHLSCHLAGEN**
|
||
|
||
```
|
||
uv run pytest tests/test_microphone_monitor.py::test_on_configured_missing_fires_immediately_at_start tests/test_microphone_monitor.py::test_on_configured_missing_does_not_fire_when_device_present -v
|
||
```
|
||
|
||
Erwartete Ausgabe: `FAILED` für beide neuen Tests.
|
||
|
||
- [ ] **Schritt 3: `PollMonitor.start()` um sofortige Prüfung erweitern**
|
||
|
||
In `whisper_local/microphone/_poll.py` die Methode `start()` ersetzen:
|
||
|
||
```python
|
||
async def start(self) -> None:
|
||
self._known_devices = self._current_devices()
|
||
if (
|
||
self.configured_device
|
||
and self.configured_device not in self._known_devices
|
||
and self.on_configured_missing
|
||
):
|
||
await self.on_configured_missing()
|
||
self._task = asyncio.create_task(self._loop())
|
||
```
|
||
|
||
- [ ] **Schritt 4: Alle Tests ausführen — müssen BESTEHEN**
|
||
|
||
```
|
||
uv run pytest tests/test_microphone_monitor.py -v
|
||
```
|
||
|
||
Erwartete Ausgabe: 4× `PASSED`
|
||
|
||
- [ ] **Schritt 5: Committen**
|
||
|
||
```
|
||
git add whisper_local/microphone/_poll.py tests/test_microphone_monitor.py
|
||
git commit -m "feat(microphone): PollMonitor meldet fehlendes Gerät sofort beim Start"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 5: `Win32Monitor` mit IMMNotificationClient
|
||
|
||
**Files:**
|
||
- Create: `whisper_local/microphone/_win32.py`
|
||
|
||
- [ ] **Schritt 1: `_win32.py` anlegen**
|
||
|
||
```python
|
||
# whisper_local/microphone/_win32.py
|
||
"""Windows Mikrofon-Monitor via IMMNotificationClient (Core Audio API)."""
|
||
import asyncio
|
||
import ctypes
|
||
import logging
|
||
from collections.abc import Awaitable, Callable
|
||
|
||
import sounddevice as sd
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
_CLSID_MMDeviceEnumerator = "{BCDE0395-E52F-467C-8E3D-C4579291692E}"
|
||
_IID_IMMDeviceEnumerator = "{A95664D2-9614-4F35-A746-DE8DB63617E6}"
|
||
_IID_IMMNotificationClient = "{7991EEC9-7E89-4D85-8390-6C703CEC60C0}"
|
||
|
||
|
||
def _build_com_interfaces():
|
||
"""Definiert IMMDeviceEnumerator und IMMNotificationClient via comtypes."""
|
||
import comtypes
|
||
from comtypes import COMMETHOD, GUID, HRESULT, IUnknown, POINTER
|
||
|
||
class _IMMNotificationClient(IUnknown):
|
||
_iid_ = GUID(_IID_IMMNotificationClient)
|
||
_methods_ = [
|
||
COMMETHOD([], HRESULT, "OnDeviceStateChanged",
|
||
(["in"], ctypes.c_wchar_p, "pwstrDeviceId"),
|
||
(["in"], ctypes.c_uint, "dwNewState")),
|
||
COMMETHOD([], HRESULT, "OnDeviceAdded",
|
||
(["in"], ctypes.c_wchar_p, "pwstrDeviceId")),
|
||
COMMETHOD([], HRESULT, "OnDeviceRemoved",
|
||
(["in"], ctypes.c_wchar_p, "pwstrDeviceId")),
|
||
COMMETHOD([], HRESULT, "OnDefaultDeviceChanged",
|
||
(["in"], ctypes.c_int, "flow"),
|
||
(["in"], ctypes.c_int, "role"),
|
||
(["in"], ctypes.c_wchar_p, "pwstrDefaultDeviceId")),
|
||
COMMETHOD([], HRESULT, "OnPropertyValueChanged",
|
||
(["in"], ctypes.c_wchar_p, "pwstrDeviceId"),
|
||
(["in"], ctypes.c_void_p, "key")),
|
||
]
|
||
|
||
class _IMMDeviceEnumerator(IUnknown):
|
||
_iid_ = GUID(_IID_IMMDeviceEnumerator)
|
||
_methods_ = [
|
||
COMMETHOD([], HRESULT, "EnumAudioEndpoints",
|
||
(["in"], ctypes.c_int, "dataFlow"),
|
||
(["in"], ctypes.c_uint, "dwStateMask"),
|
||
(["out"], POINTER(IUnknown), "ppDevices")),
|
||
COMMETHOD([], HRESULT, "GetDefaultAudioEndpoint",
|
||
(["in"], ctypes.c_int, "dataFlow"),
|
||
(["in"], ctypes.c_int, "role"),
|
||
(["out"], POINTER(IUnknown), "ppEndpoint")),
|
||
COMMETHOD([], HRESULT, "GetDevice",
|
||
(["in"], ctypes.c_wchar_p, "pwstrId"),
|
||
(["out"], POINTER(IUnknown), "ppDevice")),
|
||
COMMETHOD([], HRESULT, "RegisterEndpointNotificationCallback",
|
||
(["in"], POINTER(_IMMNotificationClient), "pClient")),
|
||
COMMETHOD([], HRESULT, "UnregisterEndpointNotificationCallback",
|
||
(["in"], POINTER(_IMMNotificationClient), "pClient")),
|
||
]
|
||
|
||
return _IMMNotificationClient, _IMMDeviceEnumerator
|
||
|
||
|
||
def _build_client_class(IMMNotificationClient, callback):
|
||
"""Erstellt eine comtypes.COMObject-Implementierung von IMMNotificationClient."""
|
||
import comtypes
|
||
|
||
class _NotificationClientImpl(comtypes.COMObject):
|
||
_com_interfaces_ = [IMMNotificationClient]
|
||
|
||
def OnDeviceStateChanged(self, pwstrDeviceId, dwNewState):
|
||
callback()
|
||
return 0
|
||
|
||
def OnDeviceAdded(self, pwstrDeviceId):
|
||
callback()
|
||
return 0
|
||
|
||
def OnDeviceRemoved(self, pwstrDeviceId):
|
||
callback()
|
||
return 0
|
||
|
||
def OnDefaultDeviceChanged(self, flow, role, pwstrDefaultDeviceId):
|
||
return 0
|
||
|
||
def OnPropertyValueChanged(self, pwstrDeviceId, key):
|
||
return 0
|
||
|
||
return _NotificationClientImpl()
|
||
|
||
|
||
class Win32Monitor:
|
||
def __init__(self, configured_device: str | None):
|
||
self.configured_device = configured_device
|
||
self.on_device_added: Callable[[str], Awaitable[None]] | None = None
|
||
self.on_device_removed: Callable[[str], Awaitable[None]] | None = None
|
||
self.on_configured_missing: Callable[[], Awaitable[None]] | None = None
|
||
self._loop: asyncio.AbstractEventLoop | None = None
|
||
self._known_devices: set[str] = set()
|
||
self._enumerator = None
|
||
self._client = None
|
||
self._fallback = None
|
||
|
||
def _current_devices(self) -> set[str]:
|
||
try:
|
||
return {
|
||
dev["name"]
|
||
for dev in sd.query_devices()
|
||
if dev["max_input_channels"] > 0
|
||
}
|
||
except Exception:
|
||
logger.exception("Fehler beim Abfragen der Audiogeräte")
|
||
return self._known_devices.copy()
|
||
|
||
async def start(self) -> None:
|
||
self._loop = asyncio.get_running_loop()
|
||
self._known_devices = self._current_devices()
|
||
|
||
if (
|
||
self.configured_device
|
||
and self.configured_device not in self._known_devices
|
||
and self.on_configured_missing
|
||
):
|
||
await self.on_configured_missing()
|
||
|
||
try:
|
||
self._start_com()
|
||
except Exception:
|
||
logger.warning(
|
||
"IMMNotificationClient nicht verfügbar, Fallback auf Polling",
|
||
exc_info=True,
|
||
)
|
||
from whisper_local.microphone._poll import PollMonitor
|
||
fallback = PollMonitor(self.configured_device)
|
||
fallback.on_device_added = self.on_device_added
|
||
fallback.on_device_removed = self.on_device_removed
|
||
fallback._known_devices = self._known_devices
|
||
self._fallback = fallback
|
||
self._fallback._task = asyncio.create_task(self._fallback._loop())
|
||
|
||
def _start_com(self) -> None:
|
||
import comtypes
|
||
import comtypes.client
|
||
from comtypes import GUID
|
||
|
||
comtypes.CoInitialize()
|
||
IMMNotificationClient, IMMDeviceEnumerator = _build_com_interfaces()
|
||
self._enumerator = comtypes.client.CreateObject(
|
||
GUID(_CLSID_MMDeviceEnumerator),
|
||
interface=IMMDeviceEnumerator,
|
||
)
|
||
self._client = _build_client_class(IMMNotificationClient, self._on_com_event)
|
||
self._enumerator.RegisterEndpointNotificationCallback(self._client)
|
||
|
||
def _on_com_event(self) -> None:
|
||
if self._loop is not None:
|
||
self._loop.call_soon_threadsafe(
|
||
lambda: asyncio.ensure_future(self._handle_change())
|
||
)
|
||
|
||
async def _handle_change(self) -> None:
|
||
current = self._current_devices()
|
||
added = current - self._known_devices
|
||
removed = self._known_devices - current
|
||
self._known_devices = current
|
||
|
||
for name in added:
|
||
if self.on_device_added:
|
||
await self.on_device_added(name)
|
||
|
||
for name in removed:
|
||
if self.on_device_removed:
|
||
await self.on_device_removed(name)
|
||
|
||
def stop(self) -> None:
|
||
if self._fallback is not None:
|
||
self._fallback.stop()
|
||
return
|
||
if self._enumerator is not None and self._client is not None:
|
||
try:
|
||
self._enumerator.UnregisterEndpointNotificationCallback(self._client)
|
||
except Exception:
|
||
logger.warning("Fehler beim Deregistrieren des Notification-Clients")
|
||
try:
|
||
import comtypes
|
||
comtypes.CoUninitialize()
|
||
except Exception:
|
||
pass
|
||
```
|
||
|
||
- [ ] **Schritt 2: Importtest auf Windows**
|
||
|
||
```
|
||
uv run python -c "from whisper_local.microphone._win32 import Win32Monitor; print('OK')"
|
||
```
|
||
|
||
Erwartete Ausgabe: `OK`
|
||
|
||
- [ ] **Schritt 3: Alle Tests laufen lassen**
|
||
|
||
```
|
||
uv run pytest tests/ -v
|
||
```
|
||
|
||
Erwartete Ausgabe: alle bestehenden Tests `PASSED`
|
||
|
||
- [ ] **Schritt 4: Committen**
|
||
|
||
```
|
||
git add whisper_local/microphone/_win32.py
|
||
git commit -m "feat(microphone): Win32Monitor via IMMNotificationClient mit Polling-Fallback"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 6: `PystrayApp.set_warning()` + `NoOpTray.set_warning()`
|
||
|
||
**Files:**
|
||
- Modify: `whisper_local/tray/_tray.py`
|
||
|
||
- [ ] **Schritt 1: `set_warning()` zu `PystrayApp` hinzufügen**
|
||
|
||
In `whisper_local/tray/_tray.py` nach der Methode `set_state` die neue Methode einfügen:
|
||
|
||
```python
|
||
def set_warning(self, msg: str | None) -> None:
|
||
"""Setzt Tray-Titel auf Warnung oder zurück auf normal (thread-sicher)."""
|
||
if self._icon is not None:
|
||
self._icon.title = "whisper-local" if msg is None else f"whisper-local ⚠ {msg}"
|
||
```
|
||
|
||
- [ ] **Schritt 2: `set_warning()` zu `NoOpTray` hinzufügen**
|
||
|
||
In `NoOpTray` nach `set_state` einfügen:
|
||
|
||
```python
|
||
def set_warning(self, msg: str | None) -> None:
|
||
pass
|
||
```
|
||
|
||
- [ ] **Schritt 3: Importtest**
|
||
|
||
```
|
||
uv run python -c "from whisper_local.tray._tray import PystrayApp, NoOpTray; print('OK')"
|
||
```
|
||
|
||
Erwartete Ausgabe: `OK`
|
||
|
||
- [ ] **Schritt 4: Committen**
|
||
|
||
```
|
||
git add whisper_local/tray/_tray.py
|
||
git commit -m "feat(tray): set_warning() für Tray-Tooltip-Warnung"
|
||
```
|
||
|
||
---
|
||
|
||
## Task 7: App-Integration
|
||
|
||
**Files:**
|
||
- Modify: `whisper_local/__main__.py`
|
||
|
||
- [ ] **Schritt 1: Import und Monitor-Erstellung in `App.__init__` hinzufügen**
|
||
|
||
In `whisper_local/__main__.py` den Import-Block am Anfang der Datei ergänzen:
|
||
|
||
```python
|
||
from whisper_local.microphone import create_monitor
|
||
```
|
||
|
||
In `App.__init__` nach `self.hotkey = create_listener(key_name=config.hotkey)` einfügen:
|
||
|
||
```python
|
||
self.monitor = create_monitor(config.microphone or None)
|
||
self.monitor.on_device_added = self._on_microphone_added
|
||
self.monitor.on_device_removed = self._on_microphone_removed
|
||
self.monitor.on_configured_missing = self._on_configured_microphone_missing
|
||
```
|
||
|
||
- [ ] **Schritt 2: Callbacks implementieren** (in `App`, nach `_open_settings`)
|
||
|
||
```python
|
||
async def _on_configured_microphone_missing(self) -> None:
|
||
"""Konfiguriertes Mikrofon nicht gefunden — auf Standard wechseln."""
|
||
from whisper_local.tray._notification import notify
|
||
device_name = self._config.microphone or "Mikrofon"
|
||
logger.warning("Konfiguriertes Mikrofon '%s' nicht gefunden, nutze Standard", device_name)
|
||
self.recorder = Recorder(
|
||
sample_rate=self._config.sample_rate,
|
||
channels=self._config.channels,
|
||
min_duration=self._config.min_duration,
|
||
device=None,
|
||
)
|
||
notify(
|
||
"Mikrofon nicht gefunden",
|
||
f"„{device_name}" ist nicht verfügbar. Standard-Mikrofon wird verwendet.",
|
||
)
|
||
self.tray.set_warning("Mikrofon nicht gefunden")
|
||
|
||
async def _on_microphone_added(self, device_name: str) -> None:
|
||
"""Neues Mikrofon erkannt — konfiguriertes Gerät ggf. wiederherstellen."""
|
||
if device_name != self._config.microphone:
|
||
return
|
||
from whisper_local.tray._notification import notify
|
||
logger.info("Konfiguriertes Mikrofon '%s' wieder verfügbar", device_name)
|
||
self.recorder = Recorder(
|
||
sample_rate=self._config.sample_rate,
|
||
channels=self._config.channels,
|
||
min_duration=self._config.min_duration,
|
||
device=self._config.microphone or None,
|
||
)
|
||
notify("Mikrofon verbunden", f"„{device_name}" ist wieder verfügbar.")
|
||
self.tray.set_warning(None)
|
||
|
||
async def _on_microphone_removed(self, device_name: str) -> None:
|
||
"""Mikrofon entfernt — konfiguriertes Gerät → Fallback auslösen."""
|
||
logger.info("Mikrofon entfernt: %s", device_name)
|
||
if device_name == self._config.microphone:
|
||
await self._on_configured_microphone_missing()
|
||
```
|
||
|
||
- [ ] **Schritt 3: Monitor in `App.run()` starten**
|
||
|
||
In `App.run()` nach `self._hotkey_task = asyncio.create_task(self.hotkey.listen())` einfügen:
|
||
|
||
```python
|
||
asyncio.create_task(self.monitor.start())
|
||
```
|
||
|
||
- [ ] **Schritt 4: Monitor in `_on_config_reload` neu starten**
|
||
|
||
In `_on_config_reload` nach dem Block mit `self.recorder = Recorder(...)` einfügen:
|
||
|
||
```python
|
||
self.monitor.stop()
|
||
self.monitor = create_monitor(new_config.microphone or None)
|
||
self.monitor.on_device_added = self._on_microphone_added
|
||
self.monitor.on_device_removed = self._on_microphone_removed
|
||
self.monitor.on_configured_missing = self._on_configured_microphone_missing
|
||
if self._loop is not None:
|
||
asyncio.run_coroutine_threadsafe(self.monitor.start(), self._loop)
|
||
self.tray.set_warning(None)
|
||
```
|
||
|
||
- [ ] **Schritt 5: Alle Tests ausführen**
|
||
|
||
```
|
||
uv run pytest tests/ -v
|
||
```
|
||
|
||
Erwartete Ausgabe: alle Tests `PASSED`
|
||
|
||
- [ ] **Schritt 6: App manuell testen**
|
||
|
||
```
|
||
uv run whisper-local
|
||
```
|
||
|
||
Prüfen:
|
||
- App startet ohne Fehler
|
||
- USB/Bluetooth-Mikrofon anstecken → kein Absturz
|
||
- Konfiguriertes Mikrofon abziehen (falls gesetzt) → Toast erscheint, Tray-Tooltip zeigt Warnung
|
||
- Mikrofon wieder anstecken → Toast „verbunden", Warnung verschwindet
|
||
|
||
- [ ] **Schritt 7: Committen**
|
||
|
||
```
|
||
git add whisper_local/__main__.py
|
||
git commit -m "feat(app): Mikrofon-Monitor in App integriert"
|
||
```
|