49f101d785
Direct-call accept hangs forever at the QUIC handshake on Android. Logs
from d7b37a5 showed:
CallEngine::start (android) invoked relay=172.16.81.172:4433 room=call-…
resolved relay addr
identity loaded
endpoint created, dialing relay ← reached
← nothing, 90s+, no error
The "connect failed" and "QUIC connection established" log lines never
fire, meaning endpoint.connect_with(…).await never makes progress.
Repro is 100%: SFU room join (one endpoint) works perfectly; direct call
(opens a SECOND quinn::Endpoint on top of the signal one) hangs in the
QUIC handshake. Creating two quinn::Endpoints on Android's AAudio-adjacent
UDP stack apparently causes the second one's datagrams to never reach the
relay (the server never sees the Initial packet). Rather than fight the
platform, quinn is happy to multiplex multiple Connections on a single
Endpoint — so we reuse the signal endpoint for the media connection.
- SignalState now stores the quinn::Endpoint alongside the QuinnTransport.
register_signal populates both at the same time.
- CallEngine::start (both android and desktop branches) takes an
Option<wzp_transport::Endpoint>. Some → reuse (direct-call path, after
register_signal). None → create fresh (SFU room join path).
- The connect tauri command reads state.signal.endpoint and threads it
through to CallEngine::start, so the direct-call auto-connect (fired by
the "setup" signal-event in main.ts) lands on the existing UDP socket.
- wzp_transport re-exports quinn::Endpoint so wzp-desktop doesn't need to
depend on quinn directly.
- Also wraps the android connect in tokio::time::timeout(10s) so future
hangs become deterministic "connect TIMED OUT" errors in logcat
instead of silent deadlock.
Same fix applies verbatim to the desktop client — the user suspects
direct call is broken there too and this was likely always the cause,
just never surfaced because desktop was only tested via SFU rooms.
35 lines
1.3 KiB
Rust
35 lines
1.3 KiB
Rust
//! WarzonePhone Transport Layer
|
|
//!
|
|
//! QUIC-based transport using quinn with:
|
|
//! - DATAGRAM frames for unreliable media packets
|
|
//! - Reliable streams for signaling messages
|
|
//! - Path quality monitoring (EWMA loss, RTT, bandwidth estimation)
|
|
//! - Connection lifecycle management
|
|
//!
|
|
//! ## Architecture
|
|
//!
|
|
//! - `config` — QUIC configuration tuned for lossy VoIP links
|
|
//! - `datagram` — DATAGRAM frame serialization and MTU management
|
|
//! - `reliable` — Length-prefixed JSON framing over reliable QUIC streams
|
|
//! - `path_monitor` — EWMA-based PathQuality estimation
|
|
//! - `quic` — `QuinnTransport` implementing the `MediaTransport` trait
|
|
//! - `connection` — Connection lifecycle (create endpoint, connect, accept)
|
|
|
|
pub mod config;
|
|
pub mod connection;
|
|
pub mod datagram;
|
|
pub mod path_monitor;
|
|
pub mod quic;
|
|
pub mod reliable;
|
|
|
|
pub use config::{client_config, server_config, server_config_from_seed, tls_fingerprint};
|
|
pub use connection::{accept, connect, create_endpoint};
|
|
pub use path_monitor::PathMonitor;
|
|
pub use quic::QuinnTransport;
|
|
pub use wzp_proto::{MediaTransport, PathQuality, TransportError};
|
|
|
|
// Re-export the quinn Endpoint type so downstream crates (wzp-desktop) can
|
|
// thread a shared endpoint between signaling and media connections without
|
|
// needing to depend on quinn directly.
|
|
pub use quinn::Endpoint;
|