♻️ capsule plugin spawn method and move plugin trait to utils

client/src/main.rs

@@ -117,7 +117,7 @@ impl Application for Centerpiece {
                 }
                 _ => None,
             }),
-            crate::plugin::windows::WindowsPlugin::spawn(),
+            crate::plugin::utils::spawn::<crate::plugin::windows::WindowsPlugin>(),
             crate::plugin::applications::Plugin::spawn(),
             crate::plugin::brave::progressive_web_apps::Plugin::spawn(),
             crate::plugin::git_repositories::Plugin::spawn(),

client/src/plugin/mod.rs

@@ -5,5 +5,3 @@ pub mod git_repositories;
 pub mod resource_monitor;
 pub mod utils;
 pub mod windows;
-
-pub mod plugin;

client/src/plugin/utils.rs

@@ -1,4 +1,125 @@
 use fuzzy_matcher::FuzzyMatcher;
+use anyhow::Context;
+use iced::futures::StreamExt;
+
+pub fn spawn<PluginType: Plugin + std::marker::Send + 'static>(
+) -> iced::Subscription<crate::Message> {
+    return iced::subscription::channel(
+        std::any::TypeId::of::<PluginType>(),
+        100,
+        |plugin_channel_out| async move {
+            let mut plugin = PluginType::new();
+
+            let main_loop_result = plugin.main(plugin_channel_out).await;
+            if let Err(error) = main_loop_result {
+                log::error!(
+                    target: PluginType::id(),
+                    "{:?}", error,
+                );
+                panic!();
+            }
+
+            loop {}
+        },
+    );
+}
+
+#[async_trait::async_trait]
+pub trait Plugin {
+    fn id() -> &'static str;
+    fn priority() -> u32;
+    fn title() -> &'static str;
+
+    fn new() -> Self;
+
+    fn entries(&self) -> Vec<crate::model::Entry>;
+
+    fn plugin(
+        &self,
+        app_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::model::PluginRequest>,
+    ) -> crate::model::Plugin {
+        return crate::model::Plugin {
+            id: String::from(Self::id()),
+            priority: Self::priority(),
+            title: String::from(Self::title()),
+            app_channel_out: app_channel_out.clone(),
+            entries: self.entries(),
+        };
+    }
+
+    async fn main(
+        &mut self,
+        mut plugin_channel_out: iced::futures::channel::mpsc::Sender<crate::Message>,
+    ) -> anyhow::Result<()> {
+        let (mut app_channel_out, mut plugin_channel_in) =
+            iced::futures::channel::mpsc::channel(100);
+        self.register_plugin(&mut plugin_channel_out, &mut app_channel_out)?;
+
+        loop {
+            self.update(&mut plugin_channel_out, &mut plugin_channel_in)
+                .await?;
+        }
+    }
+
+    fn register_plugin(
+        &mut self,
+        plugin_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::Message>,
+        app_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::model::PluginRequest>,
+    ) -> anyhow::Result<()> {
+        plugin_channel_out
+            .try_send(crate::Message::RegisterPlugin(self.plugin(app_channel_out)))
+            .context("Failed to send message to register plugin.")?;
+
+        return Ok(());
+    }
+
+    async fn update(
+        &mut self,
+        plugin_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::Message>,
+        plugin_channel_in: &mut iced::futures::channel::mpsc::Receiver<crate::model::PluginRequest>,
+    ) -> anyhow::Result<()> {
+        let plugin_request = plugin_channel_in.select_next_some().await;
+
+        match plugin_request {
+            crate::model::PluginRequest::Search(query) => {
+                self.search(&query, plugin_channel_out)?
+            }
+            crate::model::PluginRequest::Timeout => (),
+            crate::model::PluginRequest::Activate(entry_id) => {
+                self.activate(entry_id, plugin_channel_out)?
+            }
+        }
+
+        return Ok(());
+    }
+
+    fn search(
+        &mut self,
+        query: &String,
+        plugin_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::Message>,
+    ) -> anyhow::Result<()> {
+        let filtered_entries = crate::plugin::utils::search(self.entries(), query);
+
+        plugin_channel_out
+            .try_send(crate::Message::UpdateEntries(
+                String::from(Self::id()),
+                filtered_entries,
+            ))
+            .context(format!(
+                "Failed to send message to update entries while searching for '{}'.",
+                query
+            ))?;
+
+        return Ok(());
+    }
+
+    fn activate(
+        &mut self,
+        entry_id: String,
+        plugin_channel_out: &mut iced::futures::channel::mpsc::Sender<crate::Message>,
+    ) -> anyhow::Result<()>;
+}
+
 
 pub fn search(entries: Vec<crate::model::Entry>, query: &String) -> Vec<crate::model::Entry> {
     let matcher = fuzzy_matcher::skim::SkimMatcherV2::default();

client/src/plugin/windows.rs

@@ -1,4 +1,4 @@
-use crate::plugin::plugin::Plugin;
+use crate::plugin::utils::Plugin;
 use anyhow::Context;
 
 pub struct WindowsPlugin {
@@ -7,30 +7,6 @@ pub struct WindowsPlugin {
 }
 
 impl WindowsPlugin {
-    pub fn spawn() -> iced::Subscription<crate::Message> {
-        let plugin_result = PluginType::new();
-        if let Err(_) = plugin_result {
-            return iced::Subscription::<crate::Message>::none()
-        }
-
-        let mut plugin = plugin_result.unwrap();
-        return iced::subscription::channel(
-            std::any::TypeId::of::<Self>(),
-            100,
-            |plugin_channel_out| async move {
-                let (app_channel_out, plugin_channel_in) =
-                    iced::futures::channel::mpsc::channel(100);
-                let main_loop_result = plugin
-                    .main(plugin_channel_out, app_channel_out, plugin_channel_in)
-                    .await;
-                if let Err(error) = main_loop_result {
-                    Self::log_and_panic(error);
-                }
-                loop {}
-            },
-        );
-    }
-
     fn get_window_nodes(node: swayipc::Node) -> Vec<swayipc::Node> {
         if !node.nodes.is_empty() {
             return node
@@ -46,10 +22,6 @@ impl WindowsPlugin {
 
         return vec![];
     }
-
-    fn try_new() -> Result<Self, ()> {
-        Ok(Self::new())
-    }
 }
 
 impl Plugin for WindowsPlugin {
@@ -71,15 +43,15 @@ impl Plugin for WindowsPlugin {
         let connection_result =
             swayipc::Connection::new().context("Failed to establish sway ipc connection.");
         if let Err(error) = connection_result {
-            Self::log_and_panic(error);
-            panic!("");
+            log::error!(target: Self::id(), "{:?}", error);
+            panic!();
         }
         let mut sway = connection_result.unwrap();
 
         let root_node_result = sway.get_tree().context("Failed to get_tree from sway ipc.");
         if let Err(error) = root_node_result {
-            Self::log_and_panic(error);
-            panic!("");
+            log::error!(target: Self::id(), "{:?}", error);
+            panic!();
         }
         let root_node = root_node_result.unwrap();