feat: add swift image compress native module

Author: khushal87

package/native-package/ios/ImageCompression/StreamChatImageCompress.swift

@@ -0,0 +1,120 @@
+import SDWebImageWebPCoder
+
+internal enum ImageFormat: String {
+  case jpeg
+  case jpg
+  case png
+  case webp
+
+  var fileExtension: String {
+    switch self {
+      case .jpeg, .jpg:
+        return "jpeg"
+      case .png:
+        return "png"
+      case .webp:
+        return "webp"
+    }
+  }
+}
+
+internal struct SaveImageOptions {
+  var base64: Bool = false
+  var compressImageQuality: Double = 1.0
+  var format: ImageFormat = .jpeg
+}
+
+internal typealias SaveImageResult = (url: URL, data: Data)
+
+func imageData(from image: UIImage, options: SaveImageOptions) -> Data? {
+  switch options.format {
+    case .jpeg, .jpg:
+      return image.jpegData(compressionQuality: options.compressImageQuality)
+    case .png:
+      return image.pngData()
+    case .webp:
+      return SDImageWebPCoder.shared.encodedData(with: image, format: .webP, options: [.encodeCompressionQuality: options.compressImageQuality])
+  }
+}
+
+
+@objc(StreamChatImageCompress)
+class StreamChatImageCompress: NSObject {
+  private func saveImage(image: UIImage, options: SaveImageOptions) -> SaveImageResult? {
+    // First create a file path
+    let fileManager = FileManager.default
+    let tempDirectory = fileManager.temporaryDirectory
+    let fileName = UUID().uuidString
+    let filePath = tempDirectory.appendingPathComponent(fileName).appendingPathExtension(options.format.fileExtension)
+
+    // Then save the image to the file path
+    guard let data = imageData(from: image, options: options) else {
+        print("Failed to get image data")
+        return nil
+    }
+
+    do {
+      try data.write(to: filePath, options: .atomic)
+    } catch {
+      // Log the error
+      print("Error saving image: \(error)")
+      return nil
+    }
+
+    return SaveImageResult(url: filePath, data: data)
+  }
+
+  private func parseSaveImageOptions(from dict: NSDictionary) -> SaveImageOptions {
+    var options = SaveImageOptions()
+
+    if let quality = dict["compressImageQuality"] as? Double {
+      options.compressImageQuality = quality
+    }
+
+    if let formatString = dict["format"] as? String,
+        let format = ImageFormat(rawValue: formatString.lowercased()) {
+      options.format = format
+    }
+
+    if let base64 = dict["base64"] as? Bool {
+      options.base64 = base64
+    }
+
+    return options
+  }
+
+  @objc
+  func compressImage(_ imageURL: String,
+                     options: NSDictionary,
+                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+    let savedOptions = parseSaveImageOptions(from: options)
+
+    print("Compressing image at \(imageURL)")
+
+    // Convert URL string to path
+    var imagePath = imageURL
+    if imageURL.hasPrefix("file://") {
+      if let url = URL(string: imageURL) {
+        imagePath = url.path
+      }
+    }
+
+    print("Compressing image at \(imagePath)")
+
+
+    // First load the image
+    guard let image = UIImage(contentsOfFile: imagePath) else {
+      reject("Failed to load image", "Failed to load image", nil)
+      return
+    }
+
+    // Then compress the image
+    guard let result = saveImage(image: image, options: savedOptions) else {
+      reject("IMAGE_SAVE_ERROR", "Failed to save compressed image", nil)
+      return
+    }
+
+    resolve(result.url.absoluteString)
+  }
+}

package/native-package/ios/ImageCompression/StreamChatImageCompressBridge.m

@@ -0,0 +1,12 @@
+// StreamChatImageCompressBridge.m
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(StreamChatImageCompress, NSObject)
+
+RCT_EXTERN_METHOD(compressImage:(NSString *)imageURL
+                  options:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/native-package/src/handlers/compressImage.ts

@@ -1,33 +1,19 @@
-import StreamChatReactNative from '../native';
-
-type CompressImageParams = {
-  compressImageQuality: number;
-  height: number;
-  uri: string;
-  width: number;
-};
+import { compressImage as compressImageNative } from '../native';
 
 export const compressImage = async ({
-  compressImageQuality = 1,
-  height,
   uri,
-  width,
-}: CompressImageParams) => {
+  compressImageQuality = 1,
+}: {
+  uri: string;
+  compressImageQuality?: number;
+}) => {
   try {
-    const { uri: compressedUri } = await StreamChatReactNative.createResizedImage(
-      uri,
-      width,
-      height,
-      'JPEG',
-      Math.min(Math.max(0, compressImageQuality), 1) * 100,
-      0,
-      undefined,
-      false,
-      { mode: 'cover' },
-    );
-    return compressedUri;
+    const result = await compressImageNative(uri, {
+      compressImageQuality: Math.min(Math.max(0, compressImageQuality), 1),
+    });
+    return result;
   } catch (error) {
     console.log('Error resizing image:', error);
-    return uri;
+    return null;
   }
 };

package/native-package/src/native/NativeStreamChatImageCompress.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  compressImage(
+    imageURL: string,
+    options: {
+      base64: boolean;
+      compressImageQuality: number;
+      format: 'JPEG' | 'PNG' | 'WEBP';
+    },
+  ): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('StreamChatImageCompress');

package/native-package/src/native/index.tsx

@@ -10,6 +10,8 @@ import type {
 export type { ResizeFormat, ResizeMode, Response } from './types';
 import NativeStreamChatHapticsModule from './NativeStreamChatHapticsModule';
 import NativeStreamChatReactNative from './NativeStreamChatReactNative';
+import NativeStreamChatImageCompress from './NativeStreamChatImageCompress';
+import { CompressImageOptions } from './types/compressImage';
 
 // @ts-ignore
 // eslint-disable-next-line no-underscore-dangle
@@ -23,6 +25,10 @@ const Haptics = isTurboModuleEnabled
   ? NativeStreamChatHapticsModule
   : NativeModules.StreamChatHapticsModule;
 
+const ImageCompress = isTurboModuleEnabled
+  ? NativeStreamChatImageCompress
+  : NativeModules.StreamChatImageCompress;
+
 const defaultOptions: Options = {
   mode: 'contain',
   onlyScaleDown: false,
@@ -67,6 +73,10 @@ export async function selectionFeedback() {
   await Haptics.selectionFeedback();
 }
 
+export async function compressImage(imageURL: string, options: CompressImageOptions) {
+  return await ImageCompress.compressImage(imageURL, options);
+}
+
 export default {
   createResizedImage,
 };

package/native-package/src/native/types/compressImage.ts

@@ -0,0 +1,7 @@
+export type ImageFormat = 'JPEG' | 'PNG' | 'WEBP';
+
+export type CompressImageOptions = {
+  base64?: boolean;
+  compressImageQuality?: number;
+  format?: ImageFormat;
+};

package/native-package/stream-chat-react-native.podspec

@@ -18,6 +18,8 @@ Pod::Spec.new do |s|
 
   s.ios.framework = 'AssetsLibrary', 'MobileCoreServices'
 
+  s.dependency "SDWebImageWebPCoder"
+
   if respond_to?(:install_modules_dependencies, true)
     install_modules_dependencies(s)
   else