Set app badge to notification count periodically

crates/radicle-tauri/Cargo.toml

@@ -33,6 +33,15 @@ ts-rs = { version = "10.0.0", features = ["serde-json-impl", "no-serde-warnings"
 tokio = { version = "1.40.0", features = ["time"] }
 tauri-plugin-dialog = { version = "2.2.0" }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2-foundation = { version = "0.2.2", features = [
+  "NSThread",
+] }
+objc2-app-kit = { version = "0.2.2", features = [
+  "NSApplication",
+  "NSDockTile",
+] }
+
 [features]
 # by default Tauri runs in production mode
 # when `tauri dev` runs it is executed with `cargo run --no-default-features` if `devPath` is an URL

crates/radicle-tauri/src/commands/inbox.rs

@@ -179,3 +179,28 @@ pub fn clear_notifications(
 
     Ok(())
 }
+
+#[tauri::command]
+#[cfg(target_os = "macos")]
+pub fn set_badge(count: i32) {
+    use objc2_app_kit::NSApp;
+    use objc2_foundation::{MainThreadMarker, NSString};
+
+    let label = if count > 0 {
+        Some(NSString::from_str(&format!("{}", count)))
+    } else {
+        None
+    };
+
+    if let Some(thread) = MainThreadMarker::new() {
+        unsafe {
+            let app = NSApp(thread);
+            let dock_tile = app.dockTile();
+
+            dock_tile.setBadgeLabel(label.as_deref());
+            dock_tile.display();
+        }
+    } else {
+        eprintln!("Failed to obtain MainThreadMarker.");
+    }
+}

crates/radicle-tauri/src/lib.rs

@@ -84,9 +84,10 @@ pub fn run() {
             repo::diff_stats,
             repo::list_commits,
             diff::get_diff,
-            inbox::list_notifications,
-            inbox::count_notifications_by_repo,
             inbox::clear_notifications,
+            inbox::count_notifications_by_repo,
+            inbox::list_notifications,
+            inbox::set_badge,
             cob::get_embed,
             cob::save_embed_to_disk,
             cob::save_embed_by_path,

src/App.svelte

@@ -1,7 +1,10 @@
 <script lang="ts">
   import type { UnlistenFn } from "@tauri-apps/api/event";
+  import type { NotificationCount } from "@bindings/cob/inbox/NotificationCount";
 
   import { onDestroy, onMount } from "svelte";
+  import { SvelteMap } from "svelte/reactivity";
+  import sum from "lodash/sum";
 
   import { invoke } from "@app/lib/invoke";
   import { listen } from "@tauri-apps/api/event";
@@ -19,12 +22,14 @@
   import Patch from "@app/views/repo/Patch.svelte";
   import Patches from "@app/views/repo/Patches.svelte";
   import Repos from "./views/home/Repos.svelte";
-  import { dynamicInterval, checkAuth } from "./lib/auth";
+  import { dynamicInterval, checkAuth, authenticated } from "./lib/auth";
 
   const activeRouteStore = router.activeRouteStore;
 
   let unlistenEvents: UnlistenFn | undefined = undefined;
   let unlistenNodeEvents: UnlistenFn | undefined = undefined;
+  let notificationPoll: ReturnType<typeof setInterval> | undefined = undefined;
+  let pollingNotificationsInProgress: boolean = false;
 
   onMount(async () => {
     if (window.__TAURI_INTERNALS__) {
@@ -39,13 +44,15 @@
 
     try {
       await invoke("authenticate");
+      authenticated.set(true);
       void router.loadFromLocation();
       void dynamicInterval(
         checkAuth,
         import.meta.env.VITE_AUTH_LONG_DELAY || 30_000,
       );
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any) {
+      authenticated.set(false);
       void router.push({
         resource: "authenticationError",
         params: {
@@ -55,15 +62,44 @@
       });
       void dynamicInterval(checkAuth, 1000);
     }
+
+    await setNotificationBadge();
+    notificationPoll = setInterval(async () => {
+      if (pollingNotificationsInProgress || !$nodeRunning || !$authenticated) {
+        return;
+      }
+
+      await setNotificationBadge();
+    }, 5_000);
   });
 
+  async function setNotificationBadge() {
+    try {
+      pollingNotificationsInProgress = true;
+
+      let count = await invoke<Record<string, NotificationCount>>(
+        "count_notifications_by_repo",
+      );
+      const notificationCount = new SvelteMap(Object.entries(count));
+      invoke("set_badge", {
+        count: sum(Array.from(notificationCount.values()).map(c => c.count)),
+      });
+      console.log("YAY");
+    } finally {
+      pollingNotificationsInProgress = false;
+    }
+  }
+
   onDestroy(() => {
     if (unlistenEvents) {
       unlistenEvents();
     }
     if (unlistenNodeEvents) {
       unlistenNodeEvents();
     }
+    if (notificationPoll) {
+      clearInterval(notificationPoll);
+    }
   });
 
   $effect(() => document.documentElement.setAttribute("data-theme", $theme));

src/lib/auth.ts

@@ -1,10 +1,14 @@
-import { invoke } from "@app/lib/invoke";
-import { activeRouteStore } from "@app/lib/router";
 import { get } from "svelte/store";
+import { writable } from "svelte/store";
+
 import * as router from "@app/lib/router";
+import { activeRouteStore } from "@app/lib/router";
+import { invoke } from "@app/lib/invoke";
 
 let intervalId: ReturnType<typeof setTimeout>;
 
+export const authenticated = writable<boolean>(false);
+
 export function dynamicInterval(callback: () => void, period: number) {
   clearTimeout(intervalId);
 
@@ -23,12 +27,14 @@ export async function checkAuth() {
     }
     lock = true;
     await invoke("authenticate");
+    authenticated.set(true);
     if (get(activeRouteStore).resource === "authenticationError") {
       window.history.back();
     }
     dynamicInterval(checkAuth, import.meta.env.VITE_AUTH_LONG_DELAY || 30_000);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (e: any) {
+    authenticated.set(false);
     if (get(activeRouteStore).resource !== "authenticationError") {
       await router.push({
         resource: "authenticationError",