use ads_core::{adb_tcp_connect, dial, next_control, relay, tcp_connect, NetworkArgs}; use anyhow::{bail, Context, Result}; use std::{sync::Arc, time::Duration}; use tokio::{net::TcpStream, task::JoinSet, time::sleep}; use tracing::{info, warn}; #[derive(Clone)] pub struct Gateway { pub network: NetworkArgs, pub token: String, pub device: String, pub target: Option, pub adb_serial: Option, pub adb_server: String, pub device_port: u16, } #[derive(Default, Clone)] pub struct Health { pub connected: bool, pub last_error: Option, } pub type WorkerHealth = Arc>; async fn upstream(args: &Gateway) -> Result { match &args.target { Some(address) => tcp_connect(address).await, None => { adb_tcp_connect( &args.adb_server, args.adb_serial.as_deref().context("missing serial")?, args.device_port, ) .await } } } async fn serve_session( args: Arc, session: String, signal_key: Option, ) -> Result<()> { let tcp = upstream(&args).await.context("cannot reach phone adbd")?; if let Some(key) = signal_key { let signal = dial( args.network .url("/v2/signal", &[("session", &session), ("key", &key)])?, &args.token, args.network.connect_address.as_deref(), ) .await?; return ads_core::transport::agent_session(tcp, signal, &args.network).await; } let ws = dial( args.network.url( "/v1/data", &[("device", &args.device), ("session", &session)], )?, &args.token, args.network.connect_address.as_deref(), ) .await?; relay(tcp, ws).await } async fn online(args: Arc, health: &Option) -> Result<()> { let mut ws = dial( args.network .url("/v1/agent", &[("device", &args.device), ("v", "2")])?, &args.token, args.network.connect_address.as_deref(), ) .await?; let hello = next_control(&mut ws).await?; if hello.kind != "registered" { bail!("expected registered response"); } if let Some(health) = health { let mut state = health.lock().unwrap_or_else(|e| e.into_inner()); state.connected = true; state.last_error = None; } info!(device = %args.device, "gateway registered"); let mut tasks = JoinSet::new(); loop { tokio::select! { message = next_control(&mut ws) => { let message = message?; if message.kind != "open" && message.kind != "open_v2" { bail!("unexpected gateway control message"); } let signal_key = if message.kind == "open_v2" { Some(message.signal_key.context("missing signal key")?) } else { None }; let session = message.session.context("missing session ticket")?; if tasks.len() >= 32 { warn!("gateway stream limit reached"); continue; } let args = args.clone(); let health = health.clone(); tasks.spawn(async move { let device=args.device.clone(); if let Err(error) = serve_session(args, session, signal_key).await { if let Some(health)=health {health.lock().unwrap_or_else(|e|e.into_inner()).last_error=Some(format!("{error:#}"));} warn!(%device,%error, "device stream ended"); } }); }, _ = tasks.join_next(), if !tasks.is_empty() => {}, } } // JoinSet drop aborts all streams when the control connection is lost. } pub async fn run(args: Arc, health: Option) { let mut delay = 1; loop { let started = std::time::Instant::now(); if let Err(error) = online(args.clone(), &health).await { if let Some(health) = &health { let mut state = health.lock().unwrap_or_else(|e| e.into_inner()); state.connected = false; state.last_error = Some(format!("{error:#}")); } warn!(device=%args.device,%error, "gateway offline; reconnecting"); } if started.elapsed() > Duration::from_secs(30) { delay = 1; } sleep(Duration::from_secs(delay)).await; delay = (delay * 2).min(30); } }