@pickleball/expo-sdk 0.2.0 → 1.0.0

package/dist/version.cjs

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTRLASNPQcjs = require('./chunk-TRLASNPQ.cjs');
+var _chunkGXQYMPHEcjs = require('./chunk-GXQYMPHE.cjs');
 require('./chunk-7OX2DSKI.cjs');
 
 
-exports.PICKLEBALL_EXPO_SDK_VERSION = _chunkTRLASNPQcjs.PICKLEBALL_EXPO_SDK_VERSION;
+exports.PICKLEBALL_EXPO_SDK_VERSION = _chunkGXQYMPHEcjs.PICKLEBALL_EXPO_SDK_VERSION;

package/dist/version.js

@@ -1,6 +1,6 @@
 import {
   PICKLEBALL_EXPO_SDK_VERSION
-} from "./chunk-6JOMESNT.js";
+} from "./chunk-XL4CISVQ.js";
 import "./chunk-KFQGP6VL.js";
 export {
   PICKLEBALL_EXPO_SDK_VERSION

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pickleball/expo-sdk",
-  "version": "0.2.0",
-  "description": "Foreground livestream engine, React hooks, UI, and Expo config plugin for Pickleball Live",
+  "version": "1.0.0",
+  "description": "RTMP livestream engine, camera-grant session provider, React hooks, ready-made camera UI, and Expo config plugin for Pickleball Live",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -93,6 +93,28 @@
       }
     },
     "./app.plugin.js": "./app.plugin.js",
