camilla dsp service

Author: Idrimi

src/app/app-routing.module.ts

@@ -74,6 +74,10 @@ const routes: Routes = [
     path: 'setup-server',
     loadChildren: () => import('./pages/setup/setup-server/setup-server.module').then( m => m.SetupServerPageModule)
   },
+  {
+    path: 'camilla-dsp',
+    loadChildren: () => import('./pages/camilla-dsp/camilla-dsp.module').then( m => m.CamillaDspPageModule)
+  },
 
 
 ];

src/app/services/camilla-dsp.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CamillaDspService } from './camilla-dsp.service';
+
+describe('CamillaDspService', () => {
+  let service: CamillaDspService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(CamillaDspService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

src/app/services/camilla-dsp.service.ts

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { webSocket, WebSocketSubject } from 'rxjs/webSocket';
+import { Subject, Observable, BehaviorSubject, timer, of } from 'rxjs';
+import { retryWhen, switchMap, tap, delayWhen } from 'rxjs/operators';
+
+// Defines the possible connection states
+export type ConnectionStatus = 'Connected' | 'Connecting' | 'Disconnected' | 'Error';
+
+// A simple type for the JSON commands CamillaDSP expects
+// Example: { "command": "GetState", "params": null }
+interface CamillaDspCommand {
+  [command: string]: any;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CamillaDspService {
+  private socket$!: WebSocketSubject<any>;
+  private messagesSubject = new Subject<any>();
+  private connectionStatusSubject = new BehaviorSubject<ConnectionStatus>('Disconnected');
+  private readonly RECONNECT_INTERVAL_MS = 5000;
+
+  // Public observables for components to subscribe to
+  public messages$: Observable<any> = this.messagesSubject.asObservable();
+  public connectionStatus$: Observable<ConnectionStatus> = this.connectionStatusSubject.asObservable();
+
+  constructor() {}
+
+  /**
+   * Establishes a connection to the CamillaDSP WebSocket server.
+   * @param url The full WebSocket URL (e.g., 'ws://beatnik-client-amp.local:1234')
+   */
+  public connect(url: string): void {
+    if (this.socket$ && !this.socket$.closed) {
+      console.log('Already connected.');
+      return;
+    }
+
+    this.connectionStatusSubject.next('Connecting');
+    console.log(`Connecting to ${url}...`);
+
+    this.socket$ = webSocket({
+      url: url,
+      openObserver: {
+        next: () => {
+          console.log('WebSocket connection established successfully! 🎉');
+          this.connectionStatusSubject.next('Connected');
+        },
+      },
+      closeObserver: {
+        next: () => {
+          console.log('WebSocket connection closed.');
+          this.connectionStatusSubject.next('Disconnected');
+        },
+      },
+    });
+
+    this.socket$
+      .pipe(
+        // The retryWhen operator handles reconnection logic
+        retryWhen(errors =>
+          errors.pipe(
+            tap(err => {
+              console.error(`Connection error: ${err}. Retrying in ${this.RECONNECT_INTERVAL_MS / 1000}s...`);
+              this.connectionStatusSubject.next('Error');
+            }),
+            // Wait for the specified interval before trying to reconnect
+            delayWhen(() => timer(this.RECONNECT_INTERVAL_MS))
+          )
+        )
+      )
+      .subscribe({
+        next: msg => this.messagesSubject.next(msg), // Forward messages to our subject
+        error: err => {
+          // This block is less likely to be hit due to retryWhen, but good for unrecoverable errors
+          console.error('WebSocket unrecoverable error:', err);
+          this.connectionStatusSubject.next('Error');
+        },
+      });
+  }
+
+  /**
+   * Sends a command to the CamillaDSP server.
+   * @param command The command name (e.g., 'GetState', 'SetConfigJson').
+   * @param params Optional parameters for the command.
+   */
+  public sendCommand(command: string, params: any = null): void {
+    if (this.connectionStatusSubject.value !== 'Connected') {
+      console.warn('Cannot send command while not connected.');
+      return;
+    }
+
+    // CamillaDSP expects a JSON object where the key is the command name
+    const commandToSend: CamillaDspCommand = { [command]: params };
+    
+    console.log('Sending command:', commandToSend);
+    this.socket$.next(commandToSend);
+  }
+
+  /**
+   * Closes the WebSocket connection gracefully.
+   */
+  public disconnect(): void {
+    if (this.socket$) {
+      this.socket$.complete(); // This will trigger the closeObserver
+    }
+  }
+}