vg-x07df 0.1.0

package/packages/sdk/src/hooks/useParticipants.ts

@@ -0,0 +1,111 @@
+import { useRtcStore } from "../state/store";
+import { useSdk } from "../provider/RtcProvider";
+import type { Participant } from "../state/types";
+
+type ParticipantKind = "active" | "missed" | "left";
+
+interface UseParticipantsOptions {
+  page?: number;
+  pageSize?: number;
+  kind?: ParticipantKind;
+}
+
+export function useParticipants(callId?: string, options?: UseParticipantsOptions) {
+  const { page = 1, pageSize = 8, kind = "active" } = options || {};
+  
+  return useRtcStore((state) => {
+    try {
+      const allParticipants = Object.values(state.room.participants) || [];
+      
+      let filteredParticipants: Participant[] = [];
+      switch (kind) {
+        case "active":
+          filteredParticipants = allParticipants.filter((p) => p.callState === "JOINED");
+          break;
+        case "missed":
+          filteredParticipants = allParticipants.filter((p) => p.callState === "INVITED");
+          break;
+        case "left":
+          filteredParticipants = allParticipants.filter((p) => p.callState === "LEFT");
+          break;
+        default:
+          filteredParticipants = allParticipants.filter((p) => p.callState === "JOINED");
+      }
+
+      const activeParticipants = allParticipants.filter((p) => p.callState === "JOINED");
+      const pendingParticipants = allParticipants.filter(
+        (p) => p.callState === "INVITED" || p.callState === "RINGING"
+      );
+      const caller = allParticipants.find((p) => p.role === "CALLER") || null;
+
+      let localParticipant: Participant | null = null;
+      try {
+        const sdk = useSdk();
+        const currentUserId = sdk.auth.getCurrentUserId();
+        localParticipant = currentUserId ? state.room.participants[currentUserId] || null : null;
+      } catch {
+        localParticipant = null;
+      }
+
+      const totalParticipants = filteredParticipants.length;
+      const totalPages = Math.ceil(totalParticipants / pageSize);
+      const startIndex = (page - 1) * pageSize;
+      const endIndex = startIndex + pageSize;
+      const participants = filteredParticipants.slice(startIndex, endIndex);
+
+      return {
+        participants,
+        activeParticipants,
+        pendingParticipants,
+        caller,
+        localParticipant,
+        totalPages,
+        currentPage: page,
+        hasNextPage: page < totalPages,
+        hasPreviousPage: page > 1,
+        totalParticipants,
+      };
+    } catch (error) {
+      return {
+        participants: [],
+        activeParticipants: [],
+        pendingParticipants: [],
+        caller: null,
+        localParticipant: null,
+        totalPages: 1,
+        currentPage: 1,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        totalParticipants: 0,
+      };
+    }
+  });
+}
+
+export function useParticipant(participantId: string): Participant | undefined {
+  return useRtcStore((state) => state.room.participants[participantId]);
+}
+
+
+export function useRingingParticipants(): Participant[] {
+  return useRtcStore((state) =>
+    Object.values(state.room.participants).filter(
+      (p) => p.callState === "RINGING"
+    )
+  );
+}
+
+export function useLocalParticipant(): Participant | undefined {
+  const sdk = useSdk();
+  
+  return useRtcStore((state) => {
+    const currentUserId = sdk.auth.getCurrentUserId();
+    return currentUserId ? state.room.participants[currentUserId] : undefined;
+  });
+}
+
+export function useSpeakingParticipants(): Participant[] {
+  return useRtcStore((state) =>
+    Object.values(state.room.participants).filter((p) => p.isSpeaking)
+  );
+}

package/packages/sdk/src/index.ts

@@ -0,0 +1,66 @@
+// React integration - main SDK entry points
+export {
+  RtcProvider,
+  useSdk,
+  type RtcOptions,
+  type RtcSdk,
+} from "./provider/RtcProvider";
+
+// React hooks for call management
+export * from "./hooks";
+
+// State selectors for advanced usage
+export {
+  useParticipant,
+  useRingingParticipants,
+  useLocalParticipant,
+  useSpeakingParticipants,
+} from "./state/selectors";
+
+// Essential types consumers need
+export type {
+  SessionStatus,
+  Participant,
+  PermissionStatus,
+  DeviceState,
+  IncomingCallInfo,
+  LiveKitJoinInfo,
+  RtcError,
+  RtcState,
+} from "./state/types";
+
+// Signal client types for call initiation
+export type {
+  InitiateCallParams,
+  CallResponse,
+  CallActionResponse,
+} from "./core/signal/types";
+
+export type { CallJoinInfoEvent } from "./core/socketio/handlers/schema";
+
+// Error management
+export * from "./state/errors";
+
+// API configuration
+export { apiConfig, type ApiConfig } from "./core/signal/api.config";
+
+// Event system for advanced usage
+export { eventBus } from "./core/events";
+export type {
+  SdkEvent,
+  SdkEventType,
+  EventHandler,
+  EventSubscription,
+  EventFilter,
+  CallInitiatedEvent,
+  CallIncomingEvent,
+  CallAcceptedEvent,
+  CallDeclinedEvent,
+  CallEndedEvent,
+  ParticipantJoinedEvent,
+  ParticipantLeftEvent,
+  MediaEnabledEvent,
+  MediaDisabledEvent,
+  ConnectionQualityChangedEvent,
+  ErrorOccurredEvent,
+} from "./core/events/types";

