@rnx-kit/react-native-host 0.2.0 → 0.2.1

package/cocoa/RNXFabricAdapter.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+
+@class RCTBridge;
+
+NS_ASSUME_NONNULL_BEGIN
+
+NSObject *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge);
+
+NS_ASSUME_NONNULL_END

package/cocoa/RNXFabricAdapter.mm

@@ -0,0 +1,27 @@
+#import "RNXFabricAdapter.h"
+
+#ifdef USE_FABRIC
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcomma"
+#pragma clang diagnostic ignored "-Wdocumentation"
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <react/config/ReactNativeConfig.h>
+#pragma clang diagnostic pop
+#endif  // USE_FABRIC
+
+NSObject *RNXInstallSurfacePresenterBridgeAdapter(RCTBridge *bridge)
+{
+#ifdef USE_FABRIC
+    auto contextContainer = std::make_shared<facebook::react::ContextContainer const>();
+    auto reactNativeConfig = std::make_shared<facebook::react::EmptyReactNativeConfig const>();
+    contextContainer->insert("ReactNativeConfig", reactNativeConfig);
+
+    auto bridgeAdapter = [[RCTSurfacePresenterBridgeAdapter alloc] initWithBridge:bridge
+                                                                 contextContainer:contextContainer];
+    bridge.surfacePresenter = bridgeAdapter.surfacePresenter;
+    return bridgeAdapter;
+#else
+    return nil;
+#endif  // USE_FABRIC
+}

package/cocoa/RNXHostConfig.h

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeDelegate.h>
+#import <React/RCTLog.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Configuration object for ``ReactNativeHost``.
+@protocol RNXHostConfig <RCTBridgeDelegate>
+
+@optional
+
+/// Returns whether the loading view should be visible while loading JavaScript.
+@property (nonatomic, readonly) BOOL isDevLoadingViewEnabled;
+
+/// Returns whether the bridge should be released when the app is backgrounded.
+@property (nonatomic, readonly) BOOL shouldReleaseBridgeWhenBackgrounded;
+
+/// Logs a message.
+- (void)logWithLevel:(RCTLogLevel)level
+              source:(RCTLogSource)source
+            filename:(NSString *)filename
+                line:(NSNumber *)line
+             message:(NSString *)message
+    __attribute__((__swift_name__("log(_:source:filename:line:message:)")));
+
+// Called when the bridge has been instantiated.
+- (void)onBridgeInstantiated:(RCTBridge *)bridge;
+
+// Called when the bridge is about to be shut down.
+- (void)onBridgeWillShutDown:(RCTBridge *)bridge;
+
+// Called when the bridge has been shut down.
+- (void)onBridgeDidShutDown;
+
+/// Handles a fatal error.
+- (void)onFatalError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/cocoa/RNXHostReleaser.h

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+
+@class RCTBridge;
+@class ReactNativeHost;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Releases resources held by a `ReactNativeHost` instance based on app state.
+@interface RNXHostReleaser : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (instancetype)initWithHost:(ReactNativeHost *)host NS_DESIGNATED_INITIALIZER;
+
+- (void)setBridge:(__weak RCTBridge *)bridge;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/cocoa/RNXHostReleaser.mm

@@ -0,0 +1,74 @@
+#import "RNXHostReleaser.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+#import "ReactNativeHost.h"
+
+@implementation RNXHostReleaser {
+#if !TARGET_OS_OSX
+    __weak ReactNativeHost *_host;
+    __weak NSDictionary<NSNumber *, UIView *> *_viewRegistry;
+#endif  // !TARGET_OS_OSX
+}
+
+- (instancetype)initWithHost:(ReactNativeHost *)host
+{
+    if (self = [super init]) {
+#if !TARGET_OS_OSX
+        _host = host;
+
+        NSNotificationCenter *notificationCenter = NSNotificationCenter.defaultCenter;
+        [notificationCenter addObserver:self
+                               selector:@selector(onAppDidEnterBackground:)
+                                   name:UIApplicationDidEnterBackgroundNotification
+                                 object:nil];
+#endif  // !TARGET_OS_OSX
+    }
+    return self;
+}
+
+- (void)setBridge:(__weak RCTBridge *)bridge
+{
+#if !TARGET_OS_OSX
+    // This may initialize `RCTAccessibilityManager` and must therefore be run
+    // on the main queue.
+    __weak typeof(self) weakSelf = self;
+    RCTExecuteOnMainQueue(^{
+      typeof(self) strongSelf = weakSelf;
+      if (strongSelf == nil) {
+          return;
+      }
+
+      RCTUIManager *manager = bridge.uiManager;
+      if (manager == nil) {
+          return;
+      }
+
+      // `addUIBlock` must be called on the UIManager queue.
+      RCTExecuteOnUIManagerQueue(^{
+        [manager addUIBlock:^(RCTUIManager *uiManager,
+                              NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+          typeof(self) strongSelf = weakSelf;
+          if (strongSelf == nil) {
+              return;
+          }
+
+          strongSelf->_viewRegistry = viewRegistry;
+        }];
+      });
+    });
+#endif  // !TARGET_OS_OSX
+}
+
+#if !TARGET_OS_OSX
+- (void)onAppDidEnterBackground:(NSNotification *)note
+{
+    if (_viewRegistry.count == 0) {
+        [_host shutdown];
+    }
+}
+#endif  // !TARGET_OS_OSX
+
+@end

