refactor: migrate DynamicFromMap to Kotlin

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/bridge/DynamicFromMap.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import androidx.core.util.Pools.SimplePool
+
+/** Implementation of Dynamic wrapping a ReadableMap. */
+internal class DynamicFromMap
+// This is a pools object. Hide the constructor.
+private constructor() : Dynamic {
+    private var map: ReadableMap? = null
+    private var name: String? = null
+
+    override fun recycle() {
+        map = null
+        name = null
+        sPool.get()?.release(this)
+    }
+
+    override val isNull: Boolean
+        get() {
+            return accessMapSafely { map, name -> map.isNull(name) }
+        }
+
+    override fun asBoolean(): Boolean {
+        return accessMapSafely { map, name -> map.getBoolean(name) }
+    }
+
+    override fun asDouble(): Double {
+        return accessMapSafely { map, name -> map.getDouble(name) }
+    }
+
+    override fun asInt(): Int {
+        return accessMapSafely { map, name -> map.getInt(name) }
+    }
+
+    override fun asString(): String? {
+        return accessMapSafely { map, name -> map.getString(name) }
+    }
+
+    override fun asArray(): ReadableArray? {
+        return accessMapSafely { map, name -> map.getArray(name) }
+    }
+
+    override fun asMap(): ReadableMap? {
+        return accessMapSafely { map, name -> map.getMap(name) }
+    }
+
+    override val type: ReadableType
+        get() {
+            return accessMapSafely { map, name -> map.getType(name) }
+        }
+
+    /**
+     * Asserts that both map and name are non-null and invokes the lambda with
+     *
+     * @param executor the callback to be invoked with non-null-asserted prop values
+     * @return value returned by the executor
+     */
+    private fun <T> accessMapSafely(executor: (map: ReadableMap, name: String) -> T): T {
+        val name = checkNotNull(name) { DYNAMIC_VALUE_RECYCLED_FAILURE_MESSAGE }
+        val map = checkNotNull(map) { DYNAMIC_VALUE_RECYCLED_FAILURE_MESSAGE }
+
+        return executor(map, name)
+    }
+
+    companion object {
+        private val sPool: ThreadLocal<SimplePool<DynamicFromMap>> =
+            ThreadLocal.withInitial { SimplePool(10) }
+
+        private const val DYNAMIC_VALUE_RECYCLED_FAILURE_MESSAGE =
+            "This dynamic value has been recycled"
+
+        fun create(map: ReadableMap, name: String): DynamicFromMap {
+            val dynamic = sPool.get()?.acquire() ?: DynamicFromMap()
+
+            return dynamic.apply {
+                this.map = map
+                this.name = name
+            }
+        }
+    }
+}

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/bridge/DynamicFromMapTest.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.Test
+
+/** Tests for [DynamicFromMap] */
+class DynamicFromMapTest {
+    @Test
+    fun testGetDynamic() {
+        assertThat(getDynamicFromMap("int").asInt()).isEqualTo(1)
+        assertThat(getDynamicFromMap("double").asDouble()).isEqualTo(2.0)
+        assertThat(getDynamicFromMap("string").asString()).isEqualTo("str")
+        assertThat(getDynamicFromMap("boolean").asBoolean()).isEqualTo(false)
+        assertThat(getDynamicFromMap("array").asArray()).isEqualTo(testSource.getArray("array"))
+        assertThat(getDynamicFromMap("map").asMap()).isEqualTo(testSource.getMap("map"))
+        assertThat(getDynamicFromMap("null").isNull).isEqualTo(true)
+        assertThat(getDynamicFromMap("int").type).isEqualTo(ReadableType.Number)
+    }
+
+    @Test
+    fun testGetFromRecycledDynamic() {
+        assertThatThrownBy { getRecycledDynamicFromMap("int").asInt() }
+        assertThatThrownBy { getRecycledDynamicFromMap("double").asDouble() }
+        assertThatThrownBy { getRecycledDynamicFromMap("string").asString() }
+        assertThatThrownBy { getRecycledDynamicFromMap("boolean").asMap() }
+        assertThatThrownBy { getRecycledDynamicFromMap("array").asArray() }
+        assertThatThrownBy { getRecycledDynamicFromMap("map").asBoolean() }
+        assertThatThrownBy { getRecycledDynamicFromMap("null").isNull }
+        assertThatThrownBy { getRecycledDynamicFromMap("anything").type }
+    }
+
+    private fun getDynamicFromMap(key: String): Dynamic {
+        return DynamicFromMap.create(testSource, key)
+    }
+
+    private fun getRecycledDynamicFromMap(key: String): Dynamic {
+        return getDynamicFromMap(key).apply { recycle() }
+    }
+
+    companion object {
+        private val testSource =
+            JavaOnlyMap.of(
+                "boolean",
+                false,
+                "array",
+                JavaOnlyArray.of(),
+                "map",
+                JavaOnlyMap.of(),
+                "null",
+                null,
+                "int",
+                1,
+                "double",
+                2.0,
+                "string",
+                "str",
+            )
+    }
+}