feat: edition 2024 (#106)

cocool97 · cocool97 · commit d9e377be2cb9 · 2025-04-13T16:59:10.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -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"
diff --git a/adb_cli/src/adb_termios.rs b/adb_cli/src/adb_termios.rs
@@ -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;
 
diff --git a/adb_cli/src/main.rs b/adb_cli/src/main.rs
@@ -51,7 +51,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);
                 }
             }
         }
@@ -66,7 +66,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)
diff --git a/adb_cli/src/utils.rs b/adb_cli/src/utils.rs
@@ -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();
diff --git a/adb_client/src/device/adb_message_device.rs b/adb_client/src/device/adb_message_device.rs
@@ -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
-                            )))
+                            )));
                         }
                     }
                 }
diff --git a/adb_client/src/device/adb_message_device_commands.rs b/adb_client/src/device/adb_message_device_commands.rs
@@ -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,
diff --git a/adb_client/src/device/adb_tcp_device.rs b/adb_client/src/device/adb_tcp_device.rs
@@ -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.
diff --git a/adb_client/src/device/adb_usb_device.rs b/adb_client/src/device/adb_usb_device.rs
@@ -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})"
-                )))
+                )));
             }
         };
 
diff --git a/adb_client/src/device/commands/framebuffer.rs b/adb_client/src/device/commands/framebuffer.rs
@@ -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> {
diff --git a/adb_client/src/device/commands/install.rs b/adb_client/src/device/commands/install.rs
@@ -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> {
diff --git a/adb_client/src/device/commands/pull.rs b/adb_client/src/device/commands/pull.rs
@@ -1,11 +1,11 @@
 use std::io::Write;
 
 use crate::{
+    ADBMessageTransport, Result, RustADBError,
     device::{
-        adb_message_device::ADBMessageDevice, models::MessageSubcommand, ADBTransportMessage,
-        MessageCommand,
+        ADBTransportMessage, MessageCommand, adb_message_device::ADBMessageDevice,
+        models::MessageSubcommand,
     },
-    ADBMessageTransport, Result, RustADBError,
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
diff --git a/adb_client/src/device/commands/push.rs b/adb_client/src/device/commands/push.rs
@@ -1,11 +1,11 @@
 use std::io::Read;
 
 use crate::{
+    ADBMessageTransport, Result, RustADBError,
     device::{
-        adb_message_device::ADBMessageDevice, ADBTransportMessage, MessageCommand,
-        MessageSubcommand,
+        ADBTransportMessage, MessageCommand, MessageSubcommand,
+        adb_message_device::ADBMessageDevice,
     },
-    ADBMessageTransport, Result, RustADBError,
 };
 
 impl<T: ADBMessageTransport> ADBMessageDevice<T> {
diff --git a/adb_client/src/device/commands/reboot.rs b/adb_client/src/device/commands/reboot.rs
@@ -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> {
diff --git a/adb_client/src/device/commands/shell.rs b/adb_client/src/device/commands/shell.rs
@@ -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> {
diff --git a/adb_client/src/device/commands/stat.rs b/adb_client/src/device/commands/stat.rs
@@ -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> {
diff --git a/adb_client/src/device/commands/uninstall.rs b/adb_client/src/device/commands/uninstall.rs
@@ -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<()> {
diff --git a/adb_client/src/device/mod.rs b/adb_client/src/device/mod.rs
@@ -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;
diff --git a/adb_client/src/device/models/adb_rsa_key.rs b/adb_client/src/device/models/adb_rsa_key.rs
@@ -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};
diff --git a/adb_client/src/device/shell_message_writer.rs b/adb_client/src/device/shell_message_writer.rs
@@ -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> {
diff --git a/adb_client/src/emulator_device/commands/rotate.rs b/adb_client/src/emulator_device/commands/rotate.rs
@@ -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
diff --git a/adb_client/src/emulator_device/commands/sms.rs b/adb_client/src/emulator_device/commands/sms.rs
@@ -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
diff --git a/adb_client/src/mdns/mdns_discovery.rs b/adb_client/src/mdns/mdns_discovery.rs
@@ -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());
+                            }
                         }
                     }
                 }
diff --git a/adb_client/src/server/adb_server.rs b/adb_client/src/server/adb_server.rs
@@ -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();
         }
     }
diff --git a/adb_client/src/server/commands/connect.rs b/adb_client/src/server/commands/connect.rs
@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
+use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 impl ADBServer {
diff --git a/adb_client/src/server/commands/devices.rs b/adb_client/src/server/commands/devices.rs
@@ -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 {
diff --git a/adb_client/src/server/commands/disconnect.rs b/adb_client/src/server/commands/disconnect.rs
@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result, RustADBError};
+use crate::{ADBServer, Result, RustADBError, models::AdbServerCommand};
 use std::net::SocketAddrV4;
 
 impl ADBServer {
diff --git a/adb_client/src/server/commands/kill.rs b/adb_client/src/server/commands/kill.rs
@@ -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.
diff --git a/adb_client/src/server/commands/mdns.rs b/adb_client/src/server/commands/mdns.rs
@@ -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";
diff --git a/adb_client/src/server/commands/reconnect.rs b/adb_client/src/server/commands/reconnect.rs
@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServer, Result};
+use crate::{ADBServer, Result, models::AdbServerCommand};
 
 impl ADBServer {
     /// Reconnect the device
diff --git a/adb_client/src/server/commands/server_status.rs b/adb_client/src/server/commands/server_status.rs
@@ -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
diff --git a/adb_client/src/server/commands/version.rs b/adb_client/src/server/commands/version.rs
@@ -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.
diff --git a/adb_client/src/server/commands/wait_for_device.rs b/adb_client/src/server/commands/wait_for_device.rs
@@ -1,5 +1,5 @@
 use crate::{
-    models::AdbServerCommand, ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport,
+    ADBServer, Result, WaitForDeviceState, WaitForDeviceTransport, models::AdbServerCommand,
 };
 
 impl ADBServer {
diff --git a/adb_client/src/server_device/adb_server_device.rs b/adb_client/src/server_device/adb_server_device.rs
@@ -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.
diff --git a/adb_client/src/server_device/adb_server_device_commands.rs b/adb_client/src/server_device/adb_server_device_commands.rs
@@ -4,9 +4,9 @@ use std::{
 };
 
 use crate::{
+    ADBDeviceExt, Result, RustADBError,
     constants::BUFFER_SIZE,
     models::{AdbServerCommand, AdbStatResponse, HostFeatures},
-    ADBDeviceExt, Result, RustADBError,
 };
 
 use super::ADBServerDevice;
diff --git a/adb_client/src/server_device/commands/forward.rs b/adb_client/src/server_device/commands/forward.rs
@@ -1,4 +1,4 @@
-use crate::{models::AdbServerCommand, ADBServerDevice, Result};
+use crate::{ADBServerDevice, Result, models::AdbServerCommand};
 
 impl ADBServerDevice {
     /// Forward socket connection
diff --git a/adb_client/src/server_device/commands/framebuffer.rs b/adb_client/src/server_device/commands/framebuffer.rs
@@ -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 {
diff --git a/adb_client/src/server_device/commands/host_features.rs b/adb_client/src/server_device/commands/host_features.rs
@@ -1,6 +1,6 @@
 use crate::{
-    models::{AdbServerCommand, HostFeatures},
     ADBServerDevice, Result,
+    models::{AdbServerCommand, HostFeatures},
 };
 
 impl ADBServerDevice {
diff --git a/adb_client/src/server_device/commands/install.rs b/adb_client/src/server_device/commands/install.rs
diff --git a/adb_client/src/server_device/commands/reboot.rs b/adb_client/src/server_device/commands/reboot.rs
diff --git a/adb_client/src/server_device/commands/reconnect.rs b/adb_client/src/server_device/commands/reconnect.rs
diff --git a/adb_client/src/server_device/commands/recv.rs b/adb_client/src/server_device/commands/recv.rs
diff --git a/adb_client/src/server_device/commands/reverse.rs b/adb_client/src/server_device/commands/reverse.rs
diff --git a/adb_client/src/server_device/commands/send.rs b/adb_client/src/server_device/commands/send.rs
diff --git a/adb_client/src/server_device/commands/stat.rs b/adb_client/src/server_device/commands/stat.rs
diff --git a/adb_client/src/server_device/commands/tcpip.rs b/adb_client/src/server_device/commands/tcpip.rs
diff --git a/adb_client/src/server_device/commands/transport.rs b/adb_client/src/server_device/commands/transport.rs
diff --git a/adb_client/src/server_device/commands/uninstall.rs b/adb_client/src/server_device/commands/uninstall.rs
diff --git a/adb_client/src/server_device/commands/usb.rs b/adb_client/src/server_device/commands/usb.rs
diff --git a/adb_client/src/transports/tcp_emulator_transport.rs b/adb_client/src/transports/tcp_emulator_transport.rs
diff --git a/adb_client/src/transports/tcp_server_transport.rs b/adb_client/src/transports/tcp_server_transport.rs
diff --git a/adb_client/src/transports/tcp_transport.rs b/adb_client/src/transports/tcp_transport.rs
diff --git a/adb_client/src/transports/traits/adb_message_transport.rs b/adb_client/src/transports/traits/adb_message_transport.rs
diff --git a/adb_client/src/transports/usb_transport.rs b/adb_client/src/transports/usb_transport.rs
diff --git a/benches/benchmark_adb_push.rs b/benches/benchmark_adb_push.rs
diff --git a/pyadb_client/src/adb_server.rs b/pyadb_client/src/adb_server.rs

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ fn main() -> Result<()> {`
`51`	`51`	`match server_command.command {`
`52`	`52`	`LocalCommand::DeviceCommands(device_commands) => (device.boxed(), device_commands),`
`53`	`53`	`LocalCommand::LocalDeviceCommand(local_device_command) => {`
`54`		`- return handle_local_commands(device, local_device_command)`
	`54`	`+ return handle_local_commands(device, local_device_command);`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`}`
`@@ -66,7 +66,9 @@ fn main() -> Result<()> {`
`66`	`66`	`None => ADBUSBDevice::autodetect()?,`
`67`	`67`	`},`
`68`	`68`	`_ => {`
`69`		`- anyhow::bail!("please either supply values for both the --vendor-id and --product-id flags or none.");`
	`69`	`+ anyhow::bail!(`
	`70`	`+ "please either supply values for both the --vendor-id and --product-id flags or none."`
	`71`	`+ );`
`70`	`72`	`}`
`71`	`73`	`};`
`72`	`74`	`(device.boxed(), usb_command.commands)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ pub fn setup_logger(debug: bool) {`
`6`	`6`	`false => "info",`
`7`	`7`	`};`
`8`	`8`
`9`		`- std::env::set_var("RUST_LOG", level);`
	`9`	`+ unsafe { std::env::set_var("RUST_LOG", level) };`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`env_logger::init();`
Original file line number	Diff line number	Diff line change
`@@ -2,9 +2,9 @@ use byteorder::{LittleEndian, ReadBytesExt};`
`2`	`2`	`use rand::Rng;`
`3`	`3`	`use std::io::{Cursor, Read, Seek};`
`4`	`4`
`5`		`-use crate::{constants::BUFFER_SIZE, ADBMessageTransport, AdbStatResponse, Result, RustADBError};`
	`5`	`+use crate::{ADBMessageTransport, AdbStatResponse, Result, RustADBError, constants::BUFFER_SIZE};`
`6`	`6`
`7`		`-use super::{models::MessageSubcommand, ADBTransportMessage, MessageCommand};`
	`7`	`+use super::{ADBTransportMessage, MessageCommand, models::MessageSubcommand};`
`8`	`8`
`9`	`9`	/// Generic structure representing an ADB device reachable over an [`ADBMessageTransport`].
`10`	`10`	`/// Structure is totally agnostic over which transport is truly used.`
`@@ -146,7 +146,7 @@ impl<T: ADBMessageTransport> ADBMessageDevice<T> {`
`146`	`146`	`return Err(RustADBError::ADBRequestFailed(format!(`
`147`	`147`	`"Wrong command received {}",`
`148`	`148`	`c`
`149`		`- )))`
	`149`	`+ )));`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::{models::AdbStatResponse, ADBDeviceExt, ADBMessageTransport, RebootType, Result};`
	`1`	`+use crate::{ADBDeviceExt, ADBMessageTransport, RebootType, Result, models::AdbStatResponse};`
`2`	`2`	`use std::{`
`3`	`3`	`io::{Read, Write},`
`4`	`4`	`path::Path,`