stream-chat-react-native 8.13.7 → 9.0.0-beta.10

package/android/build.gradle

@@ -1,3 +1,8 @@
+def kotlinVersion =
+  rootProject.ext.has("kotlinVersion")
+    ? rootProject.ext.get("kotlinVersion")
+    : project.properties["ImageResizer_kotlinVersion"]
+
 buildscript {
   repositories {
     google()
@@ -6,7 +11,7 @@ buildscript {
 
   dependencies {
     classpath "com.android.tools.build:gradle:7.2.1"
-
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
   }
 }
 
@@ -15,6 +20,7 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
 
 def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
@@ -30,6 +36,11 @@ def getExtOrDefault(name) {
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ImageResizer_" + name]).toInteger()
 }
+def localSharedNativeRootDir = new File(projectDir, "src/main/java/com/streamchatreactnative/shared")
+def sharedNativeRootDir = new File(projectDir, "../../shared-native/android")
+def hasNativeSources = { File dir ->
+  dir.exists() && !fileTree(dir).matching { include "**/*.kt"; include "**/*.java" }.files.isEmpty()
+}
 
 android {
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -65,11 +76,16 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
   sourceSets {
     main {
       if (isNewArchitectureEnabled()) {
         java.srcDirs += [
           "src/newarch",
+          "src/main/java/com/streamchatreactnative/shared",
           // This is needed to build Kotlin project with NewArch enabled
           "${project.buildDir}/generated/source/codegen/java"
         ]
@@ -80,6 +96,44 @@ android {
   }
 }
 
+tasks.register("syncSharedShimmerSources") {
+  outputs.dir(localSharedNativeRootDir)
+  outputs.upToDateWhen { false }
+  doLast {
+    def sourceRootDir = null
+    if (hasNativeSources(localSharedNativeRootDir)) {
+      sourceRootDir = localSharedNativeRootDir
+    } else if (hasNativeSources(sharedNativeRootDir)) {
+      sourceRootDir = sharedNativeRootDir
+    }
+
+    if (sourceRootDir == null) {
+      throw new GradleException(
+        "Missing shared native Android sources. Expected either src/main/java/com/streamchatreactnative/shared/**/*.{kt,java} " +
+          "or ../../shared-native/android/**/*.{kt,java}."
+      )
+    }
+
+    if (sourceRootDir != localSharedNativeRootDir) {
+      project.delete(localSharedNativeRootDir)
+      project.copy {
+        from(sourceRootDir)
+        into(localSharedNativeRootDir)
+      }
+    } else if (!hasNativeSources(localSharedNativeRootDir)) {
+      throw new GradleException("Shared native source directory exists but has no Kotlin/Java files.")
+    }
+  }
+}
+
+tasks.matching { it.name == "preBuild" }.configureEach {
+  dependsOn("syncSharedShimmerSources")
+}
+
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+  dependsOn("syncSharedShimmerSources")
+}
+
 repositories {
   mavenCentral()
   google()

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

@@ -6,9 +6,11 @@ import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.TurboReactPackage;
-
+import com.facebook.react.uimanager.ViewManager;
 
 import java.util.HashMap;
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 public class StreamChatReactNativePackage extends TurboReactPackage {
@@ -42,4 +44,9 @@ public class StreamChatReactNativePackage extends TurboReactPackage {
       return moduleInfos;
     };
   }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.<ViewManager>singletonList(new StreamShimmerViewManager());
+  }
 }

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

@@ -0,0 +1,260 @@
+package com.streamchatreactnative
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.LinearGradient
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Shader
+import android.util.AttributeSet
+import android.view.View
+import android.view.animation.LinearInterpolator
+import android.widget.FrameLayout
+import kotlin.math.roundToInt
+
+/**
+ * Native shimmer container used by `StreamShimmerView`.
+ *
+ * This view draws a base color plus a moving highlight strip directly on canvas and still behaves
+ * like a regular container for React children. The animation runs fully on the native side so it
+ * does not depend on JS-driven frame updates. It automatically stops animating when the view is
+ * detached or not visible, rebuilds its shader when size or colors change, and waits for valid
+ * dimensions before starting animation to avoid invalid draw/animation states.
+ */
+class StreamShimmerFrameLayout @JvmOverloads constructor(
+  context: Context,
+  attrs: AttributeSet? = null,
+) : FrameLayout(context, attrs) {
+  private var baseColor: Int = DEFAULT_BASE_COLOR
+  private var durationMs: Long = DEFAULT_DURATION_MS
+  private var gradientColor: Int = DEFAULT_GRADIENT_COLOR
+  private var enabled: Boolean = true
+
+  private val basePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  private val shimmerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+    style = Paint.Style.FILL
+    isDither = true
+  }
+  private val shimmerMatrix = Matrix()
+
+  private var shimmerShader: LinearGradient? = null
+  private var shimmerTranslateX: Float = 0f
+  private var animatedDurationMs: Long = 0L
+  private var animatedViewWidth: Float = 0f
+  private var animator: ValueAnimator? = null
+
+  init {
+    setWillNotDraw(false)
+  }
+
+  fun setBaseColor(color: Int) {
+    if (baseColor == color) return
+    baseColor = color
+    rebuildShimmerShader()
+    invalidate()
+  }
+
+  fun setGradientColor(color: Int) {
+    if (gradientColor == color) return
+    gradientColor = color
+    rebuildShimmerShader()
+    invalidate()
+  }
+
+  fun setDuration(duration: Int) {
+    val normalizedDurationMs =
+      if (duration > 0) duration.toLong() else DEFAULT_DURATION_MS
+    if (durationMs == normalizedDurationMs) return
+    durationMs = normalizedDurationMs
+    updateAnimatorState()
+  }
+
+  fun setShimmerEnabled(enabled: Boolean) {
+    if (this.enabled == enabled) return
+    this.enabled = enabled
+    updateAnimatorState()
+    invalidate()
+  }
+
+  fun updateAnimatorState() {
+    // Centralized lifecycle gate for animation start/stop. This keeps shimmer off for detached or
+    // hidden views to avoid wasting UI-thread work in long lists.
+    if (shouldAnimateShimmer()) {
+      startShimmer()
+    } else {
+      stopShimmer()
+    }
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    // Reattachment (including reparenting) should recheck visibility state and restart only if
+    // this instance is eligible to animate.
+    updateAnimatorState()
+  }
+
+  override fun onDetachedFromWindow() {
+    // Detached views are not drawable; stop and clear animator so a future attach starts cleanly.
+    stopShimmer()
+    super.onDetachedFromWindow()
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    rebuildShimmerShader()
+    updateAnimatorState()
+  }
+
+  override fun onWindowVisibilityChanged(visibility: Int) {
+    super.onWindowVisibilityChanged(visibility)
+    updateAnimatorState()
+  }
+
+  override fun onVisibilityChanged(changedView: View, visibility: Int) {
+    super.onVisibilityChanged(changedView, visibility)
+    if (changedView === this) {
+      updateAnimatorState()
+    }
+  }
+
+  override fun dispatchDraw(canvas: Canvas) {
+    val viewWidth = width.toFloat()
+    val viewHeight = height.toFloat()
+    if (viewWidth <= 0f || viewHeight <= 0f) {
+      super.dispatchDraw(canvas)
+      return
+    }
+
+    basePaint.color = baseColor
+    canvas.drawRect(0f, 0f, viewWidth, viewHeight, basePaint)
+
+    drawShimmer(canvas, viewWidth, viewHeight)
+    super.dispatchDraw(canvas)
+  }
+
+  private fun drawShimmer(canvas: Canvas, viewWidth: Float, viewHeight: Float) {
+    if (!enabled) return
+
+    val shader = shimmerShader ?: return
+
+    shimmerMatrix.setTranslate(shimmerTranslateX, 0f)
+    shader.setLocalMatrix(shimmerMatrix)
+    shimmerPaint.shader = shader
+    canvas.drawRect(0f, 0f, viewWidth, viewHeight, shimmerPaint)
+    shimmerPaint.shader = null
+  }
+
+  private fun rebuildShimmerShader() {
+    // Recreates the shimmer gradient for the current width/colors. This allocates shader state,
+    // so keep calls tied to real changes (size or color updates), not per frame execution.
+    val viewWidth = width.toFloat()
+    if (viewWidth <= 0f) {
+      shimmerShader = null
+      return
+    }
+
+    // Wide multi-stop strip creates a softer "glassy" sweep and avoids the hard thin-line look.
+    val shimmerWidth = (viewWidth * SHIMMER_STRIP_WIDTH_RATIO).coerceAtLeast(1f)
+    val transparentHighlight = colorWithAlpha(gradientColor, 0f)
+    val edgeBase = colorWithAlpha(gradientColor, EDGE_HIGHLIGHT_ALPHA_FACTOR)
+    val softBase = colorWithAlpha(gradientColor, SOFT_HIGHLIGHT_ALPHA_FACTOR)
+    val mediumBase = colorWithAlpha(gradientColor, MID_HIGHLIGHT_ALPHA_FACTOR)
+    val innerBase = colorWithAlpha(gradientColor, INNER_HIGHLIGHT_ALPHA_FACTOR)
+    shimmerShader = LinearGradient(
+      0f,
+      0f,
+      shimmerWidth,
+      0f,
+      intArrayOf(
+        transparentHighlight,
+        edgeBase,
+        softBase,
+        mediumBase,
+        innerBase,
+        gradientColor,
+        innerBase,
+        mediumBase,
+        softBase,
+        edgeBase,
+        transparentHighlight,
+      ),
+      floatArrayOf(
+        0f,
+        0.08f,
+        0.2f,
+        0.32f,
+        0.4f,
+        0.5f,
+        0.6f,
+        0.68f,
+        0.8f,
+        0.92f,
+        1f,
+      ),
+      Shader.TileMode.CLAMP,
+    )
+  }
+
+  private fun startShimmer() {
+    val viewWidth = width.toFloat()
+    if (viewWidth <= 0f) return
+    // Keep the existing animator only when size and duration still match the current request.
+    if (animator != null && animatedViewWidth == viewWidth && animatedDurationMs == durationMs) return
+
+    stopShimmer()
+
+    // Animate from fully offscreen left to fully offscreen right so the strip enters/exits cleanly.
+    val shimmerWidth = (viewWidth * SHIMMER_STRIP_WIDTH_RATIO).coerceAtLeast(1f)
+    animatedViewWidth = viewWidth
+    animatedDurationMs = durationMs
+    animator = ValueAnimator.ofFloat(-shimmerWidth, viewWidth).apply {
+      duration = durationMs
+      repeatCount = ValueAnimator.INFINITE
+      interpolator = LinearInterpolator()
+      addUpdateListener {
+        shimmerTranslateX = it.animatedValue as Float
+        invalidate()
+      }
+      start()
+    }
+  }
+
+  private fun stopShimmer() {
+    animator?.cancel()
+    animator = null
+    animatedDurationMs = 0L
+    animatedViewWidth = 0f
+  }
+
+  private fun shouldAnimateShimmer(): Boolean {
+    // `isShown` and explicit visibility/window checks cover different hide paths in nested
+    // hierarchies. Keeping them all prevents animations running when not visible to the user.
+    return enabled &&
+      isAttachedToWindow &&
+      width > 0 &&
+      height > 0 &&
+      visibility == View.VISIBLE &&
+      windowVisibility == View.VISIBLE &&
+      isShown &&
+      alpha > 0f
+  }
+
+  private fun colorWithAlpha(color: Int, alphaFactor: Float): Int {
+    // Preserve RGB while shaping only alpha; used for symmetric highlight falloff in gradient stops.
+    val alpha = (Color.alpha(color) * alphaFactor).roundToInt().coerceIn(0, 255)
+    return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color))
+  }
+
+  companion object {
+    private const val DEFAULT_BASE_COLOR = 0x00FFFFFF
+    private const val DEFAULT_DURATION_MS = 1200L
+    private const val DEFAULT_GRADIENT_COLOR = 0x59FFFFFF
+    private const val SHIMMER_STRIP_WIDTH_RATIO = 1.25f
+    private const val EDGE_HIGHLIGHT_ALPHA_FACTOR = 0.1f
+    private const val SOFT_HIGHLIGHT_ALPHA_FACTOR = 0.24f
+    private const val MID_HIGHLIGHT_ALPHA_FACTOR = 0.48f
+    private const val INNER_HIGHLIGHT_ALPHA_FACTOR = 0.72f
+  }
+}

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

