Add not working discord local rpc to desktop app

Author: NellowTCS

Build/src-tauri/Cargo.lock

@@ -25,4 +25,5 @@ serde_json = "1.0.149"
 tauri-plugin-fs = "2.4.5"
 tauri-plugin-notification = "2.3.3"
 tauri-plugin-dialog = "2.6.0"
+discord-rich-presence = "1.1.0"
 

Build/src-tauri/Cargo.toml

@@ -1,17 +1,65 @@
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
+
+use discord_rich_presence::{activity::Activity, DiscordIpc, DiscordIpcClient};
+
+const DISCORD_APP_ID: &str = "1419480226970341476";
+const DISCORD_LARGE_IMAGE_KEY: &str = "large_image_key";
+
 #[tauri::command]
 fn greet(name: &str) -> String {
     format!("Hello, {}! You've been greeted from Rust!", name)
 }
 
+#[tauri::command]
+fn set_discord_presence(details: String, state: String) -> Result<(), String> {
+    let mut client = DiscordIpcClient::new(DISCORD_APP_ID);
+
+    client.connect().map_err(|e| format!("Discord connect failed: {}", e))?;
+
+    let activity = Activity::new()
+        .details(details)
+        .state(state)
+        .assets(
+            discord_rich_presence::activity::Assets::new()
+                .large_image(DISCORD_LARGE_IMAGE_KEY)
+                .large_text("HTMLPlayer"),
+        );
+
+    client
+        .set_activity(activity)
+        .map_err(|e| format!("Failed to set Discord activity: {}", e))
+}
+
+#[tauri::command]
+fn clear_discord_presence() -> Result<(), String> {
+    let mut client = DiscordIpcClient::new(DISCORD_APP_ID);
+
+    client.connect().map_err(|e| format!("Discord connect failed: {}", e))?;
+    client
+        .clear_activity()
+        .map_err(|e| format!("Failed to clear Discord activity: {}", e))
+}
+
+#[tauri::command]
+fn is_discord_running() -> bool {
+    let mut client = DiscordIpcClient::new(DISCORD_APP_ID);
+    if client.connect().is_err() {
+        return false;
+    }
+
+    // Ignore errors when clearing activity; we only care whether the IPC is reachable.
+    let _ = client.clear_activity();
+    true
+}
+
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_notification::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_opener::init())
-        .invoke_handler(tauri::generate_handler![greet])
+        .invoke_handler(tauri::generate_handler![greet, set_discord_presence, clear_discord_presence, is_discord_running])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }

Build/src-tauri/src/lib.rs

@@ -29,6 +29,7 @@ import { useTranslation } from "react-i18next";
 import { languageNames } from "../types/supportedLanguages";
 import { isSafari } from "../helpers/safariHelper";
 import { Icon } from "./Icon";
