expo-modules-core 0.4.8 → 0.5.0

package/ios/AppDelegates/ExpoAppDelegate.swift

@@ -0,0 +1,264 @@
+import UIKit
+import Dispatch
+import Foundation
+
+var subscribers = [ExpoAppDelegateSubscriberProtocol]()
+
+/**
+ Allows classes extending `ExpoAppDelegateSubscriber` to hook into project's app delegate
+ by forwarding `UIApplicationDelegate` events to the subscribers.
+
+ Keep functions and markers in sync with https://developer.apple.com/documentation/uikit/uiapplicationdelegate
+ */
+@objc(EXExpoAppDelegate)
+open class ExpoAppDelegate: UIResponder, UIApplicationDelegate {
+  open var window: UIWindow?
+
+  // MARK: - Initializing the App
+
+  open func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, willFinishLaunchingWithOptions: launchOptions) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, didFinishLaunchingWithOptions: launchOptions) ?? false || result
+    }
+  }
+
+  // TODO: - Configuring and Discarding Scenes
+
+  // MARK: - Responding to App Life-Cycle Events
+
+  @objc
+  open func applicationDidBecomeActive(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationDidBecomeActive?(application) }
+  }
+
+  @objc
+  open func applicationWillResignActive(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillResignActive?(application) }
+  }
+
+  @objc
+  open func applicationDidEnterBackground(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationDidEnterBackground?(application) }
+  }
+
+  open func applicationWillEnterForeground(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillEnterForeground?(application) }
+  }
+
+  open func applicationWillTerminate(_ application: UIApplication) {
+    subscribers.forEach { $0.applicationWillTerminate?(application) }
+  }
+
+  // TODO: - Responding to Environment Changes
+
+  // TODO: - Managing App State Restoration
+
+  // MARK: - Downloading Data in the Background
+
+  open func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
+    let selector = #selector(application(_:handleEventsForBackgroundURLSession:completionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    let dispatchQueue = DispatchQueue(label: "expo.application.handleBackgroundEvents")
+
+    let handler = {
+      dispatchQueue.sync {
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler()
+        }
+      }
+    }
+
+    subs.forEach {
+      $0.application?(application, handleEventsForBackgroundURLSession: identifier, completionHandler: handler)
+    }
+  }
+
+  // MARK: - Handling Remote Notification Registration
+
+  open func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+    subscribers.forEach { $0.application?(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken) }
+  }
+
+  open func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
+    subscribers.forEach { $0.application?(application, didFailToRegisterForRemoteNotificationsWithError: error) }
+  }
+
+  open func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    let selector = #selector(application(_:didReceiveRemoteNotification:fetchCompletionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var fetchResult: UIBackgroundFetchResult = .noData
+    let dispatchQueue = DispatchQueue(label: "expo.application.remoteNotification", qos: .userInteractive)
+
+    let handler = { (result: UIBackgroundFetchResult) in
+      dispatchQueue.sync {
+        if result == .failed {
+          fetchResult = .failed
+        } else if fetchResult != .failed && result == .newData {
+          fetchResult = .newData
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(fetchResult)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, didReceiveRemoteNotification: userInfo, fetchCompletionHandler: handler)
+    }
+  }
+
+  // MARK: - Continuing User Activity and Handling Quick Actions
+
+  open func application(_ application: UIApplication, willContinueUserActivityWithType userActivityType: String) -> Bool {
+    return subscribers.reduce(false) { result, subscriber in
+      return subscriber.application?(application, willContinueUserActivityWithType: userActivityType) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
+    let selector = #selector(application(_:continue:restorationHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    let dispatchQueue = DispatchQueue(label: "expo.application.continueUserActivity", qos: .userInteractive)
+    var allRestorableObjects = [UIUserActivityRestoring]()
+
+    let handler = { (restorableObjects: [UIUserActivityRestoring]?) in
+      dispatchQueue.sync {
+        if let restorableObjects = restorableObjects {
+          allRestorableObjects.append(contentsOf: restorableObjects)
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          restorationHandler(allRestorableObjects)
+        }
+      }
+    }
+
+    return subs.reduce(false) { result, subscriber in
+      return subscriber.application?(application, continue: userActivity, restorationHandler: handler) ?? false || result
+    }
+  }
+
+  open func application(_ application: UIApplication, didUpdate userActivity: NSUserActivity) {
+    return subscribers.forEach { $0.application?(application, didUpdate: userActivity) }
+  }
+
+  open func application(_ application: UIApplication, didFailToContinueUserActivityWithType userActivityType: String, error: Error) {
+    return subscribers.forEach {
+      $0.application?(application, didFailToContinueUserActivityWithType: userActivityType, error: error)
+    }
+  }
+
+  open func application(_ application: UIApplication, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Void) {
+    let selector = #selector(application(_:performActionFor:completionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var result: Bool = false
+    let dispatchQueue = DispatchQueue(label: "expo.application.performAction", qos: .userInteractive)
+
+    let handler = { (succeeded: Bool) in
+      dispatchQueue.sync {
+        result = result || succeeded
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(result)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, performActionFor: shortcutItem, completionHandler: handler)
+    }
+  }
+
+  // MARK: - Background Fetch
+
+  open func application(_ application: UIApplication, performFetchWithCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+    let selector = #selector(application(_:performFetchWithCompletionHandler:))
+    let subs = subscribers.filter { $0.responds(to: selector) }
+    var subscribersLeft = subs.count
+    var fetchResult: UIBackgroundFetchResult = .noData
+    let dispatchQueue = DispatchQueue(label: "expo.application.performFetch", qos: .userInteractive)
+
+    let handler = { (result: UIBackgroundFetchResult) in
+      dispatchQueue.sync {
+        if result == .failed {
+          fetchResult = .failed
+        } else if fetchResult != .failed && result == .newData {
+          fetchResult = .newData
+        }
+
+        subscribersLeft -= 1
+
+        if subscribersLeft == 0 {
+          completionHandler(fetchResult)
+        }
+      }
+    }
+
+    subs.forEach { subscriber in
+      subscriber.application?(application, performFetchWithCompletionHandler: handler)
+    }
+  }
+
+  // TODO: - Interacting With WatchKit
+
+  // TODO: - Interacting With HealthKit
+
+  // MARK: - Opening a URL-Specified Resource
+
+  open func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
+    return subscribers.contains { subscriber in
+      return subscriber.application?(app, open: url, options: options) ?? false
+    }
+  }
+
+  // TODO: - Disallowing Specified App Extension Types
+
+  // TODO: - Handling SiriKit Intents
+
+  // TODO: - Handling CloudKit Invitations
+
+  // TODO: - Managing Interface Geometry
+
+  // MARK: - Statics
+
+  @objc
+  public static func registerSubscribersFrom(modulesProvider: ModulesProviderObjCProtocol) {
+    guard let provider = modulesProvider as? ModulesProviderProtocol else {
+      fatalError("Expo modules provider must implement `ModulesProviderProtocol`.")
+    }
+    provider.getAppDelegateSubscribers().forEach { subscriberType in
+      registerSubscriber(subscriberType.init())
+    }
+  }
+
+  @objc
+  public static func registerSubscriber(_ subscriber: ExpoAppDelegateSubscriberProtocol) {
+    if subscribers.contains(where: { $0 === subscriber }) {
+      fatalError("Given app delegate subscriber `\(String(describing: subscriber))` is already registered.")
+    }
+    subscribers.append(subscriber)
+  }
+
+  @objc
+  public static func getSubscriber(_ name: String) -> ExpoAppDelegateSubscriberProtocol? {
+    return subscribers.first { String(describing: $0) == name }
+  }
+}

