stream-chat-expo 9.0.0-beta.8 → 9.0.0

package/android/build.gradle

@@ -137,3 +137,33 @@ if (isNewArchitectureEnabled()) {
     codegenJavaPackageName = "com.streamchatexpo"
   }
 }
+
+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/streamchatexpo/StreamChatExpoPackage.java

@@ -14,9 +14,15 @@ import java.util.List;
 import java.util.Map;
 
 public class StreamChatExpoPackage extends TurboReactPackage {
+  private static final String STREAM_VIDEO_THUMBNAIL_MODULE = "StreamVideoThumbnail";
+
   @Nullable
   @Override
   public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(STREAM_VIDEO_THUMBNAIL_MODULE) && BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      return createNewArchModule("com.streamchatexpo.StreamVideoThumbnailModule", reactContext);
+    }
+
     return null;
   }
 
@@ -24,6 +30,18 @@ public class StreamChatExpoPackage extends TurboReactPackage {
   public ReactModuleInfoProvider getReactModuleInfoProvider() {
     return () -> {
       final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+      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;
     };
   }
@@ -32,4 +50,19 @@ public class StreamChatExpoPackage 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/streamchatexpo/StreamVideoThumbnailModule.kt

@@ -0,0 +1,50 @@
+package com.streamchatexpo
+
+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

package/ios/shared/StreamVideoThumbnailGenerator.swift

@@ -0,0 +1,338 @@
+import AVFoundation
+import Photos
+import UIKit
+
+private final class StreamPhotoLibraryAssetRequestState: @unchecked Sendable {
+  let lock = NSLock()
+  var didResume = false
+  var requestID: PHImageRequestID = PHInvalidImageRequestID
+}
+
+@objcMembers
+public final class StreamVideoThumbnailResult: NSObject {
+  public let error: String?
+  public let uri: String?
+
+  public init(error: String? = nil, uri: String? = nil) {
+    self.error = error
+    self.uri = uri
+  }
+}
+
+@objcMembers
+public final class StreamVideoThumbnailGenerator: NSObject {
+  private static let compressionQuality: CGFloat = 0.8
+  private static let maxDimension: CGFloat = 512
+  private static let cacheVersion = "v1"
+  private static let cacheDirectoryName = "@stream-io-stream-video-thumbnails"
+  private static let maxConcurrentGenerations = 5
+  private static let photoLibraryAssetResolutionTimeout: TimeInterval = 3
+
+  @objc(generateThumbnailsWithUrls:completion:)
+  public static func generateThumbnails(
+    urls: [String],
+    completion: @escaping ([StreamVideoThumbnailResult]) -> Void
+  ) {
+    Task(priority: .userInitiated) {
+      completion(await generateThumbnailsAsync(urls: urls))
+    }
+  }
+
+  private static func generateThumbnailsAsync(urls: [String]) async -> [StreamVideoThumbnailResult] {
+    guard !urls.isEmpty else {
+      return []
+    }
+
+    if urls.count == 1 {
+      return [await generateThumbnailResult(url: urls[0])]
+    }
+
+    let parallelism = min(maxConcurrentGenerations, urls.count)
+
+    return await withTaskGroup(
+      of: (Int, StreamVideoThumbnailResult).self,
+      returning: [StreamVideoThumbnailResult].self
+    ) { group in
+      var thumbnails = Array<StreamVideoThumbnailResult?>(repeating: nil, count: urls.count)
+      var nextIndexToSchedule = 0
+
+      while nextIndexToSchedule < parallelism {
+        let index = nextIndexToSchedule
+        let url = urls[index]
+        group.addTask {
+          (index, await generateThumbnailResult(url: url))
+        }
+        nextIndexToSchedule += 1
+      }
+
+      while let (index, thumbnail) = await group.next() {
+        thumbnails[index] = thumbnail
+
+        if nextIndexToSchedule < urls.count {
+          let nextIndex = nextIndexToSchedule
+          let nextURL = urls[nextIndex]
+          group.addTask {
+            (nextIndex, await generateThumbnailResult(url: nextURL))
+          }
+          nextIndexToSchedule += 1
+        }
+      }
+
+      return thumbnails.enumerated().map { index, thumbnail in
+        thumbnail ?? StreamVideoThumbnailResult(
+          error: "Thumbnail generation produced no output for index \(index)",
+          uri: nil
+        )
+      }
+    }
+  }
+
+  private static func generateThumbnailResult(url: String) async -> StreamVideoThumbnailResult {
+    do {
+      return StreamVideoThumbnailResult(uri: try await generateThumbnail(url: url))
+    } catch {
+      return StreamVideoThumbnailResult(
+        error: error.localizedDescription,
+        uri: nil
+      )
+    }
+  }
+
+  private static func generateThumbnail(url: String) async throws -> String {
+    let outputDirectory = try thumbnailCacheDirectory()
+    let outputURL = outputDirectory
+      .appendingPathComponent(buildCacheFileName(url: url))
+      .appendingPathExtension("jpg")
+
+    if
+      FileManager.default.fileExists(atPath: outputURL.path),
+      let attributes = try? FileManager.default.attributesOfItem(atPath: outputURL.path),
+      let fileSize = attributes[.size] as? NSNumber,
+      fileSize.intValue > 0
+    {
+      return outputURL.absoluteString
+    }
+
+    let asset = try await resolveAsset(url: url)
+    let generator = AVAssetImageGenerator(asset: asset)
+    generator.appliesPreferredTrackTransform = true
+    generator.maximumSize = CGSize(width: maxDimension, height: maxDimension)
+
+    let requestedTime = thumbnailTime(for: asset)
+
+    do {
+      let cgImage = try generator.copyCGImage(at: requestedTime, actualTime: nil)
+      let image = UIImage(cgImage: cgImage)
+      guard let data = image.jpegData(compressionQuality: compressionQuality) else {
+        throw thumbnailError(code: 2, message: "Failed to encode JPEG thumbnail for \(url)")
+      }
+
+      try data.write(to: outputURL, options: .atomic)
+      return outputURL.absoluteString
+    } catch {
+      throw thumbnailError(error, code: 3, message: "Thumbnail generation failed for \(url)")
+    }
+  }
+
+  private static func thumbnailCacheDirectory() throws -> URL {
+    let outputDirectory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+      .appendingPathComponent(cacheDirectoryName, isDirectory: true)
+    try FileManager.default.createDirectory(
+      at: outputDirectory,
+      withIntermediateDirectories: true
+    )
+    return outputDirectory
+  }
+
+  private static func buildCacheFileName(url: String) -> String {
+    let cacheKey = fnv1a64("\(cacheVersion)|\(Int(maxDimension))|\(compressionQuality)|\(url)")
+    return "stream-video-thumbnail-\(cacheKey)"
+  }
+
+  private static func fnv1a64(_ value: String) -> String {
+    var hash: UInt64 = 0xcbf29ce484222325
+    let prime: UInt64 = 0x100000001b3
+
+    for byte in value.utf8 {
+      hash ^= UInt64(byte)
+      hash &*= prime
+    }
+
+    return String(hash, radix: 16)
+  }
+
+  private static func thumbnailTime(for asset: AVAsset) -> CMTime {
+    let durationSeconds = asset.duration.seconds
+    if durationSeconds.isFinite, durationSeconds > 0.1 {
+      return CMTime(seconds: 0.1, preferredTimescale: 600)
+    }
+
+    return .zero
+  }
+
+  private static func resolveAsset(url: String) async throws -> AVAsset {
+    if isPhotoLibraryURL(url) {
+      return try await resolvePhotoLibraryAsset(url: url)
+    }
+
+    if let normalizedURL = normalizeLocalURL(url) {
+      return AVURLAsset(url: normalizedURL)
+    }
+
+    throw thumbnailError(code: 5, message: "Unsupported video URL for thumbnail generation: \(url)")
+  }
+
+  private static func isPhotoLibraryURL(_ url: String) -> Bool {
+    url.lowercased().hasPrefix("ph://")
+  }
+
+  private static func resolvePhotoLibraryAsset(url: String) async throws -> AVAsset {
+    let identifier = photoLibraryIdentifier(from: url)
+
+    guard !identifier.isEmpty else {
+      throw thumbnailError(code: 6, message: "Missing photo library identifier for \(url)")
+    }
+
+    let fetchResult = PHAsset.fetchAssets(withLocalIdentifiers: [identifier], options: nil)
+    guard let asset = fetchResult.firstObject else {
+      throw thumbnailError(code: 7, message: "Failed to find photo library asset for \(url)")
+    }
+
+    let options = PHVideoRequestOptions()
+    options.deliveryMode = .highQualityFormat
+    options.isNetworkAccessAllowed = true
+    options.version = .current
+
+    return try await withThrowingTaskGroup(of: AVAsset.self) { group in
+      group.addTask {
+        try await requestPhotoLibraryAsset(url: url, asset: asset, options: options)
+      }
+      group.addTask {
+        try await Task.sleep(nanoseconds: UInt64(photoLibraryAssetResolutionTimeout * 1_000_000_000))
+        throw thumbnailError(
+          code: 11,
+          message: "Timed out resolving photo library asset for \(url)"
+        )
+      }
+
+      guard let resolvedAsset = try await group.next() else {
+        throw thumbnailError(
+          code: 10,
+          message: "Failed to resolve photo library asset for \(url)"
+        )
+      }
+
+      group.cancelAll()
+      return resolvedAsset
+    }
+  }
+
+  private static func requestPhotoLibraryAsset(
+    url: String,
+    asset: PHAsset,
+    options: PHVideoRequestOptions
+  ) async throws -> AVAsset {
+    let imageManager = PHImageManager.default()
+    let state = StreamPhotoLibraryAssetRequestState()
+
+    return try await withTaskCancellationHandler(operation: {
+      try await withCheckedThrowingContinuation { continuation in
+        let requestID = imageManager.requestAVAsset(forVideo: asset, options: options) {
+          avAsset, _, info in
+          state.lock.lock()
+          if state.didResume {
+            state.lock.unlock()
+            return
+          }
+          state.didResume = true
+          state.lock.unlock()
+
+          if let isCancelled = (info?[PHImageCancelledKey] as? NSNumber)?.boolValue, isCancelled {
+            continuation.resume(
+              throwing: thumbnailError(
+                code: 8,
+                message: "Photo library asset request was cancelled for \(url)"
+              )
+            )
+            return
+          }
+
+          if let error = info?[PHImageErrorKey] as? Error {
+            continuation.resume(
+              throwing: thumbnailError(
+                error,
+                code: 9,
+                message: "Photo library asset request failed for \(url)"
+              )
+            )
+            return
+          }
+
+          guard let avAsset else {
+            continuation.resume(
+              throwing: thumbnailError(
+                code: 10,
+                message: "Failed to resolve photo library asset for \(url)"
+              )
+            )
+            return
+          }
+
+          continuation.resume(returning: avAsset)
+        }
+
+        state.lock.lock()
+        state.requestID = requestID
+        state.lock.unlock()
+      }
+    }, onCancel: {
+      state.lock.lock()
+      let requestID = state.requestID
+      state.lock.unlock()
+
+      if requestID != PHInvalidImageRequestID {
+        imageManager.cancelImageRequest(requestID)
+      }
+    })
+  }
+
+  private static func photoLibraryIdentifier(from url: String) -> String {
+    guard let parsedURL = URL(string: url), parsedURL.scheme?.lowercased() == "ph" else {
+      return url
+        .replacingOccurrences(of: "ph://", with: "", options: [.caseInsensitive])
+        .removingPercentEncoding?
+        .trimmingCharacters(in: CharacterSet(charactersIn: "/")) ?? ""
+    }
+
+    let host = parsedURL.host ?? ""
+    let path = parsedURL.path
+    let combined = host.isEmpty ? path : "\(host)\(path)"
+    return combined.removingPercentEncoding?
+      .trimmingCharacters(in: CharacterSet(charactersIn: "/")) ?? ""
+  }
+
+  private static func normalizeLocalURL(_ url: String) -> URL? {
+    if let parsedURL = URL(string: url), let scheme = parsedURL.scheme?.lowercased() {
+      if scheme == "file" {
+        return parsedURL
+      }
+
+      return nil
+    }
+
+    return URL(fileURLWithPath: url)
+  }
+
+  private static func thumbnailError(
+    _ error: Error? = nil,
+    code: Int,
+    message: String
+  ) -> Error {
+    let description = error.map { "\(message): \($0.localizedDescription)" } ?? message
+    return NSError(
+      domain: "StreamVideoThumbnail",
+      code: code,
+      userInfo: [NSLocalizedDescriptionKey: description]
+    )
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "stream-chat-expo",
   "description": "The official Expo SDK for Stream Chat, a service for building chat applications",
-  "version": "9.0.0-beta.8",
+  "version": "9.0.0",
   "author": {
     "company": "Stream.io Inc",
     "name": "Stream.io Inc"
@@ -27,10 +27,10 @@
   "types": "types/index.d.ts",
   "dependencies": {
     "mime": "^4.0.7",
-    "stream-chat-react-native-core": "9.0.0-beta.8"
+    "stream-chat-react-native-core": "9.0.0"
   },
   "peerDependencies": {
-    "expo": ">=51.0.0",
+    "expo": ">=52.0.0",
     "react-native": ">=0.76.0",
     "expo-av": "*",
     "expo-clipboard": "*",
@@ -69,6 +69,9 @@
     "expo-image-picker": {
       "optional": true
     },
+    "expo-image-manipulator": {
+      "optional": true
+    },
     "expo-sharing": {
       "optional": true
     },
@@ -82,7 +85,6 @@
     "expo-audio": "~0.4.6"
   },
   "scripts": {
-    "postinstall": "if [ -f ../scripts/sync-shared-native.sh ] && [ -d ../shared-native/ios ]; then bash ../scripts/sync-shared-native.sh expo-package; fi",
     "prepack": "bash ../scripts/sync-shared-native.sh expo-package && cp ../../README.md .",
     "postpack": "rm README.md && bash ../scripts/clean-shared-native-copies.sh expo-package"
   },
@@ -90,7 +92,13 @@
     "name": "StreamChatExpoSpec",
     "type": "all",
     "jsSrcsDir": "src/native",
+    "android": {
+      "javaPackageName": "com.streamchatexpo"
+    },
     "ios": {
+      "modulesProvider": {
+        "StreamVideoThumbnail": "StreamVideoThumbnail"
+      },
       "componentProvider": {
         "StreamShimmerView": "StreamShimmerViewComponentView"
       }

package/src/native/NativeStreamVideoThumbnail.ts

@@ -0,0 +1,14 @@
+import type { TurboModule } from 'react-native';
+
+import { TurboModuleRegistry } from 'react-native';
+
+export type VideoThumbnailResult = {
+  error?: string | null;
+  uri?: string | null;
+};
+
+export interface Spec extends TurboModule {
+  createVideoThumbnails(urls: ReadonlyArray<string>): Promise<ReadonlyArray<VideoThumbnailResult>>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('StreamVideoThumbnail');

package/src/native/videoThumbnail.ts

@@ -0,0 +1,8 @@
+import NativeStreamVideoThumbnail, { type VideoThumbnailResult } from './NativeStreamVideoThumbnail';
+
+export type { VideoThumbnailResult } from './NativeStreamVideoThumbnail';
+
+export const createVideoThumbnails = async (urls: string[]): Promise<VideoThumbnailResult[]> => {
+  const results = await NativeStreamVideoThumbnail.createVideoThumbnails(urls);
+  return Array.from(results);
+};

package/src/optionalDependencies/AudioVideo.ts

@@ -1,20 +1,18 @@
 let AudioComponent;
-let VideoComponent;
 let RecordingObject;
 
 try {
   const audioVideoPackage = require('expo-av');
   AudioComponent = audioVideoPackage.Audio;
-  VideoComponent = audioVideoPackage.Video;
   RecordingObject = audioVideoPackage.RecordingObject;
 } catch (e) {
   // do nothing
 }
 
-if (!AudioComponent || !VideoComponent) {
+if (!AudioComponent) {
   console.log(
-    'Audio Video library is currently not installed. To allow in-app audio playback, install the "expo-av" package.',
+    'The audio library is currently not installed. To allow in-app audio playback, install the "expo-av" package.',
   );
 }
 
-export { AudioComponent, RecordingObject, VideoComponent };
+export { AudioComponent, RecordingObject };

package/src/optionalDependencies/Sound.ts

@@ -138,8 +138,8 @@ class ExpoAudioSoundAdapter {
   };
 
   // eslint-disable-next-line require-await
-  setPositionAsync: SoundReturnType['setPositionAsync'] = async (seconds) => {
-    this.player.seekTo(seconds);
+  setPositionAsync: SoundReturnType['setPositionAsync'] = async (millis) => {
+    await this.player.seekTo(millis / 1000);
   };
 
   // eslint-disable-next-line require-await

package/src/optionalDependencies/Video.tsx

@@ -2,7 +2,7 @@ import React, { useEffect } from 'react';
 
 import { useEventListener } from 'expo';
 
-import { AudioComponent, VideoComponent as ExpoAVVideoComponent } from './AudioVideo';
+import { AudioComponent } from './AudioVideo';
 
 let videoPackage;
 
@@ -18,8 +18,8 @@ if (!videoPackage) {
   );
 }
 
-const VideoComponent = videoPackage ? videoPackage.VideoView : ExpoAVVideoComponent;
-const useVideoPlayer = videoPackage ? videoPackage.useVideoPlayer : null;
+const VideoComponent = videoPackage?.VideoView;
+const useVideoPlayer = videoPackage?.useVideoPlayer;
 
 let Video = null;
 
@@ -84,33 +84,5 @@ if (videoPackage) {
     );
   };
 }
-// expo-av
-else if (ExpoAVVideoComponent) {
-  Video = ({ onPlaybackStatusUpdate, paused, resizeMode, style, uri, videoRef, rate }) => {
-    // This is done so that the audio of the video is not muted when the phone is in silent mode for iOS.
-    useEffect(() => {
-      const initializeSound = async () => {
-        await AudioComponent.setAudioModeAsync({
-          playsInSilentModeIOS: true,
-        });
-      };
-      initializeSound();
-    }, []);
-
-    return (
-      <VideoComponent
-        onPlaybackStatusUpdate={onPlaybackStatusUpdate}
-        ref={videoRef}
-        resizeMode={resizeMode}
-        shouldPlay={!paused}
-        source={{
-          uri,
-        }}
-        style={[style]}
-        playbackRate={rate}
-      />
-    );
-  };
-}
 
 export { Video };

package/src/optionalDependencies/generateThumbnail.ts

@@ -0,0 +1,9 @@
+import { createGenerateVideoThumbnails } from 'stream-chat-react-native-core/src/utils/createGenerateVideoThumbnails';
+
+import { createVideoThumbnails, type VideoThumbnailResult } from '../native/videoThumbnail';
+
+export const generateThumbnails: (
+  uris: string[],
+) => Promise<Record<string, VideoThumbnailResult>> = createGenerateVideoThumbnails({
+  createVideoThumbnails,
+});

package/src/optionalDependencies/getPhotos.ts

@@ -4,6 +4,9 @@ import mime from 'mime';
 
 import type { File } from 'stream-chat-react-native-core';
 
+import { generateThumbnails } from './generateThumbnail';
+import { getLocalAssetUri } from './getLocalAssetUri';
+
 let MediaLibrary;
 
 try {
@@ -18,8 +21,6 @@ if (!MediaLibrary) {
   );
 }
 
-import { getLocalAssetUri } from './getLocalAssetUri';
-
 type ReturnType = {
   assets: File[];
   endCursor: string | undefined;
@@ -52,24 +53,41 @@ export const getPhotos = MediaLibrary
           mediaType: [MediaLibrary.MediaType.photo, MediaLibrary.MediaType.video],
           sortBy: [MediaLibrary.SortBy.modificationTime],
         });
-        const assets = await Promise.all(
+        const assetEntries = await Promise.all(
           results.assets.map(async (asset) => {
             const localUri = await getLocalAssetUri(asset.id);
             const mimeType =
               mime.getType(asset.filename || asset.uri) ||
               (asset.mediaType === MediaLibrary.MediaType.video ? 'video/*' : 'image/*');
+            const uri = localUri || asset.uri;
+
             return {
-              duration: asset.duration * 1000,
-              height: asset.height,
-              name: asset.filename,
-              size: 0,
-              thumb_url: asset.mediaType === 'photo' ? undefined : asset.uri,
-              type: mimeType,
-              uri: localUri || asset.uri,
-              width: asset.width,
+              asset,
+              isVideo: asset.mediaType === MediaLibrary.MediaType.video,
+              mimeType,
+              uri,
             };
           }),
         );
+        const videoUris = assetEntries
+          .filter(({ isVideo, uri }) => isVideo && !!uri)
+          .map(({ uri }) => uri);
+        const videoThumbnailResults = await generateThumbnails(videoUris);
+
+        const assets = assetEntries.map(({ asset, isVideo, mimeType, uri }) => {
+          const thumbnailResult = isVideo && uri ? videoThumbnailResults[uri] : undefined;
+
+          return {
+            duration: asset.duration * 1000,
+            height: asset.height,
+            name: asset.filename,
+            size: 0,
+            thumb_url: thumbnailResult?.uri || undefined,
+            type: mimeType,
+            uri,
+            width: asset.width,
+          };
+        });
 
         const hasNextPage = results.hasNextPage;
         const endCursor = results.endCursor;

package/src/optionalDependencies/index.ts

@@ -1,5 +1,6 @@
 export * from './Audio';
 export * from './deleteFile';
+export * from './generateThumbnail';
 export * from './getLocalAssetUri';
 export * from './getPhotos';
 export * from './iOS14RefreshGallerySelection';

package/src/optionalDependencies/pickImage.ts

@@ -1,6 +1,11 @@
 import { Platform } from 'react-native';
+
 import mime from 'mime';
+
 import { PickImageOptions } from 'stream-chat-react-native-core';
+
+import { generateThumbnails } from './generateThumbnail';
+
 let ImagePicker;
 
 try {
@@ -43,17 +48,37 @@ export const pickImage = ImagePicker
           const canceled = result.canceled;
 
           if (!canceled) {
-            const assets = result.assets.map((asset) => ({
-              ...asset,
-              duration: asset.duration,
-              name: asset.fileName,
-              size: asset.fileSize,
-              type:
+            const assetsWithType = result.assets.map((asset) => {
+              const type =
                 asset.mimeType ||
                 mime.getType(asset.fileName || asset.uri) ||
-                (asset.duration ? 'video/*' : 'image/*'),
-              uri: asset.uri,
-            }));
+                (asset.duration ? 'video/*' : 'image/*');
+
+              return {
+                asset,
+                isVideo: type.includes('video'),
+                type,
+              };
+            });
+            const videoUris = assetsWithType
+              .filter(({ asset, isVideo }) => isVideo && !!asset.uri)
+              .map(({ asset }) => asset.uri);
+            const videoThumbnailResults = await generateThumbnails(videoUris);
+
+            const assets = assetsWithType.map(({ asset, isVideo, type }) => {
+              const thumbnailResult =
+                isVideo && asset.uri ? videoThumbnailResults[asset.uri] : undefined;
+
+              return {
+                ...asset,
+                duration: asset.duration,
+                name: asset.fileName,
+                size: asset.fileSize,
+                thumb_url: thumbnailResult?.uri || undefined,
+                type,
+                uri: asset.uri,
+              };
+            });
             return { assets, cancelled: false };
           } else {
             return { cancelled: true };

package/src/optionalDependencies/takePhoto.ts

@@ -2,6 +2,8 @@ import { Image, Platform } from 'react-native';
 
 import mime from 'mime';
 
+import { generateThumbnails } from './generateThumbnail';
+
 let ImagePicker;
 
 try {
@@ -61,12 +63,16 @@ export const takePhoto = ImagePicker
           if (mimeType.includes('video')) {
             const clearFilter = new RegExp('[.:]', 'g');
             const date = new Date().toISOString().replace(clearFilter, '_');
+            const thumbnailResults = await generateThumbnails([photo.uri]);
+            const thumbnailResult = thumbnailResults[photo.uri];
+
             return {
               ...photo,
               cancelled: false,
               duration: photo.duration, // in milliseconds
               name: 'video_recording_' + date + '.' + photo.uri.split('.').pop(),
               size: photo.fileSize,
+              thumb_url: thumbnailResult?.uri || undefined,
               type: mimeType,
               uri: photo.uri,
             };