finished async subprocess call (for fire and forget application calls)

Signed-off-by: Deren Vural <[email protected]>

Author: Deren Vural

src/subprocess/mod.rs

@@ -19,6 +19,7 @@
  */
 
 // Imports
+use gtk::glib::Bytes;
 use gtk::prelude::*;
 use gtk::{gio, glib};
 use std::ffi::OsStr;
@@ -40,107 +41,50 @@ use std::ffi::OsStr;
  * Made by:
  * Deren Vural
  *
- * @param {string[]} argv - a list of string arguments
- * @param {Gio.Cancellable} [cancellable] - optional cancellable object
- * @returns {Promise<boolean>} - The process success
+ * Notes:
  *
  */
 pub fn exec_check(
     argv: &[&OsStr],
     cancellable: Option<&impl IsA<gio::Cancellable>>,
 ) -> Result<(), glib::Error> {
     // Create subprocess
-    println!("..creating subprocess"); //DEBUG
     match gio::Subprocess::newv(argv, gio::SubprocessFlags::NONE) {
         Err(err) => Err(err),
         Ok(proc) => {
-            println!("..Subprocess successfully created!"); //DEBUG
-
             // Run subprocess
-
-            // Define callback
-            //This should be called when the process is done
-            /*
-            let callback = |q: Result<(), glib::Error>| {
-                match q {
-                    Err(err) => {
-                        Err(err)
-                    },
-                    Ok(_out) => {
-                        println!("....process finished");//DEBUG
-                        Ok(())
-                    },
-                }
-            };
-
-            struct Listener {
-                done: bool
-            }
-            impl Listener {
-                pub fn on_call(&mut self, done: bool) { self.done = done }
-            }
-            struct Caller<'callback> {
-                callback: Box<dyn FnMut(bool) + 'callback>,
-            }
-            impl Caller<'_> {
-                pub fn call(&mut self) { (self.callback)(true) }
+            match proc.wait_async(cancellable, |_| ()) {
+                _ => Ok(()),
             }
-            let mut listener = Listener { done: false };
-            let mut caller = Caller { callback: Box::new(|x| listener.on_call(x)) };
-
-            //fn callback_fn(x: bool){println!("callback bitch!! {}", x)}
-            //let callback_box = Box::new(|x: bool| callback_fn(x));
-
-            //proc.wait_future();//not sure what this does tbh
-            */
-
-            /*
-            Do i just not use Results with callback versions?
-            */
-            // This doesn't work
-            /*
-            match proc.wait_async(cancellable,None) {
-                Err(err) => {
-                    Err(err)
-                },
-                Ok(_out) => {
-                    println!("....process finished");//DEBUG
-                    Ok(())
-                },
-            }
-            */
-            // This also doesn't work
-            /*
-            match proc.wait_async(cancellable, callback) {
-                Err(err) => {
-                    Err(err)
-                },
-                Ok(_out) => {
-                    println!("....process finished");//DEBUG
-                    Ok(())
-                },
-            }
-            */
-
-            //*
-            // This works but holds up main thread..
-            match proc.wait(cancellable) {
-                Err(err) => Err(err),
-                Ok(_out) => {
-                    println!("....process finished"); //DEBUG
-                    Ok(())
-                }
-            }
-            //*/
         }
     }
 }
 
+/*
+ * Name:
+ * exec_communicate
+ *
+ * Description:
+ * Execute a command and return any output
+ *
+ * If given, @cancellable can be used to stop the process before it finishes.
+ *
+ * https://gtk-rs.org/gtk-rs-core/stable/0.14/docs/src/gio/auto/subprocess.rs.html
+ *
+ * Made:
+ * 15/09/2022
+ *
+ * Made by:
+ * Deren Vural
+ *
+ * Notes:
+ *
+ */
 pub fn exec_communicate(
     argv: &[&OsStr],
     _input: Option<&str>,
     cancellable: Option<&impl IsA<gio::Cancellable>>,
-) -> Result<(), glib::Error> {
+) -> Result<(Option<Bytes>, Option<Bytes>), glib::Error> {
     // Create subprocess
     println!("..creating subprocess"); //DEBUG
     match gio::Subprocess::newv(argv, gio::SubprocessFlags::NONE) {
@@ -151,10 +95,7 @@ pub fn exec_communicate(
             // Run subprocess
             match proc.communicate(None, cancellable) {
                 Err(err) => Err(err),
-                Ok(_out) => {
-                    println!("....process finished"); //DEBUG
-                    Ok(())
-                }
+                Ok(out) => Ok(out),
             }
         }
     }