@cloudfort/callum-voice 0.0.3

package/lib/VoiceEventListener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoiceEventListener.d.ts","sourceRoot":"","sources":["../src/VoiceEventListener.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IACjC,6BAA6B;IAC7B,WAAW,CAAC,IAAI,IAAI,CAAC;IAErB,sBAAsB;IACtB,cAAc,CAAC,IAAI,IAAI,CAAC;IAExB,uCAAuC;IACvC,cAAc,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC,4BAA4B;IAC5B,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpC,oBAAoB;IACpB,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpC,kBAAkB;IAClB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC,+BAA+B;IAC/B,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpC,yBAAyB;IACzB,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAElC,4BAA4B;IAC5B,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtC,4BAA4B;IAC5B,aAAa,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAErC,yBAAyB;IACzB,YAAY,CAAC,IAAI,IAAI,CAAC;IAEtB,0BAA0B;IAC1B,aAAa,CAAC,IAAI,IAAI,CAAC;IAEvB,sBAAsB;IACtB,gBAAgB,CAAC,IAAI,IAAI,CAAC;IAE1B,uBAAuB;IACvB,iBAAiB,CAAC,IAAI,IAAI,CAAC;IAE3B,qBAAqB;IACrB,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAE7B,+BAA+B;IAC/B,cAAc,CAAC,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACnD"}

package/lib/VoiceEventListener.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright Cloudfort. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=VoiceEventListener.js.map

package/lib/VoiceEventListener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoiceEventListener.js","sourceRoot":"","sources":["../src/VoiceEventListener.ts"],"names":[],"mappings":";AAAA,4CAA4C"}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { VoiceClientState } from './VoiceClientState';
+export { VoiceConfig, createVoiceConfig } from './VoiceConfig';
+export { VoiceEventListener } from './VoiceEventListener';
+export { VoiceClient } from './VoiceClient';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright Cloudfort. All Rights Reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceClient = exports.createVoiceConfig = exports.VoiceClientState = void 0;
+var VoiceClientState_1 = require("./VoiceClientState");
+Object.defineProperty(exports, "VoiceClientState", { enumerable: true, get: function () { return VoiceClientState_1.VoiceClientState; } });
+var VoiceConfig_1 = require("./VoiceConfig");
+Object.defineProperty(exports, "createVoiceConfig", { enumerable: true, get: function () { return VoiceConfig_1.createVoiceConfig; } });
+var VoiceClient_1 = require("./VoiceClient");
+Object.defineProperty(exports, "VoiceClient", { enumerable: true, get: function () { return VoiceClient_1.VoiceClient; } });
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,4CAA4C;;;AAE5C,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,6CAA+D;AAAzC,gHAAA,iBAAiB,OAAA;AAEvC,6CAA4C;AAAnC,0GAAA,WAAW,OAAA"}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@cloudfort/callum-voice",
+  "version": "0.0.3",
+  "description": "Real-time voice chat SDK for React Native apps",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc"
+  },
+  "keywords": [
+    "react-native",
+    "voice-chat",
+    "voice",
+    "realtime",
+    "audio",
+    "webrtc",
+    "websocket"
+  ],
+  "author": "Cloudfort",
+  "license": "MIT",
+  "homepage": "https://cloudfort.ir",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cloudfort/callum-voice.git"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0",
+    "react-native": ">=0.64.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.72.0",
+    "react": "^18.2.0",
+    "react-native": "^0.72.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "lib/",
+    "src/",
+    "android/",
+    "ios/",
+    "callum-voice.podspec"
+  ],
+  "react-native": "src/index.ts",
+  "source": "src/index.ts"
+}
+

package/src/VoiceClient.ts

