mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-06 16:08:05 +00:00
payailk
090a1cd6df
A bottom tool window lists the connected Android devices (adb devices -l) and streams the selected one's log (adb logcat -v threadtime, the last 200 lines first), parsed into time, pid, level, tag and message in a virtualised list that follows the end until scrolled up. The filter box takes Android Studio's logcat expressions (tag:, message:, pid:, level:, -term, |, parentheses, regex) and remembers recent ones. The new ide-android crate runs adb, which it finds through ANDROID_HOME / ANDROID_SDK_ROOT, the usual SDK locations or PATH; the stream goes over a Channel in batches (300 lines, or once the oldest waiting line is 60 ms old) and stops with its request. The window is listed under the stripe's overflow until first opened. Co-authored-by: payailk <80739895+payailk@users.noreply.github.com>
66 lines
2.5 KiB
Rust
66 lines
2.5 KiB
Rust
//! Drives a real device through `adb`, checking what the Logcat tool window does:
|
|
//! that the device list parses, that the stream delivers batches, and that
|
|
//! cancelling stops both the stream and its `adb` process.
|
|
//!
|
|
//! Ignored by default (needs a connected device). Run with
|
|
//! `OPENIDEA_ADB_DEVICE=<serial> cargo test -p ide-android --test device -- --ignored --nocapture`
|
|
//! — without the variable, the connected device is used when there is exactly one.
|
|
|
|
use ide_android::*;
|
|
use ide_core::CancellationToken;
|
|
use std::sync::{Arc, Mutex};
|
|
use std::time::{Duration, Instant};
|
|
|
|
fn serial() -> Option<String> {
|
|
if let Ok(serial) = std::env::var("OPENIDEA_ADB_DEVICE") {
|
|
return Some(serial);
|
|
}
|
|
let online = devices().ok()?.into_iter().filter(AndroidDevice::is_online).collect::<Vec<_>>();
|
|
(online.len() == 1).then(|| online[0].serial.clone())
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn finds_the_adb_executable() {
|
|
let adb = adb_executable().expect("adb (set ANDROID_HOME or OPENIDEA_ADB)");
|
|
println!("adb: {}", adb.display());
|
|
assert!(adb.is_file());
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn lists_connected_devices() {
|
|
let devices = devices().expect("adb devices");
|
|
for device in &devices {
|
|
println!("{:<16} {:<14} {} ({:?})", device.serial, device.state, device.label(), device.transport_id);
|
|
}
|
|
assert!(!devices.is_empty(), "no devices connected");
|
|
}
|
|
|
|
#[test]
|
|
#[ignore]
|
|
fn streams_batches_and_stops_on_cancel() {
|
|
let serial = serial().expect("a single connected device, or OPENIDEA_ADB_DEVICE");
|
|
let cancel = CancellationToken::new();
|
|
let stop = cancel.clone();
|
|
let received = Arc::new(Mutex::new(Vec::<LogcatLine>::new()));
|
|
let sink = received.clone();
|
|
let started = Instant::now();
|
|
let stream = std::thread::spawn(move || {
|
|
ide_android::logcat(&serial, false, &stop, &mut |batch| {
|
|
sink.lock().unwrap().extend(batch);
|
|
})
|
|
});
|
|
// Enough to see the tail seed and a few live lines from a device that idles.
|
|
std::thread::sleep(Duration::from_secs(4));
|
|
cancel.cancel();
|
|
stream.join().unwrap().expect("logcat stops cleanly when cancelled");
|
|
let lines = received.lock().unwrap();
|
|
println!("{} lines in {:?}", lines.len(), started.elapsed());
|
|
for line in lines.iter().rev().take(5) {
|
|
println!("{:<14} {:>6} {}", line.tag, line.pid, line.message);
|
|
}
|
|
assert!(!lines.is_empty(), "no lines within 4s");
|
|
assert!(lines.iter().any(|l| l.level != LogcatLevel::Unknown), "every line failed to parse");
|
|
}
|