@droppii-org/chat-mobile 0.2.16 → 0.2.17

package/src/utils/videoThumbnail.ts

@@ -1,3 +1,4 @@
+import { Platform } from 'react-native';
 import RNFS from 'react-native-fs';
 import { createThumbnail } from 'react-native-create-thumbnail';
 
@@ -13,6 +14,64 @@ interface ThumbnailResult {
   height: number;
 }
 
+/**
+ * Routes the video source so react-native-create-thumbnail picks the correct
+ * native MediaMetadataRetriever.setDataSource overload.
+ *
+ * Root cause of the Android crash: CreateThumbnailModule.getBitmapAtTime branches
+ * on the URL scheme —
+ *   - "file://..."  -> setDataSource(String)            ✅ works for local files
+ *   - "content://"  -> setDataSource(Context, Uri)
+ *   - otherwise     -> setDataSource(String, Map headers) ❌ this overload is for
+ *                      REMOTE URIs; a bare local path makes it throw an uncaught
+ *                      RuntimeException (status 0xFFFFFFEA / EINVAL) → app crash.
+ * The app strips "file://" before calling, so local videos fall into the broken
+ * branch. The fix is to KEEP the file:// scheme so the working overload is used.
+ *
+ * For Android photo-picker synthetic paths we additionally copy the file into the
+ * app cache first (a clean, app-private file the retriever can always open) and
+ * still hand it back with a file:// prefix. Returns the path to pass to
+ * createThumbnail plus a raw cleanup path for any temp copy.
+ */
+const ensureRetrievableVideoPath = async (
+  videoPath: string
+): Promise<{ path: string; cleanupPath: string | null }> => {
+  // iOS (and any non-Android platform) is left completely untouched.
+  if (Platform.OS !== 'android') {
+    return { path: videoPath, cleanupPath: null };
+  }
+
+  // content:// is handled by a dedicated native branch — pass through unchanged.
+  if (videoPath.startsWith('content://')) {
+    return { path: videoPath, cleanupPath: null };
+  }
+
+  const rawPath = videoPath.startsWith('file://')
+    ? videoPath.replace('file://', '')
+    : videoPath;
+
+  const isSynthetic =
+    rawPath.includes('/.transforms/') || rawPath.includes('/synthetic/');
+
+  if (isSynthetic) {
+    const ext = (rawPath.split('.').pop() || 'mp4').split('?')[0];
+    const dest = `${RNFS.CachesDirectoryPath}/video-thumb-src-${Date.now()}-${Math.floor(
+      Math.random() * 1e6
+    )}.${ext}`;
+
+    console.log(
+      '[VideoThumbnail] Copying picker video to cache before thumbnail',
+      { from: rawPath, to: dest }
+    );
+    await RNFS.copyFile(rawPath, dest);
+    return { path: `file://${dest}`, cleanupPath: dest };
+  }
+
+  // Any other local path: ensure the file:// scheme so the native module routes
+  // to setDataSource(String) instead of the broken (String, Map) overload.
+  return { path: `file://${rawPath}`, cleanupPath: null };
+};
+
 export const VideoThumbnailUtil = {
   generateThumbnail: async (
     videoPath: string,
@@ -20,10 +79,18 @@ export const VideoThumbnailUtil = {
   ): Promise<ThumbnailResult | null> => {
     const { time = 800, quality = 80, cacheId } = options; // time in milliseconds
 
+    let tempSourcePath: string | null = null;
+
     try {
+      // Normalize the source so the native MediaMetadataRetriever can open it.
+      // Android picker paths crash the app otherwise (see ensureRetrievableVideoPath).
+      const { path: retrievablePath, cleanupPath } =
+        await ensureRetrievableVideoPath(videoPath);
+      tempSourcePath = cleanupPath;
+
       // Generate unique cache name per video to avoid conflicts with concurrent generations
       // Uses provided cacheId or generates one from videoPath filename
-      const fileName = videoPath.split('/').pop() || String(Date.now());
+      const fileName = retrievablePath.split('/').pop() || String(Date.now());
       const cacheName =
         cacheId ||
         `thumb-${fileName.replace(/[^a-zA-Z0-9-_]/g, '')}-${Math.abs(
@@ -31,14 +98,14 @@ export const VideoThumbnailUtil = {
         )}`;
 
       console.log('[VideoThumbnail] Generating thumbnail', {
-        videoPath,
+        videoPath: retrievablePath,
         timeMs: time,
         quality,
         cacheName,
       });
 
       const result = await createThumbnail({
-        url: videoPath,
+        url: retrievablePath,
         timeStamp: time,
         format: 'png',
         dirSize: 100,
@@ -60,6 +127,13 @@ export const VideoThumbnailUtil = {
     } catch (error) {
       console.error('[VideoThumbnail] Failed to generate thumbnail', error);
       return null;
+    } finally {
+      // Remove the temporary video copy made for synthetic/content sources.
+      if (tempSourcePath) {
+        RNFS.unlink(tempSourcePath).catch((err) =>
+          console.warn('[VideoThumbnail] Temp source cleanup failed:', err)
+        );
+      }
     }
   },