Merge pull request #2648 from DataDog/yl/compose/coil3-support-pr

RUM-9053: Support Coil3 for Session Replay image recording

Author: ambushwork

features/dd-sdk-android-session-replay-compose/consumer-rules.pro

@@ -32,6 +32,19 @@
 -keep class androidx.compose.ui.node.LayoutNode {
      *;
 }
+-keep class androidx.compose.ui.node.NodeChain {
+    <fields>;
+}
+-keep class androidx.compose.ui.Modifier$Node{
+    <fields>;
+}
+-keep class coil3.compose.internal.ContentPainterNode{
+    <fields>;
+}
+-keep class coil3.compose.AsyncImagePainter{
+    <methods>;
+}
+
 -keep class androidx.compose.ui.semantics.SemanticsNode {
      <fields>;
 }

features/dd-sdk-android-session-replay-compose/src/main/kotlin/com/datadog/android/sessionreplay/compose/internal/reflection/ComposeReflection.kt

@@ -24,6 +24,11 @@ internal object ComposeReflection {
 
     val LayoutNodeClass = getClassSafe("androidx.compose.ui.node.LayoutNode")
     val GetInteropViewMethod = LayoutNodeClass?.getDeclaredMethodSafe("getInteropView")
+    val NodesFieldOfLayoutNode = LayoutNodeClass?.getDeclaredFieldSafe("nodes")
+    val NodeChainClass = getClassSafe("androidx.compose.ui.node.NodeChain")
+    val HeadFieldOfNodeChain = NodeChainClass?.getDeclaredFieldSafe("head")
+    val ModifierNodeClass = getClassSafe("androidx.compose.ui.Modifier\$Node")
+    val ChildFieldOfModifierNode = ModifierNodeClass?.getDeclaredFieldSafe("child")
 
     val SemanticsNodeClass = getClassSafe("androidx.compose.ui.semantics.SemanticsNode")
     val LayoutNodeField = SemanticsNodeClass?.getDeclaredFieldSafe("layoutNode")
@@ -80,6 +85,8 @@ internal object ComposeReflection {
     val AndroidImageBitmapClass = getClassSafe("androidx.compose.ui.graphics.AndroidImageBitmap")
     val BitmapField = AndroidImageBitmapClass?.getDeclaredFieldSafe("bitmap")
 
+    // Region of Coil
+
     val ContentPainterModifierClass = getClassSafe("coil.compose.ContentPainterModifier")
     val PainterFieldOfContentPainterModifier =
         ContentPainterModifierClass?.getDeclaredFieldSafe("painter")
@@ -97,6 +104,26 @@ internal object ComposeReflection {
     )
     val PainterFieldOfAsyncImagePainter = AsyncImagePainterClass?.getDeclaredFieldSafe("_painter")
 
+    // End region of Coil
+
+    // Region of Coil3
+
+    val PainterNodeClass = getClassSafe(
+        "coil3.compose.internal.ContentPainterNode",
+        isCritical = false
+    )
+
+    val PainterFieldOfPainterNode = PainterNodeClass?.getDeclaredFieldSafe("painter")
+
+    val AsyncImagePainter3Class = getClassSafe(
+        "coil3.compose.AsyncImagePainter",
+        isCritical = false
+    )
+    val PainterMethodOfAsync3ImagePainter =
+        AsyncImagePainter3Class?.getDeclaredMethodSafe("getPainter")
+
+    // End region of Coil3
+
     // Region of MultiParagraph text
     val ParagraphInfoListField = MultiParagraph::class.java.getDeclaredFieldSafe(
         "paragraphInfoList",

features/dd-sdk-android-session-replay-compose/src/main/kotlin/com/datadog/android/sessionreplay/compose/internal/utils/ReflectionUtils.kt

@@ -24,20 +24,27 @@ import androidx.compose.ui.semantics.SemanticsNode
 import androidx.compose.ui.semantics.SemanticsOwner
 import androidx.compose.ui.text.MultiParagraph
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.AsyncImagePainterClass
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.BitmapField
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.ChildFieldOfModifierNode
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.CompositionField
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.ContentPainterElementClass
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.ContentPainterModifierClass
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.GetInnerLayerCoordinatorMethod
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.GetInteropViewMethod
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.HeadFieldOfNodeChain
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.ImageField
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.LayoutField
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.LayoutNodeField
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.NodesFieldOfLayoutNode
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterElementClass
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterField
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterFieldOfAsyncImagePainter
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterFieldOfContentPainterElement
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterFieldOfContentPainterModifier
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterFieldOfPainterNode
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterMethodOfAsync3ImagePainter
+import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.PainterNodeClass
 import com.datadog.android.sessionreplay.compose.internal.reflection.ComposeReflection.StaticLayoutField
 import com.datadog.android.sessionreplay.compose.internal.reflection.getSafe
 
@@ -141,6 +148,31 @@ internal class ReflectionUtils {
         }
     }
 
+    fun getCoil3AsyncImagePainter(semanticsNode: SemanticsNode): Painter? {
+        // Check if Coil3 ContentPainterNode is present first to optimize the performance
+        // by skipping the node chain iteration
+        if (PainterNodeClass == null) {
+            return null
+        }
+        val layoutNode = LayoutNodeField?.getSafe(semanticsNode)
+        val nodeChain = NodesFieldOfLayoutNode?.getSafe(layoutNode)
+        val headNode = HeadFieldOfNodeChain?.getSafe(nodeChain) as? Modifier.Node
+        var currentNode = headNode
+        var painterNode: Modifier.Node? = null
+        // Iterate NodeChain to find Coil3 `ContentPainterNode`
+        while (currentNode != null) {
+            if (currentNode::class.java == PainterNodeClass) {
+                painterNode = currentNode
+                break
+            }
+            currentNode = ChildFieldOfModifierNode?.getSafe(currentNode) as? Modifier.Node
+        }
+        val asyncImagePainter = PainterFieldOfPainterNode?.getSafe(painterNode)
+        val painter =
+            asyncImagePainter?.let { PainterMethodOfAsync3ImagePainter?.invoke(it) }
+        return painter as? Painter
+    }
+
     fun getLocalImagePainter(semanticsNode: SemanticsNode): Painter? {
         val modifier = semanticsNode.layoutInfo.getModifierInfo().firstOrNull {
             PainterElementClass?.isInstance(it.modifier) == true
@@ -149,6 +181,11 @@ internal class ReflectionUtils {
     }
 
     fun getAsyncImagePainter(semanticsNode: SemanticsNode): Painter? {
+        // Check if Coil AsyncImagePainter is present first to optimize the performance
+        // by skipping the modifier iteration
+        if (AsyncImagePainterClass == null) {
+            return null
+        }
         val asyncPainter = semanticsNode.layoutInfo.getModifierInfo().firstNotNullOfOrNull {
             if (ContentPainterModifierClass?.isInstance(it.modifier) == true) {
                 PainterFieldOfContentPainterModifier?.getSafe(it.modifier)

features/dd-sdk-android-session-replay-compose/src/main/kotlin/com/datadog/android/sessionreplay/compose/internal/utils/SemanticsUtils.kt

@@ -249,15 +249,21 @@ internal class SemanticsUtils(private val reflectionUtils: ReflectionUtils = Ref
     ): BitmapInfo? {
         var isContextualImage = false
         var painter = reflectionUtils.getLocalImagePainter(semanticsNode)
+
+        // Try to resolve Coil AsyncImagePainter.
         if (painter == null) {
             isContextualImage = true
             painter = reflectionUtils.getAsyncImagePainter(semanticsNode)
         }
-        // TODO RUM-6535: support more painters.
+        // In some versions of Coil, bitmap painter is nested in `AsyncImagePainter`
         if (painter != null && reflectionUtils.isAsyncImagePainter(painter)) {
             isContextualImage = true
             painter = reflectionUtils.getNestedPainter(painter)
         }
+        // Try to resolve Coil3 painter if is still null.
+        if (painter == null) {
+            painter = reflectionUtils.getCoil3AsyncImagePainter(semanticsNode)
+        }
         val bitmap = when (painter) {
             is BitmapPainter -> reflectionUtils.getBitmapInBitmapPainter(painter)
             is VectorPainter -> reflectionUtils.getBitmapInVectorPainter(painter)