@pickleball/expo-sdk 0.1.1

package/src/livekit-room-adapter.ts

@@ -0,0 +1,353 @@
+import type {
+  CameraDeviceInfo,
+  RoomAdapter,
+  RoomConnection,
+  RoomEvent,
+} from "./engine";
+
+interface LocalTrackLike {
+  kind: string;
+  stop(): void;
+  mute?(): Promise<unknown>;
+  unmute?(): Promise<unknown>;
+  /** livekit-client LocalVideoTrack restart; deterministic facing switch. */
+  restartTrack?(options: {
+    facingMode?: "user" | "environment";
+    deviceId?: string;
+    resolution?: { width: number; height: number; frameRate: number };
+  }): Promise<unknown>;
+  mediaStreamTrack?: {
+    readyState?: string;
+    /**
+     * react-native-webrtc: đổi thiết bị/facing TẠI CHỖ trên cùng track native
+     * (mediaStreamTrackApplyConstraints) — preview và sender giữ nguyên.
+     */
+    applyConstraints?(constraints: {
+      facingMode?: "user" | "environment";
+      deviceId?: string;
+      width?: number;
+      height?: number;
+      frameRate?: number;
+    }): Promise<void>;
+    /** react-native-webrtc native camera flip; blind front/back toggle. */
+    _switchCamera?(): void;
+  };
+}
+
+interface RoomLike {
+  state: string;
+  localParticipant: {
+    publishTrack(track: LocalTrackLike, options?: unknown): Promise<unknown>;
+    unpublishTrack?(
+      track: LocalTrackLike,
+      stopOnUnpublish?: boolean,
+    ): Promise<unknown> | unknown;
+  };
+  connect(serverUrl: string, token: string, options?: unknown): Promise<void>;
+  disconnect(stopTracks?: boolean): Promise<void>;
+  on(event: string, listener: (...args: unknown[]) => void): unknown;
+  off(event: string, listener: (...args: unknown[]) => void): unknown;
+}
+
+export interface NativeLiveKitBindings {
+  registerGlobals(): void;
+  createRoom(): RoomLike;
+  createLocalTracks(options: {
+    audio: true;
+    video: {
+      facingMode?: "user" | "environment";
+      deviceId?: string;
+      resolution: { width: number; height: number; frameRate: number };
+    };
+  }): Promise<LocalTrackLike[]>;
+  startAudioSession(): Promise<void> | void;
+  stopAudioSession(): Promise<void> | void;
+  /** Current window orientation; capture dimensions follow it. */
+  isLandscape?(): boolean;
+  /** Physical/virtual cameras reported by the platform. */
+  listCameras?(): Promise<CameraDeviceInfo[]>;
+  cameraSource?: unknown;
+  events: {
+    reconnecting: string;
+    reconnected: string;
+    disconnected: string;
+    mediaDevicesError: string;
+    /** LiveKit RoomEvent.DataReceived — nhận lệnh điều khiển từ dashboard. */
+    dataReceived?: string;
+  };
+}
+
+export interface LocalPreviewReference {
+  videoTrack: unknown;
+  trackRef?: {
+    participant: RoomLike["localParticipant"];
+    publication: unknown;
+    source?: unknown;
+  };
+}
+
+export class LiveKitRoomAdapter implements RoomAdapter {
+  private readonly room: RoomLike;
+  private readonly listeners = new Set<(event: RoomEvent) => void>();
+  private tracks: LocalTrackLike[] = [];
+  private videoTrack?: LocalTrackLike;
+  private audioTrack?: LocalTrackLike;
+  private preview?: LocalPreviewReference;
+  private isFront = true;
+  private orientationOverride: "portrait" | "landscape" | null = null;
+  private deviceOverride: string | null = null;
+  private published = false;
+  private disposed = false;
+  private quality: 720 | 1080 = 720;
+  private readonly nativeListeners: Array<readonly [string, (...args: unknown[]) => void]>;
+
+  constructor(private readonly bindings: NativeLiveKitBindings) {
+    bindings.registerGlobals();
+    this.room = bindings.createRoom();
+    this.nativeListeners = [
+      [bindings.events.reconnecting, () => this.emit({ type: "reconnecting" })],
+      [bindings.events.reconnected, () => this.emit({ type: "reconnected" })],
+      [bindings.events.disconnected, (reason) => {
+        this.published = false;
+        this.emit({ type: "disconnected", reason: String(reason ?? "") });
+      }],
+      [bindings.events.mediaDevicesError, (error) =>
+        this.emit({ type: "media-error", error })],
+    ];
+    if (bindings.events.dataReceived) {
+      // Payload lệnh: {"type":"cmd","action":"start|stop|config",...} — cùng
+      // giao thức với camera box (backend sendCameraCommand).
+      this.nativeListeners.push([
+        bindings.events.dataReceived,
+        (payload) => {
+          try {
+            const text = new TextDecoder().decode(payload as Uint8Array);
+            const parsed = JSON.parse(text) as { type?: string; action?: string };
+            if (parsed?.type === "cmd" && typeof parsed.action === "string") {
+              this.emit({ type: "command", action: parsed.action });
+            }
+          } catch {
+            // Data message không phải lệnh — bỏ qua.
+          }
+        },
+      ]);
+    }
+    for (const [event, listener] of this.nativeListeners) {
+      this.room.on(event, listener);
+    }
+  }
+
+  async preparePreview(quality: 720 | 1080) {
+    this.ensureNotDisposed();
+    this.quality = quality;
+    await this.ensurePreparedTracks();
+    this.ensureNotDisposed();
+    return this.preview;
+  }
+
+  async connect(input: RoomConnection) {
+    this.ensureNotDisposed();
+    if (!this.preview) throw new Error("Preview must be prepared before connecting");
+    if (this.room.state !== "disconnected") await this.disconnect(false);
+    await this.ensurePreparedTracks();
+    if (!this.videoTrack || !this.audioTrack || !this.preview) {
+      throw new Error("Camera and microphone tracks are unavailable");
+    }
+    await this.bindings.startAudioSession();
+    await this.room.connect(input.serverUrl, input.participantToken, {
+      autoSubscribe: false,
+    });
+    this.published = false;
+    if (input.microphoneEnabled) await this.audioTrack.unmute?.();
+    else await this.audioTrack.mute?.();
+    if (input.publish !== false) {
+      await this.setPublishing(true);
+    }
+  }
+
+  /** Bật/tắt publish track khi đã trong phòng — standby ↔ live. */
+  async setPublishing(enabled: boolean) {
+    this.ensureNotDisposed();
+    if (enabled === this.published) return;
+    if (!this.videoTrack || !this.audioTrack || !this.preview) {
+      throw new Error("Camera and microphone tracks are unavailable");
+    }
+    if (enabled) {
+      const publication = await this.room.localParticipant.publishTrack(
+        this.videoTrack,
+        { simulcast: false, source: this.bindings.cameraSource },
+      );
+      await this.room.localParticipant.publishTrack(this.audioTrack);
+      this.preview.trackRef = {
+        participant: this.room.localParticipant,
+        publication,
+        source: this.bindings.cameraSource,
+      };
+      this.published = true;
+      return;
+    }
+    // Gỡ publish nhưng GIỮ track sống để preview local tiếp tục chạy.
+    await this.room.localParticipant.unpublishTrack?.(this.videoTrack, false);
+    await this.room.localParticipant.unpublishTrack?.(this.audioTrack, false);
+    delete this.preview.trackRef;
+    this.published = false;
+  }
+
+  async disconnect(stopTracks = true) {
+    this.ensureNotDisposed();
+    await this.room.disconnect(stopTracks);
+    this.published = false;
+    if (this.preview) delete this.preview.trackRef;
+    await this.bindings.stopAudioSession();
+    if (stopTracks) this.releaseTracks(true);
+  }
+
+  private captureResolution() {
+    // iOS capture formats luôn là kích thước ngang; khung dọc/ngang thực tế
+    // do hướng cầm máy quyết định (WebRTC gắn rotation theo từng frame).
+    // Yêu cầu kích thước dọc khiến native chọn nhầm format nhỏ (640x480).
+    const [long, short] = this.quality === 1080 ? [1920, 1080] : [1280, 720];
+    return { width: long, height: short, frameRate: 30 };
+  }
+
+  async setCaptureOrientation(orientation: "portrait" | "landscape") {
+    this.ensureNotDisposed();
+    // Chỉ ghi nhận lựa chọn (phục vụ hint UI/telemetry); capture format không
+    // đổi vì khung hình theo hướng cầm máy — xem captureResolution().
+    this.orientationOverride = orientation;
+  }
+
+  /**
+   * livekit-client restart() chỉ giữ deviceId/facingMode khi gọi getUserMedia
+   * (vứt width/height/frameRate) nên track mới rơi về format mặc định
+   * 640x480. Native applyConstraints thì ngược lại: chỉ xử lý
+   * width/height/frameRate. Sau mỗi restartTrack phải nắn lại format trên
+   * track mới bằng applyConstraints.
+   */
+  private async reapplyCaptureFormat() {
+    const nativeTrack = this.videoTrack?.mediaStreamTrack;
+    if (nativeTrack?.applyConstraints) {
+      await nativeTrack.applyConstraints(this.captureResolution());
+    }
+  }
+
+  async switchCamera() {
+    this.ensureNotDisposed();
+    const facingMode = this.isFront ? "environment" : "user";
+    const nativeTrack = this.videoTrack?.mediaStreamTrack;
+    // restartTrack đổi thiết bị theo facing tường minh; native applyConstraints
+    // KHÔNG đổi được thiết bị (chỉ width/height/frameRate) nên không dùng
+    // để lật camera. _switchCamera là toggle mù — fallback cuối.
+    if (typeof this.videoTrack?.restartTrack === "function") {
+      await this.videoTrack.restartTrack({ facingMode });
+      await this.reapplyCaptureFormat();
+    } else if (typeof nativeTrack?._switchCamera === "function") {
+      nativeTrack._switchCamera();
+    } else if (nativeTrack?.applyConstraints) {
+      // Web fallback: applyConstraints chuẩn có thể đổi facing trên trình duyệt.
+      await nativeTrack.applyConstraints({ facingMode });
+    } else {
+      throw new Error("Camera switching is unavailable");
+    }
+    // Lật theo hướng bỏ chọn ống kính cụ thể trước đó.
+    this.deviceOverride = null;
+    this.isFront = !this.isFront;
+  }
+
+  async listCameras(): Promise<CameraDeviceInfo[]> {
+    this.ensureNotDisposed();
+    return (await this.bindings.listCameras?.()) ?? [];
+  }
+
+  async selectCamera(deviceId: string, facing: CameraDeviceInfo["facing"]) {
+    this.ensureNotDisposed();
+    if (typeof this.videoTrack?.restartTrack !== "function") {
+      throw new Error("Camera selection is unavailable");
+    }
+    await this.videoTrack.restartTrack({ deviceId });
+    await this.reapplyCaptureFormat();
+    this.deviceOverride = deviceId;
+    if (facing !== "unknown") this.isFront = facing === "front";
+  }
+
+  async setMicrophoneEnabled(enabled: boolean) {
+    this.ensureNotDisposed();
+    if (!this.audioTrack) return;
+    if (enabled) await this.audioTrack.unmute?.();
+    else await this.audioTrack.mute?.();
+  }
+
+  subscribe(listener: (event: RoomEvent) => void) {
+    this.ensureNotDisposed();
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const [event, listener] of this.nativeListeners) {
+      this.room.off(event, listener);
+    }
+    await this.room.disconnect(true);
+    await this.bindings.stopAudioSession();
+    this.releaseTracks(true);
+    this.listeners.clear();
+  }
+
+  private releaseTracks(clearPreview: boolean) {
+    for (const track of this.tracks) track.stop();
+    this.tracks = [];
+    this.videoTrack = undefined;
+    this.audioTrack = undefined;
+    if (clearPreview) this.preview = undefined;
+    else if (this.preview) delete this.preview.trackRef;
+  }
+
+  private async ensurePreparedTracks() {
+    this.ensureNotDisposed();
+    const tracksReady =
+      this.videoTrack?.mediaStreamTrack?.readyState !== "ended" &&
+      this.audioTrack?.mediaStreamTrack?.readyState !== "ended" &&
+      Boolean(this.videoTrack && this.audioTrack);
+    if (tracksReady) return;
+    if (this.tracks.length) this.releaseTracks(false);
+    const resolution = this.captureResolution();
+    const tracks = await this.bindings.createLocalTracks({
+      audio: true,
+      video: {
+        ...(this.deviceOverride
+          ? { deviceId: this.deviceOverride }
+          : { facingMode: this.isFront ? "user" : "environment" }),
+        resolution,
+      },
+    });
+    if (this.disposed) {
+      for (const track of tracks) track.stop();
+      throw new Error("LiveKit room adapter has been disposed");
+    }
+    this.tracks = tracks;
+    this.videoTrack = this.tracks.find((track) => track.kind === "video");
+    this.audioTrack = this.tracks.find((track) => track.kind === "audio");
+    if (!this.videoTrack || !this.audioTrack) {
+      this.releaseTracks(true);
+      throw new Error("LiveKit did not create camera and microphone tracks");
+    }
+    if (this.preview) {
+      this.preview.videoTrack = this.videoTrack;
+      delete this.preview.trackRef;
+    } else {
+      this.preview = { videoTrack: this.videoTrack };
+    }
+  }
+
+  private emit(event: RoomEvent) {
+    for (const listener of this.listeners) listener(event);
+  }
+
+  private ensureNotDisposed() {
+    if (this.disposed) {
+      throw new Error("LiveKit room adapter has been disposed");
+    }
+  }
+}