react-native-ensys-camera-x 1.0.7

package/src/storage.ts

@@ -0,0 +1,453 @@
+/**
+ * Media Storage Module - Bridges React Native with native media storage workflow
+ *
+ * Provides a complete API for managing media lifecycle:
+ * 1. Capture/select media -> stored in cache
+ * 2. User sends/publishes -> moved to documents
+ * 3. Persistent metadata tracking
+ * 4. Automatic cleanup and duplicate detection
+ */
+
+import { NativeModules } from 'react-native';
+import type {
+  StoredMediaMetadata,
+  MediaPublishResult,
+  CleanupResult,
+  StorageStats,
+  MediaStorageLocation,
+} from './types';
+
+const { CustomCamera } = NativeModules;
+
+/**
+ * Media Storage Manager - High-level API for media storage operations
+ */
+class MediaStorageManager {
+  private initialized = false;
+
+  /**
+   * Initialize the media storage workflow
+   * Call this once when the app starts
+   */
+  async initialize(): Promise<{ success: boolean; message?: string }> {
+    try {
+      if (this.initialized) {
+        return { success: true };
+      }
+
+      const result = await CustomCamera.initializeMediaStorage();
+      this.initialized = result.success;
+      return result;
+    } catch (error) {
+      console.error('[MediaStorage] Initialization failed', error);
+      throw new Error(`Failed to initialize media storage: ${error}`);
+    }
+  }
+
+  /**
+   * Publish media from cache to document directory
+   * Moves file if moveMode=true, copies if false
+   */
+  async publishMedia(
+    mediaId: string,
+    options?: {
+      moveMode?: boolean; // true = move, false = copy (default: true)
+    }
+  ): Promise<MediaPublishResult> {
+    try {
+      const moveMode = options?.moveMode ?? true;
+      const result = await CustomCamera.publishMedia(mediaId, moveMode);
+
+      return {
+        success: result.success,
+        mediaId: result.mediaId,
+        sourceLocation: 'cache',
+        targetLocation: 'document',
+        sourceUri: '',
+        targetUri: result.targetUri,
+        fileHash: result.fileHash,
+        movedAt: Date.now(),
+        error: result.error
+          ? { code: 'PUBLISH_ERROR', message: result.error }
+          : undefined,
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Publish failed', error);
+      return {
+        success: false,
+        mediaId,
+        sourceLocation: 'cache',
+        targetLocation: 'document',
+        sourceUri: '',
+        movedAt: Date.now(),
+        error: {
+          code: 'PUBLISH_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error',
+        },
+      };
+    }
+  }
+
+  /**
+   * Publish multiple media files in batch
+   */
+  async publishBatch(
+    mediaIds: string[],
+    options?: {
+      moveMode?: boolean;
+    }
+  ): Promise<{
+    totalCount: number;
+    successCount: number;
+    failureCount: number;
+    results: MediaPublishResult[];
+  }> {
+    try {
+      const moveMode = options?.moveMode ?? true;
+      const result = await CustomCamera.publishBatch(mediaIds, moveMode);
+
+      return {
+        totalCount: result.totalCount,
+        successCount: result.successCount,
+        failureCount: result.failureCount,
+        results: mediaIds.map((id) => ({
+          success: id in (result.results || {}),
+          mediaId: id,
+          sourceLocation: 'cache',
+          targetLocation: 'document',
+          sourceUri: '',
+          movedAt: Date.now(),
+        })),
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Batch publish failed', error);
+      throw new Error(`Failed to publish batch: ${error}`);
+    }
+  }
+
+  /**
+   * Get all cached media (not yet published)
+   */
+  async getCachedMedia(): Promise<StoredMediaMetadata[]> {
+    try {
+      const result = await CustomCamera.getCachedMedia();
+      return result.map((item: any) => ({
+        id: item.id,
+        fileName: item.fileName,
+        uri: item.cachePath || '',
+        type: item.fileType === 'video' ? 'video' : 'photo',
+        size: item.fileSize,
+        width: item.width,
+        height: item.height,
+        duration: item.duration,
+        dateTaken: item.cacheCreatedAt,
+        storageLocation: 'cache' as MediaStorageLocation,
+        storageStatus: 'cached',
+        cacheCreatedAt: item.cacheCreatedAt,
+        cacheLastModified: item.cacheLastModified,
+        isEdited: false,
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Get cached media failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get all published media
+   */
+  async getPublishedMedia(): Promise<StoredMediaMetadata[]> {
+    try {
+      const result = await CustomCamera.getPublishedMedia();
+      return result.map((item: any) => ({
+        id: item.id,
+        fileName: item.fileName,
+        uri: item.documentUri || '',
+        type: item.fileType === 'video' ? 'video' : 'photo',
+        size: item.fileSize,
+        width: item.width,
+        height: item.height,
+        duration: item.duration,
+        dateTaken: item.publishedAt,
+        documentUri: item.documentUri,
+        storageLocation: 'document' as MediaStorageLocation,
+        storageStatus: 'published',
+        cacheCreatedAt: item.cacheCreatedAt,
+        cacheLastModified: item.cacheLastModified,
+        publishedAt: item.publishedAt,
+        isEdited: false,
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Get published media failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get storage statistics
+   */
+  async getStorageStats(): Promise<StorageStats> {
+    try {
+      const stats = await CustomCamera.getStorageStats();
+      return {
+        cacheUsedMB: stats.cacheUsedMB || 0,
+        documentUsedMB: stats.documentUsedMB || 0,
+        totalAvailableMB: stats.totalAvailableMB || 0,
+        cachedItemsCount: stats.cachedItemsCount || 0,
+        publishedItemsCount: stats.publishedItemsCount || 0,
+        duplicateItemsCount: stats.duplicateItemsCount || 0,
+        oldestCacheItemAge: stats.oldestCacheItemAge || 0,
+        newestCacheItemAge: stats.newestCacheItemAge || 0,
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Get storage stats failed', error);
+      return {
+        cacheUsedMB: 0,
+        documentUsedMB: 0,
+        totalAvailableMB: 0,
+        cachedItemsCount: 0,
+        publishedItemsCount: 0,
+        duplicateItemsCount: 0,
+        oldestCacheItemAge: 0,
+        newestCacheItemAge: 0,
+      };
+    }
+  }
+
+  /**
+   * Cleanup old cache files
+   */
+  async cleanupOldCache(olderThanDays: number = 7): Promise<CleanupResult> {
+    try {
+      const result = await CustomCamera.cleanupOldCache(olderThanDays);
+      return {
+        success: result.success,
+        filesRemoved: result.filesRemoved,
+        spaceFreedMB: result.spaceFreedMB,
+        erroredFiles: [],
+        timestamp: Date.now(),
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Cleanup failed', error);
+      return {
+        success: false,
+        filesRemoved: 0,
+        spaceFreedMB: 0,
+        erroredFiles: [],
+        timestamp: Date.now(),
+      };
+    }
+  }
+
+  /**
+   * Delete a specific media
+   */
+  async deleteMedia(mediaId: string): Promise<boolean> {
+    try {
+      return await CustomCamera.deleteStoredMedia(mediaId);
+    } catch (error) {
+      console.error('[MediaStorage] Delete media failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get failed transfers that can be retried
+   */
+  async getFailedTransfers(): Promise<
+    Array<{
+      mediaId: string;
+      error: string;
+      retryCount: number;
+    }>
+  > {
+    try {
+      const result = await CustomCamera.getFailedTransfers();
+      return result || [];
+    } catch (error) {
+      console.error('[MediaStorage] Get failed transfers failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Retry failed transfers
+   */
+  async retryFailedTransfers(): Promise<MediaPublishResult[]> {
+    try {
+      const result = await CustomCamera.retryFailedTransfers();
+      return result.map((item: any) => ({
+        success: item.success,
+        mediaId: item.mediaId,
+        sourceLocation: 'cache' as MediaStorageLocation,
+        targetLocation: 'document' as MediaStorageLocation,
+        sourceUri: '',
+        targetUri: item.targetUri,
+        movedAt: Date.now(),
+        error: item.error
+          ? { code: 'RETRY_ERROR', message: item.error }
+          : undefined,
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Retry failed transfers failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get media cache size in MB
+   */
+  async getCacheSizeMB(): Promise<number> {
+    try {
+      const stats = await this.getStorageStats();
+      return stats.cacheUsedMB;
+    } catch (error) {
+      console.error('[MediaStorage] Get cache size failed', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Check if cache is almost full
+   */
+  async isCacheAlmostFull(threshold: number = 80): Promise<boolean> {
+    try {
+      const stats = await this.getStorageStats();
+      const percentageUsed =
+        (stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB)) *
+        100;
+      return percentageUsed > threshold;
+    } catch (error) {
+      console.error('[MediaStorage] Check cache full failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request cleanup if cache exceeds threshold
+   */
+  async requestCleanupIfNeeded(maxCacheMB: number = 400): Promise<boolean> {
+    try {
+      const cacheSize = await this.getCacheSizeMB();
+      if (cacheSize > maxCacheMB) {
+        const daysOld = Math.ceil((cacheSize - maxCacheMB) / 10);
+        const result = await this.cleanupOldCache(Math.max(1, daysOld));
+        return result.success;
+      }
+      return true;
+    } catch (error) {
+      console.error('[MediaStorage] Request cleanup failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get a summary of storage status
+   */
+  async getStorageSummary(): Promise<{
+    totalCached: number;
+    totalPublished: number;
+    cacheUsageMB: number;
+    cachePercentageFull: number;
+    needsCleanup: boolean;
+    duplicatesCount: number;
+  }> {
+    try {
+      const stats = await this.getStorageStats();
+      const percentageFull =
+        (stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB)) *
+        100;
+
+      return {
+        totalCached: stats.cachedItemsCount,
+        totalPublished: stats.publishedItemsCount,
+        cacheUsageMB: Math.round(stats.cacheUsedMB),
+        cachePercentageFull: Math.round(percentageFull),
+        needsCleanup: percentageFull > 75,
+        duplicatesCount: stats.duplicateItemsCount,
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Get storage summary failed', error);
+      return {
+        totalCached: 0,
+        totalPublished: 0,
+        cacheUsageMB: 0,
+        cachePercentageFull: 0,
+        needsCleanup: false,
+        duplicatesCount: 0,
+      };
+    }
+  }
+}
+
+// Singleton instance
+let instance: MediaStorageManager | null = null;
+
+/**
+ * Get the media storage manager instance
+ */
+export function getMediaStorageManager(): MediaStorageManager {
+  if (!instance) {
+    instance = new MediaStorageManager();
+  }
+  return instance;
+}
+
+/**
+ * Quick access functions for common operations
+ */
+
+export async function initializeMediaStorage(): Promise<void> {
+  const manager = getMediaStorageManager();
+  const result = await manager.initialize();
+  if (!result.success) {
+    throw new Error(result.message || 'Failed to initialize media storage');
+  }
+}
+
+export async function publishCachedMedia(
+  mediaId: string,
+  moveMode = true
+): Promise<MediaPublishResult> {
+  const manager = getMediaStorageManager();
+  const result = await manager.publishMedia(mediaId, { moveMode });
+  if (!result.success) {
+    throw new Error(result.error?.message || 'Failed to publish media');
+  }
+  return result;
+}
+
+export async function getCacheInfo(): Promise<{
+  items: number;
+  sizeMB: number;
+  percentageFull: number;
+}> {
+  const manager = getMediaStorageManager();
+  const [cached, stats] = await Promise.all([
+    manager.getCachedMedia(),
+    manager.getStorageStats(),
+  ]);
+
+  const percentageFull =
+    (stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB)) * 100;
+
+  return {
+    items: cached.length,
+    sizeMB: Math.round(stats.cacheUsedMB),
+    percentageFull: Math.round(percentageFull),
+  };
+}
+
+export async function cleanupExpiredCache(): Promise<{
+  filesRemoved: number;
+  spaceFreedMB: number;
+}> {
+  const manager = getMediaStorageManager();
+  const result = await manager.cleanupOldCache(7);
+  return {
+    filesRemoved: result.filesRemoved,
+    spaceFreedMB: Math.round(result.spaceFreedMB),
+  };
+}
+
+export { MediaStorageManager };