react-native-ensys-camera-x 1.0.7

package/src/mediaStorageService.ts

@@ -0,0 +1,546 @@
+import { Platform } from 'react-native';
+import { getMediaStorageManager } from './storage';
+import type { CameraAsset, StoredMediaMetadata } from './types';
+import { validateSecureUri, validateFileContentType } from './security';
+import { MemoryManager } from './memory';
+
+/**
+ * Media Storage Service - Complete media lifecycle management
+ * Handles capture -> cache -> publish workflow with automatic cleanup
+ */
+export class MediaStorageService {
+  private storageManager = getMediaStorageManager();
+  private memoryManager = new MemoryManager();
+  private isInitialized = false;
+
+  /**
+   * Initialize the media storage service
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) return;
+
+    try {
+      await this.storageManager.initialize();
+      this.isInitialized = true;
+
+      // Set up periodic cleanup for low-end devices
+      if (Platform.OS === 'android') {
+        this.setupPeriodicCleanup();
+      }
+    } catch (error) {
+      console.error('[MediaStorageService] Initialization failed:', error);
+      throw new Error(`Failed to initialize media storage service: ${error}`);
+    }
+  }
+
+  /**
+   * Set up periodic cleanup for Android devices
+   */
+  private setupPeriodicCleanup(): void {
+    // This would be implemented with native modules for background tasks
+    // For now, we'll just log the setup
+    console.log('[MediaStorageService] Periodic cleanup scheduled for Android');
+  }
+
+  /**
+   * Handle media capture - automatically stores in cache
+   */
+  async handleMediaCapture(
+    mediaAssets: CameraAsset[],
+    options: {
+      autoPublish?: boolean;
+      moveMode?: boolean;
+      cleanupThresholdMB?: number;
+    } = {}
+  ): Promise<{
+    success: boolean;
+    cachedAssets: CameraAsset[];
+    publishedAssets?: CameraAsset[];
+    error?: string;
+  }> {
+    try {
+      if (!this.isInitialized) {
+        await this.initialize();
+      }
+
+      const {
+        autoPublish = false,
+        moveMode = true,
+        cleanupThresholdMB = 400,
+      } = options;
+
+      // Validate all media assets
+      const validatedAssets = await this.validateMediaAssets(mediaAssets);
+      if (validatedAssets.length === 0) {
+        return {
+          success: false,
+          cachedAssets: [],
+          error: 'No valid media assets',
+        };
+      }
+
+      // Add cache metadata to assets
+      const cachedAssets = validatedAssets.map((asset) => ({
+        ...asset,
+        cachePath: asset.uri, // Initially stored in cache
+        isCached: true,
+        cacheCreatedAt: Date.now(),
+        cacheLastModified: Date.now(),
+        storageLocation: 'cache' as const,
+        storageStatus: 'cached' as const,
+      }));
+
+      // Check if auto-publish is requested
+      if (autoPublish) {
+        const publishResults = await this.publishCachedMedia(
+          cachedAssets.map((asset) => asset.id),
+          { moveMode }
+        );
+
+        const publishedAssets = publishResults.results
+          .filter((r) => r.success)
+          .map((result) => {
+            const originalAsset = cachedAssets.find(
+              (a) => a.id === result.mediaId
+            );
+            return originalAsset
+              ? {
+                  ...originalAsset,
+                  uri: result.targetUri || originalAsset.uri,
+                  storageLocation: 'document' as const,
+                  storageStatus: 'published' as const,
+                  documentUri: result.targetUri,
+                  publishedAt: Date.now(),
+                }
+              : originalAsset;
+          })
+          .filter(Boolean) as CameraAsset[];
+
+        return {
+          success: true,
+          cachedAssets,
+          publishedAssets,
+        };
+      }
+
+      // Check if cleanup is needed
+      await this.checkAndCleanupCache(cleanupThresholdMB);
+
+      return {
+        success: true,
+        cachedAssets,
+      };
+    } catch (error) {
+      console.error(
+        '[MediaStorageService] Media capture handling failed:',
+        error
+      );
+      return {
+        success: false,
+        cachedAssets: [],
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  /**
+   * Validate media assets before processing
+   */
+  private async validateMediaAssets(
+    assets: CameraAsset[]
+  ): Promise<CameraAsset[]> {
+    const validated: CameraAsset[] = [];
+
+    for (const asset of assets) {
+      try {
+        // Validate URI format
+        if (!validateSecureUri(asset.uri)) {
+          console.warn(
+            `[MediaStorageService] Invalid URI for asset ${asset.id}`
+          );
+          continue;
+        }
+
+        // Validate file type based on extension
+        const isValidType = asset.type === 'photo' || asset.type === 'video';
+        if (!isValidType) {
+          console.warn(
+            `[MediaStorageService] Invalid media type for asset ${asset.id}`
+          );
+          continue;
+        }
+
+        // Validate file content type if available
+        if (asset.mimeType && !validateFileContentType(asset.mimeType)) {
+          console.warn(
+            `[MediaStorageService] Invalid mime type for asset ${asset.id}`
+          );
+          continue;
+        }
+
+        validated.push(asset);
+      } catch (error) {
+        console.warn(
+          `[MediaStorageService] Validation failed for asset ${asset.id}:`,
+          error
+        );
+      }
+    }
+
+    return validated;
+  }
+
+  /**
+   * Publish cached media to document directory
+   */
+  async publishCachedMedia(
+    mediaIds: string[],
+    options: {
+      moveMode?: boolean;
+      retryFailed?: boolean;
+    } = {}
+  ): Promise<{
+    success: boolean;
+    results: Array<{
+      mediaId: string;
+      success: boolean;
+      targetUri?: string;
+      error?: string;
+    }>;
+    totalCount: number;
+    successCount: number;
+    failureCount: number;
+  }> {
+    try {
+      const { moveMode = true, retryFailed = true } = options;
+
+      // First try to publish the media
+      const publishResult = await this.storageManager.publishBatch(mediaIds, {
+        moveMode,
+      });
+
+      // If there are failures and retry is enabled, try to retry
+      let finalResults = publishResult.results;
+      if (retryFailed && publishResult.failureCount > 0) {
+        const failedMediaIds = publishResult.results
+          .filter((r) => !r.success)
+          .map((r) => r.mediaId);
+
+        if (failedMediaIds.length > 0) {
+          const retryResults = await this.storageManager.retryFailedTransfers();
+
+          // Merge retry results with original results
+          finalResults = publishResult.results.map((originalResult) => {
+            const retryResult = retryResults.find(
+              (r) => r.mediaId === originalResult.mediaId
+            );
+            return retryResult || originalResult;
+          });
+        }
+      }
+
+      return {
+        success: publishResult.successCount > 0,
+        results: finalResults.map((result) => ({
+          mediaId: result.mediaId,
+          success: result.success,
+          targetUri: result.targetUri,
+          error: result.error?.message,
+        })),
+        totalCount: publishResult.totalCount,
+        successCount: publishResult.successCount,
+        failureCount: publishResult.failureCount,
+      };
+    } catch (error) {
+      console.error(
+        '[MediaStorageService] Publish cached media failed:',
+        error
+      );
+      return {
+        success: false,
+        results: mediaIds.map((mediaId) => ({
+          mediaId,
+          success: false,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        })),
+        totalCount: mediaIds.length,
+        successCount: 0,
+        failureCount: mediaIds.length,
+      };
+    }
+  }
+
+  /**
+   * Check cache size and cleanup if needed
+   */
+  async checkAndCleanupCache(thresholdMB: number = 400): Promise<{
+    cleanupPerformed: boolean;
+    filesRemoved?: number;
+    spaceFreedMB?: number;
+  }> {
+    try {
+      const stats = await this.storageManager.getStorageStats();
+
+      if (stats.cacheUsedMB > thresholdMB) {
+        console.log(
+          `[MediaStorageService] Cache exceeds threshold (${stats.cacheUsedMB}MB > ${thresholdMB}MB), cleaning up...`
+        );
+
+        const cleanupResult = await this.storageManager.cleanupOldCache(3); // Clean files older than 3 days
+
+        return {
+          cleanupPerformed: true,
+          filesRemoved: cleanupResult.filesRemoved,
+          spaceFreedMB: cleanupResult.spaceFreedMB,
+        };
+      }
+
+      return { cleanupPerformed: false };
+    } catch (error) {
+      console.error('[MediaStorageService] Cache cleanup check failed:', error);
+      return { cleanupPerformed: false };
+    }
+  }
+
+  /**
+   * Get all cached media with enhanced metadata
+   */
+  async getCachedMedia(): Promise<CameraAsset[]> {
+    try {
+      const cachedMedia = await this.storageManager.getCachedMedia();
+      return cachedMedia.map((media) => this.enhanceMediaMetadata(media));
+    } catch (error) {
+      console.error('[MediaStorageService] Get cached media failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get all published media with enhanced metadata
+   */
+  async getPublishedMedia(): Promise<CameraAsset[]> {
+    try {
+      const publishedMedia = await this.storageManager.getPublishedMedia();
+      return publishedMedia.map((media) => this.enhanceMediaMetadata(media));
+    } catch (error) {
+      console.error('[MediaStorageService] Get published media failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Enhance media metadata with additional computed properties
+   */
+  private enhanceMediaMetadata(media: StoredMediaMetadata): CameraAsset {
+    const enhanced: CameraAsset = {
+      ...media,
+      // Add computed properties
+      needsThumbnail:
+        media.type === 'video' ||
+        (media.width !== undefined && media.width > 2000),
+      // Ensure all required properties are present
+      id: media.id,
+      uri: media.uri || media.cachePath || media.documentUri || '',
+      type: media.type || 'photo',
+      fileName:
+        media.fileName ||
+        `media_${media.id}.${media.type === 'video' ? 'mp4' : 'jpg'}`,
+      dateTaken: media.dateTaken || media.cacheCreatedAt || Date.now(),
+    };
+
+    return enhanced;
+  }
+
+  /**
+   * Delete media from storage
+   */
+  async deleteMedia(mediaId: string): Promise<boolean> {
+    try {
+      return await this.storageManager.deleteMedia(mediaId);
+    } catch (error) {
+      console.error('[MediaStorageService] Delete media failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get comprehensive storage statistics
+   */
+  async getStorageStatistics(): Promise<{
+    cacheUsage: {
+      count: number;
+      sizeMB: number;
+      percentageFull: number;
+    };
+    documentUsage: {
+      count: number;
+      sizeMB: number;
+    };
+    totalAvailableMB: number;
+    needsCleanup: boolean;
+    duplicatesCount: number;
+  }> {
+    try {
+      const stats = await this.storageManager.getStorageStats();
+
+      const percentageFull =
+        stats.cacheUsedMB > 0 && stats.totalAvailableMB > 0
+          ? Math.round(
+              (stats.cacheUsedMB /
+                (stats.cacheUsedMB + stats.totalAvailableMB)) *
+                100
+            )
+          : 0;
+
+      return {
+        cacheUsage: {
+          count: stats.cachedItemsCount,
+          sizeMB: Math.round(stats.cacheUsedMB),
+          percentageFull,
+        },
+        documentUsage: {
+          count: stats.publishedItemsCount,
+          sizeMB: Math.round(stats.documentUsedMB),
+        },
+        totalAvailableMB: Math.round(stats.totalAvailableMB),
+        needsCleanup: percentageFull > 75,
+        duplicatesCount: stats.duplicateItemsCount,
+      };
+    } catch (error) {
+      console.error(
+        '[MediaStorageService] Get storage statistics failed:',
+        error
+      );
+      return {
+        cacheUsage: { count: 0, sizeMB: 0, percentageFull: 0 },
+        documentUsage: { count: 0, sizeMB: 0 },
+        totalAvailableMB: 0,
+        needsCleanup: false,
+        duplicatesCount: 0,
+      };
+    }
+  }
+
+  /**
+   * Get failed transfer operations that can be retried
+   */
+  async getFailedTransfers(): Promise<
+    Array<{
+      mediaId: string;
+      error: string;
+      retryCount: number;
+      originalUri?: string;
+    }>
+  > {
+    try {
+      const failed = await this.storageManager.getFailedTransfers();
+      return failed.map((f) => ({
+        mediaId: f.mediaId,
+        error: f.error,
+        retryCount: f.retryCount,
+      }));
+    } catch (error) {
+      console.error(
+        '[MediaStorageService] Get failed transfers failed:',
+        error
+      );
+      return [];
+    }
+  }
+
+  /**
+   * Clean up the service - release resources
+   */
+  cleanup(): void {
+    this.memoryManager.clear();
+    console.log('[MediaStorageService] Service cleaned up');
+  }
+}
+
+// Singleton instance
+let serviceInstance: MediaStorageService | null = null;
+
+/**
+ * Get the media storage service instance
+ */
+export function getMediaStorageService(): MediaStorageService {
+  if (!serviceInstance) {
+    serviceInstance = new MediaStorageService();
+  }
+  return serviceInstance;
+}
+
+/**
+ * Quick access functions for common operations
+ */
+export async function initializeMediaStorageService(): Promise<void> {
+  const service = getMediaStorageService();
+  await service.initialize();
+}
+
+export async function handleCapturedMedia(
+  assets: CameraAsset[],
+  options?: {
+    autoPublish?: boolean;
+    moveMode?: boolean;
+    cleanupThresholdMB?: number;
+  }
+): Promise<{
+  success: boolean;
+  cachedAssets: CameraAsset[];
+  publishedAssets?: CameraAsset[];
+  error?: string;
+}> {
+  const service = getMediaStorageService();
+  return service.handleMediaCapture(assets, options);
+}
+
+export async function publishAllCachedMedia(options?: {
+  moveMode?: boolean;
+  retryFailed?: boolean;
+}): Promise<{
+  success: boolean;
+  results: Array<{
+    mediaId: string;
+    success: boolean;
+    targetUri?: string;
+    error?: string;
+  }>;
+  totalCount: number;
+  successCount: number;
+  failureCount: number;
+}> {
+  const service = getMediaStorageService();
+  const cachedMedia = await service.getCachedMedia();
+  const mediaIds = cachedMedia.map((media) => media.id);
+
+  if (mediaIds.length === 0) {
+    return {
+      success: false,
+      results: [],
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+    };
+  }
+
+  return service.publishCachedMedia(mediaIds, options);
+}
+
+export async function getStorageSummary(): Promise<{
+  cacheUsage: {
+    count: number;
+    sizeMB: number;
+    percentageFull: number;
+  };
+  documentUsage: {
+    count: number;
+    sizeMB: number;
+  };
+  totalAvailableMB: number;
+  needsCleanup: boolean;
+  duplicatesCount: number;
+}> {
+  const service = getMediaStorageService();
+  return service.getStorageStatistics();
+}

package/src/memory.ts

@@ -0,0 +1,102 @@
+export class MemoryManager {
+  private readonly store = new Map<string, unknown>();
+  private readonly maxSize: number;
+  private currentSize = 0;
+
+  constructor(maxSizeMB = 50) {
+    this.maxSize = maxSizeMB * 1024 * 1024; // Convert MB to bytes
+  }
+
+  set(key: string, value: unknown): void {
+    // Estimate size of the value
+    const size = this.estimateSize(value);
+
+    // Check if we need to evict items to make space
+    while (this.currentSize + size > this.maxSize && this.store.size > 0) {
+      const oldestKey = this.store.keys().next().value;
+      if (oldestKey === undefined) break;
+      const oldestValue = this.store.get(oldestKey);
+      if (oldestValue !== undefined) {
+        this.currentSize -= this.estimateSize(oldestValue);
+        this.store.delete(oldestKey);
+      }
+    }
+
+    this.store.set(key, value);
+    this.currentSize += size;
+  }
+
+  get(key: string): unknown | undefined {
+    const value = this.store.get(key);
+    return value;
+  }
+
+  delete(key: string): void {
+    const value = this.store.get(key);
+    if (value !== undefined) {
+      this.currentSize -= this.estimateSize(value);
+    }
+    this.store.delete(key);
+  }
+
+  clear(): void {
+    this.store.clear();
+    this.currentSize = 0;
+  }
+
+  get size(): number {
+    return this.currentSize;
+  }
+
+  get capacity(): number {
+    return this.maxSize;
+  }
+
+  get usageRatio(): number {
+    return this.currentSize / this.maxSize;
+  }
+
+  private estimateSize(value: unknown): number {
+    if (value === null || value === undefined) return 0;
+
+    if (typeof value === 'string') return value.length * 2; // Approximate string size in bytes
+    if (typeof value === 'number') return 8; // Approximate number size
+    if (typeof value === 'boolean') return 4;
+
+    if (Array.isArray(value)) {
+      return value.reduce((sum, item) => sum + this.estimateSize(item), 0);
+    }
+
+    if (typeof value === 'object') {
+      return Object.values(value).reduce(
+        (sum, item) => sum + this.estimateSize(item),
+        0
+      );
+    }
+
+    return 100; // Default size for other types
+  }
+}
+
+export class WeakCache<K extends object, V> {
+  private readonly store = new WeakMap<K, V>();
+
+  set(key: K, value: V): void {
+    this.store.set(key, value);
+  }
+
+  get(key: K): V | undefined {
+    return this.store.get(key);
+  }
+}
+
+export async function processMediaInChunksMemory<T>(
+  items: T[],
+  batchSize = 10,
+  processor: (chunk: T[]) => Promise<void> | void
+): Promise<void> {
+  for (let index = 0; index < items.length; index += batchSize) {
+    const chunk = items.slice(index, index + batchSize);
+    await processor(chunk);
+  }
+}