@@ -0,0 +1,85 @@
+package com.streamchatreactnative
+
+import androidx.annotation.NonNull
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.viewmanagers.StreamShimmerViewManagerDelegate
+import com.facebook.react.viewmanagers.StreamShimmerViewManagerInterface
+
+/**
+ * Fabric manager for StreamShimmerView.
+ *
+ * It creates the native shimmer layout, maps React props to native setters, and exposes child
+ * management methods so Fabric can mount and unmount children correctly inside this container.
+ * The manager rechecks animation state after prop transactions and disables shimmer when a view
+ * instance is dropped as a defensive cleanup step for recycled or unmounted views. Because the
+ * shimmer view wraps React children, this must remain a real ViewGroupManager as using a non-group
+ * manager can fail in Fabric mounting paths at runtime.
+ */
+class StreamShimmerViewManager : ViewGroupManager<StreamShimmerFrameLayout>(),
+  StreamShimmerViewManagerInterface<StreamShimmerFrameLayout> {
+  private val delegate = StreamShimmerViewManagerDelegate(this)
+
+  override fun getName(): String = REACT_CLASS
+
+  @NonNull
+  override fun createViewInstance(@NonNull reactContext: ThemedReactContext): StreamShimmerFrameLayout {
+    val layout = StreamShimmerFrameLayout(reactContext)
+    layout.updateAnimatorState()
+    return layout
+  }
+
+  override fun onAfterUpdateTransaction(@NonNull view: StreamShimmerFrameLayout) {
+    super.onAfterUpdateTransaction(view)
+    // Prop batches can change visibility/enabled/colors together, so we re-evaluate the animator once
+    // after every transaction to keep state consistent and avoid duplicate start/stop churn.
+    view.updateAnimatorState()
+  }
+
+  override fun addView(parent: StreamShimmerFrameLayout, child: android.view.View, index: Int) {
+    parent.addView(child, index)
+  }
+
+  override fun getChildAt(parent: StreamShimmerFrameLayout, index: Int): android.view.View {
+    return parent.getChildAt(index)
+  }
+
+  override fun getChildCount(parent: StreamShimmerFrameLayout): Int {
+    return parent.childCount
+  }
+
+  override fun removeViewAt(parent: StreamShimmerFrameLayout, index: Int) {
+    parent.removeViewAt(index)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<StreamShimmerFrameLayout> = delegate
+
+  override fun setEnabled(view: StreamShimmerFrameLayout, enabled: Boolean) {
+    view.setShimmerEnabled(enabled)
+  }
+
+  override fun setBaseColor(view: StreamShimmerFrameLayout, color: Int?) {
+    view.setBaseColor(color ?: DEFAULT_BASE_COLOR)
+  }
+
+  override fun setDuration(view: StreamShimmerFrameLayout, duration: Int) {
+    view.setDuration(duration)
+  }
+
+  override fun setGradientColor(view: StreamShimmerFrameLayout, color: Int?) {
+    view.setGradientColor(color ?: DEFAULT_GRADIENT_COLOR)
+  }
+
+  override fun onDropViewInstance(@NonNull view: StreamShimmerFrameLayout) {
+    super.onDropViewInstance(view)
+    // Defensive shutdown for recycled/unmounted views; avoids animator leaks in list-heavy screens.
+    view.setShimmerEnabled(false)
+  }
+
+  companion object {
+    const val REACT_CLASS = "StreamShimmerView"
+    private const val DEFAULT_BASE_COLOR = 0x00FFFFFF
+    private const val DEFAULT_GRADIENT_COLOR = 0x59FFFFFF
+  }
+}

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);
 }