Working on a snap package

[soumyaDghosh]

Hi, recently I worked on creating a snap package for your app. And that needed some changes to fall into the confinement model of snaps. I am almost successful in fixing these. Just need one help in identifying the processes and matching them with apps in cases where interpreters (specifically python) is used to run the program.

This is my changes to the 1.3.0 tag till now

index 2f06d3b..5f1a5e0 100644
--- a/src/utils/app.rs
+++ b/src/utils/app.rs
@@ -21,22 +21,63 @@ use super::{
 
 static RE_ENV_FILTER: Lazy<Regex> = Lazy::new(|| Regex::new(r"env\s*\S*=\S*\s*(.*)").unwrap());
 
-static RE_FLATPAK_FILTER: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"flatpak run .* --command=(\S*)").unwrap());
+static RE_EXEC_FILTER: Lazy<Regex> = Lazy::new(|| {
+    if std::env::var("SNAP").is_ok() {
+        Regex::new(r"env bamf_desktop_file_hint=/var/lib/snapd/desktop/applications/*_*.desktop (\S*)").unwrap()
+    } else {
+        Regex::new(r"flatpak run .* --command=(\S*)").unwrap()
+    }
+});
 
 // Adapted from Mission Center: https://gitlab.com/mission-center-devs/mission-center/
 static DATA_DIRS: Lazy<Vec<PathBuf>> = Lazy::new(|| {
-    let home = std::env::var("HOME").unwrap_or_else(|_| "/".to_string());
+    let is_snap = std::env::var("SNAP").is_ok();
+    let home = std::env::var("SNAP_REAL_HOME").unwrap_or_else(|_| std::env::var("HOME").unwrap_or_else(|_| "/".to_string()));
+
+    let snap_prefix = if std::env::var("SNAP").is_ok() {
+        "/var/lib/snapd/hostfs"
+    } else {
+        ""
+    };
+
+    let blacklist: Vec<String> = if is_snap {
+        vec![
+            format!("{}/snap/resources/*/.local/share", home),
+            format!("{}/snap/resources/*", home),
+            "/snap/resources/*/data-dir".to_string(),
+            "/snap/resources/*/usr/share".to_string(),
+            "/snap/resources/*/gnome-platform/usr/share".to_string(),
+            "/usr/share/ubuntu-wayland".to_string(),
+            "/usr/share/gnome".to_string(),
+            "/usr/local/share".to_string(),
+            "/usr/share".to_string(),
+            "/var/lib/snapd/hostfs/var/lib/snapd/desktop".to_string(),
+        ]
+    } else {
+        vec!["".to_string()]
+    };
+
     let mut data_dirs: Vec<PathBuf> = std::env::var("XDG_DATA_DIRS")
         .unwrap_or_else(|_| format!("/usr/share:{}/.local/share", home))
         .split(':')
-        .map(PathBuf::from)
+        .map(|path| {
+            if path == format!("{home}/.local/share") {
+                PathBuf::from(path)
+            } else if blacklist.contains(&path.to_string()) {
+                PathBuf::from("")
+            } else {
+                PathBuf::from(format!("{}{}", snap_prefix, path))
+            }
+        })
         .collect();
-    data_dirs.push(PathBuf::from(format!("{}/.local/share", home)));
+
+    data_dirs.push(PathBuf::from(format!("{home}/.local/share")));
     data_dirs
 });
 
-// This contains known occurences of processes having a too distinct name from the actual app
+
+
+// This contains known occurrences of processes having a too distinct name from the actual app
 // The HashMap is used like this:
 //   Key: The name of the executable of the process
 //   Value: What it should be replaced with when finding out to which app it belongs
@@ -46,11 +87,12 @@ static KNOWN_EXECUTABLE_NAME_EXCEPTIONS: Lazy<HashMap<String, String>> = Lazy::n
         ("oosplash".into(), "libreoffice".into()),
         ("soffice.bin".into(), "libreoffice".into()),
         ("resources-processes".into(), "resources".into()),
+        ("x-terminal-emulator".into(), "kitty".into()),
     ])
 });
 
 // This contains executable names that are blacklisted from being recognized as applications
-static APPLICATION_EXEC_BLACKLIST: &[&str] = &["bash", "zsh", "fish", "sh", "ksh", "flatpak"];
+static APPLICATION_EXEC_BLACKLIST: &[&str] = &["bash", "zsh", "fish", "sh", "ksh", "flatpak", "snap"];
 
 #[derive(Debug, Clone, Default)]
 pub struct AppsContext {
@@ -162,7 +204,7 @@ impl App {
             .map(str::to_string);
 
         let executable_name = commandline.clone().map(|cmdline| {
-            RE_FLATPAK_FILTER // filter flatpak stuff (e. g. from "/usr/bin/flatpak run … --command=inkscape …" to "inkscape")
+            RE_EXEC_FILTER // filter flatpak stuff (e. g. from "/usr/bin/flatpak run … --command=inkscape …" to "inkscape")
                 .captures(&cmdline)
                 .and_then(|captures| captures.get(1))
                 .map(|capture| capture.as_str().to_string())
@@ -187,7 +229,8 @@ impl App {
         }
 
         let icon = if let Some(desktop_icon) = desktop_entry.get("Icon") {
-            if is_snap {
+            println!("{}", desktop_icon);
+            if is_snap && desktop_icon.contains("/") {
                 FileIcon::new(&File::for_path(desktop_icon)).into()
             } else {
                 ThemedIcon::new(desktop_icon).into()
@@ -583,13 +626,7 @@ impl AppsContext {
                     })
                     .any(|process| process.data.containerization == Containerization::Flatpak);
 
-                let is_snap = app
-                    .processes_iter(self)
-                    .filter(|process| {
-                        !process.data.commandline.starts_with("bwrap")
-                            && !process.data.commandline.is_empty()
-                    })
-                    .any(|process| process.data.containerization == Containerization::Snap);
+                let is_snap = std::env::var("SNAP").is_ok();
 
                 let containerization = if is_flatpak {
                     Containerization::Flatpak

And this is how the app works

https://imgur.com/boJ3Q2z