h/adb_client
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: edition 2024 (#106)

Browse Source
This commit is contained in:
cocool97
2025-04-13 16:38:38 +02:00
committed by GitHub
parent b0303ad544
commit e917a45670
57 changed files with 98 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@@ -4,7 +4,7 @@ resolver = "2"
[workspace.package]
authors = ["Corentin LIAUD"]
edition = "2021"
edition = "2024"
homepage = "https://github.com/cocool97/adb_client"
keywords = ["adb", "android", "tcp", "usb"]
license = "MIT"

2
adb_cli/src/adb_termios.rs
View File

@@ -2,7 +2,7 @@
use std::os::unix::prelude::{AsRawFd, RawFd};
use termios::{tcsetattr, Termios, TCSANOW, VMIN, VTIME};
use termios::{TCSANOW, Termios, VMIN, VTIME, tcsetattr};
use crate::Result;

2
adb_cli/src/handlers/local_commands.rs
View File

@@ -1,7 +1,7 @@
use std::{fs::File, io::Write};
use adb_client::ADBServerDevice;
use anyhow::{anyhow, Result};
use anyhow::{Result, anyhow};
use crate::models::LocalDeviceCommand;

6
adb_cli/src/main.rs
View File

@@ -50,7 +50,7 @@ fn main() -> Result<()> {
match server_command.command {
LocalCommand::DeviceCommands(device_commands) => (device.boxed(), device_commands),
LocalCommand::LocalDeviceCommand(local_device_command) => {
return handle_local_commands(device, local_device_command)
return handle_local_commands(device, local_device_command);
}
}
}
@@ -65,7 +65,9 @@ fn main() -> Result<()> {
None => ADBUSBDevice::autodetect()?,
},
_ => {
anyhow::bail!("please either supply values for both the --vendor-id and --product-id flags or none.");
anyhow::bail!(
"please either supply values for both the --vendor-id and --product-id flags or none."
);
}
};
(device.boxed(), usb_command.commands)

2
adb_cli/src/utils.rs
View File

@@ -6,7 +6,7 @@ pub fn setup_logger(debug: bool) {
false => "info",
};
std::env::set_var("RUST_LOG", level);
unsafe { std::env::set_var("RUST_LOG", level) };
}
env_logger::init();

6
adb_client/src/device/adb_message_device.rs
View File

@@ -2,9 +2,9 @@ use byteorder::{LittleEndian, ReadBytesExt};
use rand::Rng;
use std::io::{Cursor, Read, Seek};
use crate::{constants::BUFFER_SIZE, ADBMessageTransport, AdbStatResponse, Result, RustADBError};
use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};
use super::{models::MessageSubcommand, ADBTransportMessage, MessageCommand};
use super::{ADBTransportMessage, MessageCommand, models::MessageSubcommand};
/// Generic structure representing an ADB device reachable over an [`ADBMessageTransport`].
/// Structure is totally agnostic over which transport is truly used.
@@ -146,7 +146,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {
return Err(RustADBError::ADBRequestFailed(format!(
"Wrong command received {}",
c
)))
)));
}
}
}

