@bota-dev/react-native-sdk 0.0.2

package/src/models/Device.ts

@@ -0,0 +1,164 @@
+/**
+ * Device-related type definitions
+ */
+
+/**
+ * Device type identifier
+ */
+export type DeviceType = 'bota_pin' | 'bota_pin_4g' | 'bota_note';
+
+/**
+ * Pairing state of a device
+ */
+export type PairingState = 'unpaired' | 'pairing' | 'paired' | 'error';
+
+/**
+ * Connection state of a device
+ */
+export type ConnectionState =
+  | 'disconnected'
+  | 'connecting'
+  | 'bonding'
+  | 'discovering'
+  | 'connected'
+  | 'disconnecting';
+
+/**
+ * Device operational state
+ */
+export type DeviceState =
+  | 'idle'
+  | 'recording'
+  | 'syncing'
+  | 'uploading'
+  | 'charging'
+  | 'lowBattery'
+  | 'storageFull'
+  | 'error';
+
+/**
+ * Device status flags
+ */
+export interface DeviceFlags {
+  charging: boolean;
+  usbConnected: boolean;
+  lowBattery: boolean;
+  criticalBattery: boolean;
+  storageWarning: boolean;
+  storageFull: boolean;
+  cellularAvailable: boolean;
+  cellularRoaming: boolean;
+  wifiConnected: boolean;
+  recordingActive: boolean;
+  syncRequired: boolean;
+  updateAvailable: boolean;
+}
+
+/**
+ * Device discovered during BLE scan (not yet connected)
+ */
+export interface DiscoveredDevice {
+  /** BLE device identifier (platform-specific UUID) */
+  id: string;
+  /** Device name from advertisement (e.g., "Bota-Pin-A1B2C3") */
+  name: string;
+  /** Device type parsed from advertisement */
+  deviceType: DeviceType;
+  /** Firmware version from manufacturer data */
+  firmwareVersion: string;
+  /** Pairing state from manufacturer data */
+  pairingState: PairingState;
+  /** Signal strength (RSSI) */
+  rssi: number;
+  /** Raw manufacturer data bytes */
+  manufacturerData?: Uint8Array;
+  /** Timestamp when discovered */
+  discoveredAt: Date;
+}
+
+/**
+ * Device after successful BLE connection
+ */
+export interface ConnectedDevice {
+  /** BLE device identifier */
+  id: string;
+  /** Device serial number (read from Device Info service) */
+  serialNumber: string;
+  /** Device type */
+  deviceType: DeviceType;
+  /** Firmware version */
+  firmwareVersion: string;
+  /** Hardware revision (if available) */
+  hardwareRevision?: string;
+  /** Whether device has been provisioned with a token */
+  isProvisioned: boolean;
+  /** Current connection state */
+  connectionState: ConnectionState;
+  /** Negotiated MTU size */
+  mtu: number;
+}
+
+/**
+ * Device status information
+ */
+export interface DeviceStatus {
+  /** Battery level (0-100) */
+  batteryLevel: number;
+  /** Storage used percentage (0-100) */
+  storageUsedPercent: number;
+  /** Current operational state */
+  state: DeviceState;
+  /** Number of pending recordings to sync */
+  pendingRecordings: number;
+  /** Last sync timestamp */
+  lastSyncAt: Date | null;
+  /** Signal strength (for 4G devices, 0-5) */
+  signalStrength?: number;
+  /** Status flags */
+  flags: DeviceFlags;
+  /** Raw timestamp from device */
+  timestamp: number;
+}
+
+/**
+ * Storage information from device
+ */
+export interface StorageInfo {
+  /** Total storage in KB */
+  totalKb: number;
+  /** Used storage in KB */
+  usedKb: number;
+  /** Total recording count */
+  totalRecordings: number;
+  /** Pending sync count */
+  pendingSyncCount: number;
+}
+
+/**
+ * Configuration for device scanning
+ */
+export interface ScanOptions {
+  /** Timeout in milliseconds (default: 30000) */
+  timeout?: number;
+  /** Filter by device types */
+  deviceTypes?: DeviceType[];
+  /** Filter by pairing state */
+  pairingState?: PairingState;
+  /** Minimum RSSI to include */
+  minRssi?: number;
+  /** Allow duplicates (same device reported multiple times) */
+  allowDuplicates?: boolean;
+}
+
+/**
+ * Environment for API endpoint configuration
+ */
+export type Environment = 'production' | 'sandbox';
+
+/**
+ * Provisioning result
+ */
+export interface ProvisioningResult {
+  success: boolean;
+  error?: 'invalid_token' | 'storage_error' | 'chunk_error' | 'unknown';
+}

