bart/jellyfin-client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(eventserver): implement Kodi UDP EventServer on port 9777 for Yatse

Browse Source
This commit is contained in:
bart
2026-11-02 21:52:14 +01:00
parent 3a0ea206a2
commit 935225b7bb
6 changed files with 162 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Dockerfile
+1 -1
View File
@@ -29,7 +29,7 @@ COPY config.example.yaml ./config.example.yaml
# If no config.yaml exists at runtime, fallback to config.example.yaml
RUN cp config.example.yaml config.yaml
EXPOSE 8080 9090 8097
EXPOSE 8080 9090 8097 9777/udp
ENTRYPOINT ["python3", "-m", "src.main"]
CMD ["-c", "config.yaml"]
docker-compose.yml
+4 -3
View File
@@ -6,9 +6,10 @@ services:
container_name: jellyfin-client
restart: unless-stopped
ports:
- "8080:8080" # Kodi JSON-RPC (Yatse)
- "9090:9090" # Kodi JSON-RPC WebSocket
- "8097:8097" # Web Remote & REST API
- "8080:8080" # Kodi JSON-RPC (Yatse)
- "9090:9090" # Kodi JSON-RPC WebSocket & TCP Socket
- "9777:9777/udp" # Kodi EventServer (UDP)
- "8097:8097" # Web Remote & REST API
environment:
- DISPLAY=${DISPLAY:-:0}
- MPV_VO=${MPV_VO:-gpu} # Change to 'null' for headless test without window
src/config.py
+1
View File
@@ -39,6 +39,7 @@ class KodiRpcConfig:
enabled: bool = True
http_port: int = 8080
ws_port: int = 9090
event_port: int = 9777
@dataclass
src/main.py
+5
View File
@@ -10,6 +10,7 @@ from typing import List
from src.config import AppConfig
from src.jellyfin.client import JellyfinClient
from src.player.mpv_controller import MpvController
from src.remotes.kodi_eventserver import KodiEventServer
from src.remotes.kodi_rpc import KodiRpcServer
from src.remotes.rest_api import RestApiServer
@@ -27,12 +28,14 @@ async def run_app(config: AppConfig) -> None:
player = MpvController(config.player)
jellyfin = JellyfinClient(config.jellyfin, player)
kodi_rpc = KodiRpcServer(config.kodi_rpc, player)
kodi_event = KodiEventServer(config.kodi_rpc.event_port, player)
rest_api = RestApiServer(config.web_api, player)
# Start services
await player.start()
await jellyfin.start()
await kodi_rpc.start()
await kodi_event.start()
await rest_api.start()
logger.info("Jellyfin HTPC Client is fully initialized and ready.")
@@ -55,9 +58,11 @@ async def run_app(config: AppConfig) -> None:
logger.info("Shutting down services...")
await rest_api.shutdown()
await kodi_event.shutdown()
await kodi_rpc.shutdown()
await jellyfin.shutdown()
await player.shutdown()
logger.info("Graceful shutdown complete.")
src/remotes/kodi_eventserver.py
+142
View File
@@ -0,0 +1,142 @@
from __future__ import annotations
import asyncio
import logging
import struct
from typing import Optional
from src.player.mpv_controller import MpvController
logger = logging.getLogger(__name__)
# Kodi EventServer Packet Types
PT_HELO = 0x01
PT_BYE = 0x02
PT_BUTTON = 0x03
PT_MOUSE = 0x04
PT_PING = 0x05
PT_NOTIFICATION = 0x06
PT_BLOB = 0x07
PT_LOG = 0x08
PT_ACTION = 0x09
HEADER_FORMAT = "!4sBBHIIHI10s"
HEADER_SIZE = struct.calcsize(HEADER_FORMAT) # 32 bytes
class KodiEventServerProtocol(asyncio.DatagramProtocol):
"""UDP protocol handler for Kodi EventServer packets from Yatse."""
def __init__(self, player: MpvController):
self.player = player
self.transport: Optional[asyncio.DatagramTransport] = None
def connection_made(self, transport: asyncio.DatagramTransport) -> None:
self.transport = transport
logger.info("Kodi EventServer UDP protocol initialized")
def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
if len(data) < HEADER_SIZE:
return
try:
sig, majver, minver, pkttype, seq, maxseq, paylen, client_token, _ = struct.unpack(
HEADER_FORMAT, data[:HEADER_SIZE]
)
if sig != b"XBMC":
return
payload = data[HEADER_SIZE : HEADER_SIZE + paylen]
self._handle_packet(pkttype, payload, addr)
except Exception as e:
logger.debug("Error parsing EventServer packet: %s", e)
def _handle_packet(self, pkttype: int, payload: bytes, addr: tuple[str, int]) -> None:
if pkttype == PT_HELO:
# Client registration
devname = payload.split(b"\x00")[0].decode("utf-8", errors="ignore")
logger.info("Yatse EventServer connected from %s (Device: %s)", addr, devname)
elif pkttype == PT_PING:
logger.debug("Yatse EventServer PING from %s", addr)
elif pkttype == PT_BUTTON:
self._handle_button(payload)
elif pkttype == PT_ACTION:
self._handle_action(payload)
elif pkttype == PT_BYE:
logger.info("Yatse EventServer disconnected from %s", addr)
def _handle_button(self, payload: bytes) -> None:
# Format: code(2B) + map_name(null-terminated) + button_name(null-terminated) + flags(2B) + amount(2B)
if len(payload) < 6:
return
try:
parts = payload[2:].split(b"\x00")
if len(parts) >= 2:
map_name = parts[0].decode("utf-8", errors="ignore")
button_name = parts[1].decode("utf-8", errors="ignore").lower()
# Check flags: 0x01 is KEY_DOWN
tail = b"\x00".join(parts[2:])
if len(tail) >= 2:
flags = struct.unpack("!H", tail[:2])[0]
if not (flags & 0x01): # Ignore key up events
return
logger.info("EventServer button pressed: map=%s, btn=%s", map_name, button_name)
self._dispatch_button(button_name)
except Exception as e:
logger.debug("Error handling EventServer button: %s", e)
def _handle_action(self, payload: bytes) -> None:
# Format: action_type(1B) + action_name(null-terminated string)
if len(payload) < 2:
return
action = payload[1:].split(b"\x00")[0].decode("utf-8", errors="ignore").lower()
logger.info("EventServer action received: %s", action)
if "playpause" in action or "play" in action:
asyncio.create_task(self.player.play_pause())
elif "stop" in action:
asyncio.create_task(self.player.stop())
def _dispatch_button(self, btn: str) -> None:
if btn in ("left", "stepback"):
asyncio.create_task(self.player.seek(-10))
elif btn in ("right", "stepforward"):
asyncio.create_task(self.player.seek(10))
elif btn in ("up", "bigstepforward"):
asyncio.create_task(self.player.seek(60))
elif btn in ("down", "bigstepback"):
asyncio.create_task(self.player.seek(-60))
elif btn in ("select", "enter", "play", "pause", "playpause"):
asyncio.create_task(self.player.play_pause())
elif btn in ("back", "stop"):
asyncio.create_task(self.player.stop())
elif btn in ("volumeup", "volup"):
asyncio.create_task(self.player.set_volume(self.player.status.volume + 5))
elif btn in ("volumedown", "voldown"):
asyncio.create_task(self.player.set_volume(self.player.status.volume - 5))
class KodiEventServer:
"""Manages the UDP socket for Kodi EventServer."""
def __init__(self, port: int, player: MpvController):
self.port = port
self.player = player
self.transport: Optional[asyncio.DatagramTransport] = None
async def start(self) -> None:
loop = asyncio.get_running_loop()
try:
transport, _ = await loop.create_datagram_endpoint(
lambda: KodiEventServerProtocol(self.player),
local_addr=("0.0.0.0", self.port),
)
self.transport = transport
logger.info("Kodi EventServer UDP listener started on 0.0.0.0:%d (Yatse compatible)", self.port)
except Exception as e:
logger.error("Failed to start Kodi EventServer on UDP port %d: %s", self.port, e)
async def shutdown(self) -> None:
if self.transport:
self.transport.close()
src/remotes/kodi_rpc.py
+9 -1
View File
@@ -264,7 +264,15 @@ class KodiRpcServer:
async def _rpc_xbmc_get_info_booleans(self, params: Dict[str, Any]) -> Dict[str, bool]:
booleans = params.get("booleans", [])
return {b: False for b in booleans}
result = {}
for b in booleans:
if b in ("Services.EventServer", "Services.Webserver"):
result[b] = True
elif b == "System.HasModalDialog":
result[b] = False
else:
result[b] = True
return result
async def _rpc_xbmc_get_info_labels(self, params: Dict[str, Any]) -> Dict[str, str]:
labels = params.get("labels", [])