expo-modules-core 0.11.0 → 0.11.3

package/CHANGELOG.md

@@ -10,6 +10,24 @@
 
 ### 💡 Others
 
+## 0.11.3 — 2022-07-18
+
+### 💡 Others
+
+- Changed access levels in the Logger and fixed the timer to log milliseconds instead of seconds. ([#18271](https://github.com/expo/expo/pull/18271) by [@douglowder](https://github.com/douglowder))
+
+## 0.11.2 — 2022-07-16
+
+### 🐛 Bug fixes
+
+- Fix dangling pointer in the fbjni from the MethodMetadata::createPromiseBody on Android. ([#18206](https://github.com/expo/expo/pull/18206) by [@lukmccall](https://github.com/lukmccall))
+
+## 0.11.1 — 2022-07-11
+
+### 🐛 Bug fixes
+
+- Fixed a crash when remote debugging is enabled on Android. ([#18165](https://github.com/expo/expo/pull/18165) by [@kudo](https://github.com/kudo))
+
 ## 0.11.0 — 2022-07-07
 
 ### 🎉 New features

package/android/build.gradle

@@ -6,7 +6,7 @@ apply plugin: 'maven-publish'
 apply plugin: "de.undercouch.download"
 
 group = 'host.exp.exponent'
-version = '0.11.0'
+version = '0.11.3'
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -144,7 +144,7 @@ android {
     targetSdkVersion safeExtGet("targetSdkVersion", 31)
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "0.11.0"
+    versionName "0.11.3"
 
     testInstrumentationRunner "expo.modules.TestRunner"
 

package/android/src/main/cpp/CachedReferencesRegistry.cpp

@@ -22,6 +22,8 @@ void CachedReferencesRegistry::loadJClasses(JNIEnv *env) {
   loadJClass(env, "com/facebook/react/bridge/PromiseImpl", {
     {"<init>", "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V"}
   });
+
+  loadJClass(env, "java/lang/Object", {});
 }
 
 void CachedReferencesRegistry::loadJClass(

package/android/src/main/cpp/JNIFunctionBody.cpp

@@ -1,30 +1,30 @@
 // Copyright © 2021-present 650 Industries, Inc. (aka Expo)
 
 #include "JNIFunctionBody.h"
+#include "CachedReferencesRegistry.h"
 
 namespace jni = facebook::jni;
 namespace react = facebook::react;
 
 namespace expo {
 jni::local_ref<react::ReadableNativeArray::javaobject>
-JNIFunctionBody::invoke(jni::local_ref<jni::JArrayClass<jobject>> &&args) {
+JNIFunctionBody::invoke(jobjectArray args) {
   // Do NOT use getClass here!
   // Method obtained from `getClass` will point to the overridden version of the method.
   // Because of that, it can't be cached - we will try to invoke the nonexistent method
   // if we receive an object of a different class than the one used to obtain the method id.
   // The only cacheable method id can be obtain from the base class.
   static const auto method = jni::findClassLocal("expo/modules/kotlin/jni/JNIFunctionBody")
-    ->getMethod<
-      react::ReadableNativeArray::javaobject(jni::local_ref<jni::JArrayClass<jobject>>)
-    >(
-      "invoke"
+    ->getMethod<jni::local_ref<react::ReadableNativeArray::javaobject>(jobjectArray)>(
+      "invoke",
+      "([Ljava/lang/Object;)Lcom/facebook/react/bridge/ReadableNativeArray;"
     );
 
   return method(this->self(), args);
 }
 
 void JNIAsyncFunctionBody::invoke(
-  jni::local_ref<jni::JArrayClass<jobject>> &&args,
+  jobjectArray args,
   jobject promise
 ) {
   // Do NOT use getClass here!
@@ -34,9 +34,10 @@ void JNIAsyncFunctionBody::invoke(
   // The only cacheable method id can be obtain from the base class.
   static const auto method = jni::findClassLocal("expo/modules/kotlin/jni/JNIAsyncFunctionBody")
     ->getMethod<
-      void(jni::local_ref<jni::JArrayClass<jobject>>, jobject)
+      void(jobjectArray , jobject)
     >(
-      "invoke"
+      "invoke",
+      "([Ljava/lang/Object;Ljava/lang/Object;)V"
     );
 
   method(this->self(), args, promise);

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

@@ -24,7 +24,7 @@ public:
    * @return result of the Kotlin function
    */
   jni::local_ref<react::ReadableNativeArray::javaobject> invoke(
-    jni::local_ref<jni::JArrayClass<jobject>> &&args
+    jobjectArray args
   );
 };
 
@@ -43,7 +43,7 @@ public:
    * @param promise that will be resolve or rejected in the Kotlin's implementation
    */
   void invoke(
-    jni::local_ref<jni::JArrayClass<jobject>> &&args,
+    jobjectArray args,
     jobject promise
   );
 };

package/android/src/main/cpp/JavaScriptRuntime.cpp

@@ -87,10 +87,10 @@ jsi::Runtime *JavaScriptRuntime::get() {
 jni::local_ref<JavaScriptValue::javaobject>
 JavaScriptRuntime::evaluateScript(const std::string &script) {
   auto scriptBuffer = std::make_shared<jsi::StringBuffer>(script);
-  std::shared_ptr<jsi::Value> result;
   try {
-    result = std::make_shared<jsi::Value>(
-      runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>")
+    return JavaScriptValue::newObjectCxxArgs(
+      weak_from_this(),
+      std::make_shared<jsi::Value>(runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>"))
     );
   } catch (const jsi::JSError &error) {
     jni::throwNewJavaException(
@@ -107,8 +107,6 @@ JavaScriptRuntime::evaluateScript(const std::string &script) {
       ).get()
     );
   }
-
-  return JavaScriptValue::newObjectCxxArgs(weak_from_this(), result);
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptRuntime::global() {

package/android/src/main/cpp/MethodMetadata.cpp

@@ -80,49 +80,65 @@ std::vector<jvalue> MethodMetadata::convertJSIArgsToJNI(
   JNIEnv *env,
   jsi::Runtime &rt,
   const jsi::Value *args,
-  size_t count
+  size_t count,
+  bool returnGlobalReferences
 ) {
   std::vector<jvalue> result(count);
 
+  auto makeGlobalIfNecessary = [env, returnGlobalReferences](jobject obj) -> jobject {
+    if (returnGlobalReferences) {
+      return env->NewGlobalRef(obj);
+    }
+    return obj;
+  };
+
   for (unsigned int argIndex = 0; argIndex < count; argIndex++) {
     const jsi::Value *arg = &args[argIndex];
     jvalue *jarg = &result[argIndex];
     int desiredType = desiredTypes[argIndex];
 
     if (desiredType & CppType::JS_VALUE) {
-      jarg->l = JavaScriptValue::newObjectCxxArgs(
-        moduleRegistry->runtimeHolder->weak_from_this(),
-        // TODO(@lukmccall): make sure that copy here is necessary
-        std::make_shared<jsi::Value>(jsi::Value(rt, *arg))
-      ).release();
+      jarg->l = makeGlobalIfNecessary(
+        JavaScriptValue::newObjectCxxArgs(
+          moduleRegistry->runtimeHolder->weak_from_this(),
+          // TODO(@lukmccall): make sure that copy here is necessary
+          std::make_shared<jsi::Value>(jsi::Value(rt, *arg))
+        ).release()
+      );
     } else if (desiredType & CppType::JS_OBJECT) {
-      jarg->l = JavaScriptObject::newObjectCxxArgs(
-        moduleRegistry->runtimeHolder->weak_from_this(),
-        std::make_shared<jsi::Object>(arg->getObject(rt))
-      ).release();
+      jarg->l = makeGlobalIfNecessary(
+        JavaScriptObject::newObjectCxxArgs(
+          moduleRegistry->runtimeHolder->weak_from_this(),
+          std::make_shared<jsi::Object>(arg->getObject(rt))
+        ).release()
+      );
     } else if (arg->isNull() || arg->isUndefined()) {
       jarg->l = nullptr;
     } else if (arg->isNumber()) {
       auto &doubleClass = CachedReferencesRegistry::instance()
         ->getJClass("java/lang/Double");
       jmethodID doubleConstructor = doubleClass.getMethod("<init>", "(D)V");
-      jarg->l = env->NewObject(doubleClass.clazz, doubleConstructor, arg->getNumber());
+      jarg->l = makeGlobalIfNecessary(
+        env->NewObject(doubleClass.clazz, doubleConstructor, arg->getNumber()));
     } else if (arg->isBool()) {
       auto &booleanClass = CachedReferencesRegistry::instance()
         ->getJClass("java/lang/Boolean");
       jmethodID booleanConstructor = booleanClass.getMethod("<init>", "(Z)V");
-      jarg->l = env->NewObject(booleanClass.clazz, booleanConstructor, arg->getBool());
+      jarg->l = makeGlobalIfNecessary(
+        env->NewObject(booleanClass.clazz, booleanConstructor, arg->getBool()));
     } else if (arg->isString()) {
-      jarg->l = env->NewStringUTF(arg->getString(rt).utf8(rt).c_str());
+      jarg->l = makeGlobalIfNecessary(env->NewStringUTF(arg->getString(rt).utf8(rt).c_str()));
     } else if (arg->isObject()) {
       const jsi::Object object = arg->getObject(rt);
 
       // TODO(@lukmccall): stop using dynamic
       auto dynamic = jsi::dynamicFromValue(rt, *arg);
       if (arg->getObject(rt).isArray(rt)) {
-        jarg->l = react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamic)).release();
+        jarg->l = makeGlobalIfNecessary(
+          react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamic)).release());
       } else {
-        jarg->l = react::ReadableNativeMap::createWithContents(std::move(dynamic)).release();
+        jarg->l = makeGlobalIfNecessary(
+          react::ReadableNativeMap::createWithContents(std::move(dynamic)).release());
       }
     } else {
       // TODO(@lukmccall): throw an exception
@@ -202,18 +218,23 @@ jsi::Value MethodMetadata::callSync(
    */
   jni::JniLocalScope scope(env, (int) count);
 
-  std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
+  std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count,
+                                                          false);
 
   // TODO(@lukmccall): Remove this temp array
-  auto tempArray = jni::JArrayClass<jobject>::newArray(count);
+  auto tempArray = env->NewObjectArray(
+    convertedArgs.size(),
+    CachedReferencesRegistry::instance()->getJClass("java/lang/Object").clazz,
+    nullptr
+  );
   for (size_t i = 0; i < convertedArgs.size(); i++) {
-    tempArray->setElement(i, convertedArgs[i].l);
+    env->SetObjectArrayElement(tempArray, i, convertedArgs[i].l);
   }
 
   // Cast in this place is safe, cause we know that this function is promise-less.
   auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
   auto result = syncFunction->invoke(
-    std::move(tempArray)
+    tempArray
   );
 
   if (result == nullptr) {
@@ -248,20 +269,14 @@ jsi::Function MethodMetadata::toAsyncFunction(
        * all LocalReferences are deleted.
        */
       jni::JniLocalScope scope(env, (int) count);
-
-      std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
-
-      // TODO(@lukmccall): Remove this temp array
-      auto tempArray = jni::JArrayClass<jobject>::newArray(count);
-      for (size_t i = 0; i < convertedArgs.size(); i++) {
-        tempArray->setElement(i, convertedArgs[i].l);
-      }
+      std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count,
+                                                              true);
 
       auto Promise = rt.global().getPropertyAsFunction(rt, "Promise");
       // Creates a JSI promise
       jsi::Value promise = Promise.callAsConstructor(
         rt,
-        createPromiseBody(rt, moduleRegistry, std::move(tempArray))
+        createPromiseBody(rt, moduleRegistry, std::move(convertedArgs))
       );
       return promise;
     }
@@ -271,7 +286,7 @@ jsi::Function MethodMetadata::toAsyncFunction(
 jsi::Function MethodMetadata::createPromiseBody(
   jsi::Runtime &runtime,
   JSIInteropModuleRegistry *moduleRegistry,
-  jni::local_ref<jni::JArrayClass<jobject>::javaobject> &&args
+  std::vector<jvalue> &&args
 ) {
   return jsi::Function::createFromHostFunction(
     runtime,
@@ -320,10 +335,21 @@ jsi::Function MethodMetadata::createPromiseBody(
         reject
       );
 
+      auto argsSize = args.size();
+      // TODO(@lukmccall): Remove this temp array
+      auto tempArray = env->NewObjectArray(
+        argsSize,
+        CachedReferencesRegistry::instance()->getJClass("java/lang/Object").clazz,
+        nullptr
+      );
+      for (size_t i = 0; i < argsSize; i++) {
+        env->SetObjectArrayElement(tempArray, i, args[i].l);
+      }
+
       // Cast in this place is safe, cause we know that this function expects promise.
       auto asyncFunction = jni::static_ref_cast<JNIAsyncFunctionBody>(this->jBodyReference);
       asyncFunction->invoke(
-        args,
+        tempArray,
         promise
       );
 
@@ -332,6 +358,11 @@ jsi::Function MethodMetadata::createPromiseBody(
       // the ownership to the `JNIAsyncFunctionBody`.
       env->DeleteLocalRef(promise);
 
+      for (const auto &arg: args) {
+        env->DeleteGlobalRef(arg.l);
+      }
+      env->DeleteLocalRef(tempArray);
+
       return jsi::Value::undefined();
     }
   );

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

@@ -117,7 +117,7 @@ private:
   jsi::Function createPromiseBody(
     jsi::Runtime &runtime,
     JSIInteropModuleRegistry *moduleRegistry,
-    jni::local_ref<jni::JArrayClass<jobject>::javaobject> &&args
+    std::vector<jvalue> &&args
   );
 
   std::vector<jvalue> convertJSIArgsToJNI(
@@ -125,7 +125,8 @@ private:
     JNIEnv *env,
     jsi::Runtime &rt,
     const jsi::Value *args,
-    size_t count
+    size_t count,
+    bool returnGlobalReferences
   );
 };
 } // namespace expo

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

@@ -89,13 +89,15 @@ class AppContext(
   fun installJSIInterop() {
     jsiInterop = JSIInteropModuleRegistry(this)
     val reactContext = reactContextHolder.get() ?: return
-    reactContext.javaScriptContextHolder?.get()?.let {
-      jsiInterop.installJSI(
-        it,
-        reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
-        reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
-      )
-    }
+    reactContext.javaScriptContextHolder?.get()
+      ?.takeIf { it != 0L }
+      ?.let {
+        jsiInterop.installJSI(
+          it,
+          reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
+          reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
+        )
+      }
   }
 
   /**
@@ -266,6 +268,12 @@ class AppContext(
 
 // region AppContextActivityResultCaller
 
+  /**
+   * For the time being [fallbackCallback] is not working.
+   * There are some problems with saving and restoring the state of [activityResultsManager]
+   * connected with [Activity]'s lifecycle and [AppContext] lifespan. So far, we've failed with identifying
+   * what parts of the application outlives the Activity destruction (especially [AppContext] and other [Bridge]-related parts).
+   */
   @MainThread
   override suspend fun <I : Serializable, O> registerForActivityResult(
     contract: AppContextActivityResultContract<I, O>,

package/ios/JSI/EXJSIInstaller.mm

@@ -1,6 +1,7 @@
 // Copyright 2018-present 650 Industries. All rights reserved.
 
 #import <ExpoModulesCore/EXJSIInstaller.h>
+#import <ExpoModulesCore/EXJavaScriptRuntime.h>
 #import <ExpoModulesCore/ExpoModulesHostObject.h>
 #import <ExpoModulesCore/Swift.h>
 
@@ -14,6 +15,7 @@ static NSString *expoModulesHostObjectPropertyName = @"ExpoModules";
 @interface RCTBridge (ExpoBridgeWithRuntime)
 
 - (void *)runtime;
+- (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
 
 @end
 

package/ios/NativeModulesProxy/EXNativeModulesProxy.mm

@@ -201,9 +201,10 @@ RCT_EXPORT_MODULE(NativeUnimoduleProxy)
 
 - (void)setBridge:(RCTBridge *)bridge
 {
-  _appContext = [(ExpoBridgeModule *)[bridge moduleForClass:ExpoBridgeModule.class] appContext];
-  [_appContext setLegacyModuleRegistry:_exModuleRegistry];
-  [_appContext setLegacyModulesProxy:self];
+  ExpoBridgeModule* expoBridgeModule = [bridge moduleForClass:ExpoBridgeModule.class];
+  [expoBridgeModule legacyProxyDidSetBridgeWithLegacyModulesProxy:self
+                                             legacyModuleRegistry:_exModuleRegistry];
+  _appContext = [expoBridgeModule appContext];
 
   if (!_bridge) {
     // The `setBridge` can be called during module setup or after. Registering more modules
@@ -389,7 +390,7 @@ RCT_EXPORT_METHOD(callMethod:(NSString *)moduleName methodNameOrKey:(id)methodNa
 {
   // Hacky way to get a dictionary with `RCTComponentData` from UIManager.
   NSMutableDictionary<NSString *, RCTComponentData *> *componentDataByName = [bridge.uiManager valueForKey:@"_componentDataByName"];
-  NSString *className = NSStringFromClass(moduleClass);
+  NSString *className = [moduleClass moduleName] ?: NSStringFromClass(moduleClass);
 
   if ([moduleClass isSubclassOfClass:[RCTViewManager class]] && !componentDataByName[className]) {
     RCTComponentData *componentData = [[RCTComponentData alloc] initWithManagerClass:moduleClass bridge:bridge eventDispatcher:bridge.eventDispatcher];

package/ios/Swift/AppContext.swift

@@ -28,11 +28,9 @@ public final class AppContext: NSObject {
   /**
    The legacy module registry with modules written in the old-fashioned way.
    */
-  @objc
-  public weak var legacyModuleRegistry: EXModuleRegistry?
+  internal weak var legacyModuleRegistry: EXModuleRegistry?
 
-  @objc
-  public weak var legacyModulesProxy: LegacyNativeModulesProxy?
+  internal weak var legacyModulesProxy: LegacyNativeModulesProxy?
 
   /**
    React bridge of the context's app. Can be `nil` when the bridge

package/ios/Swift/Classes/ClassComponentElementsBuilder.swift

@@ -12,7 +12,7 @@ public struct ClassComponentElementsBuilder<OwnerType> {
   /**
    Default implementation without any constraints that just returns type-erased element.
    */
-  static func buildExpression<ElementType: ClassComponentElement>(
+  public static func buildExpression<ElementType: ClassComponentElement>(
     _ element: ElementType
   ) -> AnyClassComponentElement {
     return element
@@ -23,7 +23,7 @@ public struct ClassComponentElementsBuilder<OwnerType> {
    we need to instruct the function to pass `this` to the closure
    as the first argument and deduct it from `argumentsCount`.
    */
-  static func buildExpression<ElementType: ClassComponentElement>(
+  public static func buildExpression<ElementType: ClassComponentElement>(
     _ element: ElementType
   ) -> AnyClassComponentElement where ElementType.OwnerType == OwnerType {
     if var function = element as? AnyFunction {

package/ios/Swift/ExpoBridgeModule.swift

@@ -20,8 +20,7 @@ public final class ExpoBridgeModule: NSObject, RCTBridgeModule {
    architecture of Expo modules and the app itself.
    */
   override init() {
-    appContext = AppContext().useModulesProvider("ExpoModulesProvider")
-    appContext.moduleRegistry.register(moduleType: NativeModulesProxyModule.self)
+    appContext = AppContext()
     super.init()
 
     // Listen to React Native notifications posted just before the JS is executed.
@@ -50,6 +49,21 @@ public final class ExpoBridgeModule: NSObject, RCTBridgeModule {
       appContext.reactBridge = bridge
     }
   }
+  
+  /**
+   This should be called inside EXNativeModulesProxy.setBridge()
+   */
+  @objc
+  public func legacyProxyDidSetBridge(legacyModulesProxy: LegacyNativeModulesProxy,
+                                      legacyModuleRegistry: EXModuleRegistry) {
+    appContext.legacyModuleRegistry = legacyModuleRegistry
+    appContext.legacyModulesProxy = legacyModulesProxy
+    
+    // we need to register all the modules after the legacy module registry is set
+    // otherwise legacy modules (e.g. permissions) won't be available in OnCreate { }
+    appContext.useModulesProvider("ExpoModulesProvider")
+    appContext.moduleRegistry.register(moduleType: NativeModulesProxyModule.self)
+  }
 
   // MARK: - Notifications
 

package/ios/Swift/Logging/LogType.swift

@@ -45,7 +45,7 @@ public enum LogType: Int {
    Maps the log types to the log types used by the `os.log` logger.
    */
   @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
-  func toOSLogType() -> OSLogType {
+  public func toOSLogType() -> OSLogType {
     switch self {
     case .trace, .timer, .stacktrace, .debug:
       return .debug

package/ios/Swift/Logging/Logger.swift

@@ -139,7 +139,7 @@ public class Logger {
     }
     let endTime = DispatchTime.now()
     let diff = Double(endTime.uptimeNanoseconds - startTime.uptimeNanoseconds) / 1_000_000
-    log(type: .timer, "Timer '\(id)' has finished in: \(diff) seconds")
+    log(type: .timer, "Timer '\(id)' has finished in: \(diff) ms")
     timers.removeValue(forKey: id)
   }
 
@@ -183,11 +183,14 @@ public class Logger {
   }
 }
 
-fileprivate func reformatStackSymbol(_ symbol: String) -> String {
+private func reformatStackSymbol(_ symbol: String) -> String {
   return symbol.replacingOccurrences(of: #"^\d+\s+"#, with: "", options: .regularExpression)
 }
 
-fileprivate func describe(value: Any) -> String {
+private func describe(value: Any) -> String {
+  if let value = value as? String {
+    return value
+  }
   if let value = value as? CustomDebugStringConvertible {
     return value.debugDescription
   }

package/ios/Swift/Promise.swift

@@ -22,7 +22,11 @@ public struct Promise: AnyArgument {
   }
 
   public func reject(_ error: Error) {
-    rejecter(UnexpectedException(error))
+    if let exception = error as? Exception {
+      rejecter(exception)
+    } else {
+      rejecter(UnexpectedException(error))
+    }
   }
 
   public func reject(_ error: Exception) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "0.11.0",
+  "version": "0.11.3",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^2.0.0"
   },
-  "gitHead": "6e131f2da851a47c3a24eb3d6fc971a1a7822086"
+  "gitHead": "5d900179d047d9f4d89c0b9953b7121a1f1df8a2"
 }