detox 20.44.0-smoke.1 → 20.44.0-smoke.3

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3-sources.jar.md5

@@ -0,0 +1 @@
+6c1c629a4bb9fb113a38d3f2babcdaf9

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3-sources.jar.sha1

@@ -0,0 +1 @@
+016b3ca18886178b7a615db51c442a411d0dcc76

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3-sources.jar.sha256

@@ -0,0 +1 @@
+25c112c9be84680ae6ea75a3ad09ac53ad18d42f0e66ffd362047cf4cadeec13

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3-sources.jar.sha512

@@ -0,0 +1 @@
+2bae6abf332074d5a949d58ecd2499af1493b953d7ee8b2b322ab7b384c03608171d997dceac4d114973636703748f480a189a7ccaa27865665ec7c2e051b090

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.aar.md5

@@ -0,0 +1 @@
+c3f8d3dc2d7edb9ccf2e95efca9450ca

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.aar.sha1

@@ -0,0 +1 @@
+e0bcddf47775a5112e413fea3790fa565092df86

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.aar.sha256

@@ -0,0 +1 @@
+2230846f74335e85d6edd07294869e1604efdda6b98fcf0abaff34b85b18f3fb

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.aar.sha512

@@ -0,0 +1 @@
+bcff1f76753fe3725089dc1e4130aa2f4100907b1912122bf461ebe6bd588f7cf5b4c6cdb8a7eeaa84b957e511d206563d8a2cf7c0d0cef1357959448e86c483

package/Detox-android/com/wix/detox/{20.44.0-smoke.1/detox-20.44.0-smoke.1.pom → 20.44.0-smoke.3/detox-20.44.0-smoke.3.pom}

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
-  <version>20.44.0-smoke.1</version>
+  <version>20.44.0-smoke.3</version>
   <packaging>aar</packaging>
   <name>Detox</name>
   <description>Gray box end-to-end testing and automation library for mobile apps</description>

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.pom.md5

@@ -0,0 +1 @@
+d1b54d72ec1e32909012654ebb143147

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.pom.sha1

@@ -0,0 +1 @@
+bfaa5fed850535443ca38a8d7bb765f0629ffa37

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.pom.sha256

@@ -0,0 +1 @@
+4ad653fa6e356e01536665021591f24d8fddc7d9e37490b9136d3ed8ed48e09f

package/Detox-android/com/wix/detox/20.44.0-smoke.3/detox-20.44.0-smoke.3.pom.sha512

@@ -0,0 +1 @@
+0e53116005919ab7a58d00f77e3649e31c1592b18837fa91b5ed998c5eea52d08f2067b3f54d15ba053d683f54158f5404321e00cf2e67ff64f99455ca1d05df

package/Detox-android/com/wix/detox/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
   <versioning>
-    <latest>20.44.0-smoke.1</latest>
-    <release>20.44.0-smoke.1</release>
+    <latest>20.44.0-smoke.3</latest>
+    <release>20.44.0-smoke.3</release>
     <versions>
-      <version>20.44.0-smoke.1</version>
+      <version>20.44.0-smoke.3</version>
     </versions>
-    <lastUpdated>20251009104839</lastUpdated>
+    <lastUpdated>20251009174711</lastUpdated>
   </versioning>
 </metadata>

package/Detox-android/com/wix/detox/maven-metadata.xml.md5

@@ -1 +1 @@
-4baad9ede6680e5d2b46f1246a48c8f9
+c8acd83b4c64653b9e9ba87a7e37abf1

package/Detox-android/com/wix/detox/maven-metadata.xml.sha1

@@ -1 +1 @@
-b07f36a5c0ae07b6a7961b318ca15b8acc44d602
+fa3e431bbd58b9c608fe0396caa81eb7b2123391

package/Detox-android/com/wix/detox/maven-metadata.xml.sha256

@@ -1 +1 @@
-a95b41be51ad53267864aae6fc777db00648abe236c7bdbd46c645543e9c052f
+4c4fe8daadb8a5ecad499fd25cf6b5556dbfab190c98280df02898da11bf7b71

