stream-chat-react-native 9.0.0-beta.9 → 9.0.0

package/android/build.gradle

@@ -155,3 +155,33 @@ if (isNewArchitectureEnabled()) {
     codegenJavaPackageName = "com.streamchatreactnative"
   }
 }
+
+if (isNewArchitectureEnabled()) {
+  gradle.projectsEvaluated {
+    if (rootProject.ext.has("streamChatReactNativeCodegenHookInstalled")) {
+      return
+    }
+
+    def androidAppProject = rootProject.subprojects.find { it.plugins.hasPlugin("com.android.application") }
+    if (androidAppProject == null) {
+      return
+    }
+
+    def dependencyCodegenTasks = rootProject.subprojects
+      .findAll { it != androidAppProject }
+      .collect { it.tasks.findByName("generateCodegenArtifactsFromSchema") }
+      .findAll { it != null }
+
+    if (dependencyCodegenTasks.isEmpty()) {
+      return
+    }
+
+    rootProject.ext.set("streamChatReactNativeCodegenHookInstalled", true)
+
+    androidAppProject.tasks.matching { task ->
+      task.name.startsWith("configureCMake")
+    }.configureEach {
+      dependsOn(dependencyCodegenTasks)
+    }
+  }
+}

package/android/src/main/java/com/streamchatreactnative/StreamChatReactNativePackage.java

@@ -14,12 +14,18 @@ import java.util.List;
 import java.util.Map;
 
 public class StreamChatReactNativePackage extends TurboReactPackage {
+  private static final String STREAM_VIDEO_THUMBNAIL_MODULE = "StreamVideoThumbnail";
 
   @Nullable
   @Override
   public NativeModule getModule(String name, ReactApplicationContext reactContext) {
     if (name.equals(StreamChatReactNativeModule.NAME)) {
         return new StreamChatReactNativeModule(reactContext);
+    } else if (name.equals(STREAM_VIDEO_THUMBNAIL_MODULE) && BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+        return createNewArchModule(
+                "com.streamchatreactnative.StreamVideoThumbnailModule",
+                reactContext
+        );
     } else {
         return null;
     }
@@ -41,6 +47,17 @@ public class StreamChatReactNativePackage extends TurboReactPackage {
                       false, // isCxxModule
                       isTurboModule // isTurboModule
       ));
+      moduleInfos.put(
+              STREAM_VIDEO_THUMBNAIL_MODULE,
+              new ReactModuleInfo(
+                      STREAM_VIDEO_THUMBNAIL_MODULE,
+                      STREAM_VIDEO_THUMBNAIL_MODULE,
+                      false, // canOverrideExistingModule
+                      false, // needsEagerInit
+                      false, // hasConstants
+                      false, // isCxxModule
+                      isTurboModule // isTurboModule
+      ));
       return moduleInfos;
     };
   }
@@ -49,4 +66,19 @@ public class StreamChatReactNativePackage extends TurboReactPackage {
   public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
     return Collections.<ViewManager>singletonList(new StreamShimmerViewManager());
   }
+
+  @Nullable
+  private NativeModule createNewArchModule(
+          String className,
+          ReactApplicationContext reactContext
+  ) {
+    try {
+      Class<?> moduleClass = Class.forName(className);
+      return (NativeModule) moduleClass
+              .getConstructor(ReactApplicationContext.class)
+              .newInstance(reactContext);
+    } catch (Throwable ignored) {
+      return null;
+    }
+  }
 }

package/android/src/main/java/com/streamchatreactnative/shared/StreamVideoThumbnailGenerator.kt

