Merge pull request #64 from teamclouday/improve-adb

Improve adb and others

Author: teamclouday

Android/app/src/main/java/com/example/androidMic/domain/streaming/AdbStreamer.kt

@@ -1,5 +1,6 @@
 package com.example.androidMic.domain.streaming
 
+import Message
 import android.os.Messenger
 import android.util.Log
 import com.example.androidMic.domain.service.AudioPacket
@@ -31,7 +32,7 @@ class AdbStreamer(private val scope: CoroutineScope) : Streamer {
         // create socket
         socket = Socket()
         try {
-            socket?.connect(InetSocketAddress(address, 6000), MAX_WAIT_TIME)
+            socket?.connect(InetSocketAddress(address, 55555), MAX_WAIT_TIME)
         } catch (e: IOException) {
             Log.d(TAG, "connect [Socket]: ${e.message}")
             null

RustApp/src/app.rs

@@ -22,14 +22,15 @@ use crate::{
     message::{AppMsg, ConfigMsg},
     streamer::{self, ConnectOption, Status, StreamerCommand, StreamerMsg},
     utils::APP_ID,
-    view::{advanced_window, view_app, AudioWave},
+    view::{advanced_window, main_window, AudioWave},
 };
 use zconf::ConfigManager;
 
 pub fn run_ui(config: ConfigManager<Config>) {
     let flags = Flags { config };
+    let settings = Settings::default().no_main_window(true);
 
-    cosmic::app::run::<AppState>(Settings::default(), flags).unwrap();
+    cosmic::app::run::<AppState>(settings, flags).unwrap();
 }
 
 #[derive(Clone)]
@@ -98,11 +99,12 @@ pub struct AppState {
     pub audio_stream: Option<cpal::Stream>,
     pub audio_wave: AudioWave,
     pub state: State,
-    pub advanced_window: Option<AdvancedWindow>,
+    pub main_window: Option<CustomWindow>,
+    pub advanced_window: Option<CustomWindow>,
     pub logs: String,
 }
 
-pub struct AdvancedWindow {
+pub struct CustomWindow {
     pub window_id: window::Id,
 }
 
@@ -196,6 +198,12 @@ impl Application for AppState {
         &self.core
     }
 
+    fn style(&self) -> Option<cosmic::iced_runtime::Appearance> {
+        Some(cosmic::style::iced::application::appearance(
+            &cosmic::theme::Theme::dark(),
+        ))
+    }
+
     fn core_mut(&mut self) -> &mut cosmic::app::Core {
         &mut self.core
     }
@@ -224,6 +232,15 @@ impl Application for AppState {
             None => audio_host.default_output_device(),
         };
 
+        let settings = window::Settings {
+            size: Size::new(800.0, 600.0),
+            position: window::Position::Centered,
+            exit_on_close_request: true,
+            ..Default::default()
+        };
+
+        let (new_id, command) = cosmic::iced::window::open(settings);
+
         let app = Self {
             core,
             audio_stream: None,
@@ -234,11 +251,12 @@ impl Application for AppState {
             audio_devices,
             audio_wave: AudioWave::new(),
             state: State::Default,
+            main_window: Some(CustomWindow { window_id: new_id }),
             advanced_window: None,
             logs: String::new(),
         };
 
-        (app, Task::none())
+        (app, command.map(|_| cosmic::action::Action::None))
     }
 
     fn update(&mut self, message: Self::Message) -> Task<Self::Message> {
@@ -309,17 +327,14 @@ impl Application for AppState {
                 }
                 None => {
                     let settings = window::Settings {
-                        size: Size::new(500.0, 500.0),
-                        resizable: false,
+                        size: Size::new(500.0, 600.0),
                         position: window::Position::Centered,
-                        decorations: false,
-                        transparent: true,
-                        level: window::Level::AlwaysOnTop,
+                        exit_on_close_request: true,
                         ..Default::default()
                     };
 
-                    let (new_id, command) = cosmic::iced::runtime::window::open(settings);
-                    self.advanced_window = Some(AdvancedWindow { window_id: new_id });
+                    let (new_id, command) = cosmic::iced::window::open(settings);
+                    self.advanced_window = Some(CustomWindow { window_id: new_id });
                     return command.map(|_| cosmic::action::Action::None);
                 }
             },
@@ -343,18 +358,27 @@ impl Application for AppState {
                     self.config.update(|s| s.auto_connect = auto_connect);
                 }
             },
+            AppMsg::Shutdown => {
+                return cosmic::iced_runtime::task::effect(Action::Exit);
+            }
         }
 
         Task::none()
     }
