@pose-tracker/react-native-pose-estimation-light 0.1.0

package/src/backends/webview/WebViewPoseBackend.ts

@@ -0,0 +1,582 @@
+/**
+ * WebView inference backend — the SDK's base runtime on BOTH platforms.
+ *
+ * Runs MoveNet SinglePose Lightning (17 keypoints, 192×192) inside a real
+ * browser WebGL context (Chromium ANGLE on Android, WKWebView on iOS) — the
+ * same approach the PoseTracker WebView product uses in production, and the
+ * only one real-time across the whole Android park in Expo Go. Fully
+ * offline: TF.js and the model ship inside the npm package (poseHtml.ts).
+ *
+ * The WebView owns the camera (`getUserMedia`). Frames are NOT pushed from
+ * React Native — `estimatePose()` returns the latest pose posted by the page.
+ * Mount {@link WebViewPoseView} (or a 1×1 warmer) to attach the runtime.
+ */
+
+import type { PoseBackend, PoseBackendInitOptions, PoseInputFrame } from '../PoseBackend';
+import type { KeypointName, Pose } from '../../types/pose';
+import type {
+  AccelerationDiagnostics,
+  AccelerationState,
+  DiagnosticListener,
+} from '../../types/acceleration';
+import type { PoseTrackerEvent } from '../../types/events';
+
+export type WebViewPoseMessage =
+  | {
+      type: 'ready';
+      backend: string;
+      medianInferenceMs: number | null;
+      warmUpRunsMs: number[];
+      estimatedFps?: number | null;
+      profileId?: string;
+      /** false after basic (model-only) cold-start; true once getUserMedia ran. */
+      cameraOpened?: boolean;
+      coldStart?: 'basic' | 'full';
+      gl: { renderer: string | null; vendor: string | null; version: string | null } | null;
+      note?: string | null;
+    }
+  | {
+      type: 'warmup_estimate';
+      medianInferenceMs: number | null;
+      estimatedFps: number | null;
+      /** Platform floor (iOS 30 / Android 15). */
+      minTargetFps: number;
+      /** @deprecated Use {@link minTargetFps}. */
+      targetFps?: number;
+      profileId: string;
+      previousProfileId?: string;
+      idealWidth?: number;
+      idealHeight?: number;
+      gl?: { renderer: string | null; vendor: string | null; version: string | null } | null;
+    }
+  | {
+      type: 'pose';
+      keypoints: Array<{ name: string; x: number; y: number; score: number }>;
+      score: number;
+      inferenceTimeMs: number;
+      timestampMs: number;
+    }
+  | {
+      type: 'stats';
+      fps: number;
+      medianInferenceMs: number | null;
+      estimatedFpsFromMedian?: number | null;
+      frames: number;
+      backend: string;
+      breakdown?: {
+        drawMs: number | null;
+        fromPixelsMs: number | null;
+        executeMs: number | null;
+        totalPipelineMs?: number | null;
+      };
+      windowCounts?: { inferred: number; skipped: number };
+      experiments?: Record<string, unknown>;
+      leverHints?: {
+        dominantStage?: string;
+        dominantMs?: number;
+        bitmapShare?: number;
+        fromPixelsShare?: number;
+        executeShare?: number;
+        hints?: string[];
+      } | null;
+      videoSize?: string;
+      mode?: string;
+    }
+  | {
+      type: 'initialization';
+      message: string;
+      ready?: boolean;
+      step?: 'accessing_webcam' | 'loading_pose_model' | 'ready';
+    }
+  | { type: 'warning'; message: string; code?: string }
+  | { type: 'diag'; message: string }
+  | { type: 'error'; message: string; code?: string };
+
+export interface WebViewPoseStats {
+  fps: number;
+  medianInferenceMs: number | null;
+  estimatedFpsFromMedian?: number | null;
+  frames: number;
+  backend: string;
+  videoSize?: string;
+  mode?: string;
+  breakdown?: {
+    drawMs: number | null;
+    fromPixelsMs: number | null;
+    executeMs: number | null;
+    totalPipelineMs?: number | null;
+  };
+  windowCounts?: { inferred: number; skipped: number };
+  experiments?: Record<string, unknown>;
+  leverHints?: {
+    dominantStage?: string;
+    dominantMs?: number;
+    bitmapShare?: number;
+    fromPixelsShare?: number;
+    executeShare?: number;
+    hints?: string[];
+  } | null;
+}
+
+export interface WebViewPoseBackendOptions {
+  onDiagnostic?: DiagnosticListener;
+  onAccelerationChange?: (state: AccelerationState) => void;
+  /** Fired on every pose from the WebView (used by WebViewPoseView / ingest). */
+  onPose?: (pose: Pose, inferenceTimeMs: number) => void;
+  /** Fired when the Chromium page reports ready (model + backend warmed). */
+  onReady?: (info: {
+    backend: string;
+    medianInferenceMs: number | null;
+    estimatedFps?: number | null;
+    profileId?: string | null;
+    glRenderer: string | null;
+  }) => void;
+  /**
+   * Fired after zeros warm-up, typically *before* getUserMedia — used to pick
+   * a capture profile targeting ≥15 FPS.
+   */
+  onWarmupEstimate?: (info: {
+    medianInferenceMs: number | null;
+    estimatedFps: number | null;
+    profileId: string;
+    glRenderer: string | null;
+  }) => void;
+  /** Fired ~1 Hz with inference FPS / breakdown (adaptive quality input). */
+  onStats?: (stats: WebViewPoseStats) => void;
+  /**
+   * Promotes page-level init / warning / error into typed {@link PoseTrackerEvent}s
+   * so the host can listen the same way as the classic PoseTracker WebView.
+   */
+  onTrackerEvent?: (event: PoseTrackerEvent) => void;
+}
+
+type ReadyResolver = {
+  resolve: () => void;
+  reject: (err: Error) => void;
+};
+
+export class WebViewPoseBackend implements PoseBackend {
+  readonly name = 'webview-movenet';
+
+  private acceleration: AccelerationState = 'unknown';
+  private attached = false;
+  private ready = false;
+  private warm = false;
+  /** True after the page successfully opened getUserMedia. */
+  private cameraOpened = false;
+  private openCameraHandler: (() => void) | undefined;
+  private lastPose: Pose | null = null;
+  private inferenceTimesMs: number[] = [];
+  private medianInferenceMs: number | null = null;
+  private glRenderer: string | null = null;
+  private glVendor: string | null = null;
+  private glVersion: string | null = null;
+  private tfjsBackend: string | null = null;
+  private reasons: string[] = [];
+  private readyWaiters: ReadyResolver[] = [];
+  private cameraWaiters: ReadyResolver[] = [];
+  private readonly onDiagnostic: DiagnosticListener | undefined;
+  private readonly onAccelerationChange: ((state: AccelerationState) => void) | undefined;
+  private onPose: ((pose: Pose, inferenceTimeMs: number) => void) | undefined;
+  private onReady: WebViewPoseBackendOptions['onReady'];
+  private onWarmupEstimate: WebViewPoseBackendOptions['onWarmupEstimate'];
+  private onStats: WebViewPoseBackendOptions['onStats'];
+  private onTrackerEvent: WebViewPoseBackendOptions['onTrackerEvent'];
+
+  constructor(options: WebViewPoseBackendOptions = {}) {
+    this.onDiagnostic = options.onDiagnostic;
+    this.onAccelerationChange = options.onAccelerationChange;
+    this.onPose = options.onPose;
+    this.onReady = options.onReady;
+    this.onWarmupEstimate = options.onWarmupEstimate;
+    this.onStats = options.onStats;
+    this.onTrackerEvent = options.onTrackerEvent;
+  }
+
+  /** Host view calls this when the WebView mounts / unmounts. */
+  setAttached(attached: boolean): void {
+    this.attached = attached;
+    this.onDiagnostic?.(
+      `[posetracker] WebViewPoseBackend attached=${attached} ready=${this.ready}`,
+    );
+    if (!attached) {
+      this.ready = false;
+      this.warm = false;
+      this.cameraOpened = false;
+      this.openCameraHandler = undefined;
+      // Drop stale GPU verdict from a previous warmer/page so the host does
+      // not show acceleration=gpu while the next WebView is still booting.
+      this.setAcceleration('unknown');
+    }
+  }
+
+  setOnPose(handler: ((pose: Pose, inferenceTimeMs: number) => void) | undefined): void {
+    this.onPose = handler;
+  }
+
+  setOnReady(handler: WebViewPoseBackendOptions['onReady']): void {
+    this.onReady = handler;
+  }
+
+  setOnStats(handler: WebViewPoseBackendOptions['onStats']): void {
+    this.onStats = handler;
+  }
+
+  /** Feed a message from the WebView `onMessage` handler. */
+  handleMessage(raw: string): void {
+    let msg: WebViewPoseMessage;
+    try {
+      msg = JSON.parse(raw) as WebViewPoseMessage;
+    } catch {
+      return;
+    }
+
+    if (msg.type === 'warmup_estimate') {
+      this.glRenderer = msg.gl?.renderer ?? this.glRenderer;
+      this.medianInferenceMs = msg.medianInferenceMs;
+      const minTarget = msg.minTargetFps ?? msg.targetFps;
+      this.onDiagnostic?.(
+        `[posetracker] WebView warmup_estimate fps=${
+          msg.estimatedFps != null ? msg.estimatedFps.toFixed(1) : '?'
+        } medianMs=${msg.medianInferenceMs != null ? msg.medianInferenceMs.toFixed(1) : '?'} ` +
+          `profile=${msg.profileId} minTarget=${minTarget}`,
+      );
+      this.onWarmupEstimate?.({
+        medianInferenceMs: msg.medianInferenceMs,
+        estimatedFps: msg.estimatedFps,
+        profileId: msg.profileId,
+        glRenderer: this.glRenderer,
+      });
+      return;
+    }
+
+    if (msg.type === 'ready') {
+      this.ready = true;
+      this.warm = true;
+      if (msg.cameraOpened === true) {
+        this.cameraOpened = true;
+        this.flushCameraWaiters();
+      }
+      this.tfjsBackend = msg.backend;
+      this.medianInferenceMs = msg.medianInferenceMs;
+      this.inferenceTimesMs = msg.warmUpRunsMs ?? [];
+      this.glRenderer = msg.gl?.renderer ?? null;
+      this.glVendor = msg.gl?.vendor ?? null;
+      this.glVersion = msg.gl?.version ?? null;
+      const med = msg.medianInferenceMs;
+      // Chromium WebGL on Android mid-range is typically 15–80 ms — treat as GPU.
+      this.setAcceleration(med != null && med > 200 ? 'cpu-fallback' : 'gpu');
+      this.onDiagnostic?.(
+        `[posetracker] WebView Chromium ready backend=${msg.backend} ` +
+          `medianMs=${med != null ? med.toFixed(1) : 'n/a'} ` +
+          `estFps=${msg.estimatedFps != null ? msg.estimatedFps.toFixed(1) : 'n/a'} ` +
+          `profile=${msg.profileId ?? 'n/a'} coldStart=${msg.coldStart ?? '?'} ` +
+          `camera=${msg.cameraOpened === true ? 'on' : 'deferred'} ` +
+          `renderer=${this.glRenderer ?? 'n/a'}` +
+          (msg.note ? ` note=${msg.note}` : ''),
+      );
+      this.onReady?.({
+        backend: msg.backend,
+        medianInferenceMs: med,
+        estimatedFps: msg.estimatedFps,
+        profileId: msg.profileId,
+        glRenderer: this.glRenderer,
+      });
+      this.onTrackerEvent?.({
+        type: 'initialization',
+        step: 'ready',
+        message: 'running',
+        ready: true,
+      });
+      this.flushReadyWaiters();
+      return;
+    }
+
+    if (msg.type === 'initialization') {
+      const step = msg.step ?? (msg.ready ? 'ready' : 'loading_pose_model');
+      this.onDiagnostic?.(
+        `[posetracker] WebView init: ${msg.message} ready=${Boolean(msg.ready)}`,
+      );
+      this.onTrackerEvent?.({
+        type: 'initialization',
+        step,
+        message: msg.message,
+        ready: Boolean(msg.ready),
+      });
+      return;
+    }
+
+    if (msg.type === 'warning') {
+      this.onDiagnostic?.(`[posetracker] WebView warning: ${msg.message}`);
+      this.onTrackerEvent?.({
+        type: 'warning',
+        code: 'webview',
+        message: msg.message,
+        timestampMs: Date.now(),
+      });
+      return;
+    }
+
+    if (msg.type === 'error') {
+      // Mid-boot quality swaps abort getUserMedia; ignore so warmup can finish.
+      if (/abort/i.test(msg.message)) {
+        this.onDiagnostic?.(
+          `[posetracker] WebView pose error ignored (abort during quality swap): ${msg.message}`,
+        );
+        return;
+      }
+      this.reasons.push(msg.message);
+      this.onDiagnostic?.(`[posetracker] WebView pose error: ${msg.message}`);
+      this.onTrackerEvent?.({
+        type: 'error',
+        code: 'webview_error',
+        message: msg.message,
+      });
+      const err = new Error(msg.message);
+      for (const w of this.readyWaiters) w.reject(err);
+      this.readyWaiters = [];
+      return;
+    }
+
+    if (msg.type === 'diag') {
+      this.onDiagnostic?.(`[posetracker] WebView diag: ${msg.message}`);
+      return;
+    }
+
+    if (msg.type === 'stats') {
+      this.medianInferenceMs = msg.medianInferenceMs;
+      this.tfjsBackend = msg.backend;
+      const b = msg.breakdown;
+      const fmt = (v: number | null | undefined) => (v != null ? v.toFixed(1) : 'n/a');
+      const wc = msg.windowCounts;
+      const lh = msg.leverHints;
+      this.onDiagnostic?.(
+        `[posetracker] WebView stats fps=${msg.fps} medianMs=${
+          msg.medianInferenceMs != null ? Math.round(msg.medianInferenceMs) : 'n/a'
+        }` +
+          (msg.estimatedFpsFromMedian != null
+            ? ` estFps=${msg.estimatedFpsFromMedian.toFixed(1)}`
+            : '') +
+          ` backend=${msg.backend}` +
+          (msg.mode ? ` mode=${msg.mode}` : '') +
+          (msg.videoSize ? ` video=${msg.videoSize}` : '') +
+          (b
+            ? ` bitmap=${fmt(b.drawMs)} fromPixels=${fmt(b.fromPixelsMs)} execute=${fmt(b.executeMs)}` +
+              (b.totalPipelineMs != null ? ` total=${fmt(b.totalPipelineMs)}` : '')
+            : '') +
+          (wc ? ` inferred/skipped=${wc.inferred}/${wc.skipped}` : ''),
+      );
+      if (lh?.hints?.length) {
+        this.onDiagnostic?.(
+          `[posetracker] WebView leverHints dominant=${lh.dominantStage ?? '?'} ` +
+            `shares bmp=${lh.bitmapShare ?? '?'} px=${lh.fromPixelsShare ?? '?'} ex=${lh.executeShare ?? '?'} ` +
+            `→ ${lh.hints.join(' | ')}`,
+        );
+      }
+      this.onStats?.({
+        fps: msg.fps,
+        medianInferenceMs: msg.medianInferenceMs,
+        estimatedFpsFromMedian: msg.estimatedFpsFromMedian,
+        frames: msg.frames,
+        backend: msg.backend,
+        videoSize: msg.videoSize,
+        mode: msg.mode,
+        breakdown: msg.breakdown,
+        windowCounts: msg.windowCounts,
+        experiments: msg.experiments,
+        leverHints: msg.leverHints,
+      });
+      return;
+    }
+
+    if (msg.type === 'pose') {
+      const pose: Pose = {
+        keypoints: msg.keypoints.map((k) => ({
+          name: k.name as KeypointName,
+          x: k.x,
+          y: k.y,
+          score: k.score,
+        })),
+        score: msg.score,
+        timestampMs: msg.timestampMs,
+      };
+      this.lastPose = pose;
+      this.onPose?.(pose, msg.inferenceTimeMs);
+    }
+  }
+
+  async init(_options: PoseBackendInitOptions): Promise<void> {
+    this.onDiagnostic?.(
+      '[posetracker] WebViewPoseBackend.init — waiting for Chromium WebView to mount (WebViewPoseView)',
+    );
+    // Actual model load happens inside the HTML page once the view attaches.
+  }
+
+  async warmup(): Promise<void> {
+    if (this.warm) return;
+    this.onDiagnostic?.(
+      '[posetracker] WebViewPoseBackend.warmup — awaiting page ready (model cold-start)…',
+    );
+    await this.waitUntilReady(60_000);
+  }
+
+  /** Whether getUserMedia has already run in the attached page. */
+  isCameraOpened(): boolean {
+    return this.cameraOpened;
+  }
+
+  /**
+   * Host injects `__PT_OPEN_CAMERA` via {@link setOpenCameraHandler}.
+   * Used when upgrading basic → full cold-start without remounting the page.
+   */
+  setOpenCameraHandler(handler: (() => void) | undefined): void {
+    this.openCameraHandler = handler;
+  }
+
+  /**
+   * Open getUserMedia after a basic (model-only) ready. No-op if the page
+   * already opened the camera (coldStart=full boot).
+   */
+  async openCamera(): Promise<void> {
+    if (this.cameraOpened) return;
+    if (!this.ready) {
+      await this.waitUntilReady(60_000);
+    }
+    if (this.cameraOpened) return;
+    if (!this.openCameraHandler) {
+      throw new Error(
+        'WebViewPoseBackend.openCamera: no WebViewPoseView attached to inject __PT_OPEN_CAMERA.',
+      );
+    }
+    this.onDiagnostic?.('[posetracker] WebViewPoseBackend.openCamera — requesting getUserMedia…');
+    this.openCameraHandler();
+    await this.waitUntilCameraOpened(30_000);
+  }
+
+  async estimatePose(_frame: PoseInputFrame): Promise<Pose | null> {
+    // Camera lives inside the WebView; return last pose for API compatibility.
+    return this.lastPose;
+  }
+
+  getAcceleration(): AccelerationDiagnostics | null {
+    if (this.acceleration === 'unknown' && !this.ready) {
+      return null;
+    }
+    return {
+      state: this.acceleration,
+      tfjsBackend: this.tfjsBackend,
+      runtime: 'webview',
+      medianInferenceMs: this.medianInferenceMs,
+      inferenceTimesMs: [...this.inferenceTimesMs],
+      maxAcceptableInferenceMs: 200,
+      capabilities: this.glRenderer
+        ? {
+            glVersion: this.glVersion,
+            renderer: this.glRenderer,
+            vendor: this.glVendor,
+            maxTextureSize: null,
+            colorBufferFloat: true,
+            colorBufferHalfFloat: true,
+            textureFloat: true,
+            textureHalfFloat: true,
+            extensionQueriesShimmed: false,
+          }
+        : null,
+      flags: {
+        WEBVIEW_CHROMIUM: true,
+        note:
+          this.tfjsBackend === 'wasm'
+            ? 'Inference runs in WebView WASM (slow fallback)'
+            : 'Inference runs in WebView main-thread WebGL MoveNet (camera capped, createImageBitmap 192)',
+      },
+      contextLossCount: 0,
+      reasons: [
+        ...this.reasons,
+        'backend=webview-movenet (Chromium getUserMedia + TF.js WebGL MoveNet Lightning)',
+      ],
+    };
+  }
+
+  async dispose(): Promise<void> {
+    this.ready = false;
+    this.warm = false;
+    this.cameraOpened = false;
+    this.attached = false;
+    this.openCameraHandler = undefined;
+    this.lastPose = null;
+    this.acceleration = 'unknown';
+    this.readyWaiters = [];
+    this.cameraWaiters = [];
+  }
+
+  private waitUntilReady(timeoutMs: number): Promise<void> {
+    if (this.ready) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new Error(
+            'WebViewPoseBackend: timed out waiting for Chromium page ready. ' +
+              'Mount <WebViewPoseView coldStart="basic" /> (or full) so MoveNet can warm up.',
+          ),
+        );
+      }, timeoutMs);
+      this.readyWaiters.push({
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        },
+      });
+    });
+  }
+
+  private waitUntilCameraOpened(timeoutMs: number): Promise<void> {
+    if (this.cameraOpened) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new Error(
+            'WebViewPoseBackend: timed out waiting for getUserMedia. ' +
+              'Ensure the user grants camera permission when prompted.',
+          ),
+        );
+      }, timeoutMs);
+      this.cameraWaiters.push({
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        },
+      });
+    });
+  }
+
+  private flushReadyWaiters(): void {
+    const waiters = this.readyWaiters;
+    this.readyWaiters = [];
+    for (const w of waiters) w.resolve();
+  }
+
+  private flushCameraWaiters(): void {
+    const waiters = this.cameraWaiters;
+    this.cameraWaiters = [];
+    for (const w of waiters) w.resolve();
+  }
+
+  private setAcceleration(state: AccelerationState): void {
+    if (this.acceleration !== state) {
+      this.acceleration = state;
+      this.onAccelerationChange?.(state);
+    }
+  }
+}
+
+export function isWebViewPoseBackend(backend: PoseBackend): backend is WebViewPoseBackend {
+  return backend.name === 'webview-movenet';
+}

package/src/backends/webview/brandAssets.ts

@@ -0,0 +1,5 @@
+/**
+ * PoseTracker join logo (icon + wordmark) for WebView overlays.
+ * Generated from assets/PoseTracker_logo.png — do not edit by hand.
+ */
+export const POSETRACKER_LOGO_DATA_URL = "data:image/png;base64,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";