Method _handle_unity_connection

relay/server.py:228–296

Handle a Unity Editor connection

(
        self,
        reader: asyncio.StreamReader,
        writer: asyncio.StreamWriter,
        register_msg: dict[str, Any],
    )

    # ===== Unity Connection Handling =====

    async def _handle_unity_connection(
        self,
        reader: asyncio.StreamReader,
        writer: asyncio.StreamWriter,
        register_msg: dict[str, Any],
    ) -> None:
        """Handle a Unity Editor connection"""
        # Validate protocol version
        protocol_version = register_msg.get("protocol_version", "")
        if protocol_version != PROTOCOL_VERSION:
            response = RegisteredMessage(
                success=False,
                error={
                    "code": ErrorCode.PROTOCOL_VERSION_MISMATCH.value,
                    "message": f"Unsupported protocol version: {protocol_version}. Expected: {PROTOCOL_VERSION}",
                },
            )
            await write_frame(writer, response.to_dict())
            return

        # Register instance
        instance_id = register_msg.get("instance_id", "")
        raw_bridge_version = register_msg.get("bridge_version", "")
        bridge_version = raw_bridge_version if isinstance(raw_bridge_version, str) else ""
        if len(bridge_version) > 64:
            bridge_version = ""
        instance = await self.registry.register(
            instance_id=instance_id,
            project_name=register_msg.get("project_name", ""),
            unity_version=register_msg.get("unity_version", ""),
            capabilities=register_msg.get("capabilities", []),
            reader=reader,
            writer=writer,
            bridge_version=bridge_version,
        )

        # Send registration response
        response = RegisteredMessage(
            success=True,
            heartbeat_interval_ms=HEARTBEAT_INTERVAL_MS,
        )
        await write_frame(writer, response.to_dict())

        # Start heartbeat task
        heartbeat_task = asyncio.create_task(self._heartbeat_loop(instance_id))
        self._heartbeat_tasks[instance_id] = heartbeat_task

        # Handle messages from Unity
        try:
            while self._running and instance.is_connected:
                try:
                    msg = await asyncio.wait_for(
                        read_frame(reader),
                        timeout=HEARTBEAT_TIMEOUT_MS / 1000,
                    )
                    await self._handle_unity_message(instance, msg)
                except TimeoutError:
                    # Don't disconnect here — let _heartbeat_loop handle retries via PING/PONG.