@@ -0,0 +1,568 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+import { VoiceClientState } from './VoiceClientState';
+import { VoiceConfig } from './VoiceConfig';
+import { VoiceEventListener } from './VoiceEventListener';
+
+// ── Constants ────────────────────────────────────────────────────────
+const SPEAKING_CHECK_INTERVAL_MS = 80;
+const SPEAKING_RMS_THRESHOLD = 0.012;
+const PEER_RING_CAPACITY = 96000; // ~2s at 48 kHz
+
+// ── Peer State ───────────────────────────────────────────────────────
+
+interface PeerState {
+  peerId: string;
+  isSpeaking: boolean;
+  rmsLevel: number;
+  ring: Int16Array;
+  writePos: number;
+  length: number;
+}
+
+function createPeerState(peerId: string): PeerState {
+  return {
+    peerId,
+    isSpeaking: false,
+    rmsLevel: 0,
+    ring: new Int16Array(PEER_RING_CAPACITY),
+    writePos: 0,
+    length: 0,
+  };
+}
+
+function peerEnqueue(peer: PeerState, samples: Int16Array): void {
+  if (peer.length + samples.length > PEER_RING_CAPACITY) {
+    const drop = peer.length + samples.length - PEER_RING_CAPACITY;
+    peer.length -= drop;
+  }
+  for (let i = 0; i < samples.length; i++) {
+    peer.ring[(peer.writePos + i) % PEER_RING_CAPACITY] = samples[i];
+  }
+  peer.writePos = (peer.writePos + samples.length) % PEER_RING_CAPACITY;
+  peer.length += samples.length;
+}
+
+function peerComputeRms(peer: PeerState): number {
+  const count = Math.min(peer.length, 480); // ~10ms at 48 kHz
+  if (count === 0) return 0;
+
+  let sum = 0;
+  const start = (peer.writePos - count + PEER_RING_CAPACITY) % PEER_RING_CAPACITY;
+  for (let i = 0; i < count; i++) {
+    const v = peer.ring[(start + i) % PEER_RING_CAPACITY] / 32768.0;
+    sum += v * v;
+  }
+  return Math.sqrt(sum / count);
+}
+
+function peerClear(peer: PeerState): void {
+  peer.writePos = 0;
+  peer.length = 0;
+  peer.isSpeaking = false;
+  peer.rmsLevel = 0;
+}
+
+// ── VoiceClient ──────────────────────────────────────────────────────
+
+/**
+ * Cross-platform voice-chat client for React Native.
+ *
+ * Connects to the Go voice service over WebSocket, captures microphone audio
+ * via a native audio engine, and plays back remote peer audio.
+ *
+ * @example
+ * ```ts
+ * const client = new VoiceClient(createVoiceConfig({
+ *   server: 'callem.cloudfort.ir',
+ *   apiKey: 'vc_live_...',
+ *   peerId: 'user_123',
+ * }));
+ *
+ * client.setListener({
+ *   onConnected: () => console.log('Connected!'),
+ *   onPeerSpeaking: (id) => console.log(`${id} is speaking`),
+ * });
+ *
+ * await client.connect();
+ * await client.joinRoom('game_room_1');
+ * await client.enableMic();
+ * ```
+ */
+export class VoiceClient {
+  private readonly config: VoiceConfig;
+  private listener: VoiceEventListener | null = null;
+
+  private ws: WebSocket | null = null;
+  private _state: VoiceClientState = VoiceClientState.Disconnected;
+  private currentRoom: string | null = null;
+  private micEnabled = false;
+  private speakerEnabled = false;
+  private reconnectAttempts = 0;
+  private prevRoom: string | null = null;
+  private prevMicEnabled = false;
+
+  private peers: Map<string, PeerState> = new Map();
+  private speakingTimer: ReturnType<typeof setInterval> | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(config: VoiceConfig) {
+    this.config = config;
+  }
+
+  // ── Public Properties ────────────────────────────────────────────
+
+  /** Current connection state */
+  get state(): VoiceClientState {
+    return this._state;
+  }
+
+  /** Whether connected to server */
+  get isConnected(): boolean {
+    return this._state >= VoiceClientState.Connected;
+  }
+
+  /** Whether joined a room */
+  get isInRoom(): boolean {
+    return this._state === VoiceClientState.InRoom;
+  }
+
+  /** Whether microphone is active */
+  get isMicEnabled(): boolean {
+    return this.micEnabled;
+  }
+
+  /** Whether speaker output is active */
+  get isSpeakerEnabled(): boolean {
+    return this.speakerEnabled;
+  }
+
+  /** Current room ID (null if not in room) */
+  get currentRoomId(): string | null {
+    return this.currentRoom;
+  }
+
+  /** List of peer IDs in the current room */
+  get peerIds(): string[] {
+    return Array.from(this.peers.keys());
+  }
+
+  // ── Listener ─────────────────────────────────────────────────────
+
+  /** Set the event listener */
+  setListener(listener: VoiceEventListener | null): void {
+    this.listener = listener;
+  }
+
+  // ── Connection ───────────────────────────────────────────────────
+
+  /** Connect to the voice server */
+  async connect(): Promise<void> {
+    if (this._state >= VoiceClientState.Connected) return;
+
+    this.setState(VoiceClientState.Connecting);
+
+    const scheme = this.resolveScheme();
+    const url =
+      `${scheme}://${this.config.server}/ws` +
+      `?room=__lobby__` +
+      `&peer=${encodeURIComponent(this.config.peerId)}` +
+      `&api_key=${encodeURIComponent(this.config.apiKey)}`;
+
+    try {
+      this.ws = new WebSocket(url);
+      this.ws.binaryType = 'arraybuffer';
+
+      this.ws.onopen = () => {
+        this.handleWebSocketConnected();
+      };
+
+      this.ws.onmessage = (event) => {
+        if (typeof event.data === 'string') {
+          this.handleTextMessage(event.data);
+        } else if (event.data instanceof ArrayBuffer) {
+          this.handleBinaryMessage(new Uint8Array(event.data));
+        }
+      };
+
+      this.ws.onclose = (event) => {
+        this.handleClose(event.code ?? 1006, event.reason ?? '');
+        this.handleDisconnect();
+      };
+
+      this.ws.onerror = () => {
+        this.raiseError(new Error('WebSocket error'));
+        this.handleDisconnect();
+      };
+    } catch (e) {
+      this.raiseError(e instanceof Error ? e : new Error(String(e)));
+      this.setState(VoiceClientState.Disconnected);
+    }
+  }
+
+  /** Disconnect from the server */
+  disconnect(): void {
+    this.config.autoReconnect = false;
+    this.cleanup();
+    this.setState(VoiceClientState.Disconnected);
+    this.listener?.onDisconnected?.();
+  }
+
+  // ── Room Management ──────────────────────────────────────────────
+
+  /** Join a voice room */
+  async joinRoom(roomId: string): Promise<void> {
+    if (this._state < VoiceClientState.Connected) {
+      this.raiseError(new Error('Not connected'));
+      return;
+    }
+
+    if (this.currentRoom !== null) {
+      await this.leaveRoom();
+    }
+
+    // TODO: Start native audio playback engine via NativeModules
+
+    const joinMsg = JSON.stringify({
+      type: 'join',
+      room: roomId,
+      peer: this.config.peerId,
+      sampleRate: this.config.sampleRate,
+    });
+
+    this.sendText(joinMsg);
+
+    this.currentRoom = roomId;
+    this.setState(VoiceClientState.InRoom);
+
+    // Start speaking detection timer
+    this.speakingTimer = setInterval(() => {
+      this.checkSpeaking();
+    }, SPEAKING_CHECK_INTERVAL_MS);
+
+    this.listener?.onRoomJoined?.(roomId);
+  }
+
+  /** Leave the current room */
+  async leaveRoom(): Promise<void> {
+    if (this.currentRoom === null) return;
+
+    this.stopMic();
+    if (this.speakingTimer !== null) {
+      clearInterval(this.speakingTimer);
+      this.speakingTimer = null;
+    }
+
+    const room = this.currentRoom;
+
+    // Notify peers leaving
+    const peerIds = Array.from(this.peers.keys());
+    this.peers.clear();
+    for (const peerId of peerIds) {
+      this.listener?.onPeerLeft?.(peerId);
+    }
+
+    // TODO: Clear peers and stop playback via native audio engine
+
+    this.currentRoom = null;
+    this.setState(VoiceClientState.Connected);
+    this.listener?.onRoomLeft?.(room);
+  }
+
+  // ── Microphone Control ───────────────────────────────────────────
+
+  /** Enable microphone (must be in a room) */
+  async enableMic(): Promise<void> {
+    if (this.micEnabled) return;
+    if (this._state !== VoiceClientState.InRoom) {
+      this.raiseError(new Error('Must be in a room to enable mic'));
+      return;
+    }
+
+    // TODO: Request microphone permission via NativeModules
+    // TODO: Start native audio capture via NativeModules
+
+    this.micEnabled = true;
+    this.listener?.onMicEnabled?.();
+  }
+
+  /** Disable microphone */
+  disableMic(): void {
+    if (!this.micEnabled) return;
+    this.stopMic();
+    this.listener?.onMicDisabled?.();
+  }
+
+  /** Toggle microphone, returns new state */
+  async toggleMic(): Promise<boolean> {
+    if (this.micEnabled) {
+      this.disableMic();
+      return false;
+    }
+    await this.enableMic();
+    return true;
+  }
+
+  // ── Speaker Control ──────────────────────────────────────────────
+
+  /** Enable speaker output */
+  enableSpeaker(): void {
+    if (this.speakerEnabled) return;
+    this.speakerEnabled = true;
+    // TODO: Set speaker routing via NativeModules
+    this.listener?.onSpeakerEnabled?.();
+  }
+
+  /** Disable speaker output */
+  disableSpeaker(): void {
+    if (!this.speakerEnabled) return;
+    this.speakerEnabled = false;
+    // TODO: Set speaker routing via NativeModules
+    this.listener?.onSpeakerDisabled?.();
+  }
+
+  /** Toggle speaker, returns new state */
+  toggleSpeaker(): boolean {
+    if (this.speakerEnabled) {
+      this.disableSpeaker();
+      return false;
+    }
+    this.enableSpeaker();
+    return true;
+  }
+
+  // ── Speaking Detection ───────────────────────────────────────────
+
+  /** Check if a specific peer is speaking */
+  isPeerSpeaking(peerId: string): boolean {
+    return this.peers.get(peerId)?.isSpeaking ?? false;
+  }
+
+  /** Get peer speaking state with RMS level */
+  getPeerSpeakingInfo(peerId: string): { speaking: boolean; rms: number } {
+    const peer = this.peers.get(peerId);
+    if (!peer) return { speaking: false, rms: 0 };
+    return { speaking: peer.isSpeaking, rms: peer.rmsLevel };
+  }
+
+  // ── Cleanup ──────────────────────────────────────────────────────
+
+  /** Dispose and release all resources */
+  dispose(): void {
+    this.config.autoReconnect = false;
+    this.cleanup();
+  }
+
+  // ── Private: WebSocket Event Handlers ────────────────────────────
+
+  private handleWebSocketConnected(): void {
+    this.setState(VoiceClientState.Connected);
+    this.reconnectAttempts = 0;
+    this.listener?.onConnected?.();
+
+    // Re-join room if we were in one before disconnect
+    if (this.prevRoom !== null) {
+      const restoreMic = this.prevMicEnabled;
+      const room = this.prevRoom;
+      this.prevRoom = null;
+      this.prevMicEnabled = false;
+
+      this.joinRoom(room).then(() => {
+        if (restoreMic) {
+          this.enableMic();
+        }
+      }).catch((e) => {
+        this.raiseError(e instanceof Error ? e : new Error(String(e)));
+      });
+    }
+  }
+
+  private handleTextMessage(text: string): void {
+    try {
+      const json = JSON.parse(text);
+      if (json && typeof json === 'object') {
+        const type = json['type'];
+        if (type === 'udp_token') {
+          // Handle UDP token if needed
+        }
+      }
+    } catch (e) {
+      this.raiseError(e instanceof Error ? e : new Error(String(e)));
+    }
+  }
+
+  // ── Private: Binary Packet Parsing ───────────────────────────────
+  // Format: [1B RoomLen][RoomID][1B PeerLen][PeerID][PCM Audio Data]
+
+  private handleBinaryMessage(data: Uint8Array): void {
+    if (data.length < 4) return;
+
+    const roomLen = data[0];
+    if (data.length < 2 + roomLen) return;
+
+    const peerLen = data[1 + roomLen];
+    if (data.length < 2 + roomLen + peerLen) return;
+
+    const peerIdBytes = data.slice(2 + roomLen, 2 + roomLen + peerLen);
+    const peerId = new TextDecoder().decode(peerIdBytes);
+
+    if (peerId === this.config.peerId) return; // ignore own echo
+
+    const audioOffset = 2 + roomLen + peerLen;
+    const audioLen = data.length - audioOffset;
+    if (audioLen === 0) return;
+
+    // Convert PCM bytes → Int16Array
+    const sampleCount = Math.floor(audioLen / 2);
+    const samples = new Int16Array(sampleCount);
+    const view = new DataView(data.buffer, data.byteOffset + audioOffset, sampleCount * 2);
+    for (let i = 0; i < sampleCount; i++) {
+      samples[i] = view.getInt16(i * 2, true); // little-endian
+    }
+
+    this.handlePeerAudio(peerId, samples);
+  }
+
+  private handlePeerAudio(peerId: string, samples: Int16Array): void {
+    let peer = this.peers.get(peerId);
+    if (!peer) {
+      peer = createPeerState(peerId);
+      this.peers.set(peerId, peer);
+      this.listener?.onPeerJoined?.(peerId);
+    }
+
+    // TODO: Enqueue audio to native playback engine
+    peerEnqueue(peer, samples);
+  }
+
+  private checkSpeaking(): void {
+    for (const [peerId, peer] of this.peers) {
+      const rms = peerComputeRms(peer);
+      const wasSpeaking = peer.isSpeaking;
+      const isSpeaking = rms > SPEAKING_RMS_THRESHOLD;
+
+      if (isSpeaking !== wasSpeaking) {
+        peer.isSpeaking = isSpeaking;
+        if (isSpeaking) {
+          this.listener?.onPeerSpeaking?.(peerId);
+        } else {
+          this.listener?.onPeerStopped?.(peerId);
+        }
+      }
+
+      peer.rmsLevel = rms;
+    }
+  }
+
+  // ── Private: Close / Disconnect / Reconnect ──────────────────────
+
+  private handleClose(code: number, reason: string): void {
+    // Close codes 1008 / 4001 indicate auth failure
+    if (code === 1008 || code === 4001) {
+      this.listener?.onAuthFailed?.(reason || 'Authentication failed');
+      this.config.autoReconnect = false;
+    }
+  }
+
+  private handleDisconnect(): void {
+    const wasConnected = this._state >= VoiceClientState.Connected;
+
+    // Save state for reconnect restoration
+    this.prevRoom = this.currentRoom;
+    this.prevMicEnabled = this.micEnabled;
+
+    this.cleanup();
+
+    if (!wasConnected) return;
+
+    this.setState(VoiceClientState.Disconnected);
+    this.listener?.onDisconnected?.();
+
+    if (
+      this.config.autoReconnect &&
+      this.reconnectAttempts < this.config.maxReconnectAttempts
+    ) {
+      this.reconnectAttempts++;
+      this.setState(VoiceClientState.Reconnecting);
+      this.listener?.onReconnecting?.(this.reconnectAttempts);
+
+      this.reconnectTimer = setTimeout(() => {
+        this.connect();
+      }, this.config.reconnectDelayMs);
+    }
+  }
+
+  // ── Private: Send Helpers ────────────────────────────────────────
+
+  private sendText(text: string): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(text);
+    }
+  }
+
+  /** Send captured audio to server (called from native audio engine) */
+  sendAudio(samples: Int16Array): void {
+    if (!this.micEnabled || this.ws?.readyState !== WebSocket.OPEN) return;
+
+    const bytes = new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+    this.ws.send(bytes.slice());
+  }
+
+  // ── Private: Cleanup ─────────────────────────────────────────────
+
+  private cleanup(): void {
+    this.stopMic();
+
+    if (this.speakingTimer !== null) {
+      clearInterval(this.speakingTimer);
+      this.speakingTimer = null;
+    }
+
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    // Notify peers leaving
+    const peerIds = Array.from(this.peers.keys());
+    this.peers.clear();
+    for (const peerId of peerIds) {
+      this.listener?.onPeerLeft?.(peerId);
+    }
+
+    if (this.ws !== null) {
+      try {
+        this.ws.close(1000, 'bye');
+      } catch {
+        // ignore
+      }
+      this.ws = null;
+    }
+
+    this.currentRoom = null;
+  }
+
+  private stopMic(): void {
+    if (!this.micEnabled) return;
+    // TODO: Stop native audio capture
+    this.micEnabled = false;
+  }
+
+  // ── Private: Helpers ─────────────────────────────────────────────
+
+  private resolveScheme(): string {
+    if (this.config.useTls === true) return 'wss';
+    if (this.config.useTls === false) return 'ws';
+    return 'ws';
+  }
+
+  private setState(newState: VoiceClientState): void {
+    if (this._state === newState) return;
+    this._state = newState;
+    this.listener?.onStateChanged?.(newState);
+  }
+
+  private raiseError(error: Error): void {
+    this.listener?.onError?.(error);
+  }
+}

package/src/VoiceClientState.ts

@@ -0,0 +1,21 @@
+// Copyright Cloudfort. All Rights Reserved.
+
+/**
+ * Connection state of the VoiceClient.
+ */
+export enum VoiceClientState {
+  /** Not connected, not attempting to connect */
+  Disconnected = 0,
+
+  /** Establishing WebSocket connection */
+  Connecting = 1,
+
+  /** Connected to server, not yet in a room */
+  Connected = 2,
+
+  /** Joined a room and ready for audio */
+  InRoom = 3,
+
+  /** Attempting to reconnect after an unexpected disconnect */
+  Reconnecting = 4,
+}