machinaos 0.0.1

package/server/services/android/protocol.py

@@ -0,0 +1,165 @@
+"""
+JSON-RPC 2.0 Protocol for Android Services Relay
+
+Handles message encoding/decoding and request/response tracking.
+
+Request format:  {"jsonrpc": "2.0", "method": "...", "params": {...}, "id": 1}
+Response format: {"jsonrpc": "2.0", "result": {...}, "id": 1}
+Event format:    {"jsonrpc": "2.0", "method": "...", "params": {...}}
+
+Error codes:
+- -32600: Invalid request
+- -32601: Method not found
+- -32602: Invalid params
+- -32001: Not paired
+- -32002: Pairing failed
+- -32003: Relay error
+"""
+import asyncio
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
+from enum import Enum
+
+
+class RPCErrorCode(Enum):
+    """JSON-RPC 2.0 error codes"""
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INVALID_PARAMS = -32602
+    NOT_PAIRED = -32001
+    PAIRING_FAILED = -32002
+    RELAY_ERROR = -32003
+
+
+@dataclass
+class RPCRequest:
+    """JSON-RPC 2.0 request"""
+    method: str
+    params: Dict[str, Any] = field(default_factory=dict)
+    id: Optional[int] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        msg = {
+            "jsonrpc": "2.0",
+            "method": self.method,
+            "params": self.params,
+        }
+        if self.id is not None:
+            msg["id"] = self.id
+        return msg
+
+
+@dataclass
+class RPCResponse:
+    """JSON-RPC 2.0 response"""
+    id: int
+    result: Optional[Any] = None
+    error: Optional[Dict[str, Any]] = None
+
+    @property
+    def is_error(self) -> bool:
+        return self.error is not None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RPCResponse":
+        return cls(
+            id=data.get("id"),
+            result=data.get("result"),
+            error=data.get("error"),
+        )
+
+
+@dataclass
+class RPCEvent:
+    """JSON-RPC 2.0 server event (notification without id)"""
+    method: str
+    params: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RPCEvent":
+        return cls(
+            method=data.get("method", ""),
+            params=data.get("params", {}),
+        )
+
+
+class RPCRequestTracker:
+    """Tracks pending JSON-RPC requests and matches responses"""
+
+    def __init__(self):
+        self._request_id = 0
+        self._pending: Dict[int, asyncio.Future] = {}
+
+    def next_id(self) -> int:
+        """Get next request ID"""
+        self._request_id += 1
+        return self._request_id
+
+    def create_request(self, method: str, params: Dict[str, Any] = None) -> tuple[RPCRequest, asyncio.Future]:
+        """Create request and future for response"""
+        request_id = self.next_id()
+        request = RPCRequest(method=method, params=params or {}, id=request_id)
+
+        loop = asyncio.get_event_loop()
+        future = loop.create_future()
+        self._pending[request_id] = future
+
+        return request, future
+
+    def resolve(self, response: RPCResponse) -> bool:
+        """Resolve pending request with response. Returns True if matched."""
+        if response.id not in self._pending:
+            return False
+
+        future = self._pending.pop(response.id)
+
+        if response.is_error:
+            error_msg = response.error.get("message", "RPC Error")
+            future.set_exception(RPCError(error_msg, response.error.get("code")))
+        else:
+            future.set_result(response.result)
+
+        return True
+
+    def cancel(self, request_id: int) -> bool:
+        """Cancel pending request. Returns True if found."""
+        if request_id in self._pending:
+            future = self._pending.pop(request_id)
+            future.cancel()
+            return True
+        return False
+
+    def cancel_all(self):
+        """Cancel all pending requests"""
+        for future in self._pending.values():
+            future.cancel()
+        self._pending.clear()
+
+    @property
+    def pending_count(self) -> int:
+        return len(self._pending)
+
+
+class RPCError(Exception):
+    """JSON-RPC error"""
+    def __init__(self, message: str, code: int = None):
+        super().__init__(message)
+        self.code = code
+
+
+def parse_message(data: Dict[str, Any]) -> RPCResponse | RPCEvent:
+    """Parse incoming message as response or event"""
+    if "id" in data and data["id"] is not None:
+        return RPCResponse.from_dict(data)
+    else:
+        return RPCEvent.from_dict(data)
+
+
+def is_response(data: Dict[str, Any]) -> bool:
+    """Check if message is a response (has id)"""
+    return "id" in data and data["id"] is not None
+
+
+def is_event(data: Dict[str, Any]) -> bool:
+    """Check if message is an event (no id, has method)"""
+    return ("id" not in data or data["id"] is None) and "method" in data