expo-modules-core 55.0.2 → 55.0.4

package/android/src/main/cpp/JavaScriptTypedArray.h

@@ -2,7 +2,6 @@
 
 #include "TypedArray.h"
 #include "JavaScriptObject.h"
-#include "WeakRuntimeHolder.h"
 
 #include <fbjni/fbjni.h>
 #include <fbjni/ByteBuffer.h>
@@ -36,11 +35,6 @@ public:
     std::shared_ptr<jsi::Object> jsObject
   );
 
-  JavaScriptTypedArray(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Object> jsObject
-  );
-
   /**
    * Gets a raw kind of the underlying typed array.
    */

package/android/src/main/cpp/JavaScriptValue.cpp

@@ -39,14 +39,7 @@ JavaScriptValue::JavaScriptValue(
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Value> jsValue
 ) : runtimeHolder(std::move(runtime)), jsValue(std::move(jsValue)) {
-  runtimeHolder.ensureRuntimeIsValid();
-}
-
-JavaScriptValue::JavaScriptValue(
-  WeakRuntimeHolder runtime,
-  std::shared_ptr<jsi::Value> jsValue
-) : runtimeHolder(std::move(runtime)), jsValue(std::move(jsValue)) {
-  runtimeHolder.ensureRuntimeIsValid();
+  assert((!runtimeHolder.expired()) && "JS Runtime was used after deallocation");
 }
 
 std::shared_ptr<jsi::Value> JavaScriptValue::get() {
@@ -113,8 +106,11 @@ bool JavaScriptValue::isSymbol() {
 
 bool JavaScriptValue::isFunction() {
   if (jsValue->isObject()) {
-    auto &jsRuntime = runtimeHolder.getJSRuntime();
-    return jsValue->asObject(jsRuntime).isFunction(jsRuntime);
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return jsValue->asObject(rawRuntime).isFunction(rawRuntime);
   }
 
   return false;
@@ -122,8 +118,11 @@ bool JavaScriptValue::isFunction() {
 
 bool JavaScriptValue::isArray() {
   if (jsValue->isObject()) {
-    auto &jsRuntime = runtimeHolder.getJSRuntime();
-    return jsValue->asObject(jsRuntime).isArray(jsRuntime);
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return jsValue->asObject(rawRuntime).isArray(rawRuntime);
   }
 
   return false;
@@ -135,8 +134,11 @@ bool JavaScriptValue::isObject() {
 
 bool JavaScriptValue::isTypedArray() {
   if (jsValue->isObject()) {
-    jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
-    return expo::isTypedArray(jsRuntime, jsValue->getObject(jsRuntime));
+    auto runtime = runtimeHolder.lock();
+    assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+    auto &rawRuntime = runtime->get();
+
+    return expo::isTypedArray(rawRuntime, jsValue->getObject(rawRuntime));
   }
   return false;
 }
@@ -150,46 +152,57 @@ double JavaScriptValue::getDouble() {
 }
 
 std::string JavaScriptValue::getString() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  return jsValue->getString(jsRuntime).utf8(jsRuntime);
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  return jsValue->getString(rawRuntime).utf8(rawRuntime);
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptValue::getObject() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(rawRuntime));
   return JavaScriptObject::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsObject
   );
 }
 
 jni::local_ref<JavaScriptFunction::javaobject> JavaScriptValue::jniGetFunction() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
   auto jsFunction = std::make_shared<jsi::Function>(
-    jsValue->getObject(jsRuntime).asFunction(jsRuntime));
+    jsValue->getObject(rawRuntime).asFunction(rawRuntime));
   return JavaScriptFunction::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsFunction
   );
 }
 
 jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::getArray() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto moduleRegistry = runtimeHolder.getJSIContext();
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+  auto jsiContext = expo::getJSIContext(rawRuntime);
 
   auto jsArray = jsValue
