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

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/StreamChatReactNative.java

@@ -11,7 +11,6 @@ import android.net.Uri;
 import android.os.Build;
 import android.provider.MediaStore;
 import android.util.Base64;
-import android.util.Log;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -33,108 +32,6 @@ public class StreamChatReactNative {
   private final static String SCHEME_FILE = "file";
   private final static String SCHEME_HTTP = "http";
   private final static String SCHEME_HTTPS = "https";
-
-
-  // List of known EXIF tags we will be copying.
-  // Orientation, width, height, and some others are ignored
-  // TODO: Find any missing tag that might be useful
-  private final static String[] EXIF_TO_COPY_ROTATED = new String[]
-    {
-      ExifInterface.TAG_APERTURE_VALUE,
-      ExifInterface.TAG_MAX_APERTURE_VALUE,
-      ExifInterface.TAG_METERING_MODE,
-      ExifInterface.TAG_ARTIST,
-      ExifInterface.TAG_BITS_PER_SAMPLE,
-      ExifInterface.TAG_COMPRESSION,
-      ExifInterface.TAG_BODY_SERIAL_NUMBER,
-      ExifInterface.TAG_BRIGHTNESS_VALUE,
-      ExifInterface.TAG_CONTRAST,
-      ExifInterface.TAG_CAMERA_OWNER_NAME,
-      ExifInterface.TAG_COLOR_SPACE,
-      ExifInterface.TAG_COPYRIGHT,
-      ExifInterface.TAG_DATETIME,
-      ExifInterface.TAG_DATETIME_DIGITIZED,
-      ExifInterface.TAG_DATETIME_ORIGINAL,
-      ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION,
-      ExifInterface.TAG_DIGITAL_ZOOM_RATIO,
-      ExifInterface.TAG_EXIF_VERSION,
-      ExifInterface.TAG_EXPOSURE_BIAS_VALUE,
-      ExifInterface.TAG_EXPOSURE_INDEX,
-      ExifInterface.TAG_EXPOSURE_MODE,
-      ExifInterface.TAG_EXPOSURE_TIME,
-      ExifInterface.TAG_EXPOSURE_PROGRAM,
-      ExifInterface.TAG_FLASH,
-      ExifInterface.TAG_FLASH_ENERGY,
-      ExifInterface.TAG_FOCAL_LENGTH,
-      ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM,
-      ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT,
-      ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION,
-      ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION,
-      ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION,
-      ExifInterface.TAG_PLANAR_CONFIGURATION,
-      ExifInterface.TAG_F_NUMBER,
-      ExifInterface.TAG_GAIN_CONTROL,
-      ExifInterface.TAG_GAMMA,
-      ExifInterface.TAG_GPS_ALTITUDE,
-      ExifInterface.TAG_GPS_ALTITUDE_REF,
-      ExifInterface.TAG_GPS_AREA_INFORMATION,
-      ExifInterface.TAG_GPS_DATESTAMP,
-      ExifInterface.TAG_GPS_DOP,
-      ExifInterface.TAG_GPS_LATITUDE,
-      ExifInterface.TAG_GPS_LATITUDE_REF,
-      ExifInterface.TAG_GPS_LONGITUDE,
-      ExifInterface.TAG_GPS_LONGITUDE_REF,
-      ExifInterface.TAG_GPS_STATUS,
-      ExifInterface.TAG_GPS_DEST_BEARING,
-      ExifInterface.TAG_GPS_DEST_BEARING_REF,
-      ExifInterface.TAG_GPS_DEST_DISTANCE,
-      ExifInterface.TAG_GPS_DEST_DISTANCE_REF,
-      ExifInterface.TAG_GPS_DEST_LATITUDE,
-      ExifInterface.TAG_GPS_DEST_LATITUDE_REF,
-      ExifInterface.TAG_GPS_DEST_LONGITUDE,
-      ExifInterface.TAG_GPS_DEST_LONGITUDE_REF,
-      ExifInterface.TAG_GPS_DIFFERENTIAL,
-      ExifInterface.TAG_GPS_IMG_DIRECTION,
-      ExifInterface.TAG_GPS_IMG_DIRECTION_REF,
-      ExifInterface.TAG_GPS_MAP_DATUM,
-      ExifInterface.TAG_GPS_MEASURE_MODE,
-      ExifInterface.TAG_GPS_PROCESSING_METHOD,
-      ExifInterface.TAG_GPS_SATELLITES,
-      ExifInterface.TAG_GPS_SPEED,
-      ExifInterface.TAG_GPS_SPEED_REF,
-      ExifInterface.TAG_GPS_STATUS,
-      ExifInterface.TAG_GPS_TIMESTAMP,
-      ExifInterface.TAG_GPS_TRACK,
-      ExifInterface.TAG_GPS_TRACK_REF,
-      ExifInterface.TAG_GPS_VERSION_ID,
-      ExifInterface.TAG_IMAGE_DESCRIPTION,
-      ExifInterface.TAG_IMAGE_UNIQUE_ID,
-      ExifInterface.TAG_ISO_SPEED,
-      ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY,
-      ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT,
-      ExifInterface.TAG_JPEG_INTERCHANGE_FORMAT_LENGTH,
-      ExifInterface.TAG_LENS_MAKE,
-      ExifInterface.TAG_LENS_MODEL,
-      ExifInterface.TAG_LENS_SERIAL_NUMBER,
-      ExifInterface.TAG_LENS_SPECIFICATION,
-      ExifInterface.TAG_LIGHT_SOURCE,
-      ExifInterface.TAG_MAKE,
-      ExifInterface.TAG_MAKER_NOTE,
-      ExifInterface.TAG_MODEL,
-      // ExifInterface.TAG_ORIENTATION, // removed
-      ExifInterface.TAG_SATURATION,
-      ExifInterface.TAG_SHARPNESS,
-      ExifInterface.TAG_SHUTTER_SPEED_VALUE,
-      ExifInterface.TAG_SOFTWARE,
-      ExifInterface.TAG_SUBJECT_DISTANCE,
-      ExifInterface.TAG_SUBJECT_DISTANCE_RANGE,
-      ExifInterface.TAG_SUBJECT_LOCATION,
-      ExifInterface.TAG_USER_COMMENT,
-      ExifInterface.TAG_WHITE_BALANCE
-    };
-
-
-
   /**
    * Resize the specified bitmap.
    */
@@ -263,55 +160,6 @@ public class StreamChatReactNative {
     return file;
   }
 
-  /**
-   * Attempts to copy exif info from one file to another. Note: orientation, width, and height
-   exif attributes are not copied since those are lost after image rotation.
-
-   * imageUri: original image URI as provided from JS
-   * dstPath: final image output path
-   * Returns true if copy was successful, false otherwise.
-   */
-  public static boolean copyExif(Context context, Uri imageUri, String dstPath){
-    ExifInterface src = null;
-    ExifInterface dst = null;
-
-    try {
-
-      File file = getFileFromUri(context, imageUri);
-      if (!file.exists()) {
-        return false;
-      }
-
-      src = new ExifInterface(file.getAbsolutePath());
-      dst = new ExifInterface(dstPath);
-
-    } catch (Exception ignored) {
-      Log.e("StreamChatReactNative::copyExif", "EXIF read failed", ignored);
-    }
-
-    if(src == null || dst == null){
-      return false;
-    }
-
-    try{
-
-      for (String attr : EXIF_TO_COPY_ROTATED)
-      {
-        String value = src.getAttribute(attr);
-        if (value != null){
-          dst.setAttribute(attr, value);
-        }
-      }
-      dst.saveAttributes();
-
-    } catch (Exception ignored) {
-      Log.e("StreamChatReactNative::copyExif", "EXIF copy failed", ignored);
-      return false;
-    }
-
-    return true;
-  }
-
   /**
    * Get orientation by reading Image metadata
    */
@@ -591,4 +439,3 @@ public class StreamChatReactNative {
     return scaledImage;
   }
 }
