expo-modules-core 0.4.6 → 0.6.0

package/ios/AppDelegates/EXAppDelegateWrapper.m

@@ -0,0 +1,45 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXAppDelegateWrapper.h>
+#import <ExpoModulesCore/EXReactDelegateWrapper+Private.h>
+#import <ExpoModulesCore/Swift.h>
+
+
+@interface EXAppDelegateWrapper()
+
+@property (nonatomic, strong) EXReactDelegateWrapper *reactDelegate;
+
+@end
+
+@implementation EXAppDelegateWrapper {
+  EXExpoAppDelegate *_expoAppDelegate;
+}
+
+// Synthesize window, so the AppDelegate can synthesize it too.
+@synthesize window = _window;
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _expoAppDelegate = [[EXExpoAppDelegate alloc] init];
+    _reactDelegate = [[EXReactDelegateWrapper alloc] initWithExpoReactDelegate:_expoAppDelegate.reactDelegate];
+  }
+  return self;
+}
+
+// This needs to be implemented, otherwise forwarding won't be called.
+// When the app starts, `UIApplication` uses it to check beforehand
+// which `UIApplicationDelegate` selectors are implemented.
+- (BOOL)respondsToSelector:(SEL)selector
+{
+  return [super respondsToSelector:selector]
+    || [_expoAppDelegate respondsToSelector:selector];
+}
+
+// Forwards all invocations to `ExpoAppDelegate` object.
+- (id)forwardingTargetForSelector:(SEL)selector
+{
+  return _expoAppDelegate;
+}
+
+@end

package/ios/AppDelegates/EXAppDelegatesLoader.h

@@ -0,0 +1,15 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ Loads `ExpoAppDelegate` subscribers based on
+ the list from the generated `ExpoModulesProvider`.
+ */
+@interface EXAppDelegatesLoader : NSObject
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/AppDelegates/EXAppDelegatesLoader.m

@@ -0,0 +1,30 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXAppDelegatesLoader.h>
+#import <ExpoModulesCore/EXNativeModulesProxy.h>
+
+#if __has_include(<ExpoModulesCore/ExpoModulesCore-Swift.h>)
+// When `use_frameworks!` is used, the generated Swift header is inside ExpoModulesCore module.
+#import <ExpoModulesCore/ExpoModulesCore-Swift.h>
+#else
+#import "ExpoModulesCore-Swift.h"
+#endif
+
+// Make the legacy wrapper conform to the protocol for subscribers.
+@interface EXLegacyAppDelegateWrapper () <EXAppDelegateSubscriberProtocol>
+@end
+
+@implementation EXAppDelegatesLoader
+
+// App delegate providers must be registered before any `AppDelegate` life-cycle event is called.
+// Unfortunately it's not possible in Swift to run code right after the binary is loaded
+// and before any code is executed, so we switch back to Objective-C just to do this one thing.
++ (void)load
+{
+  id<ModulesProviderObjCProtocol> modulesProvider = [EXNativeModulesProxy getExpoModulesProvider];
+  [EXExpoAppDelegate registerSubscriber:[[EXLegacyAppDelegateWrapper alloc] init]];
+  [EXExpoAppDelegate registerSubscribersFromModulesProvider:modulesProvider];
+  [EXExpoAppDelegate registerReactDelegateHandlersFromModulesProvider:modulesProvider];
+}
+
+@end

package/ios/AppDelegates/EXLegacyAppDelegateWrapper.h

@@ -0,0 +1,16 @@
+// Copyright © 2018 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ The legacy wrapper is still used to forward app delegate calls to singleton modules.
+ See `EXAppDelegatesLoader.m` which registers this class as a subscriber of `ExpoAppDelegate`.
+ */
+@interface EXLegacyAppDelegateWrapper : UIResponder <UIApplicationDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/{EXAppDelegateWrapper.m → AppDelegates/EXLegacyAppDelegateWrapper.m}

@@ -3,13 +3,13 @@
 #import <Foundation/FoundationErrors.h>
 
 #import <ExpoModulesCore/EXModuleRegistryProvider.h>
-#import <ExpoModulesCore/EXAppDelegateWrapper.h>
+#import <ExpoModulesCore/EXLegacyAppDelegateWrapper.h>
 
 static NSMutableArray<id<UIApplicationDelegate>> *subcontractors;
 static NSMutableDictionary<NSString *,NSArray<id<UIApplicationDelegate>> *> *subcontractorsForSelector;
 static dispatch_once_t onceToken;
 