package/ios/AppDelegates/ExpoAppDelegateSubscriber.swift

@@ -0,0 +1,24 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import UIKit
+
+/**
+ Base class for app delegate subscribers. Ensures the class
+ inherits from `UIResponder` and has `required init()` initializer.
+ */
+@objc(EXBaseAppDelegateSubscriber)
+open class BaseExpoAppDelegateSubscriber: UIResponder {
+  public override required init() {}
+}
+
+/**
+ Typealias to `UIApplicationDelegate` protocol.
+ Might be useful for compatibility reasons if we decide to add more things here.
+ */
+@objc(EXAppDelegateSubscriberProtocol)
+public protocol ExpoAppDelegateSubscriberProtocol: UIApplicationDelegate {}
+
+/**
+ Typealias merging the base class for app delegate subscribers and protocol inheritance to `UIApplicationDelegate`.
+ */
+public typealias ExpoAppDelegateSubscriber = BaseExpoAppDelegateSubscriber & ExpoAppDelegateSubscriberProtocol

package/ios/ExpoModulesCore.podspec

@@ -18,19 +18,24 @@ Pod::Spec.new do |s|
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {
-    'DEFINES_MODULE' => 'YES'
+    'USE_HEADERMAP' => 'YES',
+    'DEFINES_MODULE' => 'YES',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++14',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
   }
 
   s.dependency 'React-Core'