package/packages/sdk/src/livekit/constants.ts

@@ -0,0 +1,76 @@
+import type {
+  ConnectionQuality,
+  ReconnectPolicy,
+  RoomOptions,
+} from "livekit-client";
+import { VideoPresets } from "livekit-client";
+
+/**
+ * Production-ready room options with optimal settings
+ */
+export const DEFAULT_ROOM_OPTIONS: RoomOptions = {
+  // Performance optimizations
+  adaptiveStream: true,
+  dynacast: true,
+
+  // Browser lifecycle handling
+  disconnectOnPageLeave: true,
+
+  // Reconnection handling with exponential backoff
+  reconnectPolicy: {
+    nextRetryDelayInMs: (context) => {
+      // Exponential backoff with jitter: base delay * 2^retryCount + random jitter
+      const baseDelay = 1000;
+      const maxDelay = 30000;
+      const delay = Math.min(baseDelay * 2 ** context.retryCount, maxDelay);
+      const jitter = Math.random() * 1000; // Add up to 1s jitter
+      return delay + jitter;
+    },
+  },
+
+  // Media capture defaults
+  videoCaptureDefaults: {
+    facingMode: "user",
+    resolution: VideoPresets.h720.resolution,
+  },
+  publishDefaults: {
+    videoSimulcastLayers: [
+      VideoPresets.h180,
+      VideoPresets.h360,
+      VideoPresets.h720,
+    ],
+    // stopLocalTrackOnUnpublish: true, // Not available in current LiveKit version
+  },
+  audioCaptureDefaults: {
+    autoGainControl: true,
+    echoCancellation: true,
+    noiseSuppression: true,
+  },
+
+  // Audio handling
+  webAudioMix: true,
+};
+
+export const TRACK_ATTACHMENT_CONFIG = {
+  maxRetries: 3,
+  retryDelay: 1000,
+  exponentialBackoff: true,
+} as const;
+
+/**
+ * Connection quality thresholds for network monitoring
+ */
+export const CONNECTION_QUALITY_THRESHOLDS = {
+  excellent: { minScore: 5, label: "excellent" },
+  good: { minScore: 3, label: "good" },
+  poor: { minScore: 1, label: "poor" },
+  lost: { minScore: 0, label: "lost" },
+} as const;
+
+/**
+ * Screen share configuration
+ */
+export const SCREEN_SHARE_CONFIG = {
+  video: true,
+  audio: true,
+} as const;

package/packages/sdk/src/livekit/device.manager.ts

