Revert D57327835 (#45884)

Summary:
Pull Request resolved: #45884

Pull Request resolved: #44569
Changelog:
[Internal] -
Reverting this diff due to internal build crashes:

This converts the vertical of NativeArray/ReadableNativeArray/WritableNativeArray classes to Kotlin.

Reviewed By: bvanderhoof

Differential Revision: D60707170

fbshipit-source-id: 95e66ebe725d0ff625b50f4711872b9f70ec2f7c

packages/react-native/ReactAndroid/api/ReactAndroid.api

@@ -1489,7 +1489,7 @@ public class com/facebook/react/bridge/ReadableNativeArray : com/facebook/react/
 	public fun getDouble (I)D
 	public fun getDynamic (I)Lcom/facebook/react/bridge/Dynamic;
 	public fun getInt (I)I
-	public static final fun getJNIPassCounter ()I
+	public static fun getJNIPassCounter ()I
 	public fun getLong (I)J
 	public synthetic fun getMap (I)Lcom/facebook/react/bridge/ReadableMap;
 	public fun getMap (I)Lcom/facebook/react/bridge/ReadableNativeMap;

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

@@ -79,9 +79,6 @@ public String extractArgument(
         @Override
         public ReadableArray extractArgument(
             JSInstance jsInstance, ReadableArray jsArguments, int atIndex) {
-          if (jsArguments.isNull(atIndex) || jsArguments.getType(atIndex) != ReadableType.Array) {
-            return null;
-          }
           return jsArguments.getArray(atIndex);
         }
       };
@@ -100,9 +97,6 @@ public Dynamic extractArgument(
         @Override
         public ReadableMap extractArgument(
             JSInstance jsInstance, ReadableArray jsArguments, int atIndex) {
-          if (jsArguments.isNull(atIndex) || jsArguments.getType(atIndex) != ReadableType.Map) {
-            return null;
-          }
           return jsArguments.getMap(atIndex);
         }
       };

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

@@ -0,0 +1,28 @@
+/*
+ * 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 com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/** Base class for an array whose members are stored in native code (C++). */
+@DoNotStrip
+public abstract class NativeArray implements NativeArrayInterface {
+  static {
+    ReactBridge.staticInit();
+  }
+
+  protected NativeArray(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  @Override
+  public native String toString();
+
+  @DoNotStrip private HybridData mHybridData;
+}

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

@@ -36,5 +36,5 @@ public interface ReadableArray {
 
   public fun size(): Int
 
-  public fun toArrayList(): ArrayList<Any?>
+  public fun toArrayList(): ArrayList<Any>
 }

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

@@ -0,0 +1,174 @@
+/*
+ * 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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Implementation of a NativeArray that allows read-only access to its members. This will generally
+ * be constructed and filled in native code so you shouldn't construct one yourself.
+ */
+@DoNotStrip
+public class ReadableNativeArray extends NativeArray implements ReadableArray {
+  static {
+    ReactBridge.staticInit();
+  }
+
+  protected ReadableNativeArray(HybridData hybridData) {
+    super(hybridData);
+  }
+
+  // WriteOnce but not in the constructor fields
+  private @Nullable Object[] mLocalArray;
+  private @Nullable ReadableType[] mLocalTypeArray;
+
+  private static int jniPassCounter = 0;
+
+  public static int getJNIPassCounter() {
+    return jniPassCounter;
+  }
+
+  private Object[] getLocalArray() {
+    if (mLocalArray != null) {
+      return mLocalArray;
+    }
+    synchronized (this) {
+      // Make sure no concurrent call already updated
+      if (mLocalArray == null) {
+        jniPassCounter++;
+        mLocalArray = Assertions.assertNotNull(importArray());
+      }
+    }
+    return mLocalArray;
+  }
+
+  private native Object[] importArray();
+
+  private ReadableType[] getLocalTypeArray() {
+    if (mLocalTypeArray != null) {
+      return mLocalTypeArray;
+    }
+    synchronized (this) {
+      // Make sure no concurrent call already updated
+      if (mLocalTypeArray == null) {
+        jniPassCounter++;
+        Object[] tempArray = Assertions.assertNotNull(importTypeArray());
+        mLocalTypeArray = Arrays.copyOf(tempArray, tempArray.length, ReadableType[].class);
+      }
+    }
+    return mLocalTypeArray;
+  }
+
+  private native Object[] importTypeArray();
+
+  @Override
+  public int size() {
+    return getLocalArray().length;
+  }
+
+  @Override
+  public boolean isNull(int index) {
+    return getLocalArray()[index] == null;
+  }
+
+  @Override
+  public boolean getBoolean(int index) {
+    return ((Boolean) getLocalArray()[index]).booleanValue();
+  }
+
+  @Override
+  public double getDouble(int index) {
+    return ((Double) getLocalArray()[index]).doubleValue();
+  }
+
+  @Override
+  public int getInt(int index) {
+    return ((Double) getLocalArray()[index]).intValue();
+  }
+
+  @Override
+  public long getLong(int index) {
+    return ((Long) getLocalArray()[index]).longValue();
+  }
+
+  @Override
+  public @NonNull String getString(int index) {
+    return (String) getLocalArray()[index];
+  }
+
+  @Override
+  public @NonNull ReadableNativeArray getArray(int index) {
+    return (ReadableNativeArray) getLocalArray()[index];
+  }
+
+  @Override
+  public @NonNull ReadableNativeMap getMap(int index) {
+    return (ReadableNativeMap) getLocalArray()[index];
+  }
+
+  @Override
+  public @NonNull ReadableType getType(int index) {
+    return getLocalTypeArray()[index];
+  }
+
+  @Override
+  public @NonNull Dynamic getDynamic(int index) {
+    return DynamicFromArray.create(this, index);
+  }
+
+  @Override
+  public int hashCode() {
+    return getLocalArray().hashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof ReadableNativeArray)) {
+      return false;
+    }
+    ReadableNativeArray other = (ReadableNativeArray) obj;
+    return Arrays.deepEquals(getLocalArray(), other.getLocalArray());
+  }
+
+  @Override
+  public @NonNull ArrayList<Object> toArrayList() {
+    ArrayList<Object> arrayList = new ArrayList<>();
+
+    for (int i = 0; i < this.size(); i++) {
+      switch (getType(i)) {
+        case Null:
+          arrayList.add(null);
+          break;
+        case Boolean:
+          arrayList.add(getBoolean(i));
+          break;
+        case Number:
+          arrayList.add(getDouble(i));
+          break;
+        case String:
+          arrayList.add(getString(i));
+          break;
+        case Map:
+          arrayList.add(getMap(i).toHashMap());
+          break;
+        case Array:
+          arrayList.add(getArray(i).toArrayList());
+          break;
+        default:
+          throw new IllegalArgumentException("Could not convert object at index: " + i + ".");
+      }
+    }
+    return arrayList;
+  }
+}