add InterprocessTokioStream

Author: wiiznokes

RustApp/src/main.rs

@@ -18,6 +18,7 @@ extern crate log;
 
 mod audio;
 mod config;
+mod single_instance;
 mod start_at_login;
 mod streamer;
 mod ui;
@@ -85,10 +86,14 @@ fn main() {
     };
     let mut app_lock = LockFile::open(&instance_lock_path).expect("Failed to open app lock file");
     if !app_lock.try_lock_with_pid().unwrap_or(false) {
-        error!(
+        info!(
             "Another instance is already running. PID can be found in {:?}",
             instance_lock_path
         );
+
+        if let Err(e) = single_instance::send_event(single_instance::IpcEvent::Show) {
+            error!("can't send ipc event {e}");
+        }
         return;
     }
 

RustApp/src/single_instance.rs

@@ -0,0 +1,78 @@
+use byteorder::WriteBytesExt;
+use futures::stream::Stream;
+use interprocess::local_socket::tokio::Stream as InterprocessTokioStream;
+use interprocess::local_socket::traits::Stream as InterprocessStreamTrait;
+use interprocess::local_socket::traits::tokio::Listener as TokioListener;
+use interprocess::local_socket::{GenericNamespaced, ListenerOptions, ToNsName};
+use interprocess::local_socket::{Name, Stream as InterprocessStream};
+
+use tokio::io::AsyncReadExt;
+
+#[derive(Debug, Clone)]
+pub enum IpcEvent {
+    Show,
+}
+
+impl TryFrom<u8> for IpcEvent {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(IpcEvent::Show),
+            _ => Err(()),
+        }
+    }
+}
+
+impl From<IpcEvent> for u8 {
+    fn from(value: IpcEvent) -> Self {
+        match value {
+            IpcEvent::Show => 0,
+        }
+    }
+}
+
+fn get_name() -> anyhow::Result<Name<'static>> {
+    let printname = "android-mic.sock";
+    let name = printname.to_ns_name::<GenericNamespaced>()?;
+    Ok(name)
+}
+
+pub async fn create_stream() -> anyhow::Result<InterprocessTokioStream> {
+    let name = get_name()?;
+
+    let opts = ListenerOptions::new().name(name);
+
+    let listener = opts.create_tokio()?;
+
+    let stream = listener.accept().await?;
+    Ok(stream)
+}
+
+pub fn parse_stream(stream: InterprocessTokioStream) -> impl Stream<Item = IpcEvent> {
+    futures::stream::unfold(stream, |mut stream| async {
+        match stream.read_u8().await {
+            Ok(value) => match value.try_into() {
+                Ok(event) => Some((event, stream)),
+                Err(()) => {
+                    error!("can't parse ipc event");
+                    None
+                }
+            },
+            Err(e) => {
+                error!("{e}");
+                None
+            }
+        }
+    })
+}
+
+pub fn send_event(event: IpcEvent) -> anyhow::Result<()> {
+    let name = get_name()?;
+
+    let mut stream = InterprocessStream::connect(name)?;
+
+    stream.write_u8(event.into())?;
+
+    Ok(())
+}

RustApp/src/ui/app.rs

@@ -33,7 +33,7 @@ use crate::{
     config::{
         AppTheme, AudioFormat, ChannelCount, Config, ConnectionMode, NetworkAdapter, SampleRate,
     },
-    fl,
+    fl, single_instance,
     streamer::{self, ConnectOption, StreamerCommand, StreamerMsg},
     ui::view::{SCROLLABLE_ID, about_window},
     utils::APP_ID,
@@ -407,6 +407,24 @@ impl Application for AppState {
             commands.push(app.open_main_window());
         }
 
+        commands.push(
+            cosmic::iced::task::Task::future(async { single_instance::create_stream().await })
+                .then(|stream| match stream {
+                    Ok(stream) => cosmic::iced::task::Task::run(
+                        single_instance::parse_stream(stream),
+                        |event| match event {
+                            single_instance::IpcEvent::Show => {
+                                cosmic::Action::App(AppMsg::ShowWindow)
+                            }
+                        },
+                    ),
+                    Err(e) => {
+                        error!("{e}");
+                        Task::none()
+                    }
+                }),
+        );
+
         (app, Task::batch(commands))
     }
 
@@ -763,6 +781,20 @@ impl Application for AppState {
                 SystemTrayMsg::Connect => return self.connect(),
                 SystemTrayMsg::Disconnect => return self.disconnect(),
             },
+            AppMsg::ShowWindow => {
+                if let Some(main_window) = &self.main_window {
+                    // avoid duplicate window
+                    return cosmic::iced_runtime::task::effect(
+                        cosmic::iced::runtime::Action::Window(window::Action::GainFocus(
+                            main_window.window_id,
+                        )),
+                    );
+                } else {
+                    let command = self.open_main_window();
+
+                    return Task::batch(vec![command, self.update_audio_stream()]);
+                }
+            }
         }
 
         Task::none()

RustApp/src/ui/message.rs

@@ -21,6 +21,7 @@ pub enum AppMsg {
     RefreshAudioDevices,
     RefreshNetworkAdapters,
     HideWindow,
+    ShowWindow,
     Menu(MenuMsg),
     LinkClicked(String),
     SystemTray(SystemTrayMsg),