Add Kotlin and Rust Android agent with signed APK export
This commit is contained in:
1 parent
e366eb5bec
commit
5b3022e1f3
20 files changed
+3568
-2
No files matched your search
Generated
+2910
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,16 @@
|
||||
[workspace]
|
||||
[package]
|
||||
name = "ads-android"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
[lib]
|
||||
crate-type = ["cdylib", "rlib"]
|
||||
[dependencies]
|
||||
ads-core = { path = "../../crates/ads-core" }
|
||||
anyhow = "1"
|
||||
jni = "0.21"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
tokio = { version = "1", features = ["full"] }
|
||||
tracing = "0.1"
|
||||
tracing-subscriber = { version = "0.3", features = ["fmt"] }
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user