react-native 0.68.1 → 0.69.0-rc.1

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/MapBuffer.kt

@@ -0,0 +1,170 @@
+/*
+ * 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.common.mapbuffer
+
+/**
+ * MapBuffer is an optimized sparse array format for transferring props-like data between C++ and
+ * JNI. It is designed to:
+ * - be compact to optimize space when sparse (sparse is the common case).
+ * - be accessible through JNI with zero/minimal copying.
+ * - work recursively for nested maps/arrays.
+ * - support dynamic types that map to JSON.
+ * - have minimal APK size and build time impact.
+ *
+ * See <react/renderer/mapbuffer/MapBuffer.h> for more information and native implementation.
+ *
+ * Limitations:
+ * - Keys are usually sized as 2 bytes, with each buffer supporting up to 65536 entries as a result.
+ * - O(log(N)) random key access for native buffers due to selected structure. Faster access can be
+ * achieved by retrieving [MapBuffer.Entry] with [entryAt] on known offsets.
+ */
+interface MapBuffer : Iterable<MapBuffer.Entry> {
+  companion object {
+    /**
+     * Key are represented as 2 byte values, and typed as Int for ease of access. The serialization
+     * format only allows to store [UShort] values.
+     */
+    internal val KEY_RANGE = IntRange(UShort.MIN_VALUE.toInt(), UShort.MAX_VALUE.toInt())
+  }
+
+  /**
+   * Data types supported by [MapBuffer]. Keep in sync with definition in
+   * `<react/renderer/mapbuffer/MapBuffer.h>`, as enum serialization relies on correct order.
+   */
+  enum class DataType {
+    BOOL,
+    INT,
+    DOUBLE,
+    STRING,
+    MAP
+  }
+
+  /**
+   * Number of elements inserted into current MapBuffer.
+   * @return number of elements in the [MapBuffer]
+   */
+  val count: Int
+
+  /**
+   * Checks whether entry for given key exists in MapBuffer.
+   * @param key key to lookup the entry
+   * @return whether entry for the given key exists in the MapBuffer.
+   */
+  fun contains(key: Int): Boolean
+
+  /**
+   * Provides offset of the key to use for [entryAt], for cases when offset is not statically known
+   * but can be cached.
+   * @param key key to lookup offset for
+   * @return offset for the given key to be used for entry access, -1 if key wasn't found.
+   */
+  fun getKeyOffset(key: Int): Int
+
+  /**
+   * Provides parsed access to a MapBuffer without additional lookups for provided offset.
+   * @param offset offset of entry in the MapBuffer structure. Can be looked up for known keys with
+   * [getKeyOffset].
+   * @return parsed entry for structured access for given offset
+   */
+  fun entryAt(offset: Int): MapBuffer.Entry
+
+  /**
+   * Provides parsed [DataType] annotation associated with the given key.
+   * @param key key to lookup type for
+   * @return data type of the given key.
+   * @throws IllegalArgumentException if the key doesn't exist
+   */
+  fun getType(key: Int): DataType
+
+  /**
+   * Provides parsed [Boolean] value if the entry for given key exists with [DataType.BOOL] type
+   * @param key key to lookup [Boolean] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getBoolean(key: Int): Boolean
+
+  /**
+   * Provides parsed [Int] value if the entry for given key exists with [DataType.INT] type
+   * @param key key to lookup [Int] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getInt(key: Int): Int
+
+  /**
+   * Provides parsed [Double] value if the entry for given key exists with [DataType.DOUBLE] type
+   * @param key key to lookup [Double] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getDouble(key: Int): Double
+
+  /**
+   * Provides parsed [String] value if the entry for given key exists with [DataType.STRING] type
+   * @param key key to lookup [String] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getString(key: Int): String
+
+  /**
+   * Provides parsed [MapBuffer] value if the entry for given key exists with [DataType.MAP] type
+   * @param key key to lookup [MapBuffer] value for
+   * @return value associated with the requested key
+   * @throws IllegalArgumentException if the key doesn't exist
+   * @throws IllegalStateException if the data type doesn't match
+   */
+  fun getMapBuffer(key: Int): MapBuffer
+
+  /** Iterable entry representing parsed MapBuffer values */
+  interface Entry {
+    /**
+     * Key of the given entry. Usually represented as 2 byte unsigned integer with the value range
+     * of [0,65536)
+     */
+    val key: Int
+
+    /** Parsed [DataType] of the entry */
+    val type: DataType
+
+    /**
+     * Entry value represented as [Boolean]
+     * @throws IllegalStateException if the data type doesn't match [DataType.BOOL]
+     */
+    val booleanValue: Boolean
+
+    /**
+     * Entry value represented as [Int]
+     * @throws IllegalStateException if the data type doesn't match [DataType.INT]
+     */
+    val intValue: Int
+
+    /**
+     * Entry value represented as [Double]
+     * @throws IllegalStateException if the data type doesn't match [DataType.DOUBLE]
+     */
+    val doubleValue: Double
+
+    /**
+     * Entry value represented as [String]
+     * @throws IllegalStateException if the data type doesn't match [DataType.STRING]
+     */
+    val stringValue: String
+
+    /**
+     * Entry value represented as [MapBuffer]
+     * @throws IllegalStateException if the data type doesn't match [DataType.MAP]
+     */
+    val mapBufferValue: MapBuffer
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/MapBufferSoLoader.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.common.mapbuffer
+
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+import com.facebook.soloader.SoLoader
+import com.facebook.systrace.Systrace
+
+object MapBufferSoLoader {
+  @Volatile private var didInit = false
+
+  @JvmStatic
+  fun staticInit() {
+    if (didInit) {
+      return
+    }
+    didInit = true
+
+    Systrace.beginSection(
+        Systrace.TRACE_TAG_REACT_JAVA_BRIDGE,
+        "ReadableMapBufferSoLoader.staticInit::load:mapbufferjni")
+    ReactMarker.logMarker(ReactMarkerConstants.LOAD_REACT_NATIVE_MAPBUFFER_SO_FILE_START)
+    SoLoader.loadLibrary("mapbufferjni")
+    ReactMarker.logMarker(ReactMarkerConstants.LOAD_REACT_NATIVE_MAPBUFFER_SO_FILE_END)
+    Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE)
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/ReadableMapBuffer.kt

@@ -0,0 +1,298 @@
+/*
+ * 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.common.mapbuffer
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.common.mapbuffer.MapBuffer.Companion.KEY_RANGE
+import java.lang.StringBuilder
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import javax.annotation.concurrent.NotThreadSafe
+
+/**
+ * Read-only implementation of the [MapBuffer], imported from C++ environment. Use
+ * `<react/common/mapbuffer/jni/JReadableMapBuffer.h> to create it.
+ *
+ * See [MapBuffer] documentation for more details
+ */
+@NotThreadSafe
+@DoNotStrip
+class ReadableMapBuffer : MapBuffer {
+
+  // Hybrid data must be kept in the `mHybridData` field for fbjni to work
+  @field:DoNotStrip private val mHybridData: HybridData?
+
+  // Byte data of the mapBuffer
+  private val buffer: ByteBuffer
+  // Amount of items serialized on the ByteBuffer
+  override var count = 0
+    private set
+
+  @DoNotStrip
+  private constructor(hybridData: HybridData) {
+    this.mHybridData = hybridData
+    this.buffer = importByteBuffer()
+    readHeader()
+  }
+
+  private constructor(buffer: ByteBuffer) {
+    this.mHybridData = null
+    this.buffer = buffer
+    readHeader()
+  }
+
+  private external fun importByteBuffer(): ByteBuffer
+
+  private fun readHeader() {
+    // byte order
+    val storedAlignment = buffer.short
+    if (storedAlignment.toInt() != ALIGNMENT) {
+      buffer.order(ByteOrder.LITTLE_ENDIAN)
+    }
+    // count
+    count = readUnsignedShort(buffer.position()).toInt()
+  }
+
+  // returns the relative offset of the first byte of dynamic data
+  private val offsetForDynamicData: Int
+    get() = getKeyOffsetForBucketIndex(count)
+
+  /**
+   * @param key Key to search for
+   * @return the "bucket index" for a key or -1 if not found. It uses a binary search algorithm
+   * (log(n))
+   */
+  private fun getBucketIndexForKey(intKey: Int): Int {
+    if (intKey !in KEY_RANGE) {
+      return -1
+    }
+    val key = intKey.toUShort()
+
+    var lo = 0
+    var hi = count - 1
+    while (lo <= hi) {
+      val mid = lo + hi ushr 1
+      val midVal = readUnsignedShort(getKeyOffsetForBucketIndex(mid))
+      when {
+        midVal < key -> lo = mid + 1
+        midVal > key -> hi = mid - 1
+        else -> return mid
+      }
+    }
+    return -1
+  }
+
+  private fun readDataType(bucketIndex: Int): MapBuffer.DataType {
+    val value = readUnsignedShort(getKeyOffsetForBucketIndex(bucketIndex) + TYPE_OFFSET).toInt()
+    return MapBuffer.DataType.values()[value]
+  }
+
+  private fun getTypedValueOffsetForKey(key: Int, expected: MapBuffer.DataType): Int {
+    val bucketIndex = getBucketIndexForKey(key)
+    require(bucketIndex != -1) { "Key not found: $key" }
+    val dataType = readDataType(bucketIndex)
+    check(!(dataType !== expected)) { "Expected $expected for key: $key, found $dataType instead." }
+    return getKeyOffsetForBucketIndex(bucketIndex) + VALUE_OFFSET
+  }
+
+  private fun readUnsignedShort(bufferPosition: Int): UShort {
+    return buffer.getShort(bufferPosition).toUShort()
+  }
+
+  private fun readDoubleValue(bufferPosition: Int): Double {
+    return buffer.getDouble(bufferPosition)
+  }
+
+  private fun readIntValue(bufferPosition: Int): Int {
+    return buffer.getInt(bufferPosition)
+  }
+
+  private fun readBooleanValue(bufferPosition: Int): Boolean {
+    return readIntValue(bufferPosition) == 1
+  }
+
+  private fun readStringValue(bufferPosition: Int): String {
+    val offset = offsetForDynamicData + buffer.getInt(bufferPosition)
+    val sizeOfString = buffer.getInt(offset)
+    val result = ByteArray(sizeOfString)
+    val stringOffset = offset + Int.SIZE_BYTES
+    buffer.position(stringOffset)
+    buffer[result, 0, sizeOfString]
+    return String(result)
+  }
+
+  private fun readMapBufferValue(position: Int): ReadableMapBuffer {
+    val offset = offsetForDynamicData + buffer.getInt(position)
+    val sizeMapBuffer = buffer.getInt(offset)
+    val newBuffer = ByteArray(sizeMapBuffer)
+    val bufferOffset = offset + Int.SIZE_BYTES
+    buffer.position(bufferOffset)
+    buffer[newBuffer, 0, sizeMapBuffer]
+    return ReadableMapBuffer(ByteBuffer.wrap(newBuffer))
+  }
+
+  private fun getKeyOffsetForBucketIndex(bucketIndex: Int): Int {
+    return HEADER_SIZE + BUCKET_SIZE * bucketIndex
+  }
+
+  override fun contains(key: Int): Boolean {
+    // TODO T83483191: Add tests
+    return getBucketIndexForKey(key) != -1
+  }
+
+  override fun getKeyOffset(key: Int): Int = getBucketIndexForKey(key)
+
+  override fun entryAt(offset: Int): MapBuffer.Entry =
+      MapBufferEntry(getKeyOffsetForBucketIndex(offset))
+
+  override fun getType(key: Int): MapBuffer.DataType {
+    val bucketIndex = getBucketIndexForKey(key)
+    require(bucketIndex != -1) { "Key not found: $key" }
+    return readDataType(bucketIndex)
+  }
+
+  override fun getInt(key: Int): Int =
+      readIntValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.INT))
+
+  override fun getDouble(key: Int): Double =
+      readDoubleValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.DOUBLE))
+
+  override fun getString(key: Int): String =
+      readStringValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.STRING))
+
+  override fun getBoolean(key: Int): Boolean =
+      readBooleanValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.BOOL))
+
+  override fun getMapBuffer(key: Int): ReadableMapBuffer =
+      readMapBufferValue(getTypedValueOffsetForKey(key, MapBuffer.DataType.MAP))
+
+  override fun hashCode(): Int {
+    buffer.rewind()
+    return buffer.hashCode()
+  }
+
+  override fun equals(other: Any?): Boolean {
+    if (other !is ReadableMapBuffer) {
+      return false
+    }
+    val thisByteBuffer = buffer
+    val otherByteBuffer = other.buffer
+    if (thisByteBuffer === otherByteBuffer) {
+      return true
+    }
+    thisByteBuffer.rewind()
+    otherByteBuffer.rewind()
+    return thisByteBuffer == otherByteBuffer
+  }
+
+  override fun toString(): String {
+    val builder = StringBuilder("{")
+    for (entry in this) {
+      val key = entry.key
+      builder.append(key)
+      builder.append('=')
+      when (entry.type) {
+        MapBuffer.DataType.BOOL -> builder.append(entry.booleanValue)
+        MapBuffer.DataType.INT -> builder.append(entry.intValue)
+        MapBuffer.DataType.DOUBLE -> builder.append(entry.doubleValue)
+        MapBuffer.DataType.STRING -> builder.append(entry.stringValue)
+        MapBuffer.DataType.MAP -> builder.append(entry.mapBufferValue.toString())
+      }
+      builder.append(',')
+    }
+    builder.append('}')
+    return builder.toString()
+  }
+
+  override fun iterator(): Iterator<MapBuffer.Entry> {
+    return object : Iterator<MapBuffer.Entry> {
+      var current = 0
+      val last = count - 1
+
+      override fun hasNext(): Boolean {
+        return current <= last
+      }
+
+      override fun next(): MapBuffer.Entry {
+        return MapBufferEntry(getKeyOffsetForBucketIndex(current++))
+      }
+    }
+  }
+
+  private inner class MapBufferEntry(private val bucketOffset: Int) : MapBuffer.Entry {
+    private fun assertType(expected: MapBuffer.DataType) {
+      val dataType = type
+      check(!(expected !== dataType)) {
+        ("Expected " +
+            expected +
+            " for key: " +
+            key +
+            " found " +
+            dataType.toString() +
+            " instead.")
+      }
+    }
+
+    override val key: Int
+      get() = readUnsignedShort(bucketOffset).toInt()
+    override val type: MapBuffer.DataType
+      get() = MapBuffer.DataType.values()[readUnsignedShort(bucketOffset + TYPE_OFFSET).toInt()]
+
+    override val doubleValue: Double
+      get() {
+        assertType(MapBuffer.DataType.DOUBLE)
+        return readDoubleValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val intValue: Int
+      get() {
+        assertType(MapBuffer.DataType.INT)
+        return readIntValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val booleanValue: Boolean
+      get() {
+        assertType(MapBuffer.DataType.BOOL)
+        return readBooleanValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val stringValue: String
+      get() {
+        assertType(MapBuffer.DataType.STRING)
+        return readStringValue(bucketOffset + VALUE_OFFSET)
+      }
+
+    override val mapBufferValue: MapBuffer
+      get() {
+        assertType(MapBuffer.DataType.MAP)
+        return readMapBufferValue(bucketOffset + VALUE_OFFSET)
+      }
+  }
+
+  companion object {
+    // Value used to verify if the data is serialized with LittleEndian order.
+    private const val ALIGNMENT = 0xFE
+
+    // 8 bytes = 2 (alignment) + 2 (count) + 4 (size)
+    private const val HEADER_SIZE = 8
+
+    // 10 bytes = 2 (key) + 2 (type) + 8 (value)
+    private const val BUCKET_SIZE = 12
+
+    // 2 bytes = 2 (key)
+    private const val TYPE_OFFSET = 2
+
+    // 4 bytes = 2 (key) + 2 (type)
+    private const val VALUE_OFFSET = 4
+
+    init {
+      MapBufferSoLoader.staticInit()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/WritableMapBuffer.kt

@@ -0,0 +1,170 @@
+/*
+ * 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.common.mapbuffer
+
+import android.util.SparseArray
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.common.mapbuffer.MapBuffer.Companion.KEY_RANGE
+import com.facebook.react.common.mapbuffer.MapBuffer.DataType
+import javax.annotation.concurrent.NotThreadSafe
+
+/**
+ * Implementation of writeable Java-only MapBuffer, which can be used to send information through
+ * JNI.
+ *
+ * See [MapBuffer] for more details
+ */
+@NotThreadSafe
+@DoNotStrip
+class WritableMapBuffer : MapBuffer {
+  private val values: SparseArray<Any> = SparseArray<Any>()
+
+  /*
+   * Write methods
+   */
+
+  /**
+   * Adds a boolean value for given key to the MapBuffer.
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: Boolean): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds an int value for given key to the MapBuffer.
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: Int): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds a double value for given key to the MapBuffer.
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: Double): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds a string value for given key to the MapBuffer.
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: String): WritableMapBuffer = putInternal(key, value)
+
+  /**
+   * Adds a [MapBuffer] value for given key to the current MapBuffer.
+   * @param key entry key
+   * @param value entry value
+   * @throws IllegalArgumentException if key is out of [UShort] range
+   */
+  fun put(key: Int, value: MapBuffer): WritableMapBuffer = putInternal(key, value)
+
+  private fun putInternal(key: Int, value: Any): WritableMapBuffer {
+    require(key in KEY_RANGE) {
+      "Only integers in [${UShort.MIN_VALUE};${UShort.MAX_VALUE}] range are allowed for keys."
+    }
+
+    values.put(key, value)
+    return this
+  }
+
+  /*
+   * Read methods
+   */
+
+  override val count: Int
+    get() = values.size()
+
+  override fun contains(key: Int): Boolean = values.get(key) != null
+
+  override fun getKeyOffset(key: Int): Int = values.indexOfKey(key)
+
+  override fun entryAt(offset: Int): MapBuffer.Entry = MapBufferEntry(offset)
+
+  override fun getType(key: Int): DataType {
+    val value = values.get(key)
+    require(value != null) { "Key not found: $key" }
+    return value.dataType(key)
+  }
+
+  override fun getBoolean(key: Int): Boolean = verifyValue(key, values.get(key))
+
+  override fun getInt(key: Int): Int = verifyValue(key, values.get(key))
+
+  override fun getDouble(key: Int): Double = verifyValue(key, values.get(key))
+
+  override fun getString(key: Int): String = verifyValue(key, values.get(key))
+
+  override fun getMapBuffer(key: Int): MapBuffer = verifyValue(key, values.get(key))
+
+  /** Generalizes verification of the value types based on the requested type. */
+  private inline fun <reified T> verifyValue(key: Int, value: Any?): T {
+    require(value != null) { "Key not found: $key" }
+    check(value is T) {
+      "Expected ${T::class.java} for key: $key, found ${value.javaClass} instead."
+    }
+    return value
+  }
+
+  private fun Any.dataType(key: Int): DataType {
+    return when (val value = this) {
+      is Boolean -> DataType.BOOL
+      is Int -> DataType.INT
+      is Double -> DataType.DOUBLE
+      is String -> DataType.STRING
+      is MapBuffer -> DataType.MAP
+      else -> throw IllegalStateException("Key $key has value of unknown type: ${value.javaClass}")
+    }
+  }
+
+  override fun iterator(): Iterator<MapBuffer.Entry> =
+      object : Iterator<MapBuffer.Entry> {
+        var count = 0
+        override fun hasNext(): Boolean = count < values.size()
+        override fun next(): MapBuffer.Entry = MapBufferEntry(count++)
+      }
+
+  private inner class MapBufferEntry(private val index: Int) : MapBuffer.Entry {
+    override val key: Int = values.keyAt(index)
+    override val type: DataType = values.valueAt(index).dataType(key)
+    override val booleanValue: Boolean
+      get() = verifyValue(key, values.valueAt(index))
+    override val intValue: Int
+      get() = verifyValue(key, values.valueAt(index))
+    override val doubleValue: Double
+      get() = verifyValue(key, values.valueAt(index))
+    override val stringValue: String
+      get() = verifyValue(key, values.valueAt(index))
+    override val mapBufferValue: MapBuffer
+      get() = verifyValue(key, values.valueAt(index))
+  }
+
+  /*
+   * JNI hooks
+   */
+
+  @DoNotStrip
+  @Suppress("UNUSED")
+  /** JNI hook for MapBuffer to retrieve sorted keys from this class. */
+  private fun getKeys(): IntArray = IntArray(values.size()) { values.keyAt(it) }
+
+  @DoNotStrip
+  @Suppress("UNUSED")
+  /** JNI hook for MapBuffer to retrieve sorted values from this class. */
+  private fun getValues(): Array<Any> = Array(values.size()) { values.valueAt(it) }
+
+  companion object {
+    init {
+      MapBufferSoLoader.staticInit()
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/jni/Android.mk

@@ -10,12 +10,11 @@ include $(CLEAR_VARS)
 LOCAL_MODULE := mapbufferjni
 
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/react/common/mapbuffer/*.cpp)
+LOCAL_SRC_FILES := $(subst $(LOCAL_PATH)/,,$(LOCAL_SRC_FILES))
 
 LOCAL_SHARED_LIBRARIES := \
   libfb \
   libfbjni \
-  libfolly_futures \
-  libfolly_json \
   libglog \
   libglog_init \
   libreact_debug \

package/ReactAndroid/src/main/java/com/facebook/react/common/mapbuffer/jni/BUCK

@@ -12,7 +12,10 @@ rn_xplat_cxx_library(
         prefix = "react/common/mapbuffer",
     ),
     fbandroid_allow_jni_merging = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     platforms = ANDROID,
     preprocessor_flags = [
         "-DLOG_TAG=\"ReactNative\"",