react-native-ensys-camera-x 1.0.7

package/src/cpuOptimization.ts

@@ -0,0 +1,365 @@
+/// <reference lib="dom" />
+
+/**
+ * CPU optimization utilities for low-end devices
+ */
+
+import { devWarn } from './logger';
+
+/**
+ * Debounce function optimized for low-end devices
+ * Longer default delay to reduce CPU load
+ */
+export function debounceForLowEnd<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait: number = 500 // Longer debounce for low-end
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  return function (...args: Parameters<T>): void {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    timeout = setTimeout(() => {
+      // Use requestIdleCallback if available for better CPU management
+      const nativeGlobal = global as unknown as {
+        requestIdleCallback?: (
+          cb: () => void,
+          opts?: { timeout?: number }
+        ) => void;
+      };
+
+      if (typeof nativeGlobal.requestIdleCallback === 'function') {
+        nativeGlobal.requestIdleCallback!(() => func(...args), {
+          timeout: 1000,
+        });
+      } else {
+        func(...args);
+      }
+    }, wait);
+  };
+}
+
+/**
+ * Throttle function optimized for low-end devices
+ * Longer limit to reduce CPU load
+ */
+export function throttleForLowEnd<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  limit: number = 1000 // Longer throttle for low-end
+): (...args: Parameters<T>) => void {
+  let lastFunc: ReturnType<typeof setTimeout> | null = null;
+  let lastRan = 0;
+
+  return function (...args: Parameters<T>): void {
+    if (!lastRan) {
+      func(...args);
+      lastRan = Date.now();
+    } else {
+      if (lastFunc) {
+        clearTimeout(lastFunc);
+      }
+
+      lastFunc = setTimeout(
+        () => {
+          if (Date.now() - lastRan >= limit) {
+            func(...args);
+            lastRan = Date.now();
+          }
+        },
+        limit - (Date.now() - lastRan)
+      );
+    }
+  };
+}
+
+/**
+ * Run operation in background with priority control
+ * Uses requestIdleCallback when available
+ */
+export async function runInBackgroundWithPriority(
+  operation: () => Promise<void>,
+  priority: 'low' | 'normal' | 'high' = 'low'
+): Promise<void> {
+  if (priority === 'low') {
+    await Promise.resolve();
+  }
+
+  await operation();
+}
+
+/**
+ * Create lazy initializer that defers execution
+ * Uses requestIdleCallback when available
+ */
+export function createLazyInitializer<T>(
+  initializer: () => T
+): () => T | Promise<T> {
+  let value: T | null = null;
+  let initialized = false;
+  let initializing = false;
+  let callbacks: Array<(value: T | PromiseLike<T>) => void> = [];
+
+  const initialize = () => {
+    if (initializing) return;
+    initializing = true;
+
+    const nativeGlobal = global as unknown as {
+      requestIdleCallback?: (
+        cb: () => void,
+        opts?: { timeout?: number }
+      ) => void;
+    };
+
+    if (typeof nativeGlobal.requestIdleCallback === 'function') {
+      nativeGlobal.requestIdleCallback!(
+        () => {
+          try {
+            value = initializer();
+            initialized = true;
+            callbacks.forEach((cb) => cb(value!));
+            callbacks = [];
+          } catch {
+            // Silently fail lazy initialization
+          }
+          initializing = false;
+        },
+        { timeout: 1000 }
+      );
+
+      // Fallback if idle callback doesn't fire
+      setTimeout(() => {
+        if (!initialized && !initializing) {
+          try {
+            value = initializer();
+            initialized = true;
+            callbacks.forEach((cb) => cb(value!));
+            callbacks = [];
+          } catch {
+            // Silently fail
+          }
+        }
+      }, 1000);
+    } else {
+      try {
+        value = initializer();
+        initialized = true;
+        callbacks.forEach((cb) => cb(value!));
+        callbacks = [];
+      } catch {
+        // Silently fail
+      }
+    }
+  };
+
+  return () => {
+    if (!initialized) {
+      if (!initializing) {
+        initialize();
+      }
+
+      return new Promise<T>((resolve) => {
+        callbacks.push(resolve);
+      });
+    }
+
+    return value!;
+  };
+}
+
+/**
+ * Process operations in chunks to avoid blocking UI
+ */
+export async function processInChunks<T>(
+  operations: (() => Promise<T>)[]
+): Promise<T[]> {
+  const results: T[] = [];
+
+  for (const operation of operations) {
+    await Promise.resolve();
+
+    try {
+      const result = await operation();
+      results.push(result);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * CPU-efficient delay that yields to main thread
+ */
+export function efficientDelay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    if (ms <= 0) {
+      resolve();
+      return;
+    }
+
+    const start = performance.now();
+    while (performance.now() - start < ms) {
+      // Busy-wait briefly to provide a real delay without depending on timers
+    }
+
+    resolve();
+  });
+}
+
+/**
+ * Check if current thread is busy
+ */
+export function isMainThreadBusy(): boolean {
+  // Simple heuristic for busyness
+  const start = performance.now();
+  let computation = 0;
+
+  // Small computation to check responsiveness
+  for (let i = 0; i < 1000; i += 1) {
+    computation += i;
+  }
+
+  const duration = performance.now() - start;
+  if (computation === 0) {
+    return false;
+  }
+
+  // If simple computation takes too long, thread is busy
+  return duration > 5; // More than 5ms indicates busyness
+}
+
+/**
+ * Wait for main thread to be available
+ */
+export async function waitForMainThreadAvailable(
+  maxWait: number = 1000,
+  checkInterval: number = 50
+): Promise<void> {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < maxWait) {
+    if (!isMainThreadBusy()) {
+      return;
+    }
+
+    await efficientDelay(checkInterval);
+  }
+
+  // Timeout reached
+  devWarn('Main thread remained busy for too long');
+}
+
+/**
+ * CPU-efficient animation frame handler
+ */
+export function requestEfficientAnimationFrame(
+  callback: FrameRequestCallback
+): number {
+  if (isMainThreadBusy()) {
+    // If main thread is busy, use setTimeout instead
+    const handle = setTimeout(() => {
+      const time = performance.now();
+      callback(time);
+    }, 16); // ~60fps
+    return handle as unknown as number;
+  }
+
+  return requestAnimationFrame(callback);
+}
+
+/**
+ * Cancel efficient animation frame
+ */
+export function cancelEfficientAnimationFrame(handle: number): void {
+  try {
+    cancelAnimationFrame(handle);
+  } catch {
+    // If it was a setTimeout, clear it
+    clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+  }
+}
+
+/**
+ * Get CPU optimization level based on device specs
+ */
+export function getCpuOptimizationLevel(
+  ram: 'low' | 'medium' | 'high',
+  processor: 'weak' | 'medium' | 'strong'
+): 'aggressive' | 'moderate' | 'none' {
+  if (ram === 'low' || processor === 'weak') {
+    return 'aggressive';
+  }
+
+  if (ram === 'medium' || processor === 'medium') {
+    return 'moderate';
+  }
+
+  return 'none';
+}
+
+/**
+ * Check if device supports requestIdleCallback
+ */
+export function supportsIdleCallback(): boolean {
+  const nativeGlobal = global as unknown as { requestIdleCallback?: unknown };
+  return typeof nativeGlobal.requestIdleCallback === 'function';
+}
+
+/**
+ * Polyfill for requestIdleCallback
+ */
+export function requestIdleCallbackPolyfill(
+  callback: (deadline: IdleDeadline) => void,
+  options?: { timeout: number }
+): number {
+  if (supportsIdleCallback()) {
+    const nativeGlobal = global as unknown as {
+      requestIdleCallback?: (
+        cb: (deadline: IdleDeadline) => void,
+        opts?: { timeout?: number }
+      ) => number;
+    };
+
+    const idleCallback = nativeGlobal.requestIdleCallback;
+    if (typeof idleCallback === 'function') {
+      return idleCallback(callback, options);
+    }
+  }
+
+  // Polyfill using setTimeout
+  const timeout = options?.timeout || 5000;
+  const start = Date.now();
+
+  const handle = setTimeout(() => {
+    callback({
+      didTimeout: false,
+      timeRemaining: () => Math.max(0, timeout - (Date.now() - start)),
+    });
+  }, 16); // Next animation frame
+
+  return handle as unknown as number;
+}
+
+/**
+ * Cancel polyfilled idle callback
+ */
+export function cancelIdleCallbackPolyfill(handle: number): void {
+  const nativeGlobal = global as unknown as {
+    cancelIdleCallback?: (handle: number) => void;
+  };
+
+  if (
+    supportsIdleCallback() &&
+    typeof nativeGlobal.cancelIdleCallback === 'function'
+  ) {
+    const idleCancelCallback = nativeGlobal.cancelIdleCallback;
+    if (typeof idleCancelCallback === 'function') {
+      idleCancelCallback(handle);
+    }
+  } else {
+    clearTimeout(handle as unknown as ReturnType<typeof setTimeout>);
+  }
+}