-    ->getObject(jsRuntime)
-    .asArray(jsRuntime);
-  size_t size = jsArray.size(jsRuntime);
+    ->getObject(rawRuntime)
+    .asArray(rawRuntime);
+  size_t size = jsArray.size(rawRuntime);
 
   auto result = jni::JArrayClass<JavaScriptValue::javaobject>::newArray(size);
   for (size_t i = 0; i < size; i++) {
     auto element = JavaScriptValue::newInstance(
-      moduleRegistry,
+      jsiContext,
       runtimeHolder,
-      std::make_shared<jsi::Value>(jsArray.getValueAtIndex(jsRuntime, i))
+      std::make_shared<jsi::Value>(jsArray.getValueAtIndex(rawRuntime, i))
     );
 
     result->setElement(i, element.release());
@@ -208,10 +221,13 @@ jni::local_ref<jstring> JavaScriptValue::jniGetString() {
 }
 
 jni::local_ref<JavaScriptTypedArray::javaobject> JavaScriptValue::getTypedArray() {
-  auto &jsRuntime = runtimeHolder.getJSRuntime();
-  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
+  auto runtime = runtimeHolder.lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = runtime->get();
+
+  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(rawRuntime));
   return JavaScriptTypedArray::newInstance(
-    runtimeHolder.getJSIContext(),
+    expo::getJSIContext(rawRuntime),
     runtimeHolder,
     jsObject
   );

package/android/src/main/cpp/JavaScriptValue.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "JSIObjectWrapper.h"
-#include "WeakRuntimeHolder.h"
 #include "JavaScriptTypedArray.h"
 #include "JavaScriptArrayBuffer.h"
 #include "JNIDeallocator.h"
@@ -49,11 +48,6 @@ public:
     std::shared_ptr<jsi::Value> jsValue
   );
 
-  JavaScriptValue(
-    WeakRuntimeHolder runtime,
-    std::shared_ptr<jsi::Value> jsValue
-  );
-
   std::shared_ptr<jsi::Value> get() override;
 
   std::string kind();
@@ -95,7 +89,7 @@ public:
 private:
   friend HybridBase;
 
-  WeakRuntimeHolder runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
   std::shared_ptr<jsi::Value> jsValue;
 
   jni::local_ref<jstring> jniKind();

package/android/src/main/cpp/JavaScriptWeakObject.cpp