@@ -0,0 +1,172 @@
+import { ConnectionState, Room, RoomEvent, Track } from "livekit-client";
+import { rtcStore } from "../state/store";
+import { classifyMediaError } from "./error-classifier";
+
+export class DeviceManager {
+  private cleanupFunctions: Array<() => void> = [];
+
+  constructor(private room: Room) {
+    this.setupDeviceEventListeners();
+  }
+
+  async enumerateDevices(): Promise<void> {
+    try {
+      const [cameras, microphones, speakers] = await Promise.all([
+        Room.getLocalDevices("videoinput"),
+        Room.getLocalDevices("audioinput"),
+        Room.getLocalDevices("audiooutput"),
+      ]);
+
+      rtcStore.getState().patch((state) => {
+        state.devices.cams = cameras;
+        state.devices.mics = microphones;
+        state.devices.speakers = speakers;
+      });
+    } catch (error) {
+      this.handleDeviceError("enumerate", error);
+      throw error;
+    }
+  }
+
+  async switchCamera(deviceId: string): Promise<void> {
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new Error("Cannot switch camera - room not connected");
+    }
+
+    try {
+      await this.room.switchActiveDevice("videoinput", deviceId);
+
+      // Update selected device in state
+      rtcStore.getState().patch((state) => {
+        state.devices.selected.camId = deviceId;
+      });
+    } catch (error) {
+      // LiveKit automatically populates lastCameraError
+      const livekitError = this.room.localParticipant.lastCameraError;
+      this.handleDeviceError("camera", error, livekitError);
+      throw error;
+    }
+  }
+
+  async switchMicrophone(deviceId: string): Promise<void> {
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new Error("Cannot switch microphone - room not connected");
+    }
+
+    try {
+      await this.room.switchActiveDevice("audioinput", deviceId);
+
+      // Update selected device in state
+      rtcStore.getState().patch((state) => {
+        state.devices.selected.micId = deviceId;
+      });
+    } catch (error) {
+      // LiveKit automatically populates lastMicrophoneError
+      const livekitError = this.room.localParticipant.lastMicrophoneError;
+      this.handleDeviceError("microphone", error, livekitError);
+      throw error;
+    }
+  }
+
+  async switchSpeaker(deviceId: string): Promise<void> {
+    if (this.room.state !== ConnectionState.Connected) {
+      throw new Error("Cannot switch speaker - room not connected");
+    }
+
+    try {
+      await this.room.switchActiveDevice("audiooutput", deviceId);
+
+      // Update selected device in state
+      rtcStore.getState().patch((state) => {
+        state.devices.selected.speakerId = deviceId;
+      });
+    } catch (error) {
+      // Note: speakers don't have a specific lastError in LiveKit
+      this.handleDeviceError("speaker", error);
+      throw error;
+    }
+  }
+
+  async getCurrentDeviceSelection(): Promise<{
+    camera: string | undefined;
+    microphone: string | undefined;
+    speaker: string | undefined;
+  }> {
+    const videoTrack = this.room.localParticipant.getTrackPublication(
+      Track.Source.Camera
+    )?.track;
+    const audioTrack = this.room.localParticipant.getTrackPublication(
+      Track.Source.Microphone
+    )?.track;
+
+    const [cameraDeviceId, microphoneDeviceId] = await Promise.all([
+      videoTrack ? videoTrack.getDeviceId() : Promise.resolve(undefined),
+      audioTrack ? audioTrack.getDeviceId() : Promise.resolve(undefined),
+    ]);
+
+    return {
+      camera: cameraDeviceId || undefined,
+      microphone: microphoneDeviceId || undefined,
+      // Speaker device ID is not directly accessible from tracks
+      speaker: rtcStore.getState().devices.selected.speakerId || undefined,
+    };
+  }
+
+  private setupDeviceEventListeners(): void {
+    const handleDevicesChanged = () => {
+      // Refresh the device list when devices are added/removed
+      this.enumerateDevices().catch(() => {
+        // Silently handle refresh errors
+      });
+    };
+
+    // Listen for device errors
+    const handleDeviceError = (error: any) => {
+      this.handleDeviceError("device_event", error);
+    };
+
+    if ("MediaDevicesChanged" in RoomEvent) {
+      this.room.on(RoomEvent.MediaDevicesChanged, handleDevicesChanged);
+    }
+    if ("MediaDevicesError" in RoomEvent) {
+      this.room.on(RoomEvent.MediaDevicesError, handleDeviceError);
+    }
+
+    this.cleanupFunctions.push(() => {
+      if ("MediaDevicesChanged" in RoomEvent) {
+        this.room.off(RoomEvent.MediaDevicesChanged, handleDevicesChanged);
+      }
+      if ("MediaDevicesError" in RoomEvent) {
+        this.room.off(RoomEvent.MediaDevicesError, handleDeviceError);
+      }
+    });
+  }
+
+  private handleDeviceError(
+    operation: string,
+    error: unknown,
+    livekitError?: Error
+  ): void {
+    const mediaError = classifyMediaError(error, operation, livekitError);
+    rtcStore.getState().addError({
+      code: mediaError.code,
+      message: mediaError.message,
+      timestamp: Date.now(),
+      context: {
+        operation,
+        category: mediaError.category,
+        recoverable: mediaError.recoverable,
+        device: mediaError.device,
+        originalError: error,
+        livekitError,
+      },
+    });
+  }
+
+  destroy(): void {
+    for (const cleanup of this.cleanupFunctions) {
+      cleanup();
+    }
+    this.cleanupFunctions = [];
+  }
+}

package/packages/sdk/src/livekit/error-classifier.ts