package/Detox-android/com/wix/detox/maven-metadata.xml.sha512

@@ -1 +1 @@
-03f466d7a8a4a9f3a5b82b78cc9fcfc0020dd9bb7e3c7d821096887eb241118db40ce09f2f4912a6de05bd2b4c4d75ad48133665e37f68c37bae4a3b227d08ca
+da8e523ed536ed9515efe564b4497e1a2872a5860aacd2388fe37ab6b12a1df3d40c3a30c5e58a33b03fec0a585d89807ea9e23cae35408024ade6c199b09daa

package/android/detox/src/full/java/com/wix/detox/adapters/server/DetoxActionHandlers.kt

@@ -69,17 +69,11 @@ class InvokeActionHandler @JvmOverloads constructor(
         val viewHierarchy = if (error is DetoxExceptionWithHierarchy) {
             error.xmlHierarchy
         } else {
-            generateFallbackViewHierarchy()
+            null
         }
 
         return mapOf<String, Any?>("details" to "${errorMessage}\n", "viewHierarchy" to viewHierarchy)
     }
-
-    private fun generateFallbackViewHierarchy() = try {
-        ViewHierarchyGenerator.generateXml(shouldInjectTestIds = false)
-    } catch (e: Exception) {
-        null
-    }
 }
 
 class CleanupActionHandler(

package/android/detox/src/full/java/com/wix/detox/espresso/hierarchy/ViewHierarchyGenerator.kt

@@ -163,9 +163,6 @@ object ViewHierarchyGenerator {
             "label" to (view.getAccessibilityLabel()?.toString() ?: "")
         )
 
-        // Add lifecycle information from ViewLifecycleRegistry
-        addLifecycleAttributes(view, attributes)
-
         val location = IntArray(2).apply { view.getLocationInWindow(this) }
         attributes["x"] = location[0].toString()
         attributes["y"] = location[1].toString()
@@ -174,6 +171,20 @@ object ViewHierarchyGenerator {
             attributes["text"] = view.text.toString()
         }
 
+        // Inject animation metadata
+        val animationMetadata = ViewLifecycleRegistry.getAnimationMetadata(view)
+        if (animationMetadata != null) {
+            animationMetadata.animated?.let {
+                attributes["lastAnimated"] = animationMetadata.getAnimationDurationMs()?.toString() ?: "0"
+            }
+            animationMetadata.updated?.let {
+                attributes["lastUpdated"] = animationMetadata.getUpdateDurationMs()?.toString() ?: "0"
+            }
+            if (ViewLifecycleRegistry.isAnimating(view)) {
+                attributes["animating"] = "true"
+            }
+        }
+
         val currentTestId = view.tag?.toString() ?: ""
 
         val injectedPrefix = "detox_temp_"
@@ -204,64 +215,4 @@ object ViewHierarchyGenerator {
         View.GONE -> "gone"
         else -> "unknown"
     }
-
-    /**
-     * Add lifecycle attributes to the view attributes map.
-     * This includes information about recent animations, updates, and mounts.
-     */
-    private fun addLifecycleAttributes(view: View, attributes: MutableMap<String, String>) {
-        try {
-            // Check if view was recently animated (within last 1.5 seconds)
-            if (ViewLifecycleRegistry.wasRecentlyAnimated(view, 1500)) {
-                attributes["recentlyAnimated"] = "true"
-
-                // Add animation count if available
-                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
-                lifecycleInfo?.let { info ->
-                    attributes["animationCount"] = info.animationCount.toString()
-                    attributes["lastAnimateTime"] = info.lastAnimateTime.toString()
-                }
-            }
-
-            // Check if view was recently updated (within last 1 second)
-            if (ViewLifecycleRegistry.wasRecentlyUpdated(view, 1000)) {
-                attributes["recentlyUpdated"] = "true"
-
-                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
-                lifecycleInfo?.let { info ->
-                    attributes["updateCount"] = info.updateCount.toString()
-                    attributes["lastUpdateTime"] = info.lastUpdateTime.toString()
-                }
-            }
-
-            // Check if view was recently mounted (within last 5 seconds)
-            if (ViewLifecycleRegistry.wasRecentlyMounted(view, 5000)) {
-                attributes["recentlyMounted"] = "true"
-
-                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
-                lifecycleInfo?.let { info ->
-                    attributes["mountTime"] = info.mountTime.toString()
-                }
-            }
-
-            // Check for problematic animations
-            if (ViewLifecycleRegistry.hasCustomEvent(view, "problematic_animation", 2000)) {
-                attributes["problematicAnimation"] = "true"
-            }
-
-            // Add any other custom events
-            val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
-            lifecycleInfo?.let { info ->
-                if (info.customEvents.isNotEmpty()) {
-                    val customEvents = info.customEvents.keys.joinToString(",")
-                    attributes["customEvents"] = customEvents
-                }
-            }
-
-        } catch (e: Exception) {
-            // Silently ignore errors to avoid breaking the hierarchy generation
-            // Log at debug level for debugging
-            android.util.Log.d("ViewHierarchyGenerator", "Failed to add lifecycle attributes", e)
-        }
-    }
 }

