@gymbrosinc/react-native-mediapipe-pose/src/ReactNativeMediapipePose.types.ts

React Native MediaPipe Pose Detection with GPU acceleration, jump detection, and high-performance analysis

import type { StyleProp, ViewStyle } from 'react-native';

export type CameraType = 'front' | 'back';

/** Pose landmark with 3D coordinates and visibility */
export type PoseLandmark = {
  x: number;
  y: number;
  z: number;
  visibility: number;
};

/** Pose detection result with performance metrics */
export type PoseDetectionResult = {
  landmarks: PoseLandmark[];
  processingTime: number;
  timestamp: number;
  deviceTier?: string;
  confidence?: number;
  gpuAccelerated?: boolean;
  processingUnit?: string;
  delegate?: string;
};

/** Frame processing performance info */
export type FrameProcessingInfo = {
  fps: number;
  frameCount: number;
  autoAdjusted?: boolean;
  newTargetFPS?: number;
  reason?: string;
};

/** Device hardware capability assessment */
export type DeviceCapability = {
  deviceTier: 'high' | 'medium' | 'low' | 'unknown';
  recommendedFPS: number;
  processorCount: number;
  physicalMemoryGB: number;
  systemVersion: string;
};

export type OnCameraReadyEventPayload = {
  ready: boolean;
};

export type OnErrorEventPayload = {
  error: string;
};

export type PoseServiceLogEvent = {
  message: string;
  level: 'info' | 'debug' | 'warning' | 'error';
  timestamp: number;
};

export type PoseServiceErrorEvent = {
  error: string;
  timestamp: number;
};

/** Jump detection result with comprehensive metrics */
export type JumpResult = {
  jumpHeight: number;
  jumpHeightInches: number;
  flightTime: number;
  takeoffVelocity: number;
  peakVelocity: number;
  takeoffForce: number;
  landingForce: number;
  hangTime: number;
  accuracy: number;
  timestamp: number;
};

export type OnBaselineSetEventPayload = {
  baselineY: number;
  confidence: number;
  timestamp: number;
};

export type OnCountdownStartEventPayload = {
  countdown: number;
  timestamp: number;
};

export type OnJumpStartEventPayload = {
  velocity: number;
  force: number;
  timestamp: number;
};

export type OnPeakHeightEventPayload = {
  height: number;
  heightInches: number;
  flightTime: number;
  timestamp: number;
};

export type OnJumpEndEventPayload = {
  impactForce: number;
  timestamp: number;
};

export type OnJumpResultEventPayload = JumpResult;

/** GPU acceleration status */
export type GPUStatusEvent = {
  isUsingGPU: boolean;
  delegate: 'GPU' | 'CPU';
  deviceTier: string;
  maxAccuracy: boolean;
  processingUnit: string;
};

export type ReactNativeMediapipePoseModuleEvents = {
  onChange: (params: ChangeEventPayload) => void;
};

export type ChangeEventPayload = {
  value: string;
};

/** Camera view component props */
export type ReactNativeMediapipePoseViewProps = {
  style?: StyleProp<ViewStyle>;
  cameraType?: CameraType;
  enablePoseDetection?: boolean;
  isJumpDetectionEnabled?: boolean;
  /** Enable streaming pose data (default: false for max performance) */
  enablePoseDataStreaming?: boolean;
  /** Throttle pose data events in ms (default: 100) */
  poseDataThrottleMs?: number;
  /** Enable detailed logging (default: false for max performance) */
  enableDetailedLogs?: boolean;
  fpsChangeThreshold?: number;
  fpsReportThrottleMs?: number;
  targetFPS?: number;
  autoAdjustFPS?: boolean;
  onCameraReady?: (event: { nativeEvent: OnCameraReadyEventPayload }) => void;
  onError?: (event: { nativeEvent: OnErrorEventPayload }) => void;
  onFrameProcessed?: (event: { nativeEvent: FrameProcessingInfo }) => void;
  onPoseDetected?: (event: { nativeEvent: PoseDetectionResult }) => void;
  onDeviceCapability?: (event: { nativeEvent: DeviceCapability }) => void;
  onPoseServiceLog?: (event: { nativeEvent: PoseServiceLogEvent }) => void;
  onPoseServiceError?: (event: { nativeEvent: PoseServiceErrorEvent }) => void;
  onGPUStatus?: (event: { nativeEvent: GPUStatusEvent }) => void;
  onBaselineSet?: (event: { nativeEvent: OnBaselineSetEventPayload }) => void;
  onCountdownStart?: (event: {
    nativeEvent: OnCountdownStartEventPayload;
  }) => void;
  onJumpStart?: (event: { nativeEvent: OnJumpStartEventPayload }) => void;
  onPeakHeight?: (event: { nativeEvent: OnPeakHeightEventPayload }) => void;
  onJumpEnd?: (event: { nativeEvent: OnJumpEndEventPayload }) => void;
  onJumpResult?: (event: { nativeEvent: OnJumpResultEventPayload }) => void;
};