2
adb_client/src/device/adb_message_device_commands.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbStatResponse, ADBDeviceExt, ADBMessageTransport, RebootType, Result};
use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};
use std::{
io::{Read, Write},
path::Path,

2
adb_client/src/device/adb_tcp_device.rs
View File

@@ -2,9 +2,9 @@ use std::io::Write;
use std::path::Path;
use std::{io::Read, net::SocketAddr};
use super::ADBTransportMessage;
use super::adb_message_device::ADBMessageDevice;
use super::models::MessageCommand;
use super::ADBTransportMessage;
use crate::{ADBDeviceExt, ADBMessageTransport, ADBTransport, Result, TcpTransport};
/// Represent a device reached and available over USB.

6
adb_client/src/device/adb_usb_device.rs
View File

@@ -1,7 +1,7 @@
use rusb::constants::LIBUSB_CLASS_VENDOR_SPEC;
use rusb::Device;
use rusb::DeviceDescriptor;
use rusb::UsbContext;
use rusb::constants::LIBUSB_CLASS_VENDOR_SPEC;
use std::fs::read_to_string;
use std::io::Read;
use std::io::Write;
@@ -12,10 +12,10 @@ use std::time::Duration;
use super::adb_message_device::ADBMessageDevice;
use super::models::MessageCommand;
use super::{ADBRsaKey, ADBTransportMessage};
use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
use crate::ADBDeviceExt;
use crate::ADBMessageTransport;
use crate::ADBTransport;
use crate::device::adb_transport_message::{AUTH_RSAPUBLICKEY, AUTH_SIGNATURE, AUTH_TOKEN};
use crate::{Result, RustADBError, USBTransport};
pub fn read_adb_private_key<P: AsRef<Path>>(private_key_path: P) -> Result<Option<ADBRsaKey>> {
@@ -188,7 +188,7 @@ impl ADBUSBDevice {
v => {
return Err(RustADBError::ADBRequestFailed(format!(
"Received AUTH message with type != 1 ({v})"
)))
)));
}
};

4
adb_client/src/device/commands/framebuffer.rs
View File

