refactor: migrate DynamicFromMap to Kotlin (facebook#50597)

Summary:
This PR introduces a rewrite of `DynamicFromMap.java` to Kotlin as requested in facebook#50513.

## Changelog:

[ANDROID] [CHANGED] - Migrated `DynamicFromMap.java` to Kotlin

Pull Request resolved: facebook#50597

Test Plan:
1. Implement unit tests for `DynamicFromMap.kt` - `DynamicFromMapTests.kt`
2. Ensure the tests pass: `./gradlew test`
3. Run the RN tester app on new & on old architectures

Reviewed By: javache, rshest

Differential Revision: D72853616

Pulled By: cortinico

fbshipit-source-id: 855acdc7fa7810ab9f223b0be7778c028a646de5

Author: artus9033

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

@@ -0,0 +1,80 @@
+/*
+ * 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
+    pool.get()?.release(this)
+  }
+
+  override val isNull: Boolean
+    get() {
+      return accessMapSafely { map, name -> map.isNull(name) }
+    }
+
+  override fun asBoolean(): Boolean = accessMapSafely { map, name -> map.getBoolean(name) }
+
+  override fun asDouble(): Double = accessMapSafely { map, name -> map.getDouble(name) }
+
+  override fun asInt(): Int = accessMapSafely { map, name -> map.getInt(name) }
+
+  override fun asString(): String? = accessMapSafely { map, name -> map.getString(name) }
+
+  override fun asArray(): ReadableArray? = accessMapSafely { map, name -> map.getArray(name) }
+
+  override fun asMap(): ReadableMap? = 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 pool: ThreadLocal<SimplePool<DynamicFromMap>> =
+        object : ThreadLocal<SimplePool<DynamicFromMap>>() {
+          override fun initialValue(): SimplePool<DynamicFromMap> {
+            return 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 = pool.get()?.acquire() ?: DynamicFromMap()
+
+      return dynamic.apply {
+        this.map = map
+        this.name = name
+      }
+    }
+  }
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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 = DynamicFromMap.create(testSource, key)
+
+  private fun getRecycledDynamicFromMap(key: String): Dynamic =
+      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",
+        )
+  }
+}