+    "./realtime": {
+      "react-native": "./src/realtime/index.ts",
+      "import": {
+        "types": "./dist/realtime/index.d.ts",
+        "default": "./dist/realtime/index.js"
+      },
+      "require": {
+        "types": "./dist/realtime/index.d.cts",
+        "default": "./dist/realtime/index.cjs"
+      }
+    },
+    "./ui": {
+      "react-native": "./src/ui/index.ts",
+      "import": {
+        "types": "./dist/ui/index.d.ts",
+        "default": "./dist/ui/index.js"
+      },
+      "require": {
+        "types": "./dist/ui/index.d.cts",
+        "default": "./dist/ui/index.cjs"
+      }
+    },
     "./version": {
       "react-native": "./src/version.ts",
       "import": {
@@ -119,8 +141,9 @@
   "keywords": [
     "expo",
     "react-native",
-    "livekit",
+    "rtmp",
     "livestream",
+    "pickleball",
     "video"
   ],
   "sideEffects": [
@@ -128,55 +151,48 @@
     "./src/native-runtime.ts"
   ],
   "peerDependencies": {
-    "@livekit/react-native": ">=2.11.1 <3",
-    "@livekit/react-native-webrtc": ">=144.1.1 <145",
-    "@pickleball/rtmp-native": ">=0.1.0 <1",
+    "@pickleball/rtmp-native": ">=0.2.0 <1",
     "@react-native-community/netinfo": ">=11 <13",
     "expo": ">=56 <58",
     "expo-audio": ">=56 <58",
     "expo-file-system": ">=56 <58",
     "expo-keep-awake": ">=55 <58",
     "expo-sqlite": ">=55 <58",
-    "livekit-client": ">=2.20.1 <3",
     "react": ">=19 <20",
     "react-native": ">=0.85 <0.87",
     "react-native-safe-area-context": ">=5 <6"
   },
   "dependencies": {
-    "@livekit/react-native-expo-plugin": "1.0.2",
     "convex": "^1.42.1",
     "@pickleball/remote-native": "0.1.0",
     "@pickleball/voice-native": "0.1.0"
   },
   "devDependencies": {
     "@expo/config-plugins": "~57.0.0",
-    "@livekit/react-native": "2.11.1",
-    "@livekit/react-native-webrtc": "144.1.1",
     "@react-native-community/netinfo": "12.0.1",
     "@testing-library/react-native": "^13.3.3",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.15.0",
     "@types/react": "~19.2.2",
-    "expo": "57.0.4",
+    "expo": "~57.0.14",
     "expo-audio": "57.0.2",
     "expo-file-system": "57.0.0",
     "expo-keep-awake": "57.0.0",
     "expo-sqlite": "57.0.0",
     "jest": "^29.7.0",
     "jest-expo": "~57.0.0",
-    "livekit-client": "2.20.1",
     "react": "19.2.3",
     "react-dom": "19.2.3",
-    "react-native": "0.86.0",
+    "react-native": "0.86.2",
     "react-native-safe-area-context": "~5.7.0",
     "react-test-renderer": "19.2.3",
     "tsup": "^8.5.0",
     "typescript": "^5.8.0",
-    "@pickleball/rtmp-native": "0.1.0",
+    "@pickleball/rtmp-native": "0.2.0",
     "@pickleball/shared": "0.1.0"
   },
   "peerDependenciesMeta": {
-    "@pickleball/rtmp-native": {
+    "expo-audio": {
       "optional": true
     }
   },

package/src/advanced.ts

@@ -1,5 +1,5 @@
 /**
- * API nâng cao: engine internals, dependency injection, adapter LiveKit và các
+ * API nâng cao: engine internals, dependency injection, adapter RTMP và các
  * factory runtime mặc định — dùng cho mock/test hoặc tuỳ biến sâu. App tích hợp
  * thông thường không cần import từ đây.
  */
@@ -14,31 +14,33 @@ export {
   type SdkRuntime,
   type SdkStorage,
   type SdkNetwork,
+  type SessionCommandChannel,
   type TelemetrySink,
   type LivestreamSnapshot,
   type DeviceMetricsSample,
   type CaptureOrientation,
   type CameraDeviceInfo,
 } from "./engine";
-export {
-  LiveKitRoomAdapter,
-  type NativeLiveKitBindings,
-  type LocalPreviewReference,
-} from "./livekit-room-adapter";
 export {
   RtmpRoomAdapter,
   type NativeRtmpBindings,
   type RtmpStatus,
 } from "./rtmp-room-adapter";
 export {
-  createNativeLiveKitBindings,
+  isBootstrap,
+  isCameraGrant,
+  isSessionGrant,
+  isSessionRefresh,
+  isTelemetryCredentials,
+  sessionApiBaseFromTelemetryEndpoint,
+} from "./session-grant";
+export {
   createDefaultRuntime,
+  createRtmpRuntime,
   createDefaultStorage,
   createDefaultNetwork,
   createDefaultTelemetry,
   createDefaultRoomFactory,
-  // Mode device-rtmp: thiết bị đẩy RTMP thẳng lên server tự host, không dùng
-  // LiveKit. Truyền vào prop roomFactory của PickleballLiveProvider để đổi mode.
   createRtmpRoomFactory,
   createNativeRtmpBindings,
   createDefaultDeviceMetrics,

package/src/auto-resume.tsx

@@ -0,0 +1,259 @@
+import { useEffect, useRef, useState } from "react";
+import type { StartLivestreamInput } from "./contracts";
+import { useLivestream, useLivestreamHost } from "./provider";
+import type { ResumableSessionProvider, ResumeAttempt } from "./resume";
+import { resumeBlocksArm, resumeExternalSessionId, resumeRetryDelayMs } from "./resume-policy";
+
+/**
+ * Ba mảnh "tự động" chuyển từ apps/device-streamer vào SDK — mọi app RTMP cần
+ * chúng, không riêng máy fleet:
+ *
+ * - PickleballAutoPrepare: camera luôn bật (prepare khi idle/ended).
+ * - PickleballAutoResume: app mở lại thấy phiên còn sống → nhận lại đúng phiên.
+ * - useStandbySession: chế độ sân — arm một phiên chờ, server lật live bằng lệnh.
+ *
+ * Các bẫy đã đo trên fleet (18–19/08/2026) nằm nguyên trong đây: retry publish
+ * khi encoder chưa có SPS, thoát hố "error" khi còn phiên chờ nhận lại, và
+ * KHÔNG arm phiên mới khi còn phiên chờ nhận lại.
+ *
+ * Kỷ luật dependency: mọi effect ở đây chỉ phụ thuộc vào TRẠNG THÁI (state,
+ * sessionId, id phiên chờ, cờ enabled) — hành động của engine, props cấu hình
+ * (resumeInput, retryDelayMs, input) và callback đi qua ref. App đối tác thường
+ * truyền object/hàm inline mỗi lần render; đưa chúng vào deps là mỗi render
+ * huỷ lượt resume đang bay, bắn lượt mới ngay (spam refresh) và timer thử lại
+ * không bao giờ kịp nổ.
+ */
+
+export type ResumeAttemptOutcome =
+  | ResumeAttempt["kind"]
+  | "start_failed"
+  | "publish_retry"
+  | "reprepare";
+
+export interface PickleballAutoResumeProps {
+  provider: ResumableSessionProvider;
+  /** Thông tin dựng lượt start nhận lại (title mặc định khi không biết tên phiên). */
+  resumeInput: {
+    consentVersion: string;
+    visibility?: "public" | "private";
+    metadata?: Record<string, string>;
+    titleFor?: (sessionId: string) => string;
+  };
+  /** false = tạm dừng (VD máy đang nghỉ). */
+  enabled?: boolean;
+  /**
+   * Nguồn thứ hai của id phiên còn sống (fleet: serverSession từ heartbeat).
+   * adoptableSessionId (dấu trên đĩa) luôn được ưu tiên vì có sớm hơn vài giây.
+   * Truyền CÙNG giá trị này vào `useStandbySession({resumeSessionId})` nếu app
+   * arm phiên chờ, để arm nhường đường nhận lại.
+   */
+  sessionIdHint?: string | null;
+  retryDelayMs?: (attempt: number) => number;
+  onAttempt?: (sessionId: string, outcome: ResumeAttemptOutcome) => void;
+}
+
+function useLatest<T>(value: T) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+export function PickleballAutoResume(props: PickleballAutoResumeProps): null {
+  const {
+    provider,
+    resumeInput,
+    enabled = true,
+    sessionIdHint = null,
+    retryDelayMs = resumeRetryDelayMs,
+    onAttempt,
+  } = props;
+  const live = useLivestream();
+  const { engine } = useLivestreamHost();
+  const goneRef = useRef<string | null>(null);
+  const attemptRef = useRef(0);
+  const [retryTick, setRetryTick] = useState(0);
+  const { state, sessionId, adoptableSessionId } = live;
+  const resumeId = adoptableSessionId ?? sessionIdHint;
+  const liveRef = useLatest(live);
+  const onAttemptRef = useLatest(onAttempt);
+  const resumeInputRef = useLatest(resumeInput);
+  const retryDelayRef = useLatest(retryDelayMs);
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (!resumeId || sessionId !== null || state !== "preview") return;
+    if (goneRef.current === resumeId) return;
+
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const scheduleRetry = () => {
+      const delay = retryDelayRef.current(attemptRef.current);
+      attemptRef.current += 1;
+      timer = setTimeout(() => {
+        if (!cancelled) setRetryTick((tick) => tick + 1);
+      }, delay);
+    };
+
+    void (async () => {
+      const result = await provider.resume(resumeId);
+      if (cancelled) return;
+      onAttemptRef.current?.(resumeId, result.kind);
+      if (result.kind === "gone") {
+        // Server nói phiên không còn. PHẢI bỏ dấu, không chỉ ghi nhớ ở ref: dấu
+        // còn nằm đó là mọi lượt start phiên MỚI bị chặn, mà lượt duy nhất được
+        // cho qua lại là nhận lại chính phiên đã chết — máy kẹt vĩnh viễn ở "error".
+        goneRef.current = resumeId;
+        attemptRef.current = 0;
+        void engine.abandonAdoptableSession(resumeId).catch(() => undefined);
+        return;
+      }
+      if (result.kind === "retry") {
+        scheduleRetry();
+        return;
+      }
+      attemptRef.current = 0;
+      provider.adoptResumeGrant(result.grant);
+      const resumeInput = resumeInputRef.current;
+      await liveRef.current
+        .start(
+          {
+            externalSessionId: resumeExternalSessionId(resumeId),
+            title: resumeInput.titleFor?.(resumeId) ?? "Phiên đang khôi phục",
+            consentVersion: resumeInput.consentVersion,
+            visibility: resumeInput.visibility ?? "public",
+            ...(resumeInput.metadata ? { metadata: resumeInput.metadata } : {}),
+          },
+          // Trạng thái lấy từ chính phản hồi refresh, KHÔNG đoán: gán cứng "live" là
+          // camera tự lên sóng khi chủ nó chỉ đang trực sân (18/08/2026).
+          { autoPublish: result.live },
+        )
+        .catch(() => {
+          // start hỏng (camera chưa sẵn, mạng rớt giữa chừng) cũng phải thử lại —
+          // bỏ qua là để phiên sống mồ côi tới khi lưới server dọn.
+          onAttemptRef.current?.(resumeId, "start_failed");
+          if (!cancelled) scheduleRetry();
+        });
+    })();
+
+    return () => {
+      cancelled = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [enabled, provider, resumeId, sessionId, state, retryTick, engine, liveRef, onAttemptRef, resumeInputRef, retryDelayRef]);
+
+  // Nhận lại hỏng ở bước PUBLISH chứ không phải bước xin grant: native ném vì
+  // encoder chưa phát SPS (app vừa mở, camera vừa bật). Engine ĐÃ SỞ HỮU phiên
+  // nên gọi start() lần nữa là sai — đường đúng là retry(), dùng lại grant sẵn có.
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId === null) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(sessionId, "publish_retry");
+      void liveRef.current.retry().catch(() => undefined);
+    }, retryDelayRef.current(attemptRef.current++));
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, liveRef, onAttemptRef, retryDelayRef]);
+
+  // Thoát hố đen "error" khi CHƯA có session mà còn phiên chờ nhận lại: transition
+  // error → preparing hợp lệ, prepare lại để về preview cho vòng nhận lại chạy tiếp.
+  useEffect(() => {
+    if (!enabled || state !== "error" || sessionId !== null || !adoptableSessionId) return;
+    const timer = setTimeout(() => {
+      onAttemptRef.current?.(adoptableSessionId, "reprepare");
+      void liveRef.current.prepare().catch(() => undefined);
+    }, 2_000);
+    return () => clearTimeout(timer);
+  }, [enabled, state, sessionId, adoptableSessionId, liveRef, onAttemptRef]);
+
+  useEffect(() => {
+    if (state === "live" || state === "standby") attemptRef.current = 0;
+  }, [state]);
+
+  return null;
+}
+
+export interface PickleballAutoPrepareProps {
+  enabled?: boolean;
+  /** Khung cố định (fleet: landscape). Bỏ trống = theo hướng máy như engine mặc định. */
+  captureOrientation?: "portrait" | "landscape";
+}
+
+/**
+ * Camera luôn sẵn: prepare khi idle và SAU KHI phiên kết thúc (thiếu nhánh
+ * `ended` là camera tối sau phiên đầu tiên). Không chạy khi đang lỗi — người
+ * dùng cần thấy lỗi, và AutoResume lo nhánh lỗi có phiên chờ.
+ */
+export function PickleballAutoPrepare(props: PickleballAutoPrepareProps): null {
+  const { enabled = true, captureOrientation } = props;
+  const live = useLivestream();
+  const { state } = live;
+  const liveRef = useLatest(live);
+  const orientedRef = useRef(false);
+
+  useEffect(() => {
+    if (!enabled || !captureOrientation || orientedRef.current) return;
+    orientedRef.current = true;
+    void liveRef.current.setCaptureOrientation(captureOrientation).catch(() => undefined);
+  }, [enabled, captureOrientation, liveRef]);
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "idle" && state !== "ended") return;
+    void liveRef.current.prepare().catch(() => undefined);
+  }, [enabled, state, liveRef]);
+
+  return null;
+}
+
+export interface UseStandbySessionOptions {
+  /** Lượt start chờ; đổi `externalSessionId` (trận kế) mới arm lại sau khi phiên trước kết thúc. */
+  input: StartLivestreamInput;
+  enabled?: boolean;
+  /**
+   * Id phiên còn sống theo nguồn NGOÀI đĩa (fleet: heartbeat; app đối tác: id
+   * backend trả về) — cùng giá trị truyền vào `PickleballAutoResume.sessionIdHint`.
+   * Có nó là arm NHƯỜNG: không tạo phiên chờ thứ hai trong lúc AutoResume đang
+   * nối lại phiên cũ.
+   */
+  resumeSessionId?: string | null;
+}
+
+/**
+ * Chế độ SÂN: điện thoại đứng chờ (standby) với grant đã cấp; trọng tài bấm
+ * match-start là server gửi lệnh `start` qua kênh lệnh và engine tự phát.
+ * Arm đúng một lần cho mỗi externalSessionId, và NHƯỜNG khi còn phiên chờ nhận
+ * lại (resumeBlocksArm) để không tạo phiên chờ thứ hai đè phiên cũ.
+ */
+export function useStandbySession(options: UseStandbySessionOptions): { armed: boolean } {
+  const { input, enabled = true, resumeSessionId = null } = options;
+  const live = useLivestream();
+  const { state, sessionId, adoptableSessionId } = live;
+  const liveRef = useLatest(live);
+  const armedForRef = useRef<string | null>(null);
+  // Chỉ externalSessionId là "khoá" của lượt arm; phần còn lại của input đọc
+  // qua ref để object inline mỗi lần render không kéo effect chạy lại.
+  const inputRef = useLatest(input);
+  const externalSessionId = input.externalSessionId;
+  const armed = sessionId !== null && armedForRef.current === externalSessionId;
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (state !== "preview" || sessionId !== null) return;
+    if (armedForRef.current === externalSessionId) return;
+    if (
+      resumeBlocksArm({
+        adoptableSessionId,
+        serverSessionId: resumeSessionId,
+        engineSessionId: sessionId,
+      })
+    ) {
+      return;
+    }
+    armedForRef.current = externalSessionId;
+    void liveRef.current.start(inputRef.current, { autoPublish: false }).catch(() => {
+      // Cho phép thử lại ở lượt render sau (VD grant lỗi tạm thời).
+      armedForRef.current = null;
+    });
+  }, [enabled, state, sessionId, adoptableSessionId, resumeSessionId, externalSessionId, liveRef, inputRef]);
+
+  return { armed };
+}

