feat: refactor watcher for sync friend request

src/main/constants.ts

@@ -31,3 +31,5 @@ export const achievementSoundPath = app.isPackaged
 export const backupsPath = path.join(app.getPath("userData"), "Backups");
 
 export const appVersion = app.getVersion() + (isStaging ? "-staging" : "");
+
+export const MAIN_LOOP_INTERVAL = 1500;

src/main/events/profile/sync-friend-requests.ts

@@ -1,18 +1,23 @@
+import { MAIN_LOOP_INTERVAL } from "@main/constants";
 import { registerEvent } from "../register-event";
-import { HydraApi } from "@main/services";
+import { HydraApi, WindowManager } from "@main/services";
 import { publishNewFriendRequestNotification } from "@main/services/notifications";
 import { UserNotLoggedInError } from "@shared";
 import type { FriendRequestSync } from "@types";
 
 interface SyncState {
   friendRequestCount: number | null;
+  tick: number;
 }
 
+const ticksToUpdate = (2 * 60 * 1000) / MAIN_LOOP_INTERVAL; // 2 minutes
+
 const syncState: SyncState = {
   friendRequestCount: null,
+  tick: 0,
 };
 
-const syncFriendRequests = async (_event: Electron.IpcMainInvokeEvent) => {
+const syncFriendRequests = async () => {
   return HydraApi.get<FriendRequestSync>(`/profile/friend-requests/sync`)
     .then((res) => {
       if (
@@ -24,6 +29,11 @@ const syncFriendRequests = async (_event: Electron.IpcMainInvokeEvent) => {
 
       syncState.friendRequestCount = res.friendRequestCount;
 
+      WindowManager.mainWindow?.webContents.send(
+        "on-sync-friend-requests",
+        res
+      );
+
       return res;
     })
     .catch((err) => {
@@ -34,4 +44,16 @@ const syncFriendRequests = async (_event: Electron.IpcMainInvokeEvent) => {
     });
 };
 
-registerEvent("syncFriendRequests", syncFriendRequests);
+const syncFriendRequestsEvent = async (_event: Electron.IpcMainInvokeEvent) => {
+  return syncFriendRequests();
+};
+
+export const watchFriendRequests = async () => {
+  if (syncState.tick % ticksToUpdate === 0) {
+    await syncFriendRequests();
+  }
+
+  syncState.tick++;
+};
+
+registerEvent("syncFriendRequests", syncFriendRequestsEvent);

src/main/services/main-loop.ts

@@ -3,18 +3,21 @@ import { DownloadManager } from "./download";
 import { watchProcesses } from "./process-watcher";
 import { AchievementWatcherManager } from "./achievements/achievement-watcher-manager";
 import { UpdateManager } from "./update-manager";
+import { watchFriendRequests } from "@main/events/profile/sync-friend-requests";
+import { MAIN_LOOP_INTERVAL } from "@main/constants";
 
 export const startMainLoop = async () => {
   // eslint-disable-next-line no-constant-condition
   while (true) {
     await Promise.allSettled([
       watchProcesses(),
+      watchFriendRequests(),
       DownloadManager.watchDownloads(),
       AchievementWatcherManager.watchAchievements(),
       DownloadManager.getSeedStatus(),
       UpdateManager.checkForUpdatePeriodically(),
     ]);
 
-    await sleep(1500);
+    await sleep(MAIN_LOOP_INTERVAL);
   }
 };

src/main/services/update-manager.ts

@@ -4,9 +4,11 @@ import { AppUpdaterEvent, UserPreferences } from "@types";
 import { app } from "electron";
 import { publishNotificationUpdateReadyToInstall } from "@main/services/notifications";
 import { db, levelKeys } from "@main/level";
+import { MAIN_LOOP_INTERVAL } from "@main/constants";
 
 const { autoUpdater } = updater;
 const sendEventsForDebug = false;
+const ticksToUpdate = (50 * 60 * 1000) / MAIN_LOOP_INTERVAL; // 50 minutes
 
 export class UpdateManager {
   private static hasNotified = false;
@@ -72,7 +74,7 @@ export class UpdateManager {
   }
 
   public static checkForUpdatePeriodically() {
-    if (this.checkTick % 2000 == 0) {
+    if (this.checkTick % ticksToUpdate == 0) {
       this.checkForUpdates();
     }
     this.checkTick++;