Logan
1a9c92b6db
Includes edge-node (FastAPI/MQTT/Discord voice), op25-container (SDR decoder), and icecast (audio streaming).
128 lines
4.3 KiB
Python
128 lines
4.3 KiB
Python
import asyncio
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
from typing import Optional, Callable, Awaitable
|
|
from app.internal.op25_client import op25_client
|
|
from app.internal.logger import logger
|
|
|
|
CallbackFn = Callable[[dict], Awaitable[None]]
|
|
|
|
HANG_THRESHOLD = 3 # polls before declaring a call ended (1 poll/sec → 3s hang time)
|
|
POLL_INTERVAL = 1.0 # seconds
|
|
|
|
|
|
class MetadataWatcher:
|
|
def __init__(self):
|
|
self._running = False
|
|
self._current_tgid: Optional[int] = None
|
|
self._hang_counter: int = 0
|
|
self._active_call_id: Optional[str] = None
|
|
self._call_started_at: Optional[datetime] = None
|
|
|
|
# Set these before calling start()
|
|
self.on_call_start: Optional[CallbackFn] = None
|
|
self.on_call_end: Optional[CallbackFn] = None
|
|
|
|
async def start(self):
|
|
self._running = True
|
|
asyncio.create_task(self._poll_loop())
|
|
logger.info("Metadata watcher started.")
|
|
|
|
async def stop(self):
|
|
self._running = False
|
|
if self._active_call_id:
|
|
await self._end_call()
|
|
|
|
async def _poll_loop(self):
|
|
while self._running:
|
|
try:
|
|
await self._tick()
|
|
except Exception as e:
|
|
logger.warning(f"Metadata poll error: {e}")
|
|
await asyncio.sleep(POLL_INTERVAL)
|
|
|
|
async def _tick(self):
|
|
status = await op25_client.get_terminal_status()
|
|
|
|
if not status:
|
|
# OP25 not responding — hang-out any active call
|
|
if self._active_call_id:
|
|
self._hang_counter += 1
|
|
if self._hang_counter >= HANG_THRESHOLD:
|
|
await self._end_call()
|
|
return
|
|
|
|
# OP25 terminal returns either a list of channels or a single dict
|
|
channels = status if isinstance(status, list) else [status]
|
|
active_tgid: Optional[int] = None
|
|
active_meta: dict = {}
|
|
|
|
for ch in channels:
|
|
tgid = ch.get("tgid") or ch.get("tg_id")
|
|
if tgid and str(tgid) not in ("0", "", "None"):
|
|
active_tgid = int(tgid)
|
|
active_meta = ch
|
|
break
|
|
|
|
if active_tgid:
|
|
self._hang_counter = 0
|
|
if self._current_tgid != active_tgid:
|
|
# Talkgroup changed — close previous call and open a new one
|
|
if self._active_call_id:
|
|
await self._end_call()
|
|
self._current_tgid = active_tgid
|
|
await self._start_call(active_tgid, active_meta)
|
|
else:
|
|
# No active talkgroup
|
|
if self._active_call_id:
|
|
self._hang_counter += 1
|
|
if self._hang_counter >= HANG_THRESHOLD:
|
|
await self._end_call()
|
|
|
|
async def _start_call(self, tgid: int, meta: dict):
|
|
self._active_call_id = str(uuid.uuid4())
|
|
self._call_started_at = datetime.now(timezone.utc)
|
|
payload = {
|
|
"call_id": self._active_call_id,
|
|
"tgid": tgid,
|
|
"tgid_name": meta.get("tag") or meta.get("tgid_tag") or "",
|
|
"freq": meta.get("freq"),
|
|
"srcaddr": meta.get("srcaddr"),
|
|
"started_at": self._call_started_at.isoformat(),
|
|
}
|
|
logger.info(f"Call start: tgid={tgid} id={self._active_call_id}")
|
|
if self.on_call_start:
|
|
await self.on_call_start(payload)
|
|
|
|
async def _end_call(self):
|
|
if not self._active_call_id:
|
|
return
|
|
payload = {
|
|
"call_id": self._active_call_id,
|
|
"tgid": self._current_tgid,
|
|
"started_at": self._call_started_at.isoformat() if self._call_started_at else None,
|
|
"ended_at": datetime.now(timezone.utc).isoformat(),
|
|
}
|
|
logger.info(f"Call end: id={self._active_call_id}")
|
|
self._active_call_id = None
|
|
self._current_tgid = None
|
|
self._hang_counter = 0
|
|
self._call_started_at = None
|
|
if self.on_call_end:
|
|
await self.on_call_end(payload)
|
|
|
|
@property
|
|
def active_call_id(self) -> Optional[str]:
|
|
return self._active_call_id
|
|
|
|
@property
|
|
def current_tgid(self) -> Optional[int]:
|
|
return self._current_tgid
|
|
|
|
@property
|
|
def is_active(self) -> bool:
|
|
return self._active_call_id is not None
|
|
|
|
|
|
metadata_watcher = MetadataWatcher()
|