package/src/camera-controls.ts

@@ -0,0 +1,99 @@
+/**
+ * Điều khiển camera RUNTIME (zoom, EV, khoá nét/sáng, đèn pin, chống chớp) —
+ * gọi THẲNG native module @pickleball/rtmp-native (singleton), chủ ý bypass
+ * engine/adapter vì đây là tinh chỉnh camera, không phải lifecycle phiên.
+ *
+ * Mọi hàm `typeof`-guard: binary cũ (rtmp-native 0.1.0 trên fleet 1.0.2) thiếu
+ * vài hàm thì trả null/no-op thay vì ném — UI ẩn control tương ứng.
+ */
+
+declare const require: (name: string) => any;
+
+export interface CameraCapabilityRange {
+  min: number;
+  max: number;
+  supported: boolean;
+}
+
+export interface CameraCapabilities {
+  zoom: CameraCapabilityRange;
+  exposureBias: CameraCapabilityRange & { step?: number };
+  torch: { supported: boolean };
+  focusLock: { supported: boolean };
+  exposureLock: { supported: boolean };
+  supportedFrameRates?: number[];
+}
+
+type NativeControls = {
+  getCameraCapabilities?: () => Promise<CameraCapabilities>;
+  setZoom?: (factor: number) => Promise<void>;
+  setExposureBias?: (ev: number) => Promise<void>;
+  setFocusLocked?: (locked: boolean) => Promise<void>;
+  setExposureLocked?: (locked: boolean) => Promise<void>;
+  setTorch?: (enabled: boolean) => Promise<void>;
+  setAntiFlicker?: (mode: "auto" | "50hz" | "60hz") => Promise<void>;
+  requestPermissions?: () => Promise<boolean>;
+};
+
+function nativeModule(): NativeControls | null {
+  try {
+    const loaded = require("@pickleball/rtmp-native");
+    const candidate = (loaded?.default ?? loaded) as NativeControls | undefined;
+    return candidate && typeof candidate === "object" ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+async function callOptional<T>(
+  name: keyof NativeControls,
+  invoke: (native: NativeControls) => Promise<T> | undefined,
+  fallback: T,
+): Promise<T> {
+  const native = nativeModule();
+  if (!native || typeof native[name] !== "function") return fallback;
+  try {
+    const result = await invoke(native);
+    return result === undefined ? fallback : result;
+  } catch {
+    return fallback;
+  }
+}
+
+/** Bounds + cờ hỗ trợ của lens đang gắn; null khi module/hàm chưa có. */
+export function getCameraCapabilities(): Promise<CameraCapabilities | null> {
+  return callOptional("getCameraCapabilities", (n) => n.getCameraCapabilities?.(), null);
+}
+
+export function setZoom(factor: number): Promise<void> {
+  return callOptional("setZoom", (n) => n.setZoom?.(factor), undefined);
+}
+
+export function setExposureBias(ev: number): Promise<void> {
+  return callOptional("setExposureBias", (n) => n.setExposureBias?.(ev), undefined);
+}
+
+export function setFocusLocked(locked: boolean): Promise<void> {
+  return callOptional("setFocusLocked", (n) => n.setFocusLocked?.(locked), undefined);
+}
+
+export function setExposureLocked(locked: boolean): Promise<void> {
+  return callOptional("setExposureLocked", (n) => n.setExposureLocked?.(locked), undefined);
+}
+
+export function setTorch(enabled: boolean): Promise<void> {
+  return callOptional("setTorch", (n) => n.setTorch?.(enabled), undefined);
+}
+
+/** Android-only: iOS/binary cũ thiếu hàm → no-op. Native tự áp lại mỗi lần mở camera/đổi lens. */
+export function applyAntiFlicker(mode: "auto" | "50hz" | "60hz"): Promise<void> {
+  return callOptional("setAntiFlicker", (n) => n.setAntiFlicker?.(mode), undefined);
+}
+
+/**
+ * Xin quyền camera/mic qua native (iOS, rtmp-native ≥ 0.2). null = native chưa
+ * có hàm → caller tự quyết (AVFoundation sẽ hỏi lúc mở camera).
+ */
+export function requestNativePermissions(): Promise<boolean | null> {
+  return callOptional("requestPermissions", (n) => n.requestPermissions?.(), null);
+}