@@ -7,8 +7,8 @@ namespace expo {
 
 void JavaScriptWeakObject::registerNatives() {
   registerHybrid({
-      makeNativeMethod("lock", JavaScriptWeakObject::lock),
-  });
+                   makeNativeMethod("lock", JavaScriptWeakObject::lock),
+                 });
 }
 
 std::shared_ptr<jsi::WeakObject> JavaScriptWeakObject::getWeak() {
@@ -16,26 +16,30 @@ std::shared_ptr<jsi::WeakObject> JavaScriptWeakObject::getWeak() {
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptWeakObject::lock() {
-  jsi::Runtime &rt = _runtimeHolder.getJSRuntime();
+  auto jsRuntime = _runtimeHolder.lock();
+  assert((jsRuntime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = jsRuntime->get();
 
-  jsi::Value value = _weakObject->lock(rt);
+  jsi::Value value = _weakObject->lock(rawRuntime);
   if (value.isUndefined()) {
     return nullptr;
   }
   std::shared_ptr<jsi::Object> objectPtr =
-      std::make_shared<jsi::Object>(value.asObject(rt));
+    std::make_shared<jsi::Object>(value.asObject(rawRuntime));
   if (!objectPtr) {
     return nullptr;
   }
-  return JavaScriptObject::newInstance(_runtimeHolder.getJSIContext(),
-                                       _runtimeHolder, objectPtr);
+  return JavaScriptObject::newInstance(
+    expo::getJSIContext(rawRuntime),
+    _runtimeHolder, objectPtr
+  );
 }
 
 jni::local_ref<jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject>
 JavaScriptWeakObject::newInstance(
-    JSIContext *jSIContext,
-    std::weak_ptr<JavaScriptRuntime> runtime,
-    std::shared_ptr<jsi::Object> jsObject) {
+  JSIContext *jSIContext,
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Object> jsObject) {
   auto weakObject = JavaScriptWeakObject::newObjectCxxArgs(std::move(runtime),
                                                            std::move(jsObject));
   jSIContext->jniDeallocator->addReference(weakObject);
@@ -43,12 +47,14 @@ JavaScriptWeakObject::newInstance(
 }
 
 JavaScriptWeakObject::JavaScriptWeakObject(
-    WeakRuntimeHolder runtime,
-    const std::shared_ptr<jsi::Object>& jsObject
+  const std::weak_ptr<JavaScriptRuntime> &runtime,
+  const std::shared_ptr<jsi::Object> &jsObject
 ) : _runtimeHolder(std::move(runtime)) {
-  _runtimeHolder.ensureRuntimeIsValid();
-  jsi::Runtime &rt = _runtimeHolder.getJSRuntime();
-  _weakObject = std::make_shared<jsi::WeakObject>(rt, *jsObject);
+  auto jsRuntime = _runtimeHolder.lock();
+  assert((jsRuntime != nullptr) && "JS Runtime was used after deallocation");
+  auto &rawRuntime = jsRuntime->get();
+
+  _weakObject = std::make_shared<jsi::WeakObject>(rawRuntime, *jsObject);
 }
 
 } // namespace expo

package/android/src/main/cpp/JavaScriptWeakObject.h

@@ -4,7 +4,6 @@
 
 #include "JNIDeallocator.h"
 #include "JavaScriptObject.h"
-#include "WeakRuntimeHolder.h"
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -22,32 +21,36 @@ class JavaScriptObject;
  * Represents to a jsi::WeakObject.
  */
 class JavaScriptWeakObject
-    : public jni::HybridClass<JavaScriptWeakObject, Destructible> {
+  : public jni::HybridClass<JavaScriptWeakObject, Destructible> {
 public:
   static auto constexpr kJavaDescriptor =
-      "Lexpo/modules/kotlin/jni/JavaScriptWeakObject;";
+    "Lexpo/modules/kotlin/jni/JavaScriptWeakObject;";
   static auto constexpr TAG = "JavaScriptWeakObject";
 
   static void registerNatives();
 
   static jni::local_ref<
-      jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject>
-  newInstance(JSIContext *jSIContext,
-              std::weak_ptr<JavaScriptRuntime> runtime,
-              std::shared_ptr<jsi::Object> jsObject);
+    jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject
+  > newInstance(
+    JSIContext *jSIContext,
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Object> jsObject
+  );
 
   jni::local_ref<JavaScriptObject::javaobject> lock();
 
   std::shared_ptr<jsi::WeakObject> getWeak();
 
 private:
-  JavaScriptWeakObject(WeakRuntimeHolder runtime,
-                       const std::shared_ptr<jsi::Object>& jsObject);
+  JavaScriptWeakObject(
+    const std::weak_ptr<JavaScriptRuntime> &runtime,
+    const std::shared_ptr<jsi::Object> &jsObject
+  );
 
 private:
   friend HybridBase;
 
-  WeakRuntimeHolder _runtimeHolder;
+  std::weak_ptr<JavaScriptRuntime> _runtimeHolder;
   std::shared_ptr<jsi::WeakObject> _weakObject;
 };
 

package/android/src/main/java/expo/modules/kotlin/AppContext.kt

@@ -264,16 +264,25 @@ class AppContext(
   }
 
   internal fun onDestroy() = trace("AppContext.onDestroy") {
-    hostingRuntimeContext.reactContext?.removeLifecycleEventListener(reactLifecycleDelegate)
-    registry.post(EventName.MODULE_DESTROY)
-    registry.cleanUp()
+    runtime.reactContext?.run {
+      removeLifecycleEventListener(reactLifecycleDelegate)
+      removeActivityEventListener(reactLifecycleDelegate)
+    }
+
+    with(registry) {
+      post(EventName.MODULE_DESTROY)
+      cleanUp()
+    }
+
     modulesQueue.cancel(ContextDestroyedException())
     mainQueue.cancel(ContextDestroyedException())
     backgroundCoroutineScope.cancel(ContextDestroyedException())
-    hostingRuntimeContext.deallocate()
+
+    runtime.deallocate()
     if (uiRuntimeHolder.isInitialized()) {
       uiRuntime.deallocate()
     }
+
     logger.info("✅ AppContext was destroyed")
   }
 

package/android/src/main/java/expo/modules/kotlin/jni/JNIDeallocator.kt

@@ -1,13 +1,13 @@
 package expo.modules.kotlin.jni
 
+import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
 import java.lang.ref.PhantomReference
 import java.lang.ref.ReferenceQueue
-import java.lang.ref.WeakReference
 
 @DoNotStrip
 interface Destructible {
-  fun deallocate()
+  fun getHybridDataForJNIDeallocator(): HybridData
 }
 
 @DoNotStrip
@@ -24,7 +24,7 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
   /**
    * A registry to keep all active [Destructible] objects and their [PhantomReference]s
    */
-  private val destructorMap = mutableMapOf<PhantomReference<Destructible>, WeakReference<Destructible>>()
+  private val destructorMap = mutableMapOf<PhantomReference<Destructible>, HybridData>()
 
   /**
    * A thread that clears your registry when an object has been garbage collected
@@ -43,9 +43,8 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    */
   @DoNotStrip
   fun addReference(destructible: Destructible): Unit = synchronized(this) {
-    val weakRef = WeakReference(destructible)
     val phantomRef = PhantomReference(destructible, referenceQueue)
-    destructorMap[phantomRef] = weakRef
+    destructorMap[phantomRef] = destructible.getHybridDataForJNIDeallocator()
   }
 
   /**
@@ -53,7 +52,7 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    */
   internal fun deallocate() = synchronized(this) {
     destructorMap.values.forEach {
-      it.get()?.deallocate()
+      it.resetNative()
     }
     destructorMap.clear()
     destructorThread?.interrupt()
@@ -64,15 +63,17 @@ class JNIDeallocator(shouldCreateDestructorThread: Boolean = true) : AutoCloseab
    * and are present in the memory.
    */
   fun inspectMemory() = synchronized(this) {
-    destructorMap.values.mapNotNull { it.get() }
+    destructorMap
+      .values
+      .filter { synchronized(it) { it.isValid } }
+      .map { it }
   }
 
   private fun Thread.deallocator() {
     while (!isInterrupted) {
       try {
-        // Referent of PhantomReference were garbage collected so we can remove it from our registry.
-        // Note that we don't have to call `deallocate` method - it was called [com.facebook.jni.HybridData].
         val current = referenceQueue.remove()
+        destructorMap[current]?.resetNative()
         synchronized(this@JNIDeallocator) {
           destructorMap.remove(current)
         }

package/android/src/main/java/expo/modules/kotlin/jni/JSIContext.kt

@@ -124,14 +124,14 @@ class JSIContext @DoNotStrip internal constructor(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    close()
   }
 
-  override fun deallocate() {
+  override fun close() {
     mHybridData.resetNative()
   }
 
-  override fun close() {
-    deallocate()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaCallback.kt

@@ -115,10 +115,10 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptArrayBuffer.kt

@@ -26,10 +26,10 @@ class JavaScriptArrayBuffer @DoNotStrip private constructor(@DoNotStrip private
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptFunction.kt

@@ -42,10 +42,10 @@ class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoN
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptModuleObject.kt

@@ -34,14 +34,14 @@ class JavaScriptModuleObject(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
-  }
-
-  override fun deallocate() {
     mHybridData.resetNative()
   }
 
   override fun toString(): String {
     return "JavaScriptModuleObject_$name"
   }
+
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
+  }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptObject.kt

@@ -144,11 +144,11 @@ open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }
 

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptValue.kt

@@ -56,10 +56,10 @@ class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mH
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptWeakObject.kt

@@ -12,11 +12,12 @@ import expo.modules.core.interfaces.DoNotStrip
 class JavaScriptWeakObject @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
+
   external fun lock(): JavaScriptObject
 }

package/android/src/main/java/expo/modules/kotlin/jni/NativeArrayBuffer.kt

@@ -44,11 +44,11 @@ class NativeArrayBuffer : Destructible, ArrayBuffer {
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 
   companion object {

package/android/src/main/java/expo/modules/kotlin/jni/PromiseImpl.kt

@@ -45,11 +45,11 @@ class PromiseImpl @DoNotStrip internal constructor(
     callback.invoke(result)
   }
 
-  override fun resolve(result: Collection<Any?>) {
+  override fun resolve(result: Collection<Any?>) = checkIfWasSettled {
     callback.invoke(result)
   }
 
-  override fun resolve(result: Map<String, Any?>) {
+  override fun resolve(result: Map<String, Any?>) = checkIfWasSettled {
     callback.invoke(result)
   }
 
@@ -62,11 +62,11 @@ class PromiseImpl @DoNotStrip internal constructor(
   private inline fun checkIfWasSettled(body: () -> Unit) {
     if (wasSettled) {
       val exception = PromiseAlreadySettledException(fullFunctionName ?: "unknown")
-      val errorManager = appContextHolder?.get()?.errorManager
+      val jsLogger = appContextHolder?.get()?.jsLogger
       // We want to report that a promise was settled twice in the development build.
       // However, in production, the app should crash.
-      if (BuildConfig.DEBUG && errorManager != null) {
-        errorManager.reportExceptionToLogBox(exception)
+      if (BuildConfig.DEBUG && jsLogger != null) {
+        jsLogger.error("Trying to resolve promise that was already settled", exception)
         logger.error("Trying to resolve promise that was already settled", exception)
         return
       }

package/android/src/main/java/expo/modules/kotlin/jni/decorators/JSDecoratorsBridgingObject.kt

@@ -98,13 +98,13 @@ class JSDecoratorsBridgingObject(jniDeallocator: JNIDeallocator) : Destructible
     )
   }
 
-  override fun deallocate() {
+  @Throws(Throwable::class)
+  protected fun finalize() {
     mHybridData.resetNative()
   }
 
-  @Throws(Throwable::class)
-  protected fun finalize() {
-    deallocate()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 
   fun ObjectDefinitionData.exportConstants() {

package/android/src/main/java/expo/modules/kotlin/jni/worklets/Serializable.kt

@@ -36,10 +36,10 @@ class Serializable @DoNotStrip private constructor(
 
   @Throws(Throwable::class)
   protected fun finalize() {
-    deallocate()
+    mHybridData.resetNative()
   }
 
-  override fun deallocate() {
-    mHybridData.resetNative()
+  override fun getHybridDataForJNIDeallocator(): HybridData {
+    return mHybridData
   }
 }

package/ios/Core/Objects/ConstantDefinition.swift

@@ -10,6 +10,11 @@ protocol AnyConstantDefinition {
    Creates the JavaScript object representing the constant property descriptor.
    */
   func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject
+
+  /**
+   Returns the raw value of the constant for encoding purposes.
+   */
+  func getRawValue() -> Any?
 }
 
 public final class ConstantDefinition<ReturnType>: AnyDefinition, AnyConstantDefinition {
@@ -59,6 +64,10 @@ public final class ConstantDefinition<ReturnType>: AnyDefinition, AnyConstantDef
     return try getter?()
   }
 
+  internal func getRawValue() -> Any? {
+    return try? getter?()
+  }
+
   /**
    Creates the JavaScript function that will be used as a getter of the constant.
    */