88 lines
2.9 KiB
TypeScript
88 lines
2.9 KiB
TypeScript
import * as Comlink from 'comlink';
|
|
import type { NetworkBackend } from '../../workers/network.worker';
|
|
import Services from '../service'; // Attention à la dépendance circulaire, on va gérer ça
|
|
|
|
export class NetworkService {
|
|
private worker: Comlink.Remote<NetworkBackend>;
|
|
private workerInstance: Worker;
|
|
|
|
// Cache local pour répondre instantanément aux demandes synchrones de l'UI
|
|
private localRelays: Record<string, string> = {};
|
|
|
|
constructor(private bootstrapUrls: string[]) {
|
|
this.workerInstance = new Worker(
|
|
new URL('../../workers/network.worker.ts', import.meta.url),
|
|
{ type: 'module' }
|
|
);
|
|
this.worker = Comlink.wrap<NetworkBackend>(this.workerInstance);
|
|
}
|
|
|
|
// Initialisation appelée par Services.ts
|
|
public async initRelays() {
|
|
// 1. Setup des callbacks : Quand le worker reçoit un message, il appelle ici
|
|
await this.worker.setCallbacks(
|
|
Comlink.proxy(this.onMessageReceived.bind(this)),
|
|
Comlink.proxy(this.onStatusChange.bind(this))
|
|
);
|
|
|
|
// 2. Lancer les connexions
|
|
for (const url of this.bootstrapUrls) {
|
|
this.addWebsocketConnection(url);
|
|
}
|
|
}
|
|
|
|
// --- MÉTHODES PUBLIQUES (API inchangée) ---
|
|
|
|
public async addWebsocketConnection(url: string) {
|
|
await this.worker.connect(url);
|
|
}
|
|
|
|
public async connectAllRelays() {
|
|
for (const url of this.bootstrapUrls) {
|
|
this.addWebsocketConnection(url);
|
|
}
|
|
}
|
|
|
|
public async sendMessage(flag: string, content: string) {
|
|
// On transmet au worker
|
|
// Note: Le type 'any' est utilisé pour simplifier la compatibilité avec AnkFlag
|
|
await this.worker.sendMessage(flag as any, content);
|
|
}
|
|
|
|
public updateRelay(url: string, spAddress: string) {
|
|
// Cette méthode était utilisée pour update l'état local.
|
|
// Maintenant c'est le worker qui gère la vérité, mais on garde le cache local.
|
|
this.localRelays[url] = spAddress;
|
|
}
|
|
|
|
public getAllRelays() {
|
|
return this.localRelays;
|
|
}
|
|
|
|
public async getAvailableRelayAddress(): Promise<string> {
|
|
// On demande au worker qui a la "vraie" info temps réel
|
|
const addr = await this.worker.getAvailableRelay();
|
|
if (addr) return addr;
|
|
|
|
// Fallback ou attente...
|
|
throw new Error('Aucun relais disponible (NetworkWorker)');
|
|
}
|
|
|
|
// --- INTERNES (CALLBACKS) ---
|
|
|
|
private async onMessageReceived(flag: string, content: string, url: string) {
|
|
// C'est ici qu'on fait le pont : NetworkWorker -> Main -> CoreWorker
|
|
// On passe par l'instance Singleton de Services pour atteindre le CoreWorker
|
|
const services = await Services.getInstance();
|
|
await services.dispatchToWorker(flag, content, url);
|
|
}
|
|
|
|
private onStatusChange(url: string, status: 'OPEN' | 'CLOSED', spAddress?: string) {
|
|
if (status === 'OPEN' && spAddress) {
|
|
this.localRelays[url] = spAddress;
|
|
} else if (status === 'CLOSED') {
|
|
this.localRelays[url] = '';
|
|
}
|
|
// On pourrait notifier l'UI ici de l'état de la connexion
|
|
}
|
|
} |