+  s.dependency 'ReactCommon/turbomodule/core'
 
   if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
     s.source_files = '**/*.h'
     s.vendored_frameworks = "#{s.name}.xcframework"
   else
-    s.source_files = '**/*.{h,m,swift}'
+    s.source_files = '**/*.{h,m,mm,swift}'
   end
 
   s.exclude_files = 'Tests/'
+  s.private_header_files = '**/Swift.h'
 
   s.test_spec 'Tests' do |test_spec|
     test_spec.dependency 'Quick'

package/ios/JSI/ExpoModulesProxySpec.h

@@ -0,0 +1,24 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <jsi/jsi.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#import <ExpoModulesCore/EXNativeModulesProxy.h>
+
+using namespace facebook;
+using namespace react;
+
+namespace expo {
+
+class JSI_EXPORT ExpoModulesProxySpec : public TurboModule {
+public:
+  ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy);
+
+  EXNativeModulesProxy *nativeModulesProxy;
+};
+
+} // namespace expo
+
+#endif

package/ios/JSI/ExpoModulesProxySpec.mm

@@ -0,0 +1,135 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <React/RCTUtils.h>
+
+#import <ExpoModulesCore/JSIConversions.h>
+#import <ExpoModulesCore/ExpoModulesProxySpec.h>
+
+namespace expo {
+
+using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
+
+static void callPromiseSetupWithBlock(jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker, std::shared_ptr<Promise> promise, PromiseInvocationBlock setupBlock)
+{
+  auto weakResolveWrapper = CallbackWrapper::createWeak(promise->resolve_.getFunction(runtime), runtime, jsInvoker);
+  auto weakRejectWrapper = CallbackWrapper::createWeak(promise->reject_.getFunction(runtime), runtime, jsInvoker);
+
+  __block BOOL resolveWasCalled = NO;
+  __block BOOL rejectWasCalled = NO;
+
+  RCTPromiseResolveBlock resolveBlock = ^(id result) {
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise after it's already been rejected.");
+    }
+
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to resolve a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongResolveWrapper2->runtime();
+      jsi::Value arg = convertObjCObjectToJSIValue(rt, result);
+      strongResolveWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    resolveWasCalled = YES;
+  };
+
+  RCTPromiseRejectBlock rejectBlock = ^(NSString *code, NSString *message, NSError *error) {
+    if (resolveWasCalled) {
+      throw std::runtime_error("Tried to reject a promise after it's already been resolved.");
+    }
+
+    if (rejectWasCalled) {
+      throw std::runtime_error("Tried to reject a promise more than once.");
+    }
+
+    auto strongResolveWrapper = weakResolveWrapper.lock();
+    auto strongRejectWrapper = weakRejectWrapper.lock();
+    if (!strongResolveWrapper || !strongRejectWrapper) {
+      return;
+    }
+
+    NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
+    strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError]() {
+      auto strongResolveWrapper2 = weakResolveWrapper.lock();
+      auto strongRejectWrapper2 = weakRejectWrapper.lock();
+      if (!strongResolveWrapper2 || !strongRejectWrapper2) {
+        return;
+      }
+
+      jsi::Runtime &rt = strongRejectWrapper2->runtime();
+      jsi::Value arg = convertNSDictionaryToJSIObject(rt, jsError);
+      strongRejectWrapper2->callback().call(rt, arg);
+
+      strongResolveWrapper2->destroy();
+      strongRejectWrapper2->destroy();
+    });
+
+    rejectWasCalled = YES;
+  };
+
+  setupBlock(resolveBlock, rejectBlock);
+}
+
+static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodAsync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
+{
+  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
+
+  // The function that is invoked as a setup of the JS `Promise`.
+  auto promiseSetupFunc = [expoModulesProxy, args](jsi::Runtime &runtime, std::shared_ptr<Promise> promise) {
+    callPromiseSetupWithBlock(runtime, expoModulesProxy->jsInvoker_, promise, ^(RCTPromiseResolveBlock resolver, RCTPromiseRejectBlock rejecter) {
+      NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
+      NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
+      NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
+
+      [expoModulesProxy->nativeModulesProxy callMethod:moduleName
+                                       methodNameOrKey:methodName
+                                             arguments:arguments
+                                              resolver:resolver
+                                              rejecter:rejecter];
+    });
+  };
+
+  return createPromiseAsJSIValue(runtime, promiseSetupFunc);
+}
+
+static jsi::Value __hostFunction_ExpoModulesProxySpec_callMethodSync(jsi::Runtime &runtime, TurboModule &turboModule, const jsi::Value *args, size_t count)
+{
+  auto expoModulesProxy = static_cast<ExpoModulesProxySpec *>(&turboModule);
+  NSString *moduleName = convertJSIStringToNSString(runtime, args[0].getString(runtime));
+  NSString *methodName = convertJSIStringToNSString(runtime, args[1].getString(runtime));
+  NSArray *arguments = convertJSIArrayToNSArray(runtime, args[2].getObject(runtime).asArray(runtime), expoModulesProxy->jsInvoker_);
+
+  id result = [expoModulesProxy->nativeModulesProxy callMethodSync:moduleName
+                                                        methodName:methodName
+                                                         arguments:arguments];
+
+  return convertObjCObjectToJSIValue(runtime, result);
+}
+
+ExpoModulesProxySpec::ExpoModulesProxySpec(std::shared_ptr<CallInvoker> callInvoker, EXNativeModulesProxy *nativeModulesProxy) :
+  TurboModule("ExpoModulesProxy", callInvoker),
+  nativeModulesProxy(nativeModulesProxy)
+{
+  methodMap_["callMethodAsync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodAsync};
+
+  methodMap_["callMethodSync"] = MethodMetadata {3, __hostFunction_ExpoModulesProxySpec_callMethodSync};
+}
+
+} // namespace expo

