Merge pull request #379 from DhanishMecha/feat/running-apps-merge

feat: Running apps api integration

Author: akshayr-mecha

Cargo.toml

@@ -47,3 +47,5 @@ networkmanager = { path = "dbus/freedesktop/networkmanager" }
 bluez = { path = "dbus/freedesktop/bluez" }
 upower = { path = "dbus/freedesktop/upower" }
 pulseaudio = { path = "dbus/freedesktop/pulseaudio" }
+tracing = "0.1.41"
+tracing-subscriber = { version = "0.3.20", features = [ "env-filter" ] }

shell/crates/running_apps/Cargo.toml

@@ -14,4 +14,14 @@ keywords.workspace = true
 gpui = { workspace = true }
 rust-embed = { workspace = true }
 anyhow = { workspace = true }
+serde = { workspace = true }
 commons = { path = "../commons" }
+tokio = { workspace = true }
+futures = { workspace = true }
+notify = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+wayland-protocols-async = { git = "https://github.com/mecha-org/wayland-protocols-async.git", rev = "0c2c8f6ab9d944e24fdff89f08fd8fe6a67eb6d3" }
+indexmap = "2.1.0"
+lazy_static = "1.5.0"
+xdg = "2.4.1"

shell/crates/running_apps/src/ui/constants.rs renamed to shell/crates/running_apps/src/config/constants.rs

@@ -0,0 +1 @@
+pub mod constants;

shell/crates/running_apps/src/config/mod.rs

@@ -1,5 +1,10 @@
 mod ui;
-
+pub mod config;
+pub mod models;
+pub mod services;
 pub mod prelude {
-    pub use crate::ui::RunningApps;
+    // pub use crate::ui::*;
+    pub use crate::config::*;
+    pub use crate::services::*;
+    pub use crate::models::*;
 }

shell/crates/running_apps/src/lib.rs

@@ -1,22 +1,122 @@
 use commons::prelude::*;
 use gpui::prelude::*;
 use gpui::*;
-use running_apps::prelude::*;
+use running_apps::models::models::{ AppCard, RunningApps };
+use running_apps::prelude::app_manager::{ AppManagerService, AppMessage };
+use tokio::sync::mpsc;
+use tracing::{ error, info };
+use tracing_subscriber::EnvFilter;
 
 fn main() {
+    tracing_subscriber
+        ::fmt()
+        .with_env_filter(EnvFilter::from_default_env()) // reads RUST_LOG
+        .init();
+
     let application = gpui::Application::new().with_assets(Assets {});
     application.run(|cx| {
-        let window_bounds =
-            WindowBounds::Windowed(Bounds::centered(None, size(px(540.0), px(620.0)), cx));
-
-        cx.open_window(
-            WindowOptions {
-                window_bounds: Some(window_bounds),
-                ..Default::default()
-            },
-            |_window, cx| cx.new(|_cx| RunningApps::new()),
-        )
-        .unwrap();
+        let window_bounds = WindowBounds::Windowed(
+            Bounds::centered(None, size(px(540.0), px(620.0)), cx)
+        );
+
+        let (message_tx, message_rx) = mpsc::channel(120);
+        let (app_channel_tx, mut app_channel_rx) = mpsc::channel(120);
+
+        let running_apps_handle = cx
+            .open_window(
+                WindowOptions {
+                    window_bounds: Some(window_bounds),
+                    ..Default::default()
+                },
+                |_window, cx| cx.new(|_cx| RunningApps::new(message_tx))
+            )
+            .unwrap();
+
+        cx.background_executor()
+            .spawn(async move {
+                tokio::runtime::Builder
+                    ::new_multi_thread()
+                    .enable_all()
+                    .build()
+                    .unwrap()
+                    .block_on(async {
+                        let mut app_manager = AppManagerService::new();
+                        app_manager.run(message_rx, app_channel_tx).await;
+                    });
+            })
+            .detach();
+
+        cx.spawn(async move |cx| {
+            info!("📬 Message receiver task started");
+            let rhandle = running_apps_handle;
+
+            loop {
+                match app_channel_rx.recv().await {
+                    Some(message) => {
+                        if
+                            let AppMessage::AppsUpdated {
+                                apps,
+                                app_id: _,
+                                active_apps_count: _,
+                            } = message
+                        {
+                            let apps_clone = apps.clone();
+                            let mut latest_apps: Vec<AppCard> = Vec::new();
+
+                            for (i, app) in apps_clone.iter().enumerate() {
+                                latest_apps.push(AppCard {
+                                    id: i,
+                                    app_id: app.app_id.clone(),
+                                    offset_y: px(0.0),
+                                    target_offset_y: px(0.0),
+                                    app_name: app.name.clone(),
+                                    app_icon_path: app.icon_path.clone(),
+                                });
+                            }
+
+                            let new_apps_count = latest_apps.len();
+
+                            let _ = rhandle.update(
+                                cx,
+                                |this: &mut RunningApps, _, cx: &mut Context<'_, RunningApps>| {
+                                    let old_apps_count = this.apps.len();
+
+                                    this.apps = latest_apps;
+
+                                    // Only recalculate scroll if the number of apps changed
+                                    if old_apps_count != new_apps_count {
+                                        let last_index = if this.apps.is_empty() {
+                                            0
+                                        } else {
+                                            this.apps.len() - 1
+                                        };
+                                        let initial_offset =
+                                            this.calculate_center_offset(last_index);
+
+                                        this.scroll_offset = initial_offset;
+                                        this.target_scroll_offset = initial_offset;
+                                        this.current_center_index = last_index;
+
+                                        // Reset animation/drag states
+                                        this.is_animating = false;
+                                        this.is_dragging = false;
+                                    }
+                                    // If count is the same, preserve current scroll position
+                                    // (scroll_offset, target_scroll_offset, current_center_index remain unchanged)
+
+                                    cx.notify();
+                                }
+                            );
+                        }
+                    }
+                    None => {
+                        error!("❌ app_channel closed, exiting loop");
+                        break;
+                    }
+                }
+            }
+        }).detach();
+
         cx.activate(true);
     });
 }

shell/crates/running_apps/src/main.rs

@@ -0,0 +1 @@
+pub mod models;

shell/crates/running_apps/src/models/mod.rs

@@ -1,5 +1,8 @@
-use crate::ui::icon::IconName;
 use gpui::*;
+use tokio::sync::mpsc;
+
+use crate::prelude::app_manager::AppManagerMessage;
+
 pub struct RunningApps {
     pub scroll_offset: Pixels,
     pub is_dragging: bool,
@@ -14,11 +17,12 @@ pub struct RunningApps {
     pub is_removing: bool,
     pub removing_card_id: Option<usize>,
     pub current_center_index: usize,
-    pub is_cleaning_up: bool, // Flag for clean up animation
+    pub is_cleaning_up: bool,
     pub position: f32,
     pub bar_drag_offset: f32,
     pub bar_drag_start_y: Option<f32>,
     pub show_apps: bool,
+    pub message_tx: mpsc::Sender<AppManagerMessage>,
 }
 
 #[derive(Clone, Copy, PartialEq)]
@@ -30,8 +34,9 @@ pub enum DragDirection {
 #[derive(Clone)]
 pub struct AppCard {
     pub id: usize,
+    pub app_id: String,
     pub offset_y: Pixels,
     pub target_offset_y: Pixels,
-    pub app_name: String,
-    pub app_icon_path: IconName,
+    pub app_name: Option<String>,
+    pub app_icon_path: Option<String>,
 }