From b136e8c0d3bea97149162ef6e76c6fd8cf242666 Mon Sep 17 00:00:00 2001 From: jmlee337 Date: Tue, 16 Apr 2024 18:19:20 +0900 Subject: [PATCH] clean up vestigial `remote` reconnect logic --- src/broadcast/api.ts | 8 +++++-- src/broadcast/ipc.ts | 7 ++---- src/broadcast/setup.ts | 22 +++++++++++++++--- src/broadcast/spectate.worker.ts | 7 ++++-- src/broadcast/types.ts | 6 +++-- src/remote/api.ts | 18 +-------------- src/remote/ipc.ts | 6 ----- src/remote/remote_server.ts | 24 ++++---------------- src/remote/setup.ts | 5 +--- src/remote/types.ts | 2 -- src/renderer/lib/hooks/use_app_listeners.ts | 13 ++++------- src/renderer/lib/hooks/use_broadcast_list.ts | 9 +++++--- src/renderer/lib/hooks/use_remote_server.ts | 6 +---- src/renderer/pages/spectate/create.tsx | 9 +++++--- 14 files changed, 59 insertions(+), 83 deletions(-) diff --git a/src/broadcast/api.ts b/src/broadcast/api.ts index a9d4278e0..1be6adb46 100644 --- a/src/broadcast/api.ts +++ b/src/broadcast/api.ts @@ -4,6 +4,7 @@ import { ipc_broadcastErrorOccurredEvent, ipc_broadcastListUpdatedEvent, ipc_broadcastReconnectEvent, + ipc_connect, ipc_dolphinStatusChangedEvent, ipc_refreshBroadcastList, ipc_slippiStatusChangedEvent, @@ -58,8 +59,11 @@ const broadcastApi: BroadcastService = { }); return destroy; }, - async refreshBroadcastList(authToken: string): Promise { - await ipc_refreshBroadcastList.renderer!.trigger({ authToken }); + async connect(authToken: string): Promise { + await ipc_connect.renderer!.trigger({ authToken }); + }, + async refreshBroadcastList(): Promise { + await ipc_refreshBroadcastList.renderer!.trigger({}); }, async watchBroadcast(broadcasterId: string): Promise { await ipc_watchBroadcast.renderer!.trigger({ broadcasterId }); diff --git a/src/broadcast/ipc.ts b/src/broadcast/ipc.ts index 5e316121d..689efa026 100644 --- a/src/broadcast/ipc.ts +++ b/src/broadcast/ipc.ts @@ -4,12 +4,9 @@ import { _, makeEndpoint } from "utils/ipc"; import type { BroadcasterItem, StartBroadcastConfig } from "./types"; // Handlers +export const ipc_connect = makeEndpoint.main("connect", <{ authToken: string }>_, _); -export const ipc_refreshBroadcastList = makeEndpoint.main( - "refreshBroadcastList", - <{ authToken: string }>_, - _, -); +export const ipc_refreshBroadcastList = makeEndpoint.main("refreshBroadcastList", _, _); export const ipc_watchBroadcast = makeEndpoint.main("watchBroadcast", <{ broadcasterId: string }>_, _); diff --git a/src/broadcast/setup.ts b/src/broadcast/setup.ts index f6cfec132..4023782b6 100644 --- a/src/broadcast/setup.ts +++ b/src/broadcast/setup.ts @@ -7,7 +7,13 @@ import log from "electron-log"; import type { BroadcastWorker } from "./broadcast.worker.interface"; import { createBroadcastWorker } from "./broadcast.worker.interface"; -import { ipc_refreshBroadcastList, ipc_startBroadcast, ipc_stopBroadcast, ipc_watchBroadcast } from "./ipc"; +import { + ipc_connect, + ipc_refreshBroadcastList, + ipc_startBroadcast, + ipc_stopBroadcast, + ipc_watchBroadcast, +} from "./ipc"; import type { SpectateWorker } from "./spectate.worker.interface"; import { createSpectateWorker } from "./spectate.worker.interface"; import type { SpectateController } from "./types"; @@ -35,11 +41,21 @@ export default function setupBroadcastIpc({ } }); - ipc_refreshBroadcastList.main!.handle(async ({ authToken }) => { + ipc_connect.main!.handle(async ({ authToken }) => { if (!spectateWorker) { spectateWorker = await createSpectateWorker(dolphinManager); } - await spectateWorker.refreshBroadcastList(authToken); + await spectateWorker.connect(authToken); + return { success: true }; + }); + + ipc_refreshBroadcastList.main!.handle(async () => { + Preconditions.checkExists( + spectateWorker, + "Could not refresh broadcast list, make sure spectateWorker is connected.", + ); + + await spectateWorker.refreshBroadcastList(); return { success: true }; }); diff --git a/src/broadcast/spectate.worker.ts b/src/broadcast/spectate.worker.ts index 6d886d65d..95207fec3 100644 --- a/src/broadcast/spectate.worker.ts +++ b/src/broadcast/spectate.worker.ts @@ -15,7 +15,8 @@ interface Methods { startSpectate(broadcastId: string, targetPath: string, dolphinOptions: SpectateDolphinOptions): Promise; stopSpectate(broadcastId: string): Promise; dolphinClosed(playbackId: string): Promise; - refreshBroadcastList(authToken: string): Promise; + connect(authToken: string): Promise; + refreshBroadcastList(): Promise; getLogObservable(): Observable; getErrorObservable(): Observable; getBroadcastListObservable(): Observable; @@ -84,8 +85,10 @@ const methods: WorkerSpec = { async dolphinClosed(playbackId: string): Promise { spectateManager.handleClosedDolphin(playbackId); }, - async refreshBroadcastList(authToken: string): Promise { + async connect(authToken: string): Promise { await spectateManager.connect(authToken); + }, + async refreshBroadcastList(): Promise { await spectateManager.refreshBroadcastList(); }, getLogObservable(): Observable { diff --git a/src/broadcast/types.ts b/src/broadcast/types.ts index 282c77439..c94a0b929 100644 --- a/src/broadcast/types.ts +++ b/src/broadcast/types.ts @@ -73,7 +73,8 @@ export type BroadcastService = { onDolphinStatusChanged(handle: (status: number) => void): () => void; onSlippiStatusChanged(handle: (status: number) => void): () => void; onSpectateErrorMessage(handle: (message: string | null) => void): () => void; - refreshBroadcastList(authToken: string): Promise; + connect(authToken: string): Promise; + refreshBroadcastList(): Promise; watchBroadcast(broadcasterId: string): Promise; startBroadcast(config: StartBroadcastConfig): Promise; stopBroadcast(): Promise; @@ -87,7 +88,8 @@ export type SpectateDolphinOptions = { export interface SpectateController { startSpectate(broadcastId: string, targetPath: string, dolphinOptions: SpectateDolphinOptions): Promise; dolphinClosed(playbackId: string): Promise; - refreshBroadcastList(authToken: string): Promise; + connect(authToken: string): Promise; + refreshBroadcastList(): Promise; getBroadcastListObservable(): Observable; getSpectateDetailsObservable(): Observable<{ playbackId: string; filePath: string; broadcasterName: string }>; getGameEndObservable(): Observable; diff --git a/src/remote/api.ts b/src/remote/api.ts index cda149c48..1c13b9799 100644 --- a/src/remote/api.ts +++ b/src/remote/api.ts @@ -1,19 +1,7 @@ -import { - ipc_reconnectRemoteServer, - ipc_remoteReconnectEvent, - ipc_remoteStateEvent, - ipc_startRemoteServer, - ipc_stopRemoteServer, -} from "./ipc"; +import { ipc_remoteStateEvent, ipc_startRemoteServer, ipc_stopRemoteServer } from "./ipc"; import type { RemoteService } from "./types"; const remoteApi: RemoteService = { - onReconnect(handle: () => void) { - const { destroy } = ipc_remoteReconnectEvent.renderer!.handle(async () => { - handle(); - }); - return destroy; - }, onState(handle: (connected: boolean, started: boolean, port?: number) => void) { const { destroy } = ipc_remoteStateEvent.renderer!.handle(async ({ connected, started, port }) => { handle(connected, started, port); @@ -24,10 +12,6 @@ const remoteApi: RemoteService = { const { result } = await ipc_startRemoteServer.renderer!.trigger({ authToken, port }); return result; }, - async reconnectRemoteServer(authToken: string) { - const { result } = await ipc_reconnectRemoteServer.renderer!.trigger({ authToken }); - return result; - }, async stopRemoteServer() { await ipc_stopRemoteServer.renderer!.trigger({}); }, diff --git a/src/remote/ipc.ts b/src/remote/ipc.ts index a663f3709..acc661e91 100644 --- a/src/remote/ipc.ts +++ b/src/remote/ipc.ts @@ -1,7 +1,6 @@ import type { EmptyPayload, SuccessPayload } from "utils/ipc"; import { _, makeEndpoint } from "utils/ipc"; -export const ipc_remoteReconnectEvent = makeEndpoint.renderer("remote_reconnect", _); export const ipc_remoteStateEvent = makeEndpoint.renderer( "remote_state", <{ connected: boolean; started: boolean; port?: number }>_, @@ -11,9 +10,4 @@ export const ipc_startRemoteServer = makeEndpoint.main( <{ authToken: string; port: number }>_, <{ success: boolean; err?: string }>_, ); -export const ipc_reconnectRemoteServer = makeEndpoint.main( - "remote_reconnectServer", - <{ authToken: string }>_, - <{ success: boolean }>_, -); export const ipc_stopRemoteServer = makeEndpoint.main("remote_stopServer", _, _); diff --git a/src/remote/remote_server.ts b/src/remote/remote_server.ts index fe7b4d022..dd05fd27f 100644 --- a/src/remote/remote_server.ts +++ b/src/remote/remote_server.ts @@ -5,7 +5,7 @@ import { DolphinEventType, DolphinLaunchType } from "@dolphin/types"; import type { SettingsManager } from "@settings/settings_manager"; import electronLog from "electron-log"; import http from "http"; -import { throttle } from "lodash"; +import throttle from "lodash/throttle"; import type { AddressInfo } from "net"; import type { connection } from "websocket"; import { server as WebSocketServer } from "websocket"; @@ -16,7 +16,6 @@ const SPECTATE_PROTOCOL = "spectate-protocol"; const log = electronLog.scope("remote_server"); export class RemoteServer { - private authToken: string; private dolphinLaunchTimes: Map; private spectateController: SpectateController | null; @@ -31,7 +30,6 @@ export class RemoteServer { private readonly settingsManager: SettingsManager, private readonly getSpectateController: () => Promise, ) { - this.authToken = ""; this.dolphinLaunchTimes = new Map(); this.spectateController = null; this.httpServer = null; @@ -117,10 +115,11 @@ export class RemoteServer { }); } - public async start(authToken: string, port: number): Promise<{ success: boolean; err?: string }> { + public async start(initialAuthToken: string, port: number): Promise<{ success: boolean; err?: string }> { if (!this.spectateController) { await this.setupSpectateController(); } + await this.spectateController!.connect(initialAuthToken); if (this.httpServer && this.remoteServer) { return (this.httpServer.address()).port === port @@ -128,7 +127,6 @@ export class RemoteServer { : { success: false, err: `server already started on port ${port}` }; } - this.authToken = authToken; try { this.httpServer = http.createServer(); await new Promise((resolve, reject) => { @@ -153,7 +151,7 @@ export class RemoteServer { const newConnection = request.accept(SPECTATE_PROTOCOL, request.origin); const throttledRefresh = throttle(async () => { try { - await this.spectateController!.refreshBroadcastList(this.authToken); + await this.spectateController!.refreshBroadcastList(); } catch (e) { const err = typeof e === "string" ? e : e instanceof Error ? e.message : "unknown"; newConnection.sendUTF(JSON.stringify({ op: "list-broadcasts-response", err })); @@ -213,20 +211,6 @@ export class RemoteServer { } } - public async reconnect(authToken: string) { - if (!authToken) { - return false; - } - - this.authToken = authToken; - try { - await this.spectateController!.refreshBroadcastList(this.authToken); - return true; - } catch (e) { - return false; - } - } - public stop() { if (this.httpServer && this.remoteServer) { if (this.connection) { diff --git a/src/remote/setup.ts b/src/remote/setup.ts index 3f63d237f..1365ea4c9 100644 --- a/src/remote/setup.ts +++ b/src/remote/setup.ts @@ -2,7 +2,7 @@ import type { SpectateController } from "@broadcast/types"; import type { DolphinManager } from "@dolphin/manager"; import type { SettingsManager } from "@settings/settings_manager"; -import { ipc_reconnectRemoteServer, ipc_startRemoteServer, ipc_stopRemoteServer } from "./ipc"; +import { ipc_startRemoteServer, ipc_stopRemoteServer } from "./ipc"; import { RemoteServer } from "./remote_server"; export default function setupRemoteIpc({ @@ -18,9 +18,6 @@ export default function setupRemoteIpc({ ipc_startRemoteServer.main!.handle(async ({ authToken, port }) => { return await remoteServer.start(authToken, port); }); - ipc_reconnectRemoteServer.main!.handle(async ({ authToken }) => { - return { success: await remoteServer.reconnect(authToken) }; - }); ipc_stopRemoteServer.main!.handle(async () => { remoteServer.stop(); return { success: true }; diff --git a/src/remote/types.ts b/src/remote/types.ts index 1105d0141..77709f7f8 100644 --- a/src/remote/types.ts +++ b/src/remote/types.ts @@ -1,7 +1,5 @@ export type RemoteService = { - onReconnect(handle: () => void): () => void; onState(handle: (connected: boolean, started: boolean, port?: number) => void): () => void; startRemoteServer(authToken: string, port: number): Promise<{ success: boolean; err?: string }>; - reconnectRemoteServer(authToken: string): Promise<{ success: boolean }>; stopRemoteServer(): Promise; }; diff --git a/src/renderer/lib/hooks/use_app_listeners.ts b/src/renderer/lib/hooks/use_app_listeners.ts index 1a0269507..a47530723 100644 --- a/src/renderer/lib/hooks/use_app_listeners.ts +++ b/src/renderer/lib/hooks/use_app_listeners.ts @@ -17,7 +17,7 @@ import { useBroadcast } from "./use_broadcast"; import { useBroadcastList, useBroadcastListStore } from "./use_broadcast_list"; import { useConsoleDiscoveryStore } from "./use_console_discovery"; import { useIsoVerification } from "./use_iso_verification"; -import { useRemoteServer, useRemoteServerStateStore } from "./use_remote_server"; +import { useRemoteServerStateStore } from "./use_remote_server"; import { useReplayBrowserNavigation } from "./use_replay_browser_list"; import { useSettings } from "./use_settings"; import { useSettingsModal } from "./use_settings_modal"; @@ -188,15 +188,10 @@ export const useAppListeners = () => { }); }, [startBroadcast, broadcastService]); - const [, refreshBroadcasts] = useBroadcastList(); + const [, connect] = useBroadcastList(); React.useEffect(() => { - return broadcastService.onSpectateReconnect(refreshBroadcasts); - }, [refreshBroadcasts, broadcastService]); - - const [, , reconnectRemoteServer] = useRemoteServer(); - React.useEffect(() => { - return remoteService.onReconnect(reconnectRemoteServer); - }, [reconnectRemoteServer, remoteService]); + return broadcastService.onSpectateReconnect(connect); + }, [connect, broadcastService]); const updateRemoteServerState = useRemoteServerStateStore((store) => store.setState); React.useEffect(() => { diff --git a/src/renderer/lib/hooks/use_broadcast_list.ts b/src/renderer/lib/hooks/use_broadcast_list.ts index f37cac19b..c02aa3e25 100644 --- a/src/renderer/lib/hooks/use_broadcast_list.ts +++ b/src/renderer/lib/hooks/use_broadcast_list.ts @@ -22,9 +22,12 @@ export const useBroadcastList = () => { const items = useBroadcastListStore((store) => store.items); const { showError } = useToasts(); - const refresh = async () => { + const connect = async () => { const authToken = await authService.getUserToken(); - await broadcastService.refreshBroadcastList(authToken); + await broadcastService.connect(authToken); + }; + const refresh = async () => { + await broadcastService.refreshBroadcastList(); }; // Limit refreshing to once every 2 seconds @@ -32,5 +35,5 @@ export const useBroadcastList = () => { refresh().catch(showError); }, 2000); - return [items, throttledRefresh] as const; + return [items, connect, throttledRefresh] as const; }; diff --git a/src/renderer/lib/hooks/use_remote_server.ts b/src/renderer/lib/hooks/use_remote_server.ts index a84419440..2897d9c29 100644 --- a/src/renderer/lib/hooks/use_remote_server.ts +++ b/src/renderer/lib/hooks/use_remote_server.ts @@ -33,12 +33,8 @@ export const useRemoteServer = () => { const authToken = await authService.getUserToken(); return remoteService.startRemoteServer(authToken, port); }; - const reconnectRemoteServer = async () => { - const authToken = await authService.getUserToken(); - return remoteService.reconnectRemoteServer(authToken); - }; const stopRemoteServer = async () => { return remoteService.stopRemoteServer(); }; - return [state, startRemoteServer, reconnectRemoteServer, stopRemoteServer] as const; + return [state, startRemoteServer, stopRemoteServer] as const; }; diff --git a/src/renderer/pages/spectate/create.tsx b/src/renderer/pages/spectate/create.tsx index 780dd86a1..16e12c16c 100644 --- a/src/renderer/pages/spectate/create.tsx +++ b/src/renderer/pages/spectate/create.tsx @@ -20,14 +20,17 @@ export function createSpectatePage({ broadcastService }: CreateSpectatePageArgs) const Page = React.memo(() => { const user = useAccount((store) => store.user); - const [currentBroadcasts, refreshBroadcasts] = useBroadcastList(); - const [remoteServerState, startRemoteServer, , stopRemoteServer] = useRemoteServer(); + const [currentBroadcasts, connect, refreshBroadcasts] = useBroadcastList(); + const [remoteServerState, startRemoteServer, stopRemoteServer] = useRemoteServer(); return ( { + await connect(); + await refreshBroadcasts(); + }} remoteServerState={remoteServerState} startRemoteServer={startRemoteServer} stopRemoteServer={stopRemoteServer}