minor consolidation & handling of data from frontend to rust side

src-tauri/src/commands/app_state.rs

@@ -1,7 +1,7 @@
 use crate::{
     lock_r,
     models::app_data::UserData,
-    services::presence_modules::models::ModuleMetadata,
+    services::{presence_modules::models::ModuleMetadata, presence_state::PresenceStateSnapshot},
     state::{init_app_data_scoped, AppDataRefreshScope, FDOLL},
 };
 
@@ -26,3 +26,9 @@ pub fn get_modules() -> Result<Vec<ModuleMetadata>, String> {
     let guard = lock_r!(FDOLL);
     Ok(guard.modules.metadatas.clone())
 }
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_presence_state() -> Result<PresenceStateSnapshot, String> {
+    Ok(crate::services::presence_state::get_presence_state_snapshot())
+}

src-tauri/src/commands/dolls.rs

@@ -1,4 +1,5 @@
 use crate::{
+    get_app_handle,
     models::dolls::{CreateDollDto, DollDto, UpdateDollDto},
     remotes::{
         dolls::DollsRemote,
@@ -7,6 +8,9 @@ use crate::{
     state::AppDataRefreshScope,
     commands::{refresh_app_data, refresh_app_data_conditionally, is_active_doll},
 };
+use crate::commands::scene::get_user_active_doll;
+use crate::services::app_events::UserActiveDollUpdated;
+use tauri_specta::Event as _;
 
 #[tauri::command]
 #[specta::specta]
@@ -87,6 +91,9 @@ pub async fn set_active_doll(doll_id: String) -> Result<(), String> {
 
     refresh_app_data(&[AppDataRefreshScope::User, AppDataRefreshScope::Friends]).await;
 
+    let active_doll = get_user_active_doll().ok().flatten();
+    let _ = UserActiveDollUpdated(active_doll).emit(get_app_handle());
+
     Ok(())
 }
 
@@ -100,5 +107,8 @@ pub async fn remove_active_doll() -> Result<(), String> {
 
     refresh_app_data(&[AppDataRefreshScope::User, AppDataRefreshScope::Friends]).await;
 
+    let active_doll = get_user_active_doll().ok().flatten();
+    let _ = UserActiveDollUpdated(active_doll).emit(get_app_handle());
+
     Ok(())
 }

src-tauri/src/commands/mod.rs

@@ -7,6 +7,7 @@ pub mod friends;
 pub mod interaction;
 pub mod sprite;
 pub mod petpet;
+pub mod scene;
 
 use crate::lock_r;
 use crate::state::{init_app_data_scoped, AppDataRefreshScope, FDOLL};

src-tauri/src/commands/scene.rs

@@ -0,0 +1,32 @@
+use crate::{
+    lock_r,
+    models::{dolls::DollDto, scene::SceneFriendNeko},
+    state::FDOLL,
+};
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_user_active_doll() -> Result<Option<DollDto>, String> {
+    let guard = lock_r!(FDOLL);
+
+    let Some(user) = &guard.user_data.user else {
+        return Ok(None);
+    };
+
+    let Some(active_doll_id) = &user.active_doll_id else {
+        return Ok(None);
+    };
+
+    Ok(guard.user_data.dolls.as_ref().and_then(|dolls| {
+        dolls
+            .iter()
+            .find(|doll| doll.id == *active_doll_id)
+            .cloned()
+    }))
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_scene_friends() -> Result<Vec<SceneFriendNeko>, String> {
+    Ok(crate::services::scene_friends::get_scene_friends_snapshot())
+}

src-tauri/src/lib.rs

@@ -1,10 +1,11 @@
 use crate::{
-    commands::app_state::get_modules,
+    commands::app_state::{get_modules, get_presence_state},
     services::{
         doll_editor::open_doll_editor_window,
         scene::{get_scene_interactive, set_pet_menu_state, set_scene_interactive},
     },
 };
+use commands::scene::{get_scene_friends, get_user_active_doll};
 use commands::app::{quit_app, restart_app, retry_connection};
 use commands::app_state::{get_app_data, refresh_app_data};
 use commands::auth::{change_password, login, logout_and_restart, register, reset_password};
@@ -26,9 +27,10 @@ use tauri_specta::{Builder as SpectaBuilder, ErrorHandlingMode, collect_commands
 use crate::services::app_events::{
     AppDataRefreshed, CreateDoll, CursorMoved, EditDoll, FriendActiveDollChanged,
     FriendCursorPositionUpdated, FriendDisconnected, FriendRequestAccepted,
-    FriendRequestDenied, FriendRequestReceived, FriendUserStatusChanged,
+    FriendRequestDenied, FriendRequestReceived, FriendUserStatusChanged, PresenceStateUpdated,
+    SceneFriendsUpdated,
     InteractionDeliveryFailed, InteractionReceived, SceneInteractiveChanged,
-    SetInteractionOverlay, Unfriended, UserStatusChanged,
+    SetInteractionOverlay, Unfriended, UserActiveDollUpdated, UserStatusChanged,
 };
 
 static APP_HANDLE: std::sync::OnceLock<tauri::AppHandle<tauri::Wry>> = std::sync::OnceLock::new();
@@ -93,13 +95,16 @@ pub fn run() {
             get_scene_interactive,
             set_scene_interactive,
             set_pet_menu_state,
+            get_user_active_doll,
+            get_scene_friends,
             login,
             register,
             change_password,
             reset_password,
             logout_and_restart,
             send_interaction_cmd,
-            get_modules
+            get_modules,
+            get_presence_state
         ])
         .events(collect_events![
             CursorMoved,
@@ -109,10 +114,13 @@ pub fn run() {
             EditDoll,
             CreateDoll,
             UserStatusChanged,
+            UserActiveDollUpdated,
             FriendCursorPositionUpdated,
             FriendDisconnected,
             FriendActiveDollChanged,
             FriendUserStatusChanged,
+            PresenceStateUpdated,
+            SceneFriendsUpdated,
             InteractionReceived,
             InteractionDeliveryFailed,
             FriendRequestReceived,

src-tauri/src/models/mod.rs

@@ -5,4 +5,5 @@ pub mod friends;
 pub mod health;
 pub mod interaction;
 pub mod remote_error;
+pub mod scene;
 pub mod user;

src-tauri/src/models/scene.rs

@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+use crate::{models::dolls::DollDto, services::cursor::CursorPositions};
+
+#[derive(Clone, Serialize, Deserialize, Debug, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneFriendNeko {
+    pub id: String,
+    pub position: CursorPositions,
+    pub active_doll: DollDto,
+}

src-tauri/src/services/app_events.rs

@@ -5,14 +5,19 @@ use tauri_specta::Event;
 use crate::{
     models::{
         app_data::UserData,
+        dolls::DollDto,
         event_payloads::{
             FriendActiveDollChangedPayload, FriendDisconnectedPayload,
             FriendRequestAcceptedPayload, FriendRequestDeniedPayload, FriendRequestReceivedPayload,
             FriendUserStatusPayload, UnfriendedPayload, UserStatusPayload,
         },
         interaction::{InteractionDeliveryFailedDto, InteractionPayloadDto},
+        scene::SceneFriendNeko,
+    },
+    services::{
+        cursor::CursorPositions, presence_state::PresenceStateSnapshot,
+        ws::OutgoingFriendCursorPayload,
     },
-    services::{cursor::CursorPositions, ws::OutgoingFriendCursorPayload},
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
@@ -43,6 +48,10 @@ pub struct CreateDoll;
 #[tauri_specta(event_name = "user-status-changed")]
 pub struct UserStatusChanged(pub UserStatusPayload);
 
+#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
+#[tauri_specta(event_name = "user-active-doll-updated")]
+pub struct UserActiveDollUpdated(pub Option<DollDto>);
+
 #[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
 #[tauri_specta(event_name = "friend-cursor-position")]
 pub struct FriendCursorPositionUpdated(pub OutgoingFriendCursorPayload);
@@ -59,6 +68,14 @@ pub struct FriendActiveDollChanged(pub FriendActiveDollChangedPayload);
 #[tauri_specta(event_name = "friend-user-status")]
 pub struct FriendUserStatusChanged(pub FriendUserStatusPayload);
 
+#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
+#[tauri_specta(event_name = "scene-friends-updated")]
+pub struct SceneFriendsUpdated(pub Vec<SceneFriendNeko>);
+
+#[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
+#[tauri_specta(event_name = "presence-state-updated")]
+pub struct PresenceStateUpdated(pub PresenceStateSnapshot);
+
 #[derive(Debug, Clone, Serialize, Deserialize, Type, Event)]
 #[tauri_specta(event_name = "interaction-received")]
 pub struct InteractionReceived(pub InteractionPayloadDto);

src-tauri/src/services/mod.rs

@@ -12,8 +12,10 @@ pub mod health_manager;
 pub mod health_monitor;
 pub mod interaction;
 pub mod petpet;
+pub mod presence_state;
 pub mod presence_modules;
 pub mod scene;
+pub mod scene_friends;
 pub mod sprite_recolor;
 pub mod welcome;
 pub mod ws;

src-tauri/src/services/presence_state.rs

@@ -0,0 +1,71 @@
+use crate::{
+    get_app_handle, lock_r, lock_w, models::event_payloads::UserStatusPayload,
+    services::app_events::PresenceStateUpdated, state::FDOLL,
+};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use tauri_specta::Event as _;
+use tracing::error;
+
+#[derive(Clone, Serialize, Deserialize, Debug, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct PresenceStateSnapshot {
+    pub current: Option<UserStatusPayload>,
+    pub friends: std::collections::HashMap<String, UserStatusPayload>,
+}
+
+pub fn get_presence_state_snapshot() -> PresenceStateSnapshot {
+    let guard = lock_r!(FDOLL);
+    PresenceStateSnapshot {
+        current: guard.presence.current.clone(),
+        friends: guard.presence.friends.clone(),
+    }
+}
+
+pub fn set_current_presence(status: UserStatusPayload) {
+    let mut guard = lock_w!(FDOLL);
+    guard.presence.current = Some(status);
+}
+
+pub fn set_friend_presence(friend_id: String, status: UserStatusPayload) {
+    let mut guard = lock_w!(FDOLL);
+    guard.presence.friends.insert(friend_id, status);
+}
+
+pub fn remove_friend_presence(friend_id: &str) {
+    let mut guard = lock_w!(FDOLL);
+    guard.presence.friends.remove(friend_id);
+}
+
+pub fn clear_missing_friends_from_presence_state() {
+    let friend_ids = {
+        let guard = lock_r!(FDOLL);
+        guard
+            .user_data
+            .friends
+            .as_ref()
+            .map(|friends| {
+                friends
+                    .iter()
+                    .filter_map(|friendship| {
+                        friendship.friend.as_ref().map(|friend| friend.id.clone())
+                    })
+                    .collect::<std::collections::HashSet<_>>()
+            })
+            .unwrap_or_default()
+    };
+
+    let mut guard = lock_w!(FDOLL);
+    guard
+        .presence
+        .friends
+        .retain(|friend_id, _| friend_ids.contains(friend_id));
+}
+
+pub fn emit_presence_state_updated() {
+    let snapshot = get_presence_state_snapshot();
+
+    if let Err(err) = PresenceStateUpdated(snapshot).emit(get_app_handle()) {
+        error!("Failed to emit presence state updated event: {}", err);
+    }
+}

src-tauri/src/services/scene_friends.rs

@@ -0,0 +1,91 @@
+use crate::{
+    get_app_handle, lock_r, lock_w,
+    models::{dolls::DollDto, scene::SceneFriendNeko},
+    services::{app_events::SceneFriendsUpdated, cursor::CursorPositions},
+    state::FDOLL,
+};
+use tauri_specta::Event as _;
+use tracing::error;
+
+pub fn get_scene_friends_snapshot() -> Vec<SceneFriendNeko> {
+    let guard = lock_r!(FDOLL);
+
+    (guard.user_data.friends.as_ref())
+        .into_iter()
+        .flatten()
+        .filter_map(|friendship| {
+            let friend = friendship.friend.as_ref()?;
+            let position = guard.friend_scene.cursor_positions.get(&friend.id)?.clone();
+
+            let active_doll = guard
+                .friend_scene
+                .active_dolls
+                .get(&friend.id)
+                .cloned()
+                .flatten()
+                .or_else(|| friend.active_doll.clone())?;
+
+            Some(SceneFriendNeko {
+                id: friend.id.clone(),
+                position,
+                active_doll,
+            })
+        })
+        .collect()
+}
+
+pub fn set_friend_cursor_position(friend_id: String, position: CursorPositions) {
+    let mut guard = lock_w!(FDOLL);
+    guard
+        .friend_scene
+        .cursor_positions
+        .insert(friend_id, position);
+}
+
+pub fn set_friend_active_doll(friend_id: String, doll: Option<DollDto>) {
+    let mut guard = lock_w!(FDOLL);
+    guard.friend_scene.active_dolls.insert(friend_id, doll);
+}
+
+pub fn remove_friend(friend_id: &str) {
+    let mut guard = lock_w!(FDOLL);
+    guard.friend_scene.cursor_positions.remove(friend_id);
+    guard.friend_scene.active_dolls.remove(friend_id);
+}
+
+pub fn clear_missing_friends_from_runtime_state() {
+    let friend_ids = {
+        let guard = lock_r!(FDOLL);
+        guard
+            .user_data
+            .friends
+            .as_ref()
+            .map(|friends| {
+                friends
+                    .iter()
+                    .filter_map(|friendship| {
+                        friendship.friend.as_ref().map(|friend| friend.id.clone())
+                    })
+                    .collect::<std::collections::HashSet<_>>()
+            })
+            .unwrap_or_default()
+    };
+
+    let mut guard = lock_w!(FDOLL);
+    guard
+        .friend_scene
+        .cursor_positions
+        .retain(|friend_id, _| friend_ids.contains(friend_id));
+    guard
+        .friend_scene
+        .active_dolls
+        .retain(|friend_id, _| friend_ids.contains(friend_id));
+}
+
+pub fn emit_scene_friends_updated() {
+    let snapshot = get_scene_friends_snapshot();
+
+    if let Err(err) = SceneFriendsUpdated(snapshot).emit(get_app_handle()) {
+        error!("Failed to emit scene friends updated event: {}", err);
+    }
+}

src-tauri/src/services/ws/friend.rs

@@ -11,7 +11,10 @@ use crate::services::app_events::{
     FriendRequestAccepted, FriendRequestDenied, FriendRequestReceived, FriendUserStatusChanged,
     Unfriended,
 };
-use crate::services::cursor::{normalized_to_absolute, CursorPositions};
+use crate::services::{
+    cursor::{normalized_to_absolute, CursorPositions},
+    presence_state, scene_friends,
+};
 use crate::state::AppDataRefreshScope;
 
 use super::{
@@ -72,7 +75,13 @@ pub fn on_friend_cursor_position(payload: Payload, _socket: RawClient) {
             },
         };
 
+        scene_friends::set_friend_cursor_position(
+            outgoing_payload.user_id.clone(),
+            outgoing_payload.position.clone(),
+        );
+
         emitter::emit_to_frontend_typed(&FriendCursorPositionUpdated(outgoing_payload));
+        scene_friends::emit_scene_friends_updated();
     }
 }
 
@@ -81,7 +90,11 @@ pub fn on_friend_disconnected(payload: Payload, _socket: RawClient) {
     if let Ok(data) =
         utils::extract_and_parse::<FriendDisconnectedPayload>(payload, "friend-disconnected")
     {
+        scene_friends::remove_friend(&data.user_id);
+        presence_state::remove_friend_presence(&data.user_id);
         emitter::emit_to_frontend_typed(&FriendDisconnected(data));
+        scene_friends::emit_scene_friends_updated();
+        presence_state::emit_presence_state_updated();
     }
 }
 
@@ -114,7 +127,9 @@ pub fn on_friend_active_doll_changed(payload: Payload, _socket: RawClient) {
         payload,
         "friend-active-doll-changed",
     ) {
+        scene_friends::set_friend_active_doll(data.friend_id.clone(), data.doll.clone());
         emitter::emit_to_frontend_typed(&FriendActiveDollChanged(data));
+        scene_friends::emit_scene_friends_updated();
         refresh::refresh_app_data(AppDataRefreshScope::Friends);
     }
 }
@@ -124,6 +139,8 @@ pub fn on_friend_user_status(payload: Payload, _socket: RawClient) {
     if let Ok(data) =
         utils::extract_and_parse::<FriendUserStatusPayload>(payload, "friend-user-status")
     {
+        presence_state::set_friend_presence(data.user_id.clone(), data.status.clone());
         emitter::emit_to_frontend_typed(&FriendUserStatusChanged(data));
+        presence_state::emit_presence_state_updated();
     }
 }

src-tauri/src/services/ws/user_status.rs

@@ -8,6 +8,7 @@ use tracing::warn;
 use crate::models::event_payloads::UserStatusPayload;
 
 use crate::services::app_events::UserStatusChanged;
+use crate::services::presence_state;
 
 use super::{emitter, types::WS_EVENT};
 
@@ -28,6 +29,9 @@ pub async fn report_user_status(status: UserStatusPayload) {
         warn!("Failed to emit user-status-changed event: {e}");
     }
 
+    presence_state::set_current_presence(status.clone());
+    presence_state::emit_presence_state_updated();
+
     // Schedule new report after 500ms
     let handle = async_runtime::spawn(async move {
         tokio::time::sleep(Duration::from_millis(500)).await;

src-tauri/src/state/mod.rs

@@ -1,7 +1,13 @@
 // in app-core/src/state.rs
 use crate::{
-    lock_w, models::app_data::UserData, services::presence_modules::models::ModuleMetadata,
+    lock_w,
+    models::{app_data::UserData, dolls::DollDto},
+    services::{
+        cursor::CursorPositions,
+        presence_modules::models::ModuleMetadata,
+    },
 };
+use std::collections::HashMap;
 use std::sync::{Arc, LazyLock, RwLock};
 use tauri::tray::TrayIcon;
 use tracing::info;
@@ -20,12 +26,26 @@ pub struct Modules {
     pub metadatas: Vec<ModuleMetadata>,
 }
 
+#[derive(Default, Clone)]
+pub struct FriendSceneRuntimeState {
+    pub cursor_positions: HashMap<String, CursorPositions>,
+    pub active_dolls: HashMap<String, Option<DollDto>>,
+}
+
+#[derive(Default, Clone)]
+pub struct PresenceRuntimeState {
+    pub current: Option<crate::models::event_payloads::UserStatusPayload>,
+    pub friends: HashMap<String, crate::models::event_payloads::UserStatusPayload>,
+}
+
 #[derive(Default)]
 pub struct AppState {
     pub app_config: crate::services::client_config_manager::AppConfig,
     pub network: NetworkState,
     pub auth: AuthState,
     pub user_data: UserData,
+    pub friend_scene: FriendSceneRuntimeState,
+    pub presence: PresenceRuntimeState,
     pub tray: Option<TrayIcon>,
     pub modules: Modules,
 }
@@ -45,6 +65,8 @@ pub fn init_app_state() {
         guard.network = init_network_state();
         guard.auth = init_auth_state();
         guard.user_data = UserData::default();
+        guard.friend_scene = FriendSceneRuntimeState::default();
+        guard.presence = PresenceRuntimeState::default();
         guard.modules = Modules::default();
     }
     update_display_dimensions_for_scene_state();

src-tauri/src/state/ui.rs

@@ -1,7 +1,7 @@
 use crate::{
     get_app_handle, lock_r, lock_w,
     remotes::{dolls::DollsRemote, friends::FriendRemote, user::UserRemote},
-    services::app_events::AppDataRefreshed,
+    services::{app_events::AppDataRefreshed, presence_state, scene_friends},
     state::FDOLL,
 };
 use std::{collections::HashSet, sync::LazyLock};
@@ -211,6 +211,9 @@ pub async fn init_app_data_scoped(scope: AppDataRefreshScope) {
                 let app_data_clone = guard.user_data.clone();
                 drop(guard); // Drop lock before emitting to prevent potential deadlocks
 
+                scene_friends::clear_missing_friends_from_runtime_state();
+                presence_state::clear_missing_friends_from_presence_state();
+
                 if let Err(e) = AppDataRefreshed(app_data_clone).emit(get_app_handle()) {
                     warn!("Failed to emit app-data-refreshed event: {}", e);
                     use tauri_plugin_dialog::MessageDialogBuilder;
@@ -223,8 +226,11 @@ pub async fn init_app_data_scoped(scope: AppDataRefreshScope) {
                         "Could not broadcast refreshed data to the UI. Some data may be stale.",
                     )
                     .kind(MessageDialogKind::Error)
-                    .show(|_| {});
+                        .show(|_| {});
                 }
+
+                scene_friends::emit_scene_friends_updated();
+                presence_state::emit_presence_state_updated();
             }
 
             Ok(())
@@ -260,4 +266,8 @@ pub fn clear_app_data() {
     guard.user_data.dolls = None;
     guard.user_data.user = None;
     guard.user_data.friends = None;
+    guard.friend_scene.cursor_positions.clear();
+    guard.friend_scene.active_dolls.clear();
+    guard.presence.current = None;
+    guard.presence.friends.clear();
 }