react-nitro-yoga 0.0.0-stage → 0.0.1-alpha.7

package/yoga/java/jni/YGJNIVanilla.h

@@ -0,0 +1,12 @@
+/*
+ * 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.
+ */
+
+#include "jni.h"
+
+namespace YGJNIVanilla {
+void registerNatives(JNIEnv* env);
+};

package/yoga/java/jni/YGJTypesVanilla.h

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <map>
+#include <vector>
+
+#include <yoga/Yoga.h>
+
+#include "common.h"
+#include "jni.h"
+
+class PtrJNodeMapVanilla {
+  std::map<YGNodeConstRef, jsize> ptrsToIdxs_{};
+  jobjectArray javaNodes_{};
+
+ public:
+  PtrJNodeMapVanilla() = default;
+
+  PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes)
+      : javaNodes_{javaNodes} {
+    using namespace facebook::yoga::vanillajni;
+
+    JNIEnv* env = getCurrentEnv();
+    jsize nativePointersSize = env->GetArrayLength(javaNativePointers);
+    std::vector<jlong> nativePointers(static_cast<size_t>(nativePointersSize));
+    env->GetLongArrayRegion(
+        javaNativePointers, 0, nativePointersSize, nativePointers.data());
+
+    for (jsize i = 0; i < nativePointersSize; ++i) {
+      ptrsToIdxs_[(YGNodeConstRef)nativePointers[static_cast<size_t>(i)]] = i;
+    }
+  }
+
+  facebook::yoga::vanillajni::ScopedLocalRef<jobject> ref(YGNodeConstRef node) {
+    using namespace facebook::yoga::vanillajni;
+
+    JNIEnv* env = getCurrentEnv();
+    auto idx = ptrsToIdxs_.find(node);
+    if (idx == ptrsToIdxs_.end()) {
+      return ScopedLocalRef<jobject>(env);
+    } else {
+      return make_local_ref(
+          env, env->GetObjectArrayElement(javaNodes_, idx->second));
+    }
+  }
+};