-

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

@@ -4,8 +4,6 @@ import android.annotation.SuppressLint;
 import android.graphics.Bitmap;
 import android.net.Uri;
 import android.os.AsyncTask;
-import android.util.Log;
-
 import androidx.annotation.Nullable;
 import androidx.annotation.NonNull;
 
@@ -36,7 +34,7 @@ public class StreamChatReactNativeModule extends StreamChatReactNativeSpec {
   }
 
   @ReactMethod
-  public void createResizedImage(String uri, double width, double height, String format, double quality, String mode, boolean onlyScaleDown, Double rotation, @Nullable String outputPath, Boolean keepMeta, Promise promise) {
+  public void createResizedImage(String uri, double width, double height, String format, double quality, String mode, boolean onlyScaleDown, Double rotation, @Nullable String outputPath, Promise promise) {
     WritableMap options = Arguments.createMap();
     options.putString("mode", mode);
     options.putBoolean("onlyScaleDown", onlyScaleDown);
@@ -46,7 +44,7 @@ public class StreamChatReactNativeModule extends StreamChatReactNativeSpec {
       @Override
       protected void doInBackgroundGuarded(Void... params) {
         try {
-          Object response = createResizedImageWithExceptions(uri, (int) width, (int) height, format, (int) quality, rotation.intValue(), outputPath, keepMeta, options);
+          Object response = createResizedImageWithExceptions(uri, (int) width, (int) height, format, (int) quality, rotation.intValue(), outputPath, options);
           promise.resolve(response);
         }
         catch (IOException e) {
@@ -59,7 +57,6 @@ public class StreamChatReactNativeModule extends StreamChatReactNativeSpec {
   @SuppressLint("LongLogTag")
   private Object createResizedImageWithExceptions(String imagePath, int newWidth, int newHeight,
                                                   String compressFormatString, int quality, int rotation, String outputPath,
-                                                  final boolean keepMeta,
                                                   final ReadableMap options) throws IOException {
 
     Bitmap.CompressFormat compressFormat = Bitmap.CompressFormat.valueOf(compressFormatString);
@@ -89,16 +86,6 @@ public class StreamChatReactNativeModule extends StreamChatReactNativeSpec {
       response.putDouble("size", resizedImage.length());
       response.putDouble("width", scaledImage.getWidth());
       response.putDouble("height", scaledImage.getHeight());
-
-      // Copy file's metadata/exif info if required
-      if(keepMeta){
-        try{
-          StreamChatReactNative.copyExif(this.getReactApplicationContext(), imageUri, resizedImage.getAbsolutePath());
-        }
-        catch(Exception ignored){
-          Log.e("StreamChatReactNative::createResizedImageWithExceptions", "EXIF copy failed", ignored);
-        }
-      }
     } else {
       throw new IOException("Error getting resized image path");
     }

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/android/src/oldarch/com/streamchatreactnative/StreamChatReactNative.java

@@ -12,5 +12,5 @@ abstract class StreamChatReactNativeSpec extends ReactContextBaseJavaModule {
     super(context);
   }
 
-  public abstract void createResizedImage(String uri, double width, double height, String format, double quality, String mode, boolean onlyScaleDown, Double rotation, @Nullable String outputPath, Boolean keepMeta, Promise promise);
+  public abstract void createResizedImage(String uri, double width, double height, String format, double quality, String mode, boolean onlyScaleDown, Double rotation, @Nullable String outputPath, Promise promise);
 }