@@ -0,0 +1,159 @@
+package com.streamchatreactnative.shared
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import java.io.File
+import java.io.FileOutputStream
+import java.util.concurrent.Executors
+
+data class StreamVideoThumbnailResult(
+  val error: String? = null,
+  val uri: String? = null,
+)
+
+object StreamVideoThumbnailGenerator {
+  private const val DEFAULT_COMPRESSION_QUALITY = 80
+  private const val DEFAULT_MAX_DIMENSION = 512
+  private const val CACHE_VERSION = "v1"
+  private const val CACHE_DIRECTORY_NAME = "@stream-io-stream-video-thumbnails"
+  private const val MAX_CONCURRENT_GENERATIONS = 5
+
+  fun generateThumbnails(context: Context, urls: List<String>): List<StreamVideoThumbnailResult> {
+    if (urls.size <= 1) {
+      return urls.map { url -> generateThumbnailResult(context, url) }
+    }
+
+    val parallelism = minOf(urls.size, MAX_CONCURRENT_GENERATIONS)
+    val executor = Executors.newFixedThreadPool(parallelism)
+
+    return try {
+      val tasks = urls.map { url ->
+        executor.submit<StreamVideoThumbnailResult> {
+          generateThumbnailResult(context, url)
+        }
+      }
+      tasks.map { task -> task.get() }
+    } finally {
+      executor.shutdown()
+    }
+  }
+
+  private fun generateThumbnailResult(context: Context, url: String): StreamVideoThumbnailResult {
+    return try {
+      StreamVideoThumbnailResult(uri = generateThumbnail(context, url))
+    } catch (error: Throwable) {
+      StreamVideoThumbnailResult(
+        error = error.message ?: "Thumbnail generation failed for $url",
+        uri = null,
+      )
+    }
+  }
+
+  private fun generateThumbnail(context: Context, url: String): String {
+    val outputDirectory = File(context.cacheDir, CACHE_DIRECTORY_NAME).apply { mkdirs() }
+    val outputFile = File(outputDirectory, buildCacheFileName(url))
+
+    if (outputFile.isFile() && outputFile.length() > 0L) {
+      return Uri.fromFile(outputFile).toString()
+    }
+
+    val retriever = MediaMetadataRetriever()
+
+    return try {
+      setDataSource(retriever, context, url)
+      val thumbnail = extractThumbnailFrame(retriever, url)
+
+      try {
+        FileOutputStream(outputFile).use { stream ->
+          thumbnail.compress(Bitmap.CompressFormat.JPEG, DEFAULT_COMPRESSION_QUALITY, stream)
+        }
+      } finally {
+        if (!thumbnail.isRecycled) {
+          thumbnail.recycle()
+        }
+      }
+
+      Uri.fromFile(outputFile).toString()
+    } catch (error: Throwable) {
+      throw IllegalStateException("Thumbnail generation failed for $url", error)
+    } finally {
+      try {
+        retriever.release()
+      } catch (_: Throwable) {
+        // Ignore cleanup failures.
+      }
+    }
+  }
+
+  private fun extractThumbnailFrame(retriever: MediaMetadataRetriever, url: String): Bitmap {
+    if (Build.VERSION.SDK_INT >= 27) {
+      return retriever.getScaledFrameAtTime(
+        100000,
+        MediaMetadataRetriever.OPTION_CLOSEST_SYNC,
+        DEFAULT_MAX_DIMENSION,
+        DEFAULT_MAX_DIMENSION,
+      ) ?: throw IllegalStateException("Failed to extract video frame for $url")
+    }
+
+    val frame =
+      retriever.getFrameAtTime(100000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+        ?: throw IllegalStateException("Failed to extract video frame for $url")
+    val scaledFrame = scaleBitmap(frame)
+
+    if (scaledFrame != frame) {
+      frame.recycle()
+    }
+
+    return scaledFrame
+  }
+
+  private fun buildCacheFileName(url: String): String {
+    val cacheKey =
+      fnv1a64("$CACHE_VERSION|$DEFAULT_MAX_DIMENSION|$DEFAULT_COMPRESSION_QUALITY|$url")
+    return "stream-video-thumbnail-$cacheKey.jpg"
+  }
+
+  private fun fnv1a64(value: String): String {
+    var hash = -0x340d631b8c46751fL
+
+    value.toByteArray(Charsets.UTF_8).forEach { byte ->
+      hash = hash xor (byte.toLong() and 0xff)
+      hash *= 0x100000001b3L
+    }
+
+    return java.lang.Long.toUnsignedString(hash, 16)
+  }
+
+  private fun setDataSource(retriever: MediaMetadataRetriever, context: Context, url: String) {
+    val uri = Uri.parse(url)
+    val scheme = uri.scheme?.lowercase()
+
+    when {
+      scheme.isNullOrEmpty() -> retriever.setDataSource(url)
+      scheme == "content" || scheme == "file" -> retriever.setDataSource(context, uri)
+      else ->
+        throw IllegalArgumentException(
+          "Unsupported video URI scheme for thumbnail generation: $scheme. Local assets only.",
+        )
+    }
+  }
+
+  private fun scaleBitmap(bitmap: Bitmap): Bitmap {
+    val width = bitmap.width
+    val height = bitmap.height
+    val largestDimension = maxOf(width, height)
+
+    if (largestDimension <= DEFAULT_MAX_DIMENSION) {
+      return bitmap
+    }
+
+    val scale = DEFAULT_MAX_DIMENSION.toFloat() / largestDimension.toFloat()
+    val targetWidth = (width * scale).toInt().coerceAtLeast(1)
+    val targetHeight = (height * scale).toInt().coerceAtLeast(1)
+
+    return Bitmap.createScaledBitmap(bitmap, targetWidth, targetHeight, true)
+  }
+}

package/android/src/newarch/com/streamchatreactnative/StreamVideoThumbnailModule.kt

@@ -0,0 +1,50 @@
+package com.streamchatreactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.streamchatreactnative.shared.StreamVideoThumbnailGenerator
+import java.util.concurrent.Executors
+
+class StreamVideoThumbnailModule(
+  reactContext: ReactApplicationContext,
+) : NativeStreamVideoThumbnailSpec(reactContext) {
+  override fun getName(): String = NAME
+
+  override fun createVideoThumbnails(urls: ReadableArray, promise: Promise) {
+    val urlList = mutableListOf<String>()
+    for (index in 0 until urls.size()) {
+      urlList.add(urls.getString(index) ?: "")
+    }
+
+    executor.execute {
+      try {
+        val thumbnails = StreamVideoThumbnailGenerator.generateThumbnails(reactApplicationContext, urlList)
+        val result = Arguments.createArray()
+        thumbnails.forEach { thumbnail ->
+          val thumbnailMap = Arguments.createMap()
+          if (thumbnail.uri != null) {
+            thumbnailMap.putString("uri", thumbnail.uri)
+          } else {
+            thumbnailMap.putNull("uri")
+          }
+          if (thumbnail.error != null) {
+            thumbnailMap.putString("error", thumbnail.error)
+          } else {
+            thumbnailMap.putNull("error")
+          }
+          result.pushMap(thumbnailMap)
+        }
+        promise.resolve(result)
+      } catch (error: Throwable) {
+        promise.reject("stream_video_thumbnail_error", error.message, error)
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "StreamVideoThumbnail"
+    private val executor = Executors.newCachedThreadPool()
+  }
+}

package/ios/shared/StreamVideoThumbnail.h

@@ -0,0 +1,14 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#if __has_include("StreamChatReactNativeSpec.h")
+#import "StreamChatReactNativeSpec.h"
+#elif __has_include("StreamChatExpoSpec.h")
+#import "StreamChatExpoSpec.h"
+#else
+#error "Unable to find generated codegen spec header for StreamVideoThumbnail."
+#endif
+
+@interface StreamVideoThumbnail : NSObject <NativeStreamVideoThumbnailSpec>
+@end
+
+#endif

package/ios/shared/StreamVideoThumbnail.mm

@@ -0,0 +1,56 @@
+#import "StreamVideoThumbnail.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#if __has_include(<stream_chat_react_native/stream_chat_react_native-Swift.h>)
+#import <stream_chat_react_native/stream_chat_react_native-Swift.h>
+#elif __has_include(<stream_chat_expo/stream_chat_expo-Swift.h>)
+#import <stream_chat_expo/stream_chat_expo-Swift.h>
+#elif __has_include("stream_chat_react_native-Swift.h")
+#import "stream_chat_react_native-Swift.h"
+#elif __has_include("stream_chat_expo-Swift.h")
+#import "stream_chat_expo-Swift.h"
+#else
+#error "Unable to import generated Swift header for StreamVideoThumbnail."
+#endif
+
+@implementation StreamVideoThumbnail
+
+RCT_EXPORT_MODULE(StreamVideoThumbnail)
+
+RCT_REMAP_METHOD(createVideoThumbnails, urls:(NSArray<NSString *> *)urls resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+{
+  [self createVideoThumbnails:urls resolve:resolve reject:reject];
+}
+
+- (void)createVideoThumbnails:(NSArray<NSString *> *)urls
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+  [StreamVideoThumbnailGenerator generateThumbnailsWithUrls:urls completion:^(NSArray<StreamVideoThumbnailResult *> *thumbnails) {
+    NSMutableArray<NSDictionary<NSString *, id> *> *payload = [NSMutableArray arrayWithCapacity:thumbnails.count];
+
+    for (StreamVideoThumbnailResult *thumbnail in thumbnails) {
+      NSMutableDictionary<NSString *, id> *entry = [NSMutableDictionary dictionaryWithCapacity:2];
+      entry[@"uri"] = thumbnail.uri ?: [NSNull null];
+      entry[@"error"] = thumbnail.error ?: [NSNull null];
+      [payload addObject:entry];
+    }
+
+    @try {
+      resolve(payload);
+    } @catch (NSException *exception) {
+      reject(@"stream_video_thumbnail_error", exception.reason, nil);
+    }
+  }];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeStreamVideoThumbnailSpecJSI>(params);
+}
+
+@end
+
+#endif