package/cocoa/RNXTurboModuleAdapter.h

@@ -0,0 +1,29 @@
+#include <memory>
+
+#import <Foundation/Foundation.h>
+
+#if USE_TURBOMODULE
+#import <ReactCommon/RCTTurboModuleManager.h>
+#endif  // USE_TURBOMODULE
+
+@class RCTBridge;
+
+namespace facebook::react
+{
+    class JSExecutorFactory;
+}  // namespace facebook::react
+
+NS_ASSUME_NONNULL_BEGIN
+
+#if USE_TURBOMODULE
+@interface RNXTurboModuleAdapter : NSObject <RCTTurboModuleManagerDelegate>
+#else
+@interface RNXTurboModuleAdapter : NSObject
+#endif  // USE_TURBOMODULE
+
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:
+    (RCTBridge *)bridge;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/cocoa/RNXTurboModuleAdapter.mm

@@ -0,0 +1,84 @@
+#import "RNXTurboModuleAdapter.h"
+
+#define FOLLY_NO_CONFIG 1
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcomma"
+#import <cxxreact/JSExecutor.h>
+#pragma clang diagnostic pop
+
+#if USE_TURBOMODULE
+#import <React/CoreModulesPlugins.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+
+#if __has_include(<React/RCTAppSetupUtils.h>)  // <0.72
+#import <React/RCTAppSetupUtils.h>
+#define USE_RUNTIME_SCHEDULER 0
+#else
+#import <RCTAppSetupUtils.h>
+
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <react/renderer/runtimescheduler/RuntimeScheduler.h>
+#import <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
+#define USE_RUNTIME_SCHEDULER 1
+#endif  // __has_include(<React/RCTAppSetupUtils.h>)
+
+#endif  // USE_TURBOMODULE
+
+@implementation RNXTurboModuleAdapter {
+#if USE_TURBOMODULE
+    RCTTurboModuleManager *_turboModuleManager;
+#endif  // USE_TURBOMODULE
+#if USE_RUNTIME_SCHEDULER
+    std::shared_ptr<facebook::react::RuntimeScheduler> _runtimeScheduler;
+#endif  // USE_RUNTIME_SCHEDULER
+}
+
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:
+    (RCTBridge *)bridge
+{
+#if USE_TURBOMODULE
+    // jsExecutorFactoryForBridge: (USE_TURBOMODULE=1)
+#if USE_RUNTIME_SCHEDULER
+    _runtimeScheduler =
+        std::make_shared<facebook::react::RuntimeScheduler>(RCTRuntimeExecutorFromBridge(bridge));
+    auto callInvoker =
+        std::make_shared<facebook::react::RuntimeSchedulerCallInvoker>(_runtimeScheduler);
+    _turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridge:bridge
+                                                               delegate:self
+                                                              jsInvoker:callInvoker];
+    return RCTAppSetupDefaultJsExecutorFactory(bridge, _turboModuleManager, _runtimeScheduler);
+#else
+    _turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridge:bridge
+                                                               delegate:self
+                                                              jsInvoker:bridge.jsCallInvoker];
+    return RCTAppSetupDefaultJsExecutorFactory(bridge, _turboModuleManager);
+#endif  // USE_RUNTIME_SCHEDULER
+#else
+    // jsExecutorFactoryForBridge: (USE_TURBOMODULE=0)
+    return nullptr;
+#endif  // USE_TURBOMODULE
+}
+
+// MARK: - RCTTurboModuleManagerDelegate details
+#if USE_TURBOMODULE
+
+- (Class)getModuleClassFromName:(const char *)name
+{
+    return RCTCoreModulesClassProvider(name);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)
+    getTurboModule:(const std::string &)name
+         jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+    return nullptr;
+}
+
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+{
+    return RCTAppSetupDefaultModuleFromClass(moduleClass);
+}
+
+#endif  // USE_TURBOMODULE
+
+@end

package/cocoa/ReactNativeHost+View.mm