package/src/db/DatabaseManager.ts

@@ -0,0 +1,212 @@
+/**
+ * DatabaseManager — the single, centralized owner of the encrypted SQLCipher
+ * connection.
+ *
+ * Responsibilities:
+ *   - Lazily open the encrypted database exactly once (idempotent `init`).
+ *   - Provision the encryption key via the Keystore-backed `secureKey` helper.
+ *   - Run schema migrations on open.
+ *   - Expose small, safe primitives (`exec`, `query`, `transaction`) that the
+ *     repository layer builds on — nothing above this file touches the raw driver.
+ *
+ * The `react-native-sqlcipher` native driver is imported lazily so the bundle
+ * still loads on platforms where it is absent (e.g. web); callers get a clear
+ * error instead of a hard crash at import time.
+ */
+import { Platform } from 'react-native';
+import type {
+  SQLiteDatabase,
+  SQLiteStatic,
+  ResultSet,
+} from 'react-native-sqlcipher';
+import { getDatabaseKey } from './secureKey';
+import { runMigrations, type MigrationExecutor } from './migrations';
+
+const DATABASE_NAME = 'media_secure.db';
+const DATABASE_LOCATION = 'default';
+
+/** A single parameterized statement for {@link DatabaseManager.batch}. */
+export interface BatchStatement {
+  sql: string;
+  params?: any[];
+}
+
+/** Loads the native SQLCipher module lazily. Returns null when unavailable. */
+function loadDriver(): SQLiteStatic | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('react-native-sqlcipher');
+    return (mod?.default ?? mod) as SQLiteStatic;
+  } catch {
+    return null;
+  }
+}
+
+export class DatabaseManager {
+  private db: SQLiteDatabase | null = null;
+  private initPromise: Promise<SQLiteDatabase> | null = null;
+
+  /** True once the encrypted database is open and migrated. */
+  get isReady(): boolean {
+    return this.db !== null;
+  }
+
+  /**
+   * Opens (once) the encrypted database and applies migrations. Concurrent
+   * callers share a single in-flight open, so `init` is safe to call from
+   * multiple screens/hooks simultaneously.
+   */
+  async init(): Promise<SQLiteDatabase> {
+    if (this.db) return this.db;
+    if (this.initPromise) return this.initPromise;
+
+    this.initPromise = this.open()
+      .then((db) => {
+        this.db = db;
+        return db;
+      })
+      .catch((error) => {
+        // Reset so a later attempt can retry from scratch.
+        this.initPromise = null;
+        throw error;
+      });
+
+    return this.initPromise;
+  }
+
+  private async open(): Promise<SQLiteDatabase> {
+    const SQLite = loadDriver();
+    if (!SQLite) {
+      throw new Error(
+        `[DatabaseManager] 'react-native-sqlcipher' is not available on ` +
+          `platform '${Platform.OS}'. Install the package and rebuild the ` +
+          `native app to enable the encrypted media database.`
+      );
+    }
+
+    SQLite.enablePromise(true);
+
+    const key = await getDatabaseKey();
+    const db = await SQLite.openDatabase({
+      name: DATABASE_NAME,
+      key,
+      location: DATABASE_LOCATION,
+    });
+
+    // Pragmas: WAL for concurrent read/write throughput, FK enforcement on.
+    await db.executeSql('PRAGMA foreign_keys = ON;');
+    try {
+      await db.executeSql('PRAGMA journal_mode = WAL;');
+    } catch {
+      // WAL is an optimization; ignore if the platform rejects it.
+    }
+
+    await runMigrations(this.createMigrationExecutor(db));
+
+    return db;
+  }
+
+  /** Ensures the DB is open and returns the live connection. */
+  private async requireDb(): Promise<SQLiteDatabase> {
+    return this.db ?? (await this.init());
+  }
+
+  /**
+   * Executes a write/DDL statement. Returns the raw result set for callers that
+   * need `insertId` / `rowsAffected`.
+   */
+  async exec(sql: string, params: any[] = []): Promise<ResultSet> {
+    const db = await this.requireDb();
+    const [result] = await db.executeSql(sql, params);
+    return result;
+  }
+
+  /** Executes a SELECT and returns the rows as an array of `T`. */
+  async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+    const db = await this.requireDb();
+    const [result] = await db.executeSql(sql, params);
+    const rows: T[] = [];
+    for (let i = 0; i < result.rows.length; i++) {
+      rows.push(result.rows.item(i) as T);
+    }
+    return rows;
+  }
+
+  /** Convenience: SELECT returning the first scalar column of the first row. */
+  async queryScalar<T = number>(
+    sql: string,
+    params: any[] = []
+  ): Promise<T | null> {
+    const rows = await this.query<Record<string, T>>(sql, params);
+    if (rows.length === 0) return null;
+    const first = rows[0]!;
+    const firstKey = Object.keys(first)[0];
+    return firstKey === undefined ? null : first[firstKey]!;
+  }
+
+  /**
+   * Runs a set of statements atomically in a single transaction.
+   *
+   * The `react-native-sqlcipher` driver requires every `executeSql` to be queued
+   * *synchronously* inside the transaction scope, so this takes a pre-built list
+   * of statements rather than an async callback — guaranteeing all-or-nothing
+   * semantics (used by `insertMany` and the migration runner).
+   */
+  async batch(statements: BatchStatement[]): Promise<void> {
+    if (statements.length === 0) return;
+    const db = await this.requireDb();
+    await db.transaction((tx) => {
+      for (const { sql, params } of statements) {
+        tx.executeSql(sql, params ?? []);
+      }
+    });
+  }
+
+  /** Adapts this manager to the migration executor contract. */
+  private createMigrationExecutor(db: SQLiteDatabase): MigrationExecutor {
+    return {
+      getVersion: async () => {
+        const [result] = await db.executeSql('PRAGMA user_version;');
+        const row = result.rows.item(0);
+        return Number(row?.user_version ?? 0);
+      },
+      runBatch: async (statements: string[]) => {
+        await db.transaction((tx) => {
+          for (const sql of statements) {
+            tx.executeSql(sql, []);
+          }
+        });
+      },
+    };
+  }
+
+  /** Closes the connection (e.g. on teardown). Safe to call when not open. */
+  async close(): Promise<void> {
+    const db = this.db;
+    this.db = null;
+    this.initPromise = null;
+    if (db) {
+      try {
+        await db.close();
+      } catch (error) {
+        console.warn('[DatabaseManager] close failed', error);
+      }
+    }
+  }
+}
+
+// Process-wide singleton — every consumer shares one encrypted connection.
+let managerInstance: DatabaseManager | null = null;
+
+/** Returns the shared `DatabaseManager` singleton. */
+export function getDatabaseManager(): DatabaseManager {
+  if (!managerInstance) {
+    managerInstance = new DatabaseManager();
+  }
+  return managerInstance;
+}
+
+/** Opens + migrates the encrypted database. Call once at app startup. */
+export async function initializeMediaDatabase(): Promise<void> {
+  await getDatabaseManager().init();
+}