@@ -0,0 +1,155 @@
+import { MediaDeviceFailure } from "livekit-client";
+
+export interface MediaErrorInfo {
+  code: string;
+  userMessage: string;
+  recoverable: boolean;
+  category: "permission" | "device" | "unknown";
+}
+
+export abstract class MediaDeviceError extends Error {
+  abstract readonly code: string;
+  abstract readonly recoverable: boolean;
+  abstract readonly category: "permission" | "device" | "unknown";
+  readonly device: string;
+  readonly deviceName: string;
+  readonly cause: Error | undefined;
+
+  protected constructor(message: string, device: string, cause?: Error) {
+    super(message);
+    this.name = this.constructor.name;
+    this.device = device;
+    this.deviceName = device === "camera" ? "camera" : "microphone";
+    this.cause = cause;
+  }
+}
+
+export class MediaPermissionError extends MediaDeviceError {
+  readonly code: string;
+  readonly recoverable = true;
+  readonly category = "permission" as const;
+
+  constructor(message: string, device: string, cause?: Error) {
+    super(message, device, cause);
+    this.code =
+      device === "camera"
+        ? "CAMERA_PERMISSION_DENIED"
+        : "MICROPHONE_PERMISSION_DENIED";
+  }
+}
+
+export class MediaNotFoundError extends MediaDeviceError {
+  readonly code: string;
+  readonly recoverable = false;
+  readonly category = "device" as const;
+
+  constructor(message: string, device: string, cause?: Error) {
+    super(message, device, cause);
+    this.code =
+      device === "camera" ? "CAMERA_NOT_FOUND" : "MICROPHONE_NOT_FOUND";
+  }
+}
+
+export class MediaInUseError extends MediaDeviceError {
+  readonly code: string;
+  readonly recoverable = true;
+  readonly category = "device" as const;
+
+  constructor(message: string, device: string, cause?: Error) {
+    super(message, device, cause);
+    this.code = device === "camera" ? "CAMERA_IN_USE" : "MICROPHONE_IN_USE";
+  }
+}
+
+export class MediaUnknownError extends MediaDeviceError {
+  readonly code: string;
+  readonly recoverable = false;
+  readonly category = "unknown" as const;
+
+  constructor(message: string, device: string, cause?: Error) {
+    super(message, device, cause);
+    this.code =
+      device === "camera" ? "CAMERA_UNKNOWN_ERROR" : "MICROPHONE_UNKNOWN_ERROR";
+  }
+}
+
+export function classifyMediaError(
+  error: unknown,
+  device: string,
+  livekitError?: Error
+): MediaDeviceError {
+  // Try LiveKit classification first
+  const livekitFailure = MediaDeviceFailure.getFailure(error as Error);
+  if (livekitFailure) {
+    return createErrorFromFailure(livekitFailure, device, error as Error);
+  }
+
+  // Use LiveKit lastError if available
+  if (livekitError) {
+    const livekitFailureFromLastError =
+      MediaDeviceFailure.getFailure(livekitError);
+    if (livekitFailureFromLastError) {
+      return createErrorFromFailure(
+        livekitFailureFromLastError,
+        device,
+        livekitError
+      );
+    }
+  }
+
+  // Fall back to basic error analysis for unhandled cases
+  const cause = error instanceof Error ? error : undefined;
+  const message = cause?.message?.toLowerCase() || "";
+
+  if (
+    message.includes("permission") ||
+    message.includes("denied") ||
+    message.includes("notallowed")
+  ) {
+    return new MediaPermissionError("Permission denied", device, cause);
+  }
+
+  if (
+    message.includes("not found") ||
+    message.includes("unavailable") ||
+    message.includes("notfound")
+  ) {
+    return new MediaNotFoundError("Device not found", device, cause);
+  }
+
+  if (
+    message.includes("already in use") ||
+    message.includes("busy") ||
+    message.includes("in use")
+  ) {
+    return new MediaInUseError("Device in use", device, cause);
+  }
+
+  // Final fallback
+  return new MediaUnknownError(
+    cause ? `Unknown error: ${cause.message}` : "Unknown device error",
+    device,
+    cause
+  );
+}
+
+function createErrorFromFailure(
+  failure: MediaDeviceFailure,
+  device: string,
+  cause: Error
+): MediaDeviceError {
+  switch (failure) {
+    case MediaDeviceFailure.PermissionDenied:
+      return new MediaPermissionError("Permission denied", device, cause);
+    case MediaDeviceFailure.NotFound:
+      return new MediaNotFoundError("Device not found", device, cause);
+    case MediaDeviceFailure.DeviceInUse:
+      return new MediaInUseError("Device in use", device, cause);
+    default:
+      return new MediaUnknownError(
+        `LiveKit failure: ${failure}`,
+        device,
+        cause
+      );
+  }
+}