@@ -4,9 +4,9 @@ use byteorder::{LittleEndian, ReadBytesExt};
use image::{ImageBuffer, Rgba};
use crate::{
device::{adb_message_device::ADBMessageDevice, MessageCommand},
models::{FrameBufferInfoV1, FrameBufferInfoV2},
ADBMessageTransport, Result, RustADBError,
device::{MessageCommand, adb_message_device::ADBMessageDevice},
models::{FrameBufferInfoV1, FrameBufferInfoV2},
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

4
adb_client/src/device/commands/install.rs
View File

@@ -3,9 +3,9 @@ use std::{fs::File, path::Path};
use rand::Rng;
use crate::{
device::{adb_message_device::ADBMessageDevice, MessageWriter},
utils::check_extension_is_apk,
ADBMessageTransport, Result,
device::{MessageWriter, adb_message_device::ADBMessageDevice},
utils::check_extension_is_apk,
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

8
adb_client/src/device/commands/pull.rs
View File

@@ -1,11 +1,11 @@
use std::io::Write;
use crate::{
device::{
adb_message_device::ADBMessageDevice, models::MessageSubcommand, ADBTransportMessage,
MessageCommand,
},
ADBMessageTransport, Result, RustADBError,
device::{
ADBTransportMessage, MessageCommand, adb_message_device::ADBMessageDevice,
models::MessageSubcommand,
},
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

8
adb_client/src/device/commands/push.rs
View File

@@ -1,11 +1,11 @@
use std::io::Read;
use crate::{
device::{
adb_message_device::ADBMessageDevice, ADBTransportMessage, MessageCommand,
MessageSubcommand,
},
ADBMessageTransport, Result, RustADBError,
device::{
ADBTransportMessage, MessageCommand, MessageSubcommand,
adb_message_device::ADBMessageDevice,
},
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

2
adb_client/src/device/commands/reboot.rs
View File

@@ -1,6 +1,6 @@
use crate::{
device::{adb_message_device::ADBMessageDevice, MessageCommand},
ADBMessageTransport, RebootType, Result,
device::{MessageCommand, adb_message_device::ADBMessageDevice},
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

4
adb_client/src/device/commands/shell.rs
View File

@@ -1,10 +1,10 @@
use std::io::{ErrorKind, Read, Write};
use crate::device::ShellMessageWriter;
use crate::Result;
use crate::device::ShellMessageWriter;
use crate::{
device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
ADBMessageTransport, RustADBError,
device::{ADBMessageDevice, ADBTransportMessage, MessageCommand},
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

2
adb_client/src/device/commands/stat.rs
View File

@@ -1,5 +1,5 @@
use crate::{
device::adb_message_device::ADBMessageDevice, ADBMessageTransport, AdbStatResponse, Result,
ADBMessageTransport, AdbStatResponse, Result, device::adb_message_device::ADBMessageDevice,
};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {

2
adb_client/src/device/commands/uninstall.rs
View File

@@ -1,4 +1,4 @@
use crate::{device::adb_message_device::ADBMessageDevice, ADBMessageTransport, Result};
use crate::{ADBMessageTransport, Result, device::adb_message_device::ADBMessageDevice};
impl<T: ADBMessageTransport> ADBMessageDevice<T> {
pub(crate) fn uninstall(&mut self, package_name: &str) -> Result<()> {

2
adb_client/src/device/mod.rs
View File

@@ -11,7 +11,7 @@ mod shell_message_writer;
use adb_message_device::ADBMessageDevice;
pub use adb_tcp_device::ADBTcpDevice;
pub use adb_transport_message::{ADBTransportMessage, ADBTransportMessageHeader};
pub use adb_usb_device::{get_default_adb_key_path, ADBUSBDevice};
pub use adb_usb_device::{ADBUSBDevice, get_default_adb_key_path};
pub use message_writer::MessageWriter;
pub use models::{ADBRsaKey, MessageCommand, MessageSubcommand};
pub use shell_message_writer::ShellMessageWriter;

4
adb_client/src/device/models/adb_rsa_key.rs
View File

@@ -1,8 +1,8 @@
use crate::{Result, RustADBError};
use base64::{engine::general_purpose::STANDARD, Engine};
use base64::{Engine, engine::general_purpose::STANDARD};
use num_bigint::{BigUint, ModInverse};
use num_traits::cast::ToPrimitive;
use num_traits::FromPrimitive;
use num_traits::cast::ToPrimitive;
use rsa::pkcs8::DecodePrivateKey;
use rsa::traits::PublicKeyParts;
use rsa::{Pkcs1v15Sign, RsaPrivateKey};

2
adb_client/src/device/shell_message_writer.rs
View File

@@ -2,7 +2,7 @@ use std::io::Write;
use crate::ADBMessageTransport;
use super::{models::MessageCommand, ADBTransportMessage};
use super::{ADBTransportMessage, models::MessageCommand};
/// [`Write`] trait implementation to hide underlying ADB protocol write logic for shell commands.
pub struct ShellMessageWriter<T: ADBMessageTransport> {

2
adb_client/src/emulator_device/commands/rotate.rs
View File

@@ -1,4 +1,4 @@
use crate::{emulator_device::ADBEmulatorCommand, ADBEmulatorDevice, Result};
use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
impl ADBEmulatorDevice {
/// Send a SMS to this emulator with given content with given phone number

2
adb_client/src/emulator_device/commands/sms.rs
View File

@@ -1,4 +1,4 @@
use crate::{emulator_device::ADBEmulatorCommand, ADBEmulatorDevice, Result};
use crate::{ADBEmulatorDevice, Result, emulator_device::ADBEmulatorCommand};
impl ADBEmulatorDevice {
/// Send a SMS to this emulator with given content with given phone number

28
adb_client/src/mdns/mdns_discovery.rs
View File

@@ -33,19 +33,21 @@ impl MDNSDiscoveryService {
pub fn start(&mut self, sender: Sender<MDNSDevice>) -> Result<()> {
let receiver = self.daemon.browse(ADB_SERVICE_NAME)?;
let handle: JoinHandle<Result<()>> = std::thread::spawn(move || loop {
while let Ok(event) = receiver.recv() {
match event {
ServiceEvent::SearchStarted(_)
| ServiceEvent::ServiceRemoved(_, _)
| ServiceEvent::ServiceFound(_, _)
| ServiceEvent::SearchStopped(_) => {
// Ignoring these events. We are only interesting in found devices
continue;
}
ServiceEvent::ServiceResolved(service_info) => {
if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
return Err(e.into());
let handle: JoinHandle<Result<()>> = std::thread::spawn(move || {
loop {
while let Ok(event) = receiver.recv() {
match event {
ServiceEvent::SearchStarted(_)
| ServiceEvent::ServiceRemoved(_, _)
| ServiceEvent::ServiceFound(_, _)
| ServiceEvent::SearchStopped(_) => {
// Ignoring these events. We are only interesting in found devices
continue;
}
ServiceEvent::ServiceResolved(service_info) => {
if let Err(e) = sender.send(MDNSDevice::from(service_info)) {
return Err(e.into());
}
}
}
}

2
adb_client/src/server/adb_server.rs
View File

@@ -105,7 +105,7 @@ impl ADBServer {
impl Drop for ADBServer {
fn drop(&mut self) {
if let Some(ref mut transport) = &mut self.transport {
if let Some(transport) = &mut self.transport {
let _ = transport.disconnect();
}
}

2
adb_client/src/server/commands/connect.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
use std::net::SocketAddrV4;
impl ADBServer {

4
adb_client/src/server/commands/devices.rs
View File

@@ -1,8 +1,8 @@
use std::io::Read;
use crate::{
models::AdbServerCommand, ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong,
DeviceShort, Result, RustADBError,
ADBEmulatorDevice, ADBServer, ADBServerDevice, DeviceLong, DeviceShort, Result, RustADBError,
models::AdbServerCommand,
};
impl ADBServer {

2
adb_client/src/server/commands/disconnect.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
use std::net::SocketAddrV4;
impl ADBServer {

2
adb_client/src/server/commands/kill.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServer, Result};
use crate::{ADBServer, Result, models::AdbServerCommand};
impl ADBServer {
/// Asks the ADB server to quit immediately.

2
adb_client/src/server/commands/mdns.rs
View File

@@ -1,7 +1,7 @@
use std::io::BufRead;
use crate::{
models::AdbServerCommand, server::models::MDNSBackend, ADBServer, MDNSServices, Result,
ADBServer, MDNSServices, Result, models::AdbServerCommand, server::models::MDNSBackend,
};
const OPENSCREEN_MDNS_BACKEND: &str = "ADB_MDNS_OPENSCREEN";

2
adb_client/src/server/commands/reconnect.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServer, Result};
use crate::{ADBServer, Result, models::AdbServerCommand};
impl ADBServer {
/// Reconnect the device

2
adb_client/src/server/commands/server_status.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, server::models::ServerStatus, ADBServer, Result};
use crate::{ADBServer, Result, models::AdbServerCommand, server::models::ServerStatus};
impl ADBServer {
/// Check ADB server status

2
adb_client/src/server/commands/version.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServer, AdbVersion, Result};
use crate::{ADBServer, AdbVersion, Result, models::AdbServerCommand};
impl ADBServer {
/// Gets server's internal version number.

2
adb_client/src/server/commands/wait_for_device.rs
View File

@@ -1,5 +1,5 @@
use crate::{
models::AdbServerCommand, ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport,
ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport, models::AdbServerCommand,
};
impl ADBServer {

2
adb_client/src/server_device/adb_server_device.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBTransport, Result, TCPServerTransport};
use crate::{ADBTransport, Result, TCPServerTransport, models::AdbServerCommand};
use std::net::SocketAddrV4;
/// Represents a device connected to the ADB server.

2
adb_client/src/server_device/adb_server_device_commands.rs
View File

@@ -4,9 +4,9 @@ use std::{
};
use crate::{
ADBDeviceExt, Result, RustADBError,
constants::BUFFER_SIZE,
models::{AdbServerCommand, AdbStatResponse, HostFeatures},
ADBDeviceExt, Result, RustADBError,
};
use super::ADBServerDevice;

2
adb_client/src/server_device/commands/forward.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Forward socket connection

2
adb_client/src/server_device/commands/framebuffer.rs
View File

@@ -4,8 +4,8 @@ use byteorder::{LittleEndian, ReadBytesExt};
use image::{ImageBuffer, Rgba};
use crate::{
models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
ADBServerDevice, Result, RustADBError,
models::{AdbServerCommand, FrameBufferInfoV1, FrameBufferInfoV2},
};
impl ADBServerDevice {

2
adb_client/src/server_device/commands/host_features.rs
View File

@@ -1,6 +1,6 @@
use crate::{
models::{AdbServerCommand, HostFeatures},
ADBServerDevice, Result,
models::{AdbServerCommand, HostFeatures},
};
impl ADBServerDevice {

2
adb_client/src/server_device/commands/install.rs
View File

@@ -1,7 +1,7 @@
use std::{fs::File, io::Read, path::Path};
use crate::{
models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk, Result,
Result, models::AdbServerCommand, server_device::ADBServerDevice, utils::check_extension_is_apk,
};
impl ADBServerDevice {

2
adb_client/src/server_device/commands/list.rs
View File

@@ -1,6 +1,6 @@
use crate::{
models::{AdbServerCommand, SyncCommand},
ADBServerDevice, Result,
models::{AdbServerCommand, SyncCommand},
};
use byteorder::{ByteOrder, LittleEndian};
use std::{

2
adb_client/src/server_device/commands/reboot.rs
View File

@@ -1,6 +1,6 @@
use crate::{
models::{AdbServerCommand, RebootType},
ADBServerDevice, Result,
models::{AdbServerCommand, RebootType},
};
impl ADBServerDevice {

2
adb_client/src/server_device/commands/reconnect.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Reconnect device

3
adb_client/src/server_device/commands/recv.rs
View File

@@ -1,7 +1,6 @@
use crate::{
constants,
ADBServerDevice, Result, constants,
models::{AdbServerCommand, SyncCommand},
ADBServerDevice, Result,
};
use byteorder::{LittleEndian, ReadBytesExt};
use std::io::{BufReader, BufWriter, Read, Write};

2
adb_client/src/server_device/commands/reverse.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Reverse socket connection

3
adb_client/src/server_device/commands/send.rs
View File

@@ -1,7 +1,6 @@
use crate::{
constants,
ADBServerDevice, Result, RustADBError, constants,
models::{AdbRequestStatus, AdbServerCommand, SyncCommand},
ADBServerDevice, Result, RustADBError,
};
use std::{
convert::TryInto,

2
adb_client/src/server_device/commands/stat.rs
View File

@@ -3,8 +3,8 @@ use std::io::{Read, Write};
use byteorder::{ByteOrder, LittleEndian};
use crate::{
models::{AdbServerCommand, AdbStatResponse, SyncCommand},
ADBServerDevice, Result, RustADBError,
models::{AdbServerCommand, AdbStatResponse, SyncCommand},
};
impl ADBServerDevice {

2
adb_client/src/server_device/commands/tcpip.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Set adb daemon to tcp/ip mode

2
adb_client/src/server_device/commands/transport.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Asks ADB server to switch the connection to either the device or emulator connect to/running on the host. Will fail if there is more than one such device/emulator available.

2
adb_client/src/server_device/commands/uninstall.rs
View File

@@ -1,6 +1,6 @@
use std::io::Read;
use crate::{models::AdbServerCommand, server_device::ADBServerDevice, Result};
use crate::{Result, models::AdbServerCommand, server_device::ADBServerDevice};
impl ADBServerDevice {
/// Uninstall a package from device

2
adb_client/src/server_device/commands/usb.rs
View File

@@ -1,4 +1,4 @@
use crate::{models::AdbServerCommand, ADBServerDevice, Result};
use crate::{ADBServerDevice, Result, models::AdbServerCommand};
impl ADBServerDevice {
/// Set adb daemon to usb mode

2
adb_client/src/transports/tcp_emulator_transport.rs
View File

@@ -7,7 +7,7 @@ use std::{
use homedir::my_home;
use super::ADBTransport;
use crate::{emulator_device::ADBEmulatorCommand, Result, RustADBError};
use crate::{Result, RustADBError, emulator_device::ADBEmulatorCommand};
/// Emulator transport running on top on TCP.
#[derive(Debug)]

2
adb_client/src/transports/tcp_server_transport.rs
View File

@@ -5,7 +5,7 @@ use std::str::FromStr;
use byteorder::{ByteOrder, LittleEndian};
use crate::models::{AdbRequestStatus, SyncCommand};
use crate::{models::AdbServerCommand, ADBTransport};
use crate::{ADBTransport, models::AdbServerCommand};
use crate::{Result, RustADBError};
const DEFAULT_SERVER_IP: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);

14
adb_client/src/transports/tcp_transport.rs
View File

@@ -1,16 +1,16 @@
use rcgen::{CertificateParams, KeyPair, PKCS_RSA_SHA256};
use rustls::{
client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
pki_types::{pem::PemObject, CertificateDer, PrivatePkcs8KeyDer},
ClientConfig, ClientConnection, KeyLogFile, SignatureScheme, StreamOwned,
client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
pki_types::{CertificateDer, PrivatePkcs8KeyDer, pem::PemObject},
};
use super::{ADBMessageTransport, ADBTransport};
use crate::{
device::{
get_default_adb_key_path, ADBTransportMessage, ADBTransportMessageHeader, MessageCommand,
},
Result, RustADBError,
device::{
ADBTransportMessage, ADBTransportMessageHeader, MessageCommand, get_default_adb_key_path,
},
};
use std::{
fs::read_to_string,
@@ -125,7 +125,7 @@ impl TcpTransport {
None => {
return Err(RustADBError::UpgradeError(
"cannot upgrade a non-existing connection...".into(),
))
));
}
};
@@ -162,7 +162,7 @@ impl TcpTransport {
CurrentConnection::Tls(_) => {
return Err(RustADBError::UpgradeError(
"cannot upgrade a TLS connection...".into(),
))
));
}
}
}

2
adb_client/src/transports/traits/adb_message_transport.rs
View File

@@ -1,7 +1,7 @@
use std::time::Duration;
use super::ADBTransport;
use crate::{device::ADBTransportMessage, Result};
use crate::{Result, device::ADBTransportMessage};
const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(u64::MAX);
const DEFAULT_WRITE_TIMEOUT: Duration = Duration::from_secs(2);

6
adb_client/src/transports/usb_transport.rs
View File

@@ -1,14 +1,14 @@
use std::{sync::Arc, time::Duration};
use rusb::{
constants::LIBUSB_CLASS_VENDOR_SPEC, Device, DeviceHandle, Direction, GlobalContext,
TransferType,
Device, DeviceHandle, Direction, GlobalContext, TransferType,
constants::LIBUSB_CLASS_VENDOR_SPEC,
};
use super::{ADBMessageTransport, ADBTransport};
use crate::{
device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
Result, RustADBError,
device::{ADBTransportMessage, ADBTransportMessageHeader, MessageCommand},
};
#[derive(Clone, Debug)]

4
benches/benchmark_adb_push.rs
View File

@@ -1,7 +1,7 @@
use adb_client::ADBServer;
use anyhow::Result;
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use rand::{rng, Rng};
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use rand::{Rng, rng};
use std::fs::File;
use std::io::Write;
use std::process::Command;

2
pyadb_client/src/adb_server.rs
View File

@@ -2,7 +2,7 @@ use std::net::SocketAddrV4;
use adb_client::ADBServer;
use anyhow::Result;
use pyo3::{pyclass, pymethods, PyResult};
use pyo3::{PyResult, pyclass, pymethods};
use pyo3_stub_gen_derive::{gen_stub_pyclass, gen_stub_pymethods};
use crate::{PyADBServerDevice, PyDeviceShort};