stream-chat-react-native 9.0.0-beta.3 → 9.0.0-beta.30

package/ios/StreamChatReactNative.mm

@@ -1,7 +1,5 @@
 #import "StreamChatReactNative.h"
 #import <React/RCTLog.h>
-#import <AssetsLibrary/AssetsLibrary.h>
-#import <MobileCoreServices/MobileCoreServices.h>
 
 #if __has_include(<React/RCTLog.h>)
 #import <React/RCTLog.h>
@@ -19,12 +17,12 @@ NSString *moduleName = @"StreamChatReactNative";
 
 RCT_EXPORT_MODULE()
 
-RCT_REMAP_METHOD(createResizedImage, uri:(NSString *)uri width:(double)width height:(double)height format:(NSString *)format quality:(double)quality mode:(NSString *)mode onlyScaleDown:(BOOL)onlyScaleDown rotation:(nonnull NSNumber *)rotation outputPath:(NSString *)outputPath keepMeta:(nonnull NSNumber *)keepMeta resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
+RCT_REMAP_METHOD(createResizedImage, uri:(NSString *)uri width:(double)width height:(double)height format:(NSString *)format quality:(double)quality mode:(NSString *)mode onlyScaleDown:(BOOL)onlyScaleDown rotation:(nonnull NSNumber *)rotation outputPath:(NSString *)outputPath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
-    [self createResizedImage:uri width:width height:height format:format quality:quality mode:mode onlyScaleDown:onlyScaleDown rotation:rotation outputPath:outputPath keepMeta:keepMeta resolve:resolve reject:reject];
+    [self createResizedImage:uri width:width height:height format:format quality:quality mode:mode onlyScaleDown:onlyScaleDown rotation:rotation outputPath:outputPath resolve:resolve reject:reject];
 }
 
-- (void)createResizedImage:(NSString *)uri width:(double)width height:(double)height format:(NSString *)format quality:(double)quality mode:(NSString *)mode onlyScaleDown:(BOOL)onlyScaleDown rotation:(nonnull NSNumber *)rotation outputPath:(NSString *)outputPath keepMeta:(nonnull NSNumber *)keepMeta resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)createResizedImage:(NSString *)uri width:(double)width height:(double)height format:(NSString *)format quality:(double)quality mode:(NSString *)mode onlyScaleDown:(BOOL)onlyScaleDown rotation:(nonnull NSNumber *)rotation outputPath:(NSString *)outputPath resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
         @try {
             CGSize newSize = CGSizeMake(width, height);
@@ -57,7 +55,7 @@ RCT_REMAP_METHOD(createResizedImage, uri:(NSString *)uri width:(double)width hei
                     reject([NSString stringWithFormat: @"%ld", (long)error.code], error.description, nil);
                     return;
                 }
-                NSDictionary * response =  transformImage(image, uri, [rotation integerValue], newSize, fullPath, format, (int)quality, [keepMeta boolValue], @{@"mode": mode, @"onlyScaleDown": [NSNumber numberWithBool:onlyScaleDown]});
+                NSDictionary * response =  transformImage(image, [rotation integerValue], newSize, fullPath, format, (int)quality, @{@"mode": mode, @"onlyScaleDown": [NSNumber numberWithBool:onlyScaleDown]});
                 resolve(response);
             }];
         } @catch (NSException *exception) {
@@ -69,65 +67,21 @@ RCT_REMAP_METHOD(createResizedImage, uri:(NSString *)uri width:(double)width hei
 
 
 
-bool saveImage(NSString * fullPath, UIImage * image, NSString * format, float quality, NSMutableDictionary *metadata)
+bool saveImage(NSString * fullPath, UIImage * image, NSString * format, float quality)
 {
-    if(metadata == nil){
-        NSData* data = nil;
-        if ([format isEqualToString:@"JPEG"]) {
-            data = UIImageJPEGRepresentation(image, quality / 100.0);
-        } else if ([format isEqualToString:@"PNG"]) {
-            data = UIImagePNGRepresentation(image);
-        }
-
-        if (data == nil) {
-            return NO;
-        }
-
-        NSFileManager* fileManager = [NSFileManager defaultManager];
-        return [fileManager createFileAtPath:fullPath contents:data attributes:nil];
+    NSData* data = nil;
+    if ([format isEqualToString:@"JPEG"]) {
+        data = UIImageJPEGRepresentation(image, quality / 100.0);
+    } else if ([format isEqualToString:@"PNG"]) {
+        data = UIImagePNGRepresentation(image);
     }
 
-    // process / write metadata together with image data
-    else{
-
-        CFStringRef imgType = kUTTypeJPEG;
-
-        if ([format isEqualToString:@"JPEG"]) {
-            [metadata setObject:@(quality / 100.0) forKey:(__bridge NSString *)kCGImageDestinationLossyCompressionQuality];
-        }
-        else if([format isEqualToString:@"PNG"]){
-            imgType = kUTTypePNG;
-        }
-        else{
-            return NO;
-        }
-
-        NSMutableData * destData = [NSMutableData data];
-
-        CGImageDestinationRef destination = CGImageDestinationCreateWithData((__bridge CFMutableDataRef)destData, imgType, 1, NULL);
-
-        @try{
-            CGImageDestinationAddImage(destination, image.CGImage, (__bridge CFDictionaryRef) metadata);
-
-            // write final image data with metadata to our destination
-            if (CGImageDestinationFinalize(destination)){
-
-                NSFileManager* fileManager = [NSFileManager defaultManager];
-                return [fileManager createFileAtPath:fullPath contents:destData attributes:nil];
-            }
-            else{
-                return NO;
-            }
-        }
-        @finally{
-            @try{
-                CFRelease(destination);
-            }
-            @catch(NSException *exception){
-                NSLog(@"Failed to release CGImageDestinationRef: %@", exception);
-            }
-        }
+    if (data == nil) {
+        return NO;
     }
+
+    NSFileManager* fileManager = [NSFileManager defaultManager];
+    return [fileManager createFileAtPath:fullPath contents:data attributes:nil];
 }
 
 NSString * generateFilePath(NSString * ext, NSString * outputPath)
@@ -268,81 +222,12 @@ UIImage* scaleImage (UIImage* image, CGSize toSize, NSString* mode, bool onlySca
     return newImage;
 }
 
-// Returns the image's metadata, or nil if failed to retrieve it.
-NSMutableDictionary * getImageMeta(NSString * path)
-{
-    if([path hasPrefix:@"assets-library"]) {
-
-        __block NSMutableDictionary* res = nil;
-
-        ALAssetsLibraryAssetForURLResultBlock resultblock = ^(ALAsset *myasset)
-        {
-
-            NSDictionary *exif = [[myasset defaultRepresentation] metadata];
-            res = [exif mutableCopy];
-
-        };
-
-        ALAssetsLibrary* assetslibrary = [[ALAssetsLibrary alloc] init];
-        NSURL *url = [NSURL URLWithString:[path stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
-
-        [assetslibrary assetForURL:url resultBlock:resultblock failureBlock:^(NSError *error) { NSLog(@"error couldn't image from assets library"); }];
-
-        return res;
-
-    } else {
-
-        NSData* imageData = nil;
-
-        if ([path hasPrefix:@"data:"] || [path hasPrefix:@"file:"]) {
-            NSURL *imageUrl = [[NSURL alloc] initWithString:path];
-            imageData = [NSData dataWithContentsOfURL:imageUrl];
-
-        } else {
-            imageData = [NSData dataWithContentsOfFile:path];
-        }
-
-        if(imageData == nil){
-            NSLog(@"Could not get image file data to extract metadata.");
-            return nil;
-        }
-
-        CGImageSourceRef source = CGImageSourceCreateWithData((CFDataRef)imageData, NULL);
-
-
-        if(source != nil){
-
-            CFDictionaryRef metaRef = CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
-
-            // release CF image
-            CFRelease(source);
-
-            CFMutableDictionaryRef metaRefMutable = CFDictionaryCreateMutableCopy(NULL, 0, metaRef);
-
-            // release the source meta ref now that we've copie it
-            CFRelease(metaRef);
-
-            // bridge CF object so it auto releases
-            NSMutableDictionary* res = (NSMutableDictionary *)CFBridgingRelease(metaRefMutable);
-
-            return res;
-
-        }
-        else{
-            return nil;
-        }
-
-    }
-}
-
 NSDictionary * transformImage(UIImage *image,
-                              NSString * originalPath,
                               int rotation,
                               CGSize newSize,
                               NSString* fullPath,
                               NSString* format,
                               int quality,
-                              BOOL keepMeta,
                               NSDictionary* options)
 {
     if (image == nil) {
@@ -368,25 +253,8 @@ NSDictionary * transformImage(UIImage *image,
     if (scaledImage == nil) {
         [NSException raise:moduleName format:@"Can't resize the image."];
     }
-
-
-    NSMutableDictionary *metadata = nil;
-
-    // to be consistent with Android, we will only allow JPEG
-    // to do this.
-    if(keepMeta && [format isEqualToString:@"JPEG"]){
-
-        metadata = getImageMeta(originalPath);
-
-        // remove orientation (since we fix it)
-        // width/height meta is adjusted automatically
-        // NOTE: This might still leave some stale values due to resize
-        metadata[(NSString*)kCGImagePropertyOrientation] = @(1);
-
-    }
-
     // Compress and save the image
-    if (!saveImage(fullPath, scaledImage, format, quality, metadata)) {
+    if (!saveImage(fullPath, scaledImage, format, quality)) {
         [NSException raise:moduleName format:@"Can't save the image. Check your compression format and your output path"];
     }
 

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-react-native",
   "description": "The official React Native SDK for Stream Chat, a service for building chat applications",
-  "version": "9.0.0-beta.3",
+  "version": "9.0.0-beta.30",
   "homepage": "https://www.npmjs.com/package/stream-chat-react-native",
   "author": {
     "company": "Stream.io Inc",
@@ -21,6 +21,7 @@
     "android/gradle",
     "ios",
     "*.podspec",
+    "react-native.config.js",
     "package.json"
   ],
   "license": "SEE LICENSE IN LICENSE",
@@ -29,7 +30,7 @@
   "dependencies": {
     "es6-symbol": "^3.1.3",
     "mime": "^4.0.7",
-    "stream-chat-react-native-core": "9.0.0-beta.3"
+    "stream-chat-react-native-core": "9.0.0-beta.30"
   },
   "peerDependencies": {
     "@react-native-camera-roll/camera-roll": ">=7.8.0",
@@ -81,7 +82,6 @@
     }
   },
   "scripts": {
-    "postinstall": "if [ -f ../scripts/sync-shared-native.sh ] && [ -d ../shared-native/ios ]; then bash ../scripts/sync-shared-native.sh native-package; fi",
     "prepack": "bash ../scripts/sync-shared-native.sh native-package && cp ../../README.md .",
     "postpack": "rm README.md && bash ../scripts/clean-shared-native-copies.sh native-package"
   },
@@ -92,7 +92,14 @@
     "name": "StreamChatReactNativeSpec",
     "type": "all",
     "jsSrcsDir": "src/native",
+    "android": {
+      "javaPackageName": "com.streamchatreactnative"
+    },
     "ios": {
+      "modulesProvider": {
+        "StreamChatReactNative": "StreamChatReactNative",
+        "StreamVideoThumbnail": "StreamVideoThumbnail"
+      },
       "componentProvider": {
         "StreamShimmerView": "StreamShimmerViewComponentView"
       }

package/react-native.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        packageImportPath: 'import com.streamchatreactnative.StreamChatReactNativePackage;',
+        packageInstance: 'new StreamChatReactNativePackage()',
+      },
+      ios: {
+        podspecPath: 'stream-chat-react-native.podspec',
+      },
+    },
+  },
+};

package/src/handlers/compressImage.ts

@@ -22,7 +22,6 @@ export const compressImage = async ({
       Math.min(Math.max(0, compressImageQuality), 1) * 100,
       0,
       undefined,
-      false,
       { mode: 'cover' },
     );
     return compressedUri;