package/yoga/java/jni/YogaJniException.cpp

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#include "YogaJniException.h"
+#include <stdexcept>
+#include <string>
+#include "common.h"
+
+namespace facebook::yoga::vanillajni {
+
+YogaJniException::YogaJniException() {
+  jclass cl = getCurrentEnv()->FindClass("java/lang/RuntimeException");
+  static const jmethodID methodId = facebook::yoga::vanillajni::getMethodId(
+      getCurrentEnv(), cl, "<init>", "()V");
+  auto throwable = getCurrentEnv()->NewObject(cl, methodId);
+  throwable_ =
+      newGlobalRef(getCurrentEnv(), static_cast<jthrowable>(throwable));
+}
+
+YogaJniException::YogaJniException(jthrowable throwable) {
+  throwable_ = newGlobalRef(getCurrentEnv(), throwable);
+}
+
+YogaJniException::YogaJniException(YogaJniException&& rhs) noexcept
+    : throwable_(std::move(rhs.throwable_)) {}
+
+YogaJniException::YogaJniException(const YogaJniException& rhs) {
+  throwable_ = newGlobalRef(getCurrentEnv(), rhs.throwable_.get());
+}
+
+YogaJniException::~YogaJniException() {
+  try {
+    throwable_.reset();
+  } catch (...) {
+    std::terminate();
+  }
+}
+
+ScopedLocalRef<jthrowable> YogaJniException::getThrowable() const noexcept {
+  return make_local_ref(
+      getCurrentEnv(),
+      static_cast<jthrowable>(getCurrentEnv()->NewLocalRef(throwable_.get())));
+}
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/YogaJniException.h

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#include <stdexcept>
+#include <string>
+#include "common.h"
+
+namespace facebook::yoga::vanillajni {
+/**
+ * This class wraps a Java exception (jthrowable) into a C++ exception; A global
+ * reference to Java exception (jthrowable) is made so that the exception object
+ * does not gets cleared before jni call completion
+ */
+class YogaJniException : public std::exception {
+ public:
+  YogaJniException();
+  ~YogaJniException() override;
+
+  explicit YogaJniException(jthrowable throwable);
+
+  YogaJniException(YogaJniException&& rhs) noexcept;
+
+  YogaJniException(const YogaJniException& rhs);
+
+  ScopedLocalRef<jthrowable> getThrowable() const noexcept;
+
+ private:
+  ScopedGlobalRef<jthrowable> throwable_;
+};
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/common.cpp

@@ -0,0 +1,109 @@
+/*
+ * 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.
+ */
+
+#include "common.h"
+
+namespace facebook::yoga::vanillajni {
+
+void registerNatives(
+    JNIEnv* env,
+    const char* className,
+    const JNINativeMethod methods[],
+    size_t numMethods) {
+  jclass clazz = env->FindClass(className);
+
+  assertNoPendingJniExceptionIf(env, clazz == nullptr);
+
+  auto result =
+      env->RegisterNatives(clazz, methods, static_cast<int32_t>(numMethods));
+
+  assertNoPendingJniExceptionIf(env, result != JNI_OK);
+}
+
+jmethodID getStaticMethodId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* methodName,
+    const char* methodDescriptor) {
+  jmethodID methodId =
+      env->GetStaticMethodID(clazz, methodName, methodDescriptor);
+  assertNoPendingJniExceptionIf(env, methodId == nullptr);
+  return methodId;
+}
+
+jmethodID getMethodId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* methodName,
+    const char* methodDescriptor) {
+  jmethodID methodId = env->GetMethodID(clazz, methodName, methodDescriptor);
+  assertNoPendingJniExceptionIf(env, methodId == nullptr);
+  return methodId;
+}
+
+jfieldID getFieldId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* fieldName,
+    const char* fieldSignature) {
+  jfieldID fieldId = env->GetFieldID(clazz, fieldName, fieldSignature);
+  assertNoPendingJniExceptionIf(env, fieldId == nullptr);
+  return fieldId;
+}
+
+#define DEFINE_CALL_METHOD_FOR_PRIMITIVE_IMPLEMENTATION(jnitype, readableType) \
+  DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jnitype, readableType) {          \
+    va_list args;                                                              \
+    va_start(args, methodId);                                                  \
+    jnitype result = env->Call##readableType##MethodV(obj, methodId, args);    \
+    va_end(args);                                                              \
+    assertNoPendingJniException(env);                                          \
+    return result;                                                             \
+  }
+
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_IMPLEMENTATION(jlong, Long);
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_IMPLEMENTATION(jfloat, Float);
+
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(void, Void) {
+  va_list args;
+  va_start(args, methodId);
+  env->CallVoidMethodV(obj, methodId, args);
+  va_end(args);
+  assertNoPendingJniException(env);
+}
+
+ScopedLocalRef<jobject>
+callStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID methodId, ...) {
+  va_list args;
+  va_start(args, methodId);
+  jobject result = env->CallStaticObjectMethodV(clazz, methodId, args);
+  va_end(args);
+  assertNoPendingJniExceptionIf(env, result == nullptr);
+  return make_local_ref(env, result);
+}
+
+ScopedGlobalRef<jobject> newGlobalRef(JNIEnv* env, jobject obj) {
+  jobject result = env->NewGlobalRef(obj);
+
+  if (result == nullptr) {
+    logErrorMessageAndDie("Could not obtain global reference from object");
+  }
+
+  return make_global_ref(result);
+}
+
+ScopedGlobalRef<jthrowable> newGlobalRef(JNIEnv* env, jthrowable obj) {
+  auto result = static_cast<jthrowable>(env->NewGlobalRef(obj));
+
+  if (result == nullptr) {
+    logErrorMessageAndDie("Could not obtain global reference from object");
+  }
+
+  return make_global_ref(result);
+}
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/common.h

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+#pragma once
+#include "ScopedGlobalRef.h"
+#include "ScopedLocalRef.h"
+
+namespace facebook::yoga::vanillajni {
+
+/**
+ * Registers a set of methods for a JNI class. Aborts if registration fails.
+ */
+void registerNatives(
+    JNIEnv* env,
+    const char* className,
+    const JNINativeMethod methods[],
+    size_t numMethods);
+
+/**
+ * Returns a jmethodID for a class static method. Aborts if any error happens.
+ */
+jmethodID getStaticMethodId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* methodName,
+    const char* methodDescriptor);
+
+/**
+ * Returns a jmethodID for a class non-static method. Aborts if any error
+ * happens.
+ */
+jmethodID getMethodId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* methodName,
+    const char* methodDescriptor);
+
+/**
+ * Returns a class non-static field ID. Aborts if any error happens.
+ */
+jfieldID getFieldId(
+    JNIEnv* env,
+    jclass clazz,
+    const char* fieldName,
+    const char* fieldSignature);
+
+// Helper methods to call a non-static method on an object depending on the
+// return type. Each method will abort the execution if an error
+// (such as a Java pending exception) is detected after invoking the
+// Java method.
+#define DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jnitype, readableType) \
+  jnitype call##readableType##Method(                                     \
+      JNIEnv* env, jobject obj, jmethodID methodId, ...)
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(void, Void);
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jlong, Long);
+DEFINE_CALL_METHOD_FOR_PRIMITIVE_INTERFACE(jfloat, Float);
+
+ScopedLocalRef<jobject>
+callStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID methodId, ...);
+
+/**
+ * Given a local or a global reference, this method creates a new global
+ * reference out of it. If any error happens, aborts the process.
+ */
+ScopedGlobalRef<jobject> newGlobalRef(JNIEnv* env, jobject obj);
+
+ScopedGlobalRef<jthrowable> newGlobalRef(JNIEnv* env, jthrowable obj);
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/corefunctions.cpp

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+#include "corefunctions.h"
+#include "YogaJniException.h"
+#include "macros.h"
+
+namespace facebook::yoga::vanillajni {
+
+namespace {
+JavaVM* globalVm = nullptr;
+struct JavaVMInitializer {
+  explicit JavaVMInitializer(JavaVM* vm) {
+    if (!vm) {
+      logErrorMessageAndDie(
+          "You cannot pass a NULL JavaVM to ensureInitialized");
+    }
+    globalVm = vm;
+  }
+};
+} // namespace
+
+jint ensureInitialized(JNIEnv** env, JavaVM* vm) {
+  static JavaVMInitializer init(vm);
+
+  if (env == nullptr) {
+    logErrorMessageAndDie(
+        "Need to pass a valid JNIEnv pointer to vanillajni initialization "
+        "routine");
+  }
+
+  if (vm->GetEnv(reinterpret_cast<void**>(env), JNI_VERSION_1_6) != JNI_OK) {
+    logErrorMessageAndDie(
+        "Error retrieving JNIEnv during initialization of vanillajni");
+  }
+
+  return JNI_VERSION_1_6;
+}
+
+// TODO why we need JNIEXPORT for getCurrentEnv ?
+JNIEXPORT JNIEnv* getCurrentEnv() {
+  JNIEnv* env = nullptr;
+  jint ret = globalVm->GetEnv((void**)&env, JNI_VERSION_1_6);
+  if (ret != JNI_OK) {
+    logErrorMessageAndDie(
+        "There was an error retrieving the current JNIEnv. Make sure the "
+        "current thread is attached");
+  }
+  return env;
+}
+
+void logErrorMessageAndDie(const char* message) {
+  (void)message;
+  VANILLAJNI_LOG_ERROR(
+      "VanillaJni",
+      "Aborting due to error detected in native code: %s",
+      message);
+  VANILLAJNI_DIE();
+}
+
+void assertNoPendingJniException(JNIEnv* env) {
+  if (env->ExceptionCheck() == JNI_FALSE) {
+    return;
+  }
+
+  auto throwable = env->ExceptionOccurred();
+  if (throwable == nullptr) {
+    logErrorMessageAndDie("Unable to get pending JNI exception.");
+  }
+  env->ExceptionClear();
+  throw YogaJniException(throwable);
+}
+
+void assertNoPendingJniExceptionIf(JNIEnv* env, bool condition) {
+  if (!condition) {
+    return;
+  }
+
+  if (env->ExceptionCheck() == JNI_TRUE) {
+    assertNoPendingJniException(env);
+    return;
+  }
+
+  throw YogaJniException();
+}
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/corefunctions.h

@@ -0,0 +1,50 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <jni.h>
+#include <cstddef>
+
+namespace facebook::yoga::vanillajni {
+
+/**
+ * This method has to be called before using the vanillajni library. This method
+ * is typically called when doing initialization in the "on load" JNI hook of a
+ * particular library.
+ *
+ * This method is thread safe, and after the first time it's called it has no
+ * initialization effect.
+ *
+ * @param  env use this output parameter to get a JNIEnv to use for things such
+ * as registering native methods and such.
+ * @param  vm  the VM instance passed by JNI. This is usually the VM instance
+ * that is passed to the "on load" JNI hook.
+ * @return an integer value to return from the "on load" hook.
+ */
+jint ensureInitialized(JNIEnv** env, JavaVM* vm);
+
+/**
+ * Returns a JNIEnv* suitable for the current thread. If the current thread is
+ * not attached to the Java VM, this method aborts execution.
+ */
+JNIEnv* getCurrentEnv();
+
+/**
+ * Logs an error message and aborts the current process.
+ */
+void logErrorMessageAndDie(const char* message);
+
+/**
+ * Checks whether there is a pending JNI exception. If so, it logs an error
+ * message and aborts the current process. Otherwise it does nothing.
+ */
+void assertNoPendingJniException(JNIEnv* env);
+
+void assertNoPendingJniExceptionIf(JNIEnv* env, bool condition);
+
+} // namespace facebook::yoga::vanillajni

package/yoga/java/jni/macros.h

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <cstdlib>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+
+#ifdef __ANDROID__
+#define VANILLAJNI_LOG_ERROR(tag, format, ...) \
+  __android_log_print(ANDROID_LOG_ERROR, tag, format, ##__VA_ARGS__)
+#else
+#define VANILLAJNI_LOG_ERROR(tag, format, ...)
+#endif
+
+#define VANILLAJNI_DIE() std::abort()