@@ -0,0 +1,44 @@
+#import "ReactNativeHost.h"
+
+#ifdef USE_FABRIC
+#import <React/RCTFabricSurfaceHostingProxyRootView.h>
+#else
+#import <React/RCTRootView.h>
+#endif  // USE_FABRIC
+
+@implementation ReactNativeHost (View)
+
++ (instancetype)hostFromRootView:(RNXView *)rootView
+{
+    if (![rootView respondsToSelector:@selector(bridge)]) {
+        return nil;
+    }
+
+    id bridge = [rootView performSelector:@selector(bridge)];
+    if (![bridge respondsToSelector:@selector(delegate)]) {
+        return nil;
+    }
+
+    id delegate = [bridge performSelector:@selector(delegate)];
+    if (![delegate isKindOfClass:self]) {
+        return nil;
+    }
+
+    return delegate;
+}
+
+- (RNXView *)viewWithModuleName:(NSString *)moduleName
+              initialProperties:(NSDictionary *)initialProperties;
+{
+#ifdef USE_FABRIC
+    return [[RCTFabricSurfaceHostingProxyRootView alloc] initWithBridge:self.bridge
+                                                             moduleName:moduleName
+                                                      initialProperties:initialProperties];
+#else
+    return [[RCTRootView alloc] initWithBridge:self.bridge
+                                    moduleName:moduleName
+                             initialProperties:initialProperties];
+#endif  // USE_FABRIC
+}
+
+@end

package/cocoa/ReactNativeHost.h

@@ -0,0 +1,56 @@
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeDelegate.h>
+
+#import "RNXHostConfig.h"
+
+#if TARGET_OS_OSX
+@class NSView;
+typedef NSView RNXView;
+#else
+@class UIView;
+typedef UIView RNXView;
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Hosts a React Native instance.
+@interface ReactNativeHost : NSObject <RCTBridgeDelegate>
+
+@property (nonatomic, readonly, nullable) RCTBridge *bridge;
+
+- (instancetype)init NS_UNAVAILABLE;
+
+- (instancetype)initWithConfig:(id<RNXHostConfig>)config NS_DESIGNATED_INITIALIZER
+    NS_SWIFT_NAME(init(_:));
+
+- (void)shutdown;
+
+/// Calls the specified block when the desired native module is retrieved. Note
+/// that this may initialize the module.
+///
+/// - Parameters:
+///     - moduleClass: Class of the native module to initialize or retrieve
+///     - block: Block that gets called when the native module is retrieved
+- (void)usingModule:(Class)moduleClass
+              block:(void (^)(id<RCTBridgeModule> _Nullable))block
+    NS_SWIFT_NAME(using(module:block:));
+
+@end
+
+@interface ReactNativeHost (View)
+
++ (nullable instancetype)hostFromRootView:(RNXView *)rootView NS_SWIFT_NAME(host(from:));
+
+/// Creates a React root view with the specified module and initial properties.
+///
+/// - Parameters:
+///     - moduleName: Name of the module to create root view of
+///     - initialProperties: Properties passed to the module
+- (RNXView *)viewWithModuleName:(NSString *)moduleName
+              initialProperties:(nullable NSDictionary *)initialProperties
+    NS_SWIFT_NAME(view(moduleName:initialProperties:));
+
+@end
+
+NS_ASSUME_NONNULL_END

package/cocoa/ReactNativeHost.mm