+
     fn view(&self) -> Element<Self::Message> {
-        view_app(self)
+        self.view_window(self.core.main_window_id().unwrap())
     }
 
     fn view_window(&self, id: window::Id) -> Element<Self::Message> {
         if let Some(window) = &self.advanced_window {
             if window.window_id == id {
-                return advanced_window(self, window).map(AppMsg::Config);
+                return advanced_window(self).map(AppMsg::Config);
+            }
+        }
+        if let Some(window) = &self.main_window {
+            if window.window_id == id {
+                return main_window(self);
             }
         }
 
@@ -364,4 +388,20 @@ impl Application for AppState {
     fn subscription(&self) -> cosmic::iced::Subscription<Self::Message> {
         Subscription::run(|| streamer::sub().map(AppMsg::Streamer))
     }
+
+    fn on_close_requested(&self, id: window::Id) -> Option<Self::Message> {
+        if let Some(window) = &self.advanced_window {
+            if window.window_id == id {
+                return Some(AppMsg::AdvancedOptions);
+            }
+        }
+        if let Some(window) = &self.main_window {
+            if window.window_id == id {
+                // close the app
+                return Some(AppMsg::Shutdown);
+            }
+        }
+
+        None
+    }
 }

RustApp/src/message.rs

@@ -14,6 +14,7 @@ pub enum AppMsg {
     AdvancedOptions,
     Config(ConfigMsg),
     RefreshAudioDevices,
+    Shutdown,
 }
 
 #[derive(Debug, Clone)]

RustApp/src/streamer/adb_streamer.rs

@@ -10,16 +10,38 @@ pub struct AdbStreamer {
     tcp_streamer: TcpStreamer,
 }
 
-async fn remove_adb_reverse_proxy() -> Result<(), ConnectError> {
+async fn get_connected_devices() -> Result<Vec<String>, ConnectError> {
     let mut cmd = Command::new("adb");
-    cmd.arg("reverse").arg("--remove").arg("tcp:6000");
+    cmd.arg("devices");
+
+    let output = exec_cmd(cmd).await?;
+    let mut devices = Vec::new();
+
+    // Skip the first line which is "List of devices attached"
+    for line in output.lines().skip(1) {
+        let parts: Vec<&str> = line.trim().split_whitespace().collect();
+        if parts.len() >= 2 {
+            devices.push(parts[0].to_string());
+        }
+    }
+
+    Ok(devices)
+}
+
+async fn remove_adb_reverse_proxy(device_id: &str) -> Result<(), ConnectError> {
+    let mut cmd = Command::new("adb");
+    cmd.arg("-s")
+        .arg(device_id)
+        .arg("reverse")
+        .arg("--remove")
+        .arg("tcp:55555");
 
     exec_cmd(cmd).await?;
 
     Ok(())
 }
 
-async fn exec_cmd(mut cmd: Command) -> Result<(), ConnectError> {
+async fn exec_cmd(mut cmd: Command) -> Result<String, ConnectError> {
     // https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
     #[cfg(target_os = "windows")]
     cmd.creation_flags(0x08000000);
@@ -34,22 +56,31 @@ async fn exec_cmd(mut cmd: Command) -> Result<(), ConnectError> {
             stderr,
         });
     }
-    Ok(())
+    let stdout = String::from_utf8_lossy(&status.stdout).trim().to_string();
+    Ok(stdout)
 }
 
 pub async fn new(producer: Producer<u8>) -> Result<AdbStreamer, ConnectError> {
     let tcp_streamer = tcp_streamer::new(str::parse("127.0.0.1").unwrap(), producer).await?;
 
-    if let Err(e) = remove_adb_reverse_proxy().await {
-        warn!("remove adb reverse proxy: {e}");
+    let devices = get_connected_devices().await?;
+    if devices.is_empty() {
+        return Err(ConnectError::NoAdbDevice);
     }
 
-    let mut cmd = Command::new("adb");
-    cmd.arg("reverse")
-        .arg(format!("tcp:{}", 6000))
-        .arg(format!("tcp:{}", tcp_streamer.port));
-
-    exec_cmd(cmd).await?;
+    for device_id in &devices {
+        if let Err(e) = remove_adb_reverse_proxy(device_id).await {
+            warn!("cannot remove adb proxy for device {device_id}: {e}");
+        }
+
+        let mut cmd = Command::new("adb");
+        cmd.arg("-s")
+            .arg(device_id)
+            .arg("reverse")
+            .arg("tcp:55555")
+            .arg(format!("tcp:{}", tcp_streamer.port));
+        exec_cmd(cmd).await?;
+    }
 
     let streamer = AdbStreamer { tcp_streamer };
     Ok(streamer)
@@ -72,8 +103,12 @@ impl StreamerTrait for AdbStreamer {
 impl Drop for AdbStreamer {
     fn drop(&mut self) {
         tokio::task::spawn_blocking(|| async {
-            if let Err(e) = remove_adb_reverse_proxy().await {
-                warn!("drop AdbStreamer: {e}");
+            let devices = get_connected_devices().await.unwrap_or_default();
+
+            for device_id in devices {
+                if let Err(e) = remove_adb_reverse_proxy(&device_id).await {
+                    warn!("cannot remove adb proxy for device {device_id}: {e}");
+                }
             }
         });
     }

RustApp/src/streamer/mod.rs

@@ -79,6 +79,8 @@ enum ConnectError {
     WriteError(#[from] WriteError),
     #[error("no usb device found: {0}")]
     NoUsbDevice(nusb::Error),
+    #[error("no adb device found")]
+    NoAdbDevice,
     #[error("can't open usb handle: {0}, make sure phone is set to charging only mode")]
     CantOpenUsbHandle(nusb::Error),
     #[error("can't open usb accessory: {0}")]

RustApp/src/view.rs

@@ -4,32 +4,36 @@ use cosmic::{
         Size,
     },
     widget::{
-        button, canvas, column, container, horizontal_space, radio, row, scrollable, settings,
-        text, toggler, vertical_space,
+        button, canvas, column, container, radio, row, scrollable, settings, text, toggler,
+        vertical_space,
     },
     Element,
 };
 use cpal::traits::DeviceTrait;
 
 use crate::{
-    app::{AdvancedWindow, AppState, State},
+    app::{AppState, State},
     config::{AudioFormat, ChannelCount, ConnectionMode, SampleRate},
     fl, icon_button,
     message::{AppMsg, ConfigMsg},
 };
 
-pub fn view_app(app: &AppState) -> Element<'_, AppMsg> {
+pub fn main_window(app: &AppState) -> Element<'_, AppMsg> {
     row()
         .padding(50)
+        .spacing(50)
         .push(
             column()
+                .width(Length::FillPortion(2))
+                .height(Length::Fill)
+                .spacing(50)
                 .push(logs(app))
-                .push(vertical_space())
                 .push(wave(app)),
         )
-        .push(horizontal_space())
         .push(
             column()
+                .width(Length::FillPortion(1))
+                .height(Length::Fill)
                 .align_x(Horizontal::Center)
                 .push(audio(app))
                 .push(vertical_space())
@@ -40,18 +44,17 @@ pub fn view_app(app: &AppState) -> Element<'_, AppMsg> {
 
 fn logs(app: &AppState) -> Element<'_, AppMsg> {
     container(scrollable(text(&app.logs).width(Length::Fill)))
-        .width(Length::FillPortion(2))
-        .height(Length::FillPortion(2))
+        .width(Length::Fill)
+        .height(Length::FillPortion(3))
         .padding(13)
         .class(cosmic::theme::Container::Card)
         .into()
 }
 
 fn wave(app: &AppState) -> Element<'_, AppMsg> {
     container(canvas(&app.audio_wave).width(Length::Fill))
-        .width(Length::FillPortion(2))
+        .width(Length::Fill)
         .height(Length::FillPortion(1))
-        .padding(13)
         .into()
 }
 
@@ -75,12 +78,7 @@ fn audio(app: &AppState) -> Element<'_, AppMsg> {
                 ))
                 .push(icon_button!("refresh24").on_press(AppMsg::RefreshAudioDevices)),
         )
-        .push(
-            row()
-                .spacing(20)
-                .push(toggler(app.advanced_window.is_some()).on_toggle(|_| AppMsg::AdvancedOptions))
-                .push(text(fl!("advanced"))),
-        )
+        .push(button::text(fl!("advanced")).on_press(AppMsg::AdvancedOptions))
         .into()
 }
 
@@ -132,15 +130,13 @@ fn connect_button(app: &AppState) -> Element<'_, AppMsg> {
     .into()
 }
 
-pub fn advanced_window<'a>(
-    app: &'a AppState,
-    _advanced_window: &'a AdvancedWindow,
-) -> Element<'a, ConfigMsg> {
+pub fn advanced_window(app: &AppState) -> Element<'_, ConfigMsg> {
     let config = app.config.data();
 
-    container(
+    scrollable(
         column()
             .padding(50)
+            .spacing(20)
             .push(settings::section().title(fl!("sample_rate")).add(pick_list(
                 SampleRate::VALUES,
                 Some(&config.sample_rate),
@@ -179,9 +175,6 @@ pub fn advanced_window<'a>(
                     .add(toggler(config.auto_connect).on_toggle(ConfigMsg::AutoConnect)),
             ),
     )
-    .class(cosmic::theme::Container::Background)
-    .center_x(Length::Fill)
-    .center_y(Length::Fill)
     .into()
 }