package/src/models/Recording.ts

@@ -0,0 +1,123 @@
+/**
+ * Recording-related type definitions
+ */
+
+/**
+ * Audio codec type
+ */
+export type AudioCodec = 'pcm_16k' | 'pcm_8k' | 'opus_16k' | 'opus_8k';
+
+/**
+ * Recording metadata from device
+ */
+export interface DeviceRecording {
+  /** Unique identifier on device (UUID) */
+  uuid: string;
+  /** Recording start timestamp */
+  startedAt: Date;
+  /** Duration in milliseconds */
+  durationMs: number;
+  /** File size in bytes */
+  fileSizeBytes: number;
+  /** Audio codec used */
+  codec: AudioCodec;
+}
+
+/**
+ * Upload information provided by customer backend
+ * (obtained by calling customer's API, not Bota API directly)
+ */
+export interface UploadInfo {
+  /** Pre-signed S3 URL for upload */
+  uploadUrl: string;
+  /** Upload token (up_*) for verification */
+  uploadToken: string;
+  /** Recording ID assigned by Bota API (rec_*) */
+  recordingId: string;
+  /** URL to call when upload is complete */
+  completeUrl: string;
+  /** Expiration time of the upload URL */
+  expiresAt: Date;
+}
+
+/**
+ * Sync progress stages
+ */
+export type SyncStage =
+  | 'preparing'
+  | 'transferring'
+  | 'uploading'
+  | 'completing'
+  | 'completed'
+  | 'failed';
+
+/**
+ * Sync progress information
+ */
+export interface SyncProgress {
+  /** Current stage */
+  stage: SyncStage;
+  /** Progress within current stage (0.0 - 1.0) */
+  progress: number;
+  /** Bytes transferred so far (for transferring stage) */
+  bytesTransferred?: number;
+  /** Total bytes to transfer */
+  totalBytes?: number;
+  /** Bytes uploaded so far (for uploading stage) */
+  bytesUploaded?: number;
+  /** Recording ID (set when completed) */
+  recordingId?: string;
+  /** Error message (set when failed) */
+  error?: string;
+}
+
+/**
+ * Upload task status
+ */
+export type UploadTaskStatus = 'pending' | 'uploading' | 'completed' | 'failed';
+
+/**
+ * Upload task in the queue
+ */
+export interface UploadTask {
+  /** Unique task identifier */
+  id: string;
+  /** Recording ID from Bota API */
+  recordingId: string;
+  /** Device ID the recording came from */
+  deviceId: string;
+  /** Local file path */
+  localPath: string;
+  /** Pre-signed S3 upload URL */
+  uploadUrl: string;
+  /** Upload token */
+  uploadToken: string;
+  /** Complete URL to call after upload */
+  completeUrl: string;
+  /** Current status */
+  status: UploadTaskStatus;
+  /** Number of retry attempts */
+  retryCount: number;
+  /** Error message if failed */
+  errorMessage?: string;
+  /** Task creation time */
+  createdAt: Date;
+  /** Last update time */
+  updatedAt: Date;
+}
+
+/**
+ * Transfer packet from device
+ */
+export interface TransferPacket {
+  /** Packet type: data, eof, or error */
+  type: 'data' | 'eof' | 'error';
+  /** Sequence number */
+  sequenceNumber: number;
+  /** Audio data (for data packets) */
+  data?: Uint8Array;
+  /** CRC32 checksum (for EOF packets) */
+  checksum?: number;
+  /** Error code (for error packets) */
+  errorCode?: number;
+}

package/src/models/Status.ts