@@ -0,0 +1,169 @@
+#import "ReactNativeHost.h"
+
+#define FOLLY_NO_CONFIG 1
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcomma"
+#import <cxxreact/JSExecutor.h>
+#pragma clang diagnostic pop
+
+#import <React/RCTBridge.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React/RCTCxxBridgeDelegate.h>
+#import <React/RCTDevLoadingViewSetEnabled.h>
+#import <React/RCTUtils.h>
+
+#import "RNXFabricAdapter.h"
+#import "RNXHostConfig.h"
+#import "RNXHostReleaser.h"
+#import "RNXTurboModuleAdapter.h"
+
+@interface ReactNativeHost () <RCTCxxBridgeDelegate>
+@end
+
+@implementation ReactNativeHost {
+    __weak id<RNXHostConfig> _config;
+    RNXTurboModuleAdapter *_turboModuleAdapter;
+    NSObject *_surfacePresenterBridgeAdapter;
+    RCTBridge *_bridge;
+    NSLock *_isShuttingDown;
+    RNXHostReleaser *_hostReleaser;
+}
+
+- (instancetype)initWithConfig:(id<RNXHostConfig>)config
+{
+    if (self = [super init]) {
+        if ([config respondsToSelector:@selector(isDevLoadingViewEnabled)]) {
+            RCTDevLoadingViewSetEnabled([config isDevLoadingViewEnabled]);
+        }
+
+        if ([config respondsToSelector:@selector(logWithLevel:source:filename:line:message:)]) {
+            RCTSetLogFunction(^(RCTLogLevel level,
+                                RCTLogSource source,
+                                NSString *filename,
+                                NSNumber *line,
+                                NSString *message) {
+              [config logWithLevel:level source:source filename:filename line:line message:message];
+            });
+        }
+
+        if ([config respondsToSelector:@selector(onFatalError:)]) {
+            RCTSetFatalHandler(^(NSError *error) {
+              [config onFatalError:error];
+            });
+        }
+
+        _config = config;
+#if USE_FABRIC || USE_TURBOMODULE
+        _turboModuleAdapter = [[RNXTurboModuleAdapter alloc] init];
+#endif
+        _isShuttingDown = [[NSLock alloc] init];
+
+        if ([config respondsToSelector:@selector(shouldReleaseBridgeWhenBackgrounded)] &&
+            [config shouldReleaseBridgeWhenBackgrounded]) {
+            _hostReleaser = [[RNXHostReleaser alloc] initWithHost:self];
+        }
+
+        (void)self.bridge;  // Initialize the bridge now
+    }
+    return self;
+}
+
+- (RCTBridge *)bridge
+{
+    if (![_isShuttingDown tryLock]) {
+        NSAssert(NO, @"Tried to access the bridge while shutting down");
+        return nil;
+    }
+
+    @try {
+        if (_bridge == nil) {
+            _bridge = [[RCTBridge alloc] initWithDelegate:self launchOptions:nil];
+            _surfacePresenterBridgeAdapter = RNXInstallSurfacePresenterBridgeAdapter(_bridge);
+            [_hostReleaser setBridge:_bridge];
+            if ([_config respondsToSelector:@selector(onBridgeInstantiated:)]) {
+                [_config onBridgeInstantiated:_bridge];
+            }
+        }
+
+        return _bridge;
+    } @finally {
+        [_isShuttingDown unlock];
+    }
+}
+
+- (void)shutdown
+{
+    if ([_config respondsToSelector:@selector(onBridgeWillShutDown:)]) {
+        [_config onBridgeWillShutDown:_bridge];
+    }
+
+    [_isShuttingDown lock];
+
+    @try {
+        [_bridge invalidate];
+        _bridge = nil;
+
+        if ([_config respondsToSelector:@selector(onBridgeDidShutDown)]) {
+            [_config onBridgeDidShutDown];
+        }
+    } @finally {
+        [_isShuttingDown unlock];
+    }
+}
+
+- (void)usingModule:(Class)moduleClass block:(void (^)(id<RCTBridgeModule> _Nullable))block
+{
+    const BOOL requiresMainQueueSetup =
+        [moduleClass respondsToSelector:@selector(requiresMainQueueSetup)] &&
+        [moduleClass requiresMainQueueSetup];
+    if (requiresMainQueueSetup && !RCTIsMainQueue()) {
+        __weak id weakSelf = self;
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf usingModule:moduleClass block:block];
+        });
+        return;
+    }
+
+    id<RCTBridgeModule> bridgeModule = [self.bridge moduleForClass:moduleClass];
+    block(bridgeModule);
+}
+
+// MARK: - RCTBridgeDelegate details
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
+{
+    NSURL *sourceURL = [_config sourceURLForBridge:bridge];
+    if (sourceURL != nil) {
+        return sourceURL;
+    }
+
+    return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"
+                                                       fallbackURLProvider:^NSURL * {
+                                                         return nil;
+                                                       }];
+}
+
+- (NSArray<id<RCTBridgeModule>> *)extraModulesForBridge:(RCTBridge *)bridge
+{
+    return [_config respondsToSelector:@selector(extraModulesForBridge:)]
+               ? [_config extraModulesForBridge:bridge]
+               : @[];
+}
+
+// MARK: - RCTCxxBridgeDelegate details
+
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:
+    (RCTBridge *)bridge
+{
+#if USE_TURBOMODULE
+    // jsExecutorFactoryForBridge: (USE_TURBOMODULE=1)
+    return [_turboModuleAdapter jsExecutorFactoryForBridge:bridge];
+#else
+    // jsExecutorFactoryForBridge: (USE_TURBOMODULE=0)
+    return nullptr;
+#endif  // USE_TURBOMODULE
+}
+
+// MARK: - Private
+
+@end

package/cocoa/ReactNativeHost.xcodeproj/project.pbxproj

@@ -0,0 +1 @@
+/* Dummy file so @react-native-community/cli recognizes this as an iOS package */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rnx-kit/react-native-host",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Simplify React Native initialization",
   "homepage": "https://github.com/microsoft/rnx-kit/tree/main/packages/react-native-host#readme",
   "license": "MIT",
@@ -11,7 +11,7 @@
   "files": [
     "ReactNativeHost.podspec",
     "android/",
-    "mac/"
+    "cocoa/"
   ],
   "repository": {
     "type": "git",