package/android/detox/src/full/java/com/wix/detox/inquiry/FabricAnimationsInquirer.kt

@@ -0,0 +1,440 @@
+package com.wix.detox.inquiry
+
+import android.util.Log
+import android.util.SparseArray
+import android.view.View
+import com.facebook.react.animated.AnimatedNode
+import com.facebook.react.animated.NativeAnimatedModule
+import com.facebook.react.animated.NativeAnimatedNodesManager
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import java.lang.reflect.Field
+import java.util.LinkedList
+import java.util.concurrent.atomic.AtomicReference
+
+object FabricAnimationsInquirer {
+    private const val LOG_TAG = "FabricAnimationsInquirer"
+
+    // Cache fields to avoid repeated reflection lookups
+    private var mActiveAnimationsField: Field? = null
+    private var mUpdatedNodesField: Field? = null
+    private var mAnimatedNodesField: Field? = null
+    private var animatedValueField: Field? = null
+    private var childrenField: Field? = null
+    private var connectedViewTagField: Field? = null
+    private var propNodeMappingField: Field? = null
+    private var propMappingField: Field? = null
+    private var nodeValueField: Field? = null
+    private var offsetField: Field? = null
+
+    fun logAnimatingViews(reactContext: ReactApplicationContext) {
+        try {
+            Log.d(LOG_TAG, "Starting animation inquiry...")
+
+            // Clear previous animated views - fresh start for this inquiry
+            ViewLifecycleRegistry.clearAnimatedViews()
+
+            val nodesManager = getNodesManager(reactContext) ?: return
+            Log.d(LOG_TAG, "Got nodesManager: ${nodesManager.javaClass.simpleName}")
+
+            // Check if there are any active animations first
+            val hasActive = nodesManager.hasActiveAnimations()
+            Log.d(LOG_TAG, "hasActiveAnimations() returned: $hasActive")
+
+            if (!hasActive) {
+                Log.d(LOG_TAG, "No active animations detected")
+                return
+            }
+
+            // Get all animated nodes from the graph
+            val allNodes = getAllAnimatedNodes(nodesManager)
+            Log.d(LOG_TAG, "Found ${allNodes.size()} total animated nodes")
+
+            // Log the field names we're using for debugging
+            Log.d(LOG_TAG, "Using field names: mActiveAnimations, mUpdatedNodes, mAnimatedNodes")
+
+            // Find nodes that are currently animating (have active drivers or are updated)
+            val animatingNodes = findAnimatingNodes(nodesManager, allNodes)
+            Log.d(LOG_TAG, "Found ${animatingNodes.size} animating nodes")
+
+            if (animatingNodes.isEmpty()) {
+                Log.d(LOG_TAG, "No animating nodes found, exiting")
+                return
+            }
+
+            // Find all relevant animated nodes (PropsAnimatedNode, StyleAnimatedNode, ValueAnimatedNode)
+            val relevantNodes = findPropsNodes(animatingNodes, allNodes)
+            Log.d(LOG_TAG, "Found ${relevantNodes.size} relevant animated nodes")
+
+            if (relevantNodes.isEmpty()) {
+                Log.d(LOG_TAG, "No relevant animated nodes found, exiting")
+                return
+            }
+
+            val viewTags = getViewTags(relevantNodes, allNodes)
+            Log.d(LOG_TAG, "Found ${viewTags.size} view tags: $viewTags")
+
+            if (viewTags.isEmpty()) {
+                Log.d(LOG_TAG, "No view tags found, exiting")
+                return
+            }
+
+            logViews(reactContext, viewTags)
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to inquire animating views", e)
+        }
+    }
+
+    private fun getNodesManager(reactContext: ReactApplicationContext): NativeAnimatedNodesManager? {
+        val nativeAnimatedModule = reactContext.getNativeModule(NativeAnimatedModule::class.java)
+        if (nativeAnimatedModule == null) {
+            Log.d(LOG_TAG, "NativeAnimatedModule not found")
+            return null
+        }
+
+        return try {
+            // Use the public getNodesManager() method instead of reflection
+            nativeAnimatedModule.nodesManager
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to get NativeAnimatedNodesManager via getNodesManager()", e)
+            null
+        }
+    }
+
+    private fun getAllAnimatedNodes(nodesManager: NativeAnimatedNodesManager): SparseArray<AnimatedNode> {
+        val allNodes = SparseArray<AnimatedNode>()
+        try {
+            // Access mAnimatedNodes field using reflection
+            val animatedNodesField = findOrCacheField(nodesManager.javaClass, "mAnimatedNodes", "mAnimatedNodesField")
+            @Suppress("UNCHECKED_CAST")
+            val animatedNodes = animatedNodesField?.get(nodesManager) as? SparseArray<AnimatedNode>
+            if (animatedNodes != null) {
+                Log.d(LOG_TAG, "Found ${animatedNodes.size()} animated nodes in graph")
+                for (i in 0 until animatedNodes.size()) {
+                    val node = animatedNodes.valueAt(i)
+                    allNodes.put(animatedNodes.keyAt(i), node)
+                }
+            } else {
+                Log.w(LOG_TAG, "Could not access mAnimatedNodes field")
+            }
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to get all animated nodes", e)
+        }
+        return allNodes
+    }
+
+    private fun findAnimatingNodes(nodesManager: NativeAnimatedNodesManager, allNodes: SparseArray<AnimatedNode>): Set<AnimatedNode> {
+        val animatingNodes = mutableSetOf<AnimatedNode>()
+
+        try {
+            // Get nodes from active animations
+            val activeAnimationsField = findOrCacheField(nodesManager.javaClass, "mActiveAnimations", "mActiveAnimationsField")
+            @Suppress("UNCHECKED_CAST")
+            val activeAnimations = activeAnimationsField?.get(nodesManager) as? SparseArray<Any>
+            if (activeAnimations != null) {
+                Log.d(LOG_TAG, "Found ${activeAnimations.size()} active animations")
+                for (i in 0 until activeAnimations.size()) {
+                    val driver = activeAnimations.valueAt(i)
+                    Log.d(LOG_TAG, "Active animation driver: ${driver.javaClass.simpleName}")
+                    val animatedValueField = findOrCacheField(driver.javaClass, "animatedValue", "animatedValueField")
+                    val valueNode = animatedValueField?.get(driver) as? AnimatedNode
+                    if (valueNode != null) {
+                        animatingNodes.add(valueNode)
+                        Log.d(LOG_TAG, "Added animating node from active animation: ${valueNode.javaClass.simpleName}")
+                    }
+                }
+            }
+
+            // Get nodes from updated nodes
+            val updatedNodesField = findOrCacheField(nodesManager.javaClass, "mUpdatedNodes", "mUpdatedNodesField")
+            @Suppress("UNCHECKED_CAST")
+            val updatedNodes = updatedNodesField?.get(nodesManager) as? SparseArray<AnimatedNode>
+            if (updatedNodes != null) {
+                Log.d(LOG_TAG, "Found ${updatedNodes.size()} updated nodes")
+                for (i in 0 until updatedNodes.size()) {
+                    val node = updatedNodes.valueAt(i)
+                    animatingNodes.add(node)
+                    Log.d(LOG_TAG, "Added updated node: ${node.javaClass.simpleName}")
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to find animating nodes", e)
+        }
+
+        return animatingNodes
+    }
+
+    private fun findPropsNodes(animatingNodes: Set<AnimatedNode>, allNodes: SparseArray<AnimatedNode>): Set<Any> {
+        val allRelevantNodes = mutableSetOf<Any>()
+        val queue = LinkedList<AnimatedNode>(animatingNodes)
+        val visited = mutableSetOf<AnimatedNode>()
+
+        while (queue.isNotEmpty()) {
+            val node = queue.poll()
+            if (node in visited) {
+                continue
+            }
+            visited.add(node)
+
+            // Check what type of node this is and log accordingly
+            val nodeType = node.javaClass.simpleName
+            when (nodeType) {
+                "PropsAnimatedNode" -> {
+                    allRelevantNodes.add(node)
+                    Log.d(LOG_TAG, "Found PropsAnimatedNode: $nodeType")
+                }
+                "StyleAnimatedNode" -> {
+                    allRelevantNodes.add(node)
+                    Log.d(LOG_TAG, "Found StyleAnimatedNode: $nodeType")
+                }
+                "ValueAnimatedNode" -> {
+                    allRelevantNodes.add(node)
+                    Log.d(LOG_TAG, "Found ValueAnimatedNode: $nodeType")
+                }
+                else -> {
+                    Log.d(LOG_TAG, "Found other animated node: $nodeType")
+                }
+            }
+
+            // Traverse children to find more nodes
+            try {
+                val childrenField = findOrCacheField(node.javaClass, "children", "childrenField")
+                @Suppress("UNCHECKED_CAST")
+                val children = childrenField?.get(node) as? List<AnimatedNode>
+                if (children != null) {
+                    queue.addAll(children)
+                }
+            } catch (e: Exception) {
+                // Ignored - not all nodes have children
+            }
+        }
+
+        return allRelevantNodes
+    }
+
+    private fun isPropsAnimatedNode(node: AnimatedNode): Boolean {
+        return try {
+            // Check if this is actually a PropsAnimatedNode by checking the class name
+            // and verifying it has the connectedViewTag field
+            val isPropsNode = node.javaClass.simpleName == "PropsAnimatedNode"
+            if (isPropsNode) {
+                val connectedViewTagField = findOrCacheField(node.javaClass, "connectedViewTag", "connectedViewTagField")
+                connectedViewTagField != null
+            } else {
+                false
+            }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun getViewTags(relevantNodes: Set<Any>, allNodes: SparseArray<AnimatedNode>): Set<Int> {
+        val viewTags = mutableSetOf<Int>()
+        for (node in relevantNodes) {
+            try {
+                val nodeType = node.javaClass.simpleName
+                Log.d(LOG_TAG, "Processing $nodeType for view tags")
+
+                when (nodeType) {
+                    "PropsAnimatedNode" -> {
+                        val connectedViewTagField = findOrCacheField(node.javaClass, "connectedViewTag", "connectedViewTagField")
+                        val viewTag = connectedViewTagField?.get(node) as? Int
+                        if (viewTag != null && viewTag != -1) {
+                            viewTags.add(viewTag)
+                            Log.d(LOG_TAG, "PropsAnimatedNode connected to view tag: $viewTag")
+
+                            // Log the property mapping to see what properties are being animated
+                            try {
+                                val propNodeMappingField = findOrCacheField(node.javaClass, "propNodeMapping", "propNodeMappingField")
+                                val propNodeMapping = propNodeMappingField?.get(node) as? Map<String, Int>
+                                if (propNodeMapping != null) {
+                                    Log.d(LOG_TAG, "View $viewTag has animated properties: ${propNodeMapping.keys}")
+                                }
+                            } catch (e: Exception) {
+                                Log.d(LOG_TAG, "Could not access propNodeMapping for PropsAnimatedNode")
+                            }
+                        }
+                    }
+                    "StyleAnimatedNode" -> {
+                        // StyleAnimatedNode doesn't have connectedViewTag field - it's connected through PropsAnimatedNode
+                        Log.d(LOG_TAG, "StyleAnimatedNode has no direct view connection (connected through PropsAnimatedNode)")
+
+                        // Try to access propMapping to see what properties it handles
+                        try {
+                            val propMappingField = findOrCacheField(node.javaClass, "propMapping", "propMappingField")
+                            val propMapping = propMappingField?.get(node) as? Map<String, Int>
+                            if (propMapping != null) {
+                                Log.d(LOG_TAG, "StyleAnimatedNode handles properties: ${propMapping.keys}")
+                            }
+                        } catch (e: Exception) {
+                            Log.d(LOG_TAG, "Could not access StyleAnimatedNode propMapping: ${e.message}")
+                        }
+
+                        // Find the connected view by traversing the graph to find PropsAnimatedNode
+                        val connectedViewTag = findConnectedViewThroughGraph(node as AnimatedNode, allNodes)
+                        if (connectedViewTag != -1) {
+                            viewTags.add(connectedViewTag)
+                            Log.d(LOG_TAG, "StyleAnimatedNode connected to view tag through graph: $connectedViewTag")
+                        } else {
+                            Log.w(LOG_TAG, "StyleAnimatedNode has no connected view - this could mean:")
+                            Log.w(LOG_TAG, "  1. No PropsAnimatedNode found in graph traversal")
+                            Log.w(LOG_TAG, "  2. PropsAnimatedNode exists but not connected to any view")
+                            Log.w(LOG_TAG, "  3. Graph traversal failed due to reflection errors")
+                            Log.w(LOG_TAG, "  4. Circular references or disconnected graph")
+                        }
+                    }
+                    "ValueAnimatedNode" -> {
+                        // ValueAnimatedNode typically doesn't have direct view connection
+                        // but we can log its value for debugging
+                        try {
+                            val nodeValueField = findOrCacheField(node.javaClass, "nodeValue", "nodeValueField")
+                            val nodeValue = nodeValueField?.get(node) as? Double
+                            val offsetField = findOrCacheField(node.javaClass, "offset", "offsetField")
+                            val offset = offsetField?.get(node) as? Double
+                            Log.d(LOG_TAG, "ValueAnimatedNode value: $nodeValue, offset: $offset")
+                        } catch (e: Exception) {
+                            Log.d(LOG_TAG, "Could not access ValueAnimatedNode values: ${e.message}")
+                        }
+                    }
+                    else -> {
+                        Log.d(LOG_TAG, "Unknown node type: $nodeType")
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(LOG_TAG, "Failed to process node: ${node.javaClass.simpleName}", e)
+            }
+        }
+        return viewTags
+    }
+
+    private fun logViews(reactContext: ReactApplicationContext, viewTags: Set<Int>) {
+        val uiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+        if (uiManager == null) {
+            Log.w(LOG_TAG, "Fabric UIManager not found.")
+            return
+        }
+
+        for (tag in viewTags) {
+            try {
+                reactContext.runOnUiQueueThread {
+                    val view = uiManager.resolveView(tag)
+                    if (view != null) {
+                        ViewLifecycleRegistry.markAnimated(view)
+
+                        // Get view coordinates and dimensions
+                        val left = view.left
+                        val top = view.top
+                        val right = view.right
+                        val bottom = view.bottom
+                        val width = right - left
+                        val height = bottom - top
+
+                        Log.i(LOG_TAG, "Animating view: tag=$tag, class=${view.javaClass.simpleName}, id=${view.id}, " +
+                                "bounds=[$left,$top,$right,$bottom], size=${width}x${height}")
+                    } else {
+                        Log.w(LOG_TAG, "Could not resolve view for tag: $tag")
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(LOG_TAG, "Failed to resolve or log view for tag: $tag", e)
+            }
+        }
+    }
+
+    private fun findOrCacheField(clazz: Class<*>, fieldName: String, cacheFieldName: String): Field? {
+        try {
+            val cacheField = FabricAnimationsInquirer::class.java.getDeclaredField(cacheFieldName).apply { isAccessible = true }
+            var field = cacheField.get(this) as? Field
+            if (field == null) {
+                field = findFieldRecursive(clazz, fieldName)
+                if (field != null) {
+                    cacheField.set(this, field)
+                }
+            }
+            return field
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Could not find or cache field $fieldName", e)
+            return null
+        }
+    }
+
+    private fun findFieldRecursive(clazz: Class<*>, fieldName: String): Field? {
+        var currentClass: Class<*>? = clazz
+        while (currentClass != null && currentClass != Any::class.java) {
+            try {
+                return currentClass.getDeclaredField(fieldName).apply { isAccessible = true }
+            } catch (e: NoSuchFieldException) {
+                // Not in this class, check superclass
+            }
+            currentClass = currentClass.superclass
+        }
+        Log.w(LOG_TAG, "Field '$fieldName' not found in class hierarchy for '${clazz.simpleName}'")
+        return null
+    }
+
+    private fun findConnectedViewThroughGraph(startNode: AnimatedNode, allNodes: SparseArray<AnimatedNode>): Int {
+        val queue = LinkedList<AnimatedNode>()
+        val visited = mutableSetOf<AnimatedNode>()
+        var propsNodesFound = 0
+        var propsNodesWithView = 0
+        var propsNodesWithoutView = 0
+
+        Log.d(LOG_TAG, "Starting graph traversal from ${startNode.javaClass.simpleName}")
+
+        queue.add(startNode)
+        visited.add(startNode)
+
+        while (queue.isNotEmpty()) {
+            val node = queue.poll()
+            val nodeType = node.javaClass.simpleName
+
+            // Check if this is a PropsAnimatedNode with a connected view
+            if (nodeType == "PropsAnimatedNode") {
+                propsNodesFound++
+                try {
+                    val connectedViewTagField = findOrCacheField(node.javaClass, "connectedViewTag", "connectedViewTagField")
+                    val viewTag = connectedViewTagField?.get(node) as? Int
+                    if (viewTag != null && viewTag != -1) {
+                        propsNodesWithView++
+                        Log.d(LOG_TAG, "Found PropsAnimatedNode with connected view: $viewTag")
+                        return viewTag
+                    } else {
+                        propsNodesWithoutView++
+                        Log.d(LOG_TAG, "Found PropsAnimatedNode but no connected view (viewTag: $viewTag)")
+                    }
+                } catch (e: Exception) {
+                    Log.w(LOG_TAG, "Failed to access connectedViewTag from PropsAnimatedNode: ${e.message}")
+                }
+            }
+
+            // Traverse children to find PropsAnimatedNode
+            try {
+                val childrenField = findOrCacheField(node.javaClass, "children", "childrenField")
+                @Suppress("UNCHECKED_CAST")
+                val children = childrenField?.get(node) as? List<AnimatedNode>
+                if (children != null) {
+                    Log.d(LOG_TAG, "Traversing ${children.size} children from $nodeType")
+                    for (child in children) {
+                        if (child !in visited) {
+                            visited.add(child)
+                            queue.add(child)
+                        }
+                    }
+                } else {
+                    Log.d(LOG_TAG, "$nodeType has no children")
+                }
+            } catch (e: Exception) {
+                Log.d(LOG_TAG, "Could not access children from $nodeType: ${e.message}")
+            }
+        }
+
+        Log.w(LOG_TAG, "Graph traversal completed:")
+        Log.w(LOG_TAG, "  - Total nodes visited: ${visited.size}")
+        Log.w(LOG_TAG, "  - PropsAnimatedNodes found: $propsNodesFound")
+        Log.w(LOG_TAG, "  - PropsAnimatedNodes with view: $propsNodesWithView")
+        Log.w(LOG_TAG, "  - PropsAnimatedNodes without view: $propsNodesWithoutView")
+
+        return -1
+    }
+}