react-native-ensys-camera-x 1.0.7

package/src/deviceCapabilities.ts

@@ -0,0 +1,438 @@
+/**
+ * Device capability detection for optimization
+ */
+
+import { Platform, Dimensions, PixelRatio } from 'react-native';
+import NativeCustomCamera from './NativeCustomCamera';
+
+export interface DeviceSpecs {
+  ram: 'low' | 'medium' | 'high';
+  processor: 'weak' | 'medium' | 'strong';
+  isLowEnd: boolean;
+  totalRamMb?: number;
+  availableRamMb?: number;
+  cpuCores?: number;
+}
+
+/**
+ * Default device specs (conservative for low-end optimization)
+ */
+const DEFAULT_LOW_END_SPEC: DeviceSpecs = {
+  ram: 'low',
+  processor: 'weak',
+  isLowEnd: true,
+};
+
+/** Shape returned by the native getDeviceCapabilities() method (Android). */
+interface NativeDeviceCapabilities {
+  isLowRamDevice?: boolean;
+  memoryClassMb?: number;
+  totalRamMb?: number;
+  availableRamMb?: number;
+  isCurrentlyLowMemory?: boolean;
+  cpuCores?: number;
+}
+
+/**
+ * Classify from REAL memory facts (Android: ActivityManager via the native
+ * module). Thresholds follow Android's own tiers: isLowRamDevice is the OS's
+ * declaration (Go edition / 1-2GB), ≤3GB total RAM or a ≤192MB app heap is
+ * treated as low, ≤6GB as medium, above that as high.
+ */
+function classifyFromNativeCaps(caps: NativeDeviceCapabilities): DeviceSpecs {
+  const totalRamMb = caps.totalRamMb ?? 0;
+  const memoryClassMb = caps.memoryClassMb ?? 0;
+  const cpuCores = caps.cpuCores ?? 4;
+
+  const isLow =
+    caps.isLowRamDevice === true ||
+    (totalRamMb > 0 && totalRamMb <= 3 * 1024) ||
+    (memoryClassMb > 0 && memoryClassMb <= 192);
+
+  const isHigh = !isLow && totalRamMb > 6 * 1024 && cpuCores >= 8;
+
+  return {
+    ram: isLow ? 'low' : isHigh ? 'high' : 'medium',
+    processor: cpuCores <= 4 ? 'weak' : cpuCores <= 6 ? 'medium' : 'strong',
+    isLowEnd: isLow,
+    totalRamMb: totalRamMb > 0 ? Math.round(totalRamMb) : undefined,
+    availableRamMb:
+      caps.availableRamMb != null && caps.availableRamMb > 0
+        ? Math.round(caps.availableRamMb)
+        : undefined,
+    cpuCores,
+  };
+}
+
+/**
+ * Detect device capabilities.
+ *
+ * On Android this asks the native module for ground truth (ActivityManager:
+ * isLowRamDevice / memoryClass / totalMem / availMem + CPU core count) and
+ * classifies from that. The screen-size heuristic remains only as a fallback
+ * for environments without the native module (web, tests, remote debugging).
+ */
+export async function detectDeviceCapabilities(): Promise<DeviceSpecs> {
+  if (Platform.OS === 'android') {
+    try {
+      const caps = (await NativeCustomCamera.getDeviceCapabilities()) as
+        | NativeDeviceCapabilities
+        | null
+        | undefined;
+      if (caps && (caps.totalRamMb || caps.memoryClassMb || caps.cpuCores)) {
+        return classifyFromNativeCaps(caps);
+      }
+    } catch {
+      // Native module unavailable (web/stub/tests) — fall through to heuristic.
+    }
+  }
+  return detectFromScreenHeuristic();
+}
+
+/**
+ * Screen-size fallback used when real memory facts are unavailable. NOTE: this
+ * can only guess. The previous version classified EVERY non-tablet Android
+ * phone as low-end (`!isTablet` in an OR chain), which pinned flagship phones
+ * to the most aggressive degradations; small-or-low-DPI screens are now the
+ * only low-end signals, and the default is a safe middle tier.
+ */
+async function detectFromScreenHeuristic(): Promise<DeviceSpecs> {
+  try {
+    const { width, height } = Dimensions.get('window');
+    const screenArea = width * height;
+    const pixelRatio = PixelRatio.get();
+
+    if (Platform.OS === 'android') {
+      const isLowEndAndroid = screenArea < 800000 || pixelRatio < 2;
+
+      if (isLowEndAndroid) {
+        return {
+          ram: 'low',
+          processor: 'weak',
+          isLowEnd: true,
+          totalRamMb: 1536, // Assume 1.5GB
+          availableRamMb: 384, // Assume 384MB available
+          cpuCores: 2,
+        };
+      }
+
+      // Mid-range Android device
+      return {
+        ram: 'medium',
+        processor: 'medium',
+        isLowEnd: false,
+        totalRamMb: 3072, // Assume 3GB
+        availableRamMb: 768, // Assume 768MB available
+        cpuCores: 6,
+      };
+    }
+
+    // iOS detection with more granularity
+    if (Platform.OS === 'ios') {
+      const isOlderDevice = screenArea < 1000000 || pixelRatio < 2;
+
+      if (isOlderDevice) {
+        return {
+          ram: 'medium',
+          processor: 'medium',
+          isLowEnd: false,
+          totalRamMb: 2048, // Assume 2GB
+          availableRamMb: 896, // Assume 896MB available
+          cpuCores: 4,
+        };
+      }
+
+      // Newer iOS device
+      return {
+        ram: 'high',
+        processor: 'strong',
+        isLowEnd: false,
+        totalRamMb: 4096, // Assume 4GB
+        availableRamMb: 1536, // Assume 1.5GB available
+        cpuCores: 6,
+      };
+    }
+
+    // Fallback for other platforms
+    return {
+      ram: 'medium',
+      processor: 'medium',
+      isLowEnd: false,
+      totalRamMb: 2048,
+      availableRamMb: 768,
+      cpuCores: 4,
+    };
+  } catch {
+    // Fallback to conservative defaults
+    return DEFAULT_LOW_END_SPEC;
+  }
+}
+
+/**
+ * Check if device is low-end
+ */
+export function isLowEndDevice(deviceSpecs: DeviceSpecs): boolean {
+  return (
+    deviceSpecs.isLowEnd ||
+    deviceSpecs.ram === 'low' ||
+    deviceSpecs.processor === 'weak'
+  );
+}
+
+/**
+ * Get optimization level based on device specs
+ */
+export function getOptimizationLevel(
+  deviceSpecs: DeviceSpecs
+): 'aggressive' | 'moderate' | 'none' {
+  if (isLowEndDevice(deviceSpecs)) {
+    return 'aggressive';
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return 'moderate';
+  }
+
+  return 'none';
+}
+
+/**
+ * Get memory optimization settings
+ */
+export function getMemorySettings(deviceSpecs: DeviceSpecs): {
+  maxCacheSizeMb: number;
+  batchSize: number;
+  concurrentOperations: number;
+} {
+  if (isLowEndDevice(deviceSpecs)) {
+    return {
+      maxCacheSizeMb: 20, // 20MB cache
+      batchSize: 2, // Small batches
+      concurrentOperations: 1, // No parallel operations
+    };
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return {
+      maxCacheSizeMb: 50, // 50MB cache
+      batchSize: 3, // Medium batches
+      concurrentOperations: 2, // Limited parallelism
+    };
+  }
+
+  return {
+    maxCacheSizeMb: 100, // 100MB cache
+    batchSize: 5, // Larger batches
+    concurrentOperations: 3, // More parallelism
+  };
+}
+
+/**
+ * Get CPU optimization settings
+ */
+export function getCpuSettings(deviceSpecs: DeviceSpecs): {
+  debounceMs: number;
+  throttleMs: number;
+  maxConcurrent: number;
+  useIdleCallback: boolean;
+} {
+  if (isLowEndDevice(deviceSpecs)) {
+    return {
+      debounceMs: 500, // Longer debounce
+      throttleMs: 1000, // Longer throttle
+      maxConcurrent: 1, // No parallel operations
+      useIdleCallback: true, // Use idle callbacks
+    };
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return {
+      debounceMs: 300, // Moderate debounce
+      throttleMs: 500, // Moderate throttle
+      maxConcurrent: 2, // Limited parallelism
+      useIdleCallback: true, // Use idle callbacks
+    };
+  }
+
+  return {
+    debounceMs: 200, // Shorter debounce
+    throttleMs: 300, // Shorter throttle
+    maxConcurrent: 3, // More parallelism
+    useIdleCallback: false, // Don't need idle callbacks
+  };
+}
+
+/**
+ * Get rendering optimization settings
+ */
+export function getRenderingSettings(deviceSpecs: DeviceSpecs): {
+  initialNumToRender: number;
+  maxToRenderPerBatch: number;
+  windowSize: number;
+  useAnimations: boolean;
+  useComplexEffects: boolean;
+} {
+  if (isLowEndDevice(deviceSpecs)) {
+    return {
+      initialNumToRender: 5, // Render fewer initially
+      maxToRenderPerBatch: 3, // Add fewer per batch
+      windowSize: 7, // Smaller window
+      useAnimations: false, // Skip animations
+      useComplexEffects: false, // Skip complex effects
+    };
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return {
+      initialNumToRender: 8, // Moderate initial render
+      maxToRenderPerBatch: 5, // Moderate batch size
+      windowSize: 10, // Moderate window
+      useAnimations: true, // Use animations
+      useComplexEffects: false, // Skip complex effects
+    };
+  }
+
+  return {
+    initialNumToRender: 12, // Render more initially
+    maxToRenderPerBatch: 8, // Larger batches
+    windowSize: 15, // Larger window
+    useAnimations: true, // Use animations
+    useComplexEffects: true, // Use complex effects
+  };
+}
+
+/**
+ * Get network optimization settings
+ */
+export function getNetworkSettings(deviceSpecs: DeviceSpecs): {
+  maxConcurrentUploads: number;
+  chunkSize: number;
+  compressionQuality: number;
+  retryCount: number;
+  useWiFiOnly: boolean;
+} {
+  if (isLowEndDevice(deviceSpecs)) {
+    return {
+      maxConcurrentUploads: 1, // One at a time
+      chunkSize: 1, // Small chunks
+      compressionQuality: 0.6, // More compression
+      retryCount: 2, // Fewer retries
+      useWiFiOnly: true, // WiFi only for large uploads
+    };
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return {
+      maxConcurrentUploads: 2, // Limited parallelism
+      chunkSize: 2, // Medium chunks
+      compressionQuality: 0.7, // Moderate compression
+      retryCount: 3, // Standard retries
+      useWiFiOnly: false, // Allow cellular
+    };
+  }
+
+  return {
+    maxConcurrentUploads: 3, // More parallelism
+    chunkSize: 3, // Larger chunks
+    compressionQuality: 0.8, // Less compression
+    retryCount: 3, // Standard retries
+    useWiFiOnly: false, // Allow cellular
+  };
+}
+
+/**
+ * Get image quality settings based on device
+ */
+export function getImageQualitySettings(deviceSpecs: DeviceSpecs): {
+  maxDimension: number;
+  compressionQuality: number;
+  previewQuality: 'low' | 'medium' | 'high';
+} {
+  if (isLowEndDevice(deviceSpecs)) {
+    return {
+      maxDimension: 800, // 800px max
+      compressionQuality: 0.99, // 99% quality
+      previewQuality: 'low', // Low quality previews
+    };
+  }
+
+  if (deviceSpecs.ram === 'medium' || deviceSpecs.processor === 'medium') {
+    return {
+      maxDimension: 1200, // 1200px max
+      compressionQuality: 0.8, // 80% quality
+      previewQuality: 'medium', // Medium quality previews
+    };
+  }
+
+  return {
+    maxDimension: 2048, // 2048px max (2K)
+    compressionQuality: 0.9, // 90% quality
+    previewQuality: 'high', // High quality previews
+  };
+}
+
+/**
+ * Check if device specs indicate a specific optimization should be used
+ */
+export function shouldUseOptimization(
+  deviceSpecs: DeviceSpecs,
+  _optimization: 'memory' | 'cpu' | 'rendering' | 'network'
+): boolean {
+  if (!isLowEndDevice(deviceSpecs)) {
+    return false; // Only optimize for low-end devices
+  }
+
+  // All optimizations should be used for low-end devices
+  return true;
+}
+
+/**
+ * Create optimized configuration based on device specs
+ */
+export function createOptimizedConfig(deviceSpecs: DeviceSpecs): {
+  memory: ReturnType<typeof getMemorySettings>;
+  cpu: ReturnType<typeof getCpuSettings>;
+  rendering: ReturnType<typeof getRenderingSettings>;
+  network: ReturnType<typeof getNetworkSettings>;
+  images: ReturnType<typeof getImageQualitySettings>;
+} {
+  return {
+    memory: getMemorySettings(deviceSpecs),
+    cpu: getCpuSettings(deviceSpecs),
+    rendering: getRenderingSettings(deviceSpecs),
+    network: getNetworkSettings(deviceSpecs),
+    images: getImageQualitySettings(deviceSpecs),
+  };
+}
+
+/**
+ * Fallback device specs for testing
+ */
+export function createTestDeviceSpecs(
+  type: 'low' | 'medium' | 'high' = 'low'
+): DeviceSpecs {
+  switch (type) {
+    case 'medium':
+      return {
+        ram: 'medium',
+        processor: 'medium',
+        isLowEnd: false,
+        totalRamMb: 3072,
+        availableRamMb: 1024,
+        cpuCores: 6,
+      };
+
+    case 'high':
+      return {
+        ram: 'high',
+        processor: 'strong',
+        isLowEnd: false,
+        totalRamMb: 6144,
+        availableRamMb: 2048,
+        cpuCores: 8,
+      };
+
+    default:
+      return DEFAULT_LOW_END_SPEC;
+  }
+}