@@ -0,0 +1,126 @@
+/**
+ * Status and configuration type definitions
+ */
+
+import type { DeviceStatus, StorageInfo } from './Device';
+import type { SyncProgress, UploadTask } from './Recording';
+
+/**
+ * SDK log level
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+
+/**
+ * SDK configuration options
+ */
+export interface BotaConfig {
+  /** Environment for API endpoint (production or sandbox) */
+  environment?: 'production' | 'sandbox';
+  /** Enable background sync (default: true) */
+  backgroundSyncEnabled?: boolean;
+  /** Only upload on WiFi (default: false) */
+  wifiOnlyUpload?: boolean;
+  /** Logging level (default: 'warn') */
+  logLevel?: LogLevel;
+  /** Enable debug mode with verbose logging */
+  debug?: boolean;
+}
+
+/**
+ * SDK state
+ */
+export type SdkState = 'uninitialized' | 'initializing' | 'ready' | 'error';
+
+/**
+ * Bluetooth state
+ */
+export type BluetoothState =
+  | 'unknown'
+  | 'resetting'
+  | 'unsupported'
+  | 'unauthorized'
+  | 'poweredOff'
+  | 'poweredOn';
+
+/**
+ * SDK status information
+ */
+export interface SdkStatus {
+  /** Current SDK state */
+  state: SdkState;
+  /** Bluetooth state */
+  bluetoothState: BluetoothState;
+  /** Whether Bluetooth is ready for operations */
+  isBluetoothReady: boolean;
+  /** Number of connected devices */
+  connectedDevicesCount: number;
+  /** Number of pending uploads in queue */
+  pendingUploadsCount: number;
+}
+
+// Re-export for convenience
+export type { DeviceStatus, StorageInfo, SyncProgress, UploadTask };
+
+/**
+ * Event types emitted by DeviceManager
+ */
+export interface DeviceManagerEvents {
+  /** Emitted when a device is discovered during scan */
+  deviceDiscovered: (device: import('./Device').DiscoveredDevice) => void;
+  /** Emitted when a device is connected */
+  deviceConnected: (device: import('./Device').ConnectedDevice) => void;
+  /** Emitted when a device is disconnected */
+  deviceDisconnected: (deviceId: string, error?: Error) => void;
+  /** Emitted when device status is updated */
+  deviceStatusUpdated: (
+    deviceId: string,
+    status: import('./Device').DeviceStatus
+  ) => void;
+  /** Emitted when scan starts */
+  scanStarted: () => void;
+  /** Emitted when scan stops */
+  scanStopped: () => void;
+  /** Emitted on scan error */
+  scanError: (error: Error) => void;
+  /** Emitted on connection state change */
+  connectionStateChanged: (
+    deviceId: string,
+    state: import('./Device').ConnectionState
+  ) => void;
+}
+
+/**
+ * Event types emitted by RecordingManager
+ */
+export interface RecordingManagerEvents {
+  /** Emitted when sync starts for a recording */
+  syncStarted: (deviceRecordingUuid: string) => void;
+  /** Emitted on sync progress update */
+  syncProgress: (deviceRecordingUuid: string, progress: SyncProgress) => void;
+  /** Emitted when sync completes successfully */
+  syncCompleted: (deviceRecordingUuid: string, recordingId: string) => void;
+  /** Emitted when sync fails */
+  syncFailed: (deviceRecordingUuid: string, error: Error) => void;
+  /** Emitted when upload queue changes */
+  queueUpdated: (tasks: UploadTask[]) => void;
+  /** Emitted when an upload starts */
+  uploadStarted: (taskId: string) => void;
+  /** Emitted on upload progress */
+  uploadProgress: (taskId: string, progress: number) => void;
+  /** Emitted when an upload completes */
+  uploadCompleted: (taskId: string, recordingId: string) => void;
+  /** Emitted when an upload fails */
+  uploadFailed: (taskId: string, error: Error) => void;
+}
+
+/**
+ * Event types emitted by BotaClient
+ */
+export interface BotaClientEvents {
+  /** Emitted when SDK state changes */
+  stateChanged: (state: SdkState) => void;
+  /** Emitted when Bluetooth state changes */
+  bluetoothStateChanged: (state: BluetoothState) => void;
+  /** Emitted on SDK error */
+  error: (error: Error) => void;
+}

package/src/models/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Models module exports
+ */
+
+export * from './Device';
+export * from './Recording';
+export * from './Status';