-@implementation EXAppDelegateWrapper
+@implementation EXLegacyAppDelegateWrapper
 
 @synthesize window = _window;
 

package/ios/AppDelegates/ExpoAppDelegate.swift

@@ -0,0 +1,282 @@
+import UIKit
+import Dispatch
+import Foundation
+
+var subscribers = [ExpoAppDelegateSubscriberProtocol]()
+var reactDelegateHandlers = [ExpoReactDelegateHandler]()
+
+/**
+ 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?
+
+  @objc
+  public let reactDelegate = ExpoReactDelegate(handlers: reactDelegateHandlers)
+
+  // 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 }
+  }
+
+  @objc
+  public static func registerReactDelegateHandlersFrom(modulesProvider: ModulesProviderObjCProtocol) {
+    guard let provider = modulesProvider as? ModulesProviderProtocol else {
+      fatalError("Expo modules provider must implement `ModulesProviderProtocol`.")
+    }
+    provider.getReactDelegateHandlers()
+      .sorted { (tuple1, tuple2) -> Bool in
+        return ModulePriorities.get(tuple1.packageName) > ModulePriorities.get(tuple2.packageName)
+      }
+      .forEach { handlerTuple in
+        reactDelegateHandlers.append(handlerTuple.handler.init())
+      }
+  }
+}

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/EXAppDefines.h

@@ -0,0 +1,26 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ For expo modules to get app build time preprocessor values.
+ We ship some modules in [prebuilt binaries](https://expo.fyi/prebuilt-modules),
+ classic defines like `DEBUG` or `RCT_DEV` may not work as expected
+ because the prebuilt modules are always built with Release configuration.
+ This class acts as a supporter to get app build time preprocessor values.
+ */
+@interface EXAppDefines : NSObject
+
+@property (class, nonatomic, assign, readonly) BOOL APP_DEBUG NS_SWIFT_NAME(APP_DEBUG);
+@property (class, nonatomic, assign, readonly) BOOL APP_RCT_DEBUG NS_SWIFT_NAME(APP_RCT_DEBUG);
+@property (class, nonatomic, assign, readonly) BOOL APP_RCT_DEV NS_SWIFT_NAME(APP_RCT_DEV);
+
++ (NSDictionary *)getAllDefines;
+
++ (void)load:(NSDictionary *)defines;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXAppDefines.m

@@ -0,0 +1,61 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXAppDefines.h>
+#import <React/RCTDefines.h>
+
+@implementation EXAppDefines
+
+static NSDictionary *_storage;
+static BOOL _loaded = NO;
+
++ (BOOL)APP_DEBUG
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_DEBUG"] boolValue];
+}
+
++ (BOOL)APP_RCT_DEBUG
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_RCT_DEBUG"] boolValue];
+}
+
++ (BOOL)APP_RCT_DEV
+{
+  [self throwIfNotLoaded];
+  return [_storage[@"APP_RCT_DEV"] boolValue];
+}
+
++ (NSDictionary *)getAllDefines
+{
+  return _storage;
+}
+
++ (void)load:(NSDictionary *)defines
+{
+  NSAssert([NSThread isMainThread], @"This function must be called on main thread");
+  NSAssert(!_loaded, @"EXAppDefines is already loaded");
+  if (!_loaded) {
+    _storage = defines;
+    _loaded = YES;
+  }
+}
+
+// Private function for EXAppDefinesTest to unload the current state.
++ (void)_unload
+{
+  _storage = nil;
+  _loaded = NO;
+}
+
++ (void)throwIfNotLoaded
+{
+  if (!_loaded) {
+    @throw [NSException exceptionWithName:NSInternalInconsistencyException
+                                   reason:@"EXAppDefines is not loaded."
+                                 userInfo:nil];
+  }
+}
+
+
+@end

package/ios/ExpoModulesCore.podspec

@@ -18,24 +18,29 @@ 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 = ['**/*+Private.h', '**/Swift.h']
 
   s.test_spec 'Tests' do |test_spec|
     test_spec.dependency 'Quick'
     test_spec.dependency 'Nimble'
 
-    test_spec.source_files = 'Tests/**/*.swift'
+    test_spec.source_files = 'Tests/**/*.{m,swift}'
   end
 end

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