Add Kotlin and Rust Android agent with signed APK export

This commit is contained in:
tongtong committed 2026-11-13 13:03:58 +08:00
1 parent e366eb5bec
commit 5b3022e1f3
20 files changed
+3568 -2

No files matched your search

+231
View File
@@ -0,0 +1,231 @@
use ads_core::{valid_device_id, validate_token, NetworkArgs};
use jni::{
objects::{JObject, JString},
sys::jstring,
JNIEnv,
};
use serde::Deserialize;
use std::{
collections::VecDeque,
io::Write,
sync::{Arc, Mutex, Once, OnceLock},
thread,
};
// Reuse the actual v1/v2 gateway (including P2P, relay fallback, bounded streams).
#[path = "../../../agent/src/gateway.rs"]
mod gateway;
#[derive(Deserialize)]
struct Config {
server: String,
token: String,
device: String,
port: u16,
}
impl Config {
fn validate(&self) -> anyhow::Result<()> {
anyhow::ensure!(
valid_device_id(&self.device),
"device ID must be 1-128 ASCII letters/digits/._-"
);
validate_token(&self.token)?;
anyhow::ensure!(self.port > 0, "adbd port must be nonzero");
self.network().url("/v1/agent", &[])?;
Ok(())
}
fn network(&self) -> NetworkArgs {
NetworkArgs {
server: self.server.clone(),
connect_address: None,
allow_insecure: false,
}
}
}
struct Worker {
stop: tokio::sync::oneshot::Sender<()>,
join: thread::JoinHandle<()>,
health: gateway::WorkerHealth,
}
static WORKER: Mutex<Option<Worker>> = Mutex::new(None);
static LOGS: OnceLock<Mutex<VecDeque<String>>> = OnceLock::new();
fn logs() -> &'static Mutex<VecDeque<String>> {
LOGS.get_or_init(|| Mutex::new(VecDeque::new()))
}
struct LogWriter;
impl Write for LogWriter {
fn write(&mut self, b: &[u8]) -> std::io::Result<usize> {
let mut q = logs().lock().unwrap_or_else(|e| e.into_inner());
q.push_back(String::from_utf8_lossy(b).into_owned());
while q.len() > 300 {
q.pop_front();
}
Ok(b.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
fn start(config: Config) -> anyhow::Result<()> {
config.validate()?;
let mut guard = WORKER.lock().unwrap_or_else(|e| e.into_inner());
anyhow::ensure!(
guard.is_none(),
"agent already running; stop before changing config"
);
static INIT: Once = Once::new();
INIT.call_once(|| {
let _ = tracing_subscriber::fmt()
.with_ansi(false)
.with_max_level(tracing::Level::INFO)
.with_writer(|| LogWriter)
.try_init();
});
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(2)
.enable_all()
.build()?;
let health = Arc::new(Mutex::new(gateway::Health::default()));
let state = health.clone();
let (stop, rx) = tokio::sync::oneshot::channel();
let args = Arc::new(gateway::Gateway {
network: config.network(),
token: config.token,
device: config.device,
target: Some(format!("127.0.0.1:{}", config.port)),
adb_serial: None,
adb_server: String::new(),
device_port: config.port,
});
let join = thread::spawn(move || {
runtime.block_on(async move {
let work = async {
tracing::info!("ANDROID_START: phone-local adbd and relay worker starting");
match ads_core::tcp_connect(args.target.as_deref().unwrap()).await {
Ok(s) => { drop(s); tracing::info!("ADBD_PROBE_OK: loopback reachable; ADB authentication still required"); }
Err(_) => tracing::warn!("ADBD_PROBE_FAILED: check ROM adbd listener and SELinux; no permission requests or setprop performed"),
}
gateway::run(args, Some(state)).await;
};
tokio::select! { _ = work => {}, _ = rx => {} }
tracing::info!("ANDROID_STOP: control and data sessions cancelled");
});
runtime.shutdown_timeout(std::time::Duration::from_secs(2));
});
*guard = Some(Worker { stop, join, health });
Ok(())
}
fn stop() {
let mut guard = WORKER.lock().unwrap_or_else(|e| e.into_inner());
if let Some(w) = guard.take() {
let _ = w.stop.send(());
let _ = w.join.join();
}
}
fn snapshot() -> String {
let guard = WORKER.lock().unwrap_or_else(|e| e.into_inner());
let (running, registered, error) = match guard.as_ref() {
Some(w) => {
let s = w.health.lock().unwrap_or_else(|e| e.into_inner());
(!w.join.is_finished(), s.connected, s.last_error.clone())
}
None => (false, false, None),
};
let lines: Vec<_> = logs()
.lock()
.unwrap_or_else(|e| e.into_inner())
.drain(..)
.collect();
serde_json::json!({"running":running,"registered":registered,"error":error,"logs":lines})
.to_string()
}
fn java_string(env: &mut JNIEnv, value: String) -> jstring {
env.new_string(value)
.map(|v| v.into_raw())
.unwrap_or(std::ptr::null_mut())
}
#[no_mangle]
pub extern "system" fn Java_com_ttstd_ads_NativeBridge_start(
mut env: JNIEnv,
_this: JObject,
json: JString,
) -> jstring {
let result =
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> anyhow::Result<()> {
let raw: String = env.get_string(&json)?.into();
let c = serde_json::from_str::<Config>(&raw)
.map_err(|_| anyhow::anyhow!("invalid configuration JSON"))?;
start(c)
}));
let message = match result {
Ok(Ok(())) => String::new(),
Ok(Err(e)) => format!("{e:#}"),
Err(_) => "native start failed".into(),
};
java_string(&mut env, message)
}
#[no_mangle]
pub extern "system" fn Java_com_ttstd_ads_NativeBridge_stop(_env: JNIEnv, _this: JObject) {
stop();
}
#[no_mangle]
pub extern "system" fn Java_com_ttstd_ads_NativeBridge_snapshot(
mut env: JNIEnv,
_this: JObject,
) -> jstring {
java_string(&mut env, snapshot())
}
#[cfg(test)]
mod tests {
use super::*;
fn config() -> Config {
Config {
server: "wss://ttstd.com/ads".into(),
token: "x".repeat(32),
device: "android-test".into(),
port: 5555,
}
}
#[test]
fn validates_prefix() {
let c = config();
c.validate().unwrap();
assert_eq!(
c.network().url("/v1/agent", &[]).unwrap().path(),
"/ads/v1/agent"
);
}
#[test]
fn rejects_invalid_inputs() {
let mut c = config();
c.port = 0;
assert!(c.validate().is_err());
c = config();
c.server = "ws://example.com".into();
assert!(c.validate().is_err());
c = config();
c.device = "bad/device".into();
assert!(c.validate().is_err());
c = config();
c.token = "short".into();
assert!(c.validate().is_err());
}
#[test]
fn worker_lifecycle_and_secret_free_status() {
stop();
let mut c = config();
c.server = "wss://127.0.0.1:1".into();
c.port = 1;
start(c).unwrap();
let s = snapshot();
assert!(s.contains("\"running\":true"));
assert!(!s.contains(&"x".repeat(32)));
assert!(
start(config()).is_err(),
"must not create duplicate workers"
);
let began = std::time::Instant::now();
stop();
assert!(began.elapsed() < std::time::Duration::from_secs(3));
assert!(snapshot().contains("\"running\":false"));
stop(); // idempotent
}
}