+import { isTauri } from "@tauri-apps/api/core";
 
 import { resetAllDialogPreferences } from "../helpers/musicIndexedDbHelper";
 import {
@@ -180,6 +181,36 @@ export const Settings = ({
     }
   };
 
+  const [discordRpcStatus, setDiscordRpcStatus] = useState<
+    "unknown" | "available" | "unavailable" | "unsupported"
+  >("unknown");
+
+  const isTauriEnv = isTauri();
+
+  const checkDiscordRpcStatus = async () => {
+    if (!isTauriEnv) {
+      setDiscordRpcStatus("unsupported");
+      return;
+    }
+
+    try {
+      const { invoke } = await import("@tauri-apps/api/core");
+      const available = await invoke("is_discord_running");
+      setDiscordRpcStatus(available ? "available" : "unavailable");
+    } catch (error) {
+      console.error("Failed to check Discord RPC status:", error);
+      setDiscordRpcStatus("unavailable");
+    }
+  };
+
+  useEffect(() => {
+    if (settings.discordEnabled) {
+      checkDiscordRpcStatus();
+    } else {
+      setDiscordRpcStatus("unknown");
+    }
+  }, [settings.discordEnabled]);
+
   // Dynamic Eruda loading/unloading functions
   const loadEruda = () => {
     return new Promise<void>((resolve, reject) => {
@@ -910,6 +941,28 @@ export const Settings = ({
               </div>
             </div>
           )}
+
+          <div className={styles.settingItem}>
+            <div className={styles.settingInfo}>
+              <label>{t("discord.status")}</label>
+              <p className={styles.settingDescription}>
+                {discordRpcStatus === "unknown" && t("discord.statusUnknown")}
+                {discordRpcStatus === "unsupported" &&
+                  t("discord.statusUnsupported")}
+                {discordRpcStatus === "available" &&
+                  t("discord.statusAvailable")}
+                {discordRpcStatus === "unavailable" &&
+                  t("discord.statusUnavailable")}
+              </p>
+            </div>
+            <Button
+              variant="outline"
+              onClick={checkDiscordRpcStatus}
+              disabled={!isTauriEnv}
+            >
+              {t("discord.refreshStatus")}
+            </Button>
+          </div>
         </>
       )}
 

Build/src/components/Settings.tsx

@@ -24,49 +24,22 @@ export class DiscordService {
   }
 
   /**
-   * Send track update to Discord backend
+   * Log track update instead of sending to Discord backend
    */
   public async updatePresence(data: DiscordPresenceData): Promise<boolean> {
-    try {
-      const response = await fetch(`${DiscordService.API_BASE_URL}/presence`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(data),
-      });
-
-      if (!response.ok) {
-        console.error(
-          "Failed to update Discord presence:",
-          response.status,
-          response.statusText,
-        );
-        return false;
-      }
-
-      return true;
-    } catch (error) {
-      console.error("Error updating Discord presence:", error);
-      return false;
-    }
+    console.log(
+      `[DiscordService] Would POST to ${DiscordService.API_BASE_URL}/presence with:`,
+      data,
+    );
+    return true;
   }
 
   /**
-   * Clear Discord presence (when music stops)
+   * Log clear presence instead of sending to Discord backend
    */
   public async clearPresence(userId: string): Promise<boolean> {
-    try {
-      // Send empty details and state to clear presence
-      return await this.updatePresence({
-        userId,
-        details: "",
-        state: "",
-      });
-    } catch (error) {
-      console.error("Error clearing Discord presence:", error);
-      return false;
-    }
+    console.log(`[DiscordService] Would clear presence for userId: ${userId}`);
+    return true;
   }
 
   /**

Build/src/helpers/discordService.ts

@@ -24,22 +24,49 @@ export class DiscordService {
   }
 
   /**
-   * Log track update instead of sending to Discord backend
+   * Send track update to Discord backend
    */
   public async updatePresence(data: DiscordPresenceData): Promise<boolean> {
-    console.log(
-      `[DiscordService] Would POST to ${DiscordService.API_BASE_URL}/presence with:`,
-      data,
-    );
-    return true;
+    try {
+      const response = await fetch(`${DiscordService.API_BASE_URL}/presence`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(data),
+      });
+
+      if (!response.ok) {
+        console.error(
+          "Failed to update Discord presence:",
+          response.status,
+          response.statusText,
+        );
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      console.error("Error updating Discord presence:", error);
+      return false;
+    }
   }
 
   /**
-   * Log clear presence instead of sending to Discord backend
+   * Clear Discord presence (when music stops)
    */
   public async clearPresence(userId: string): Promise<boolean> {
-    console.log(`[DiscordService] Would clear presence for userId: ${userId}`);
-    return true;
+    try {
+      // Send empty details and state to clear presence
+      return await this.updatePresence({
+        userId,
+        details: "",
+        state: "",
+      });
+    } catch (error) {
+      console.error("Error clearing Discord presence:", error);
+      return false;
+    }
   }
 
   /**

Build/src/helpers/discordService_backup.ts

@@ -693,21 +693,35 @@ export const useMusicPlayer = () => {
   // Discord presence update function
   const updateDiscordPresence = useCallback(
     async (song: Song | null, isPlaying: boolean) => {
-      const discordService = DiscordService.getInstance();
+      if (!settings.discordEnabled) return;
 
-      if (!settings.discordEnabled || !settings.discordUserId) {
-        return;
-      }
+      // Prefer Tauri RPC (desktop) if available
+      const isTauri = (await import("@tauri-apps/api/core")).isTauri();
 
       try {
         if (song && isPlaying) {
-          await discordService.updatePresence({
-            userId: settings.discordUserId,
-            details: song.title,
-            state: song.artist,
-          });
+          if (isTauri) {
+            const { invoke } = await import("@tauri-apps/api/core");
+            await invoke("set_discord_presence", {
+              details: song.title,
+              state: song.artist,
+            });
+          } else if (settings.discordUserId) {
+            const discordService = DiscordService.getInstance();
+            await discordService.updatePresence({
+              userId: settings.discordUserId,
+              details: song.title,
+              state: song.artist,
+            });
+          }
         } else {
-          await discordService.clearPresence(settings.discordUserId);
+          if (isTauri) {
+            const { invoke } = await import("@tauri-apps/api/core");
+            await invoke("clear_discord_presence");
+          } else if (settings.discordUserId) {
+            const discordService = DiscordService.getInstance();
+            await discordService.clearPresence(settings.discordUserId);
+          }
         }
       } catch (error) {
         console.error("Failed to update Discord presence:", error);