package/ios/JSI/JSIConversions.h

@@ -0,0 +1,42 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#ifdef __cplusplus
+
+#import <Foundation/Foundation.h>
+
+#import <jsi/jsi.h>
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/CallInvoker.h>
+
+using namespace facebook;
+using namespace react;
+
+namespace expo {
+
+jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value);
+
+jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value);
+
+jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value);
+
+jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value);
+
+jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value);
+
+std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray *value);
+
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+
+NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value);
+
+NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker);
+
+} // namespace expo
+
+#endif

package/ios/JSI/JSIConversions.mm

@@ -0,0 +1,164 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ReactCommon/TurboModuleUtils.h>
+#import <ExpoModulesCore/JSIConversions.h>
+
+namespace expo {
+
+/**
+ * All static helper functions are ObjC++ specific.
+ */
+jsi::Value convertNSNumberToJSIBoolean(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value((bool)[value boolValue]);
+}
+
+jsi::Value convertNSNumberToJSINumber(jsi::Runtime &runtime, NSNumber *value)
+{
+  return jsi::Value([value doubleValue]);
+}
+
+jsi::String convertNSStringToJSIString(jsi::Runtime &runtime, NSString *value)
+{
+  return jsi::String::createFromUtf8(runtime, [value UTF8String] ?: "");
+}
+
+jsi::Object convertNSDictionaryToJSIObject(jsi::Runtime &runtime, NSDictionary *value)
+{
+  jsi::Object result = jsi::Object(runtime);
+  for (NSString *k in value) {
+    result.setProperty(runtime, [k UTF8String], convertObjCObjectToJSIValue(runtime, value[k]));
+  }
+  return result;
+}
+
+jsi::Array convertNSArrayToJSIArray(jsi::Runtime &runtime, NSArray *value)
+{
+  jsi::Array result = jsi::Array(runtime, value.count);
+  for (size_t i = 0; i < value.count; i++) {
+    result.setValueAtIndex(runtime, i, convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+std::vector<jsi::Value> convertNSArrayToStdVector(jsi::Runtime &runtime, NSArray *value)
+{
+  std::vector<jsi::Value> result;
+  for (size_t i = 0; i < value.count; i++) {
+    result.emplace_back(convertObjCObjectToJSIValue(runtime, value[i]));
+  }
+  return result;
+}
+
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
+{
+  if ([value isKindOfClass:[NSString class]]) {
+    return convertNSStringToJSIString(runtime, (NSString *)value);
+  } else if ([value isKindOfClass:[NSNumber class]]) {
+    if ([value isKindOfClass:[@YES class]]) {
+      return convertNSNumberToJSIBoolean(runtime, (NSNumber *)value);
+    }
+    return convertNSNumberToJSINumber(runtime, (NSNumber *)value);
+  } else if ([value isKindOfClass:[NSDictionary class]]) {
+    return convertNSDictionaryToJSIObject(runtime, (NSDictionary *)value);
+  } else if ([value isKindOfClass:[NSArray class]]) {
+    return convertNSArrayToJSIArray(runtime, (NSArray *)value);
+  } else if (value == (id)kCFNull) {
+    return jsi::Value::null();
+  }
+  return jsi::Value::undefined();
+}
+
+NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value)
+{
+  return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
+}
+
+NSArray *convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  size_t size = value.size(runtime);
+  NSMutableArray *result = [NSMutableArray new];
+  for (size_t i = 0; i < size; i++) {
+    // Insert kCFNull when it's `undefined` value to preserve the indices.
+    [result
+        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker) ?: (id)kCFNull];
+  }
+  return [result copy];
+}
+
+NSDictionary *convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  jsi::Array propertyNames = value.getPropertyNames(runtime);
+  size_t size = propertyNames.size(runtime);
+  NSMutableDictionary *result = [NSMutableDictionary new];
+  for (size_t i = 0; i < size; i++) {
+    jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
+    NSString *k = convertJSIStringToNSString(runtime, name);
+    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker);
+    if (v) {
+      result[k] = v;
+    }
+  }
+  return [result copy];
+}
+
+id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  if (value.isUndefined() || value.isNull()) {
+    return nil;
+  }
+  if (value.isBool()) {
+    return @(value.getBool());
+  }
+  if (value.isNumber()) {
+    return @(value.getNumber());
+  }
+  if (value.isString()) {
+    return convertJSIStringToNSString(runtime, value.getString(runtime));
+  }
+  if (value.isObject()) {
+    jsi::Object o = value.getObject(runtime);
+    if (o.isArray(runtime)) {
+      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker);
+    }
+    if (o.isFunction(runtime)) {
+      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker);
+    }
+    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
+  }
+
+  throw std::runtime_error("Unsupported jsi::jsi::Value kind");
+}
+
+RCTResponseSenderBlock convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker)
+{
+  auto weakWrapper = CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  BOOL __block wrapperWasCalled = NO;
+  RCTResponseSenderBlock callback = ^(NSArray *responses) {
+    if (wrapperWasCalled) {
+      throw std::runtime_error("callback arg cannot be called more than once");
+    }
+
+    auto strongWrapper = weakWrapper.lock();
+    if (!strongWrapper) {
+      return;
+    }
+
+    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses]() {
+      auto strongWrapper2 = weakWrapper.lock();
+      if (!strongWrapper2) {
+        return;
+      }
+
+      std::vector<jsi::Value> args = convertNSArrayToStdVector(strongWrapper2->runtime(), responses);
+      strongWrapper2->callback().call(strongWrapper2->runtime(), (const jsi::Value *)args.data(), args.size());
+      strongWrapper2->destroy();
+    });
+
+    wrapperWasCalled = YES;
+  };
+
+  return callback;
+}
+
+} // namespace expo