expo-modules-core 1.3.2 → 1.4.0

package/ios/Swift/AppContext.swift

@@ -8,7 +8,7 @@ public final class AppContext: NSObject {
   internal static func create() -> AppContext {
     let appContext = AppContext()
 
-    appContext._runtime = JavaScriptRuntime()
+    appContext._runtime = ExpoRuntime()
     return appContext
   }
 
@@ -44,7 +44,7 @@ public final class AppContext: NSObject {
    Underlying JSI runtime of the running app.
    */
   @objc
-  public var _runtime: JavaScriptRuntime? {
+  public var _runtime: ExpoRuntime? {
     didSet {
       if _runtime == nil {
         // When the runtime is unpinned from the context (e.g. deallocated),
@@ -52,9 +52,8 @@ public final class AppContext: NSObject {
         // Otherwise the JSCRuntime asserts may fail on deallocation.
         releaseRuntimeObjects()
       } else if _runtime != oldValue {
-        // Try to install ExpoModules host object automatically when the runtime changes.
-        // TODO: Should we uninstall in the old runtime? (@tsapeta)
-        try? installExpoModulesHostObject()
+        // Try to install the core object automatically when the runtime changes.
+        try? prepareRuntime()
       }
     }
   }
@@ -62,7 +61,7 @@ public final class AppContext: NSObject {
   /**
    JSI runtime of the running app.
    */
-  public var runtime: JavaScriptRuntime {
+  public var runtime: ExpoRuntime {
     get throws {
       if let runtime = _runtime {
         return runtime
@@ -71,6 +70,11 @@ public final class AppContext: NSObject {
     }
   }
 
+  /**
+   The core module that defines the `expo` object in the global scope of Expo runtime.
+   */
+  internal private(set) lazy var coreModule = CoreModule(appContext: self)
+
   /**
    Designated initializer without modules provider.
    */
@@ -127,7 +131,8 @@ public final class AppContext: NSObject {
    */
   internal func newObject(nativeClassId: ObjectIdentifier) throws -> JavaScriptObject? {
     guard let jsClass = classRegistry.getJavaScriptClass(nativeClassId: nativeClassId) else {
-      return nil
+      // TODO: Define a JS class for SharedRef in the CoreModule and then use it here instead of a raw object (?)
+      return try runtime.createObject()
     }
     let prototype = try jsClass.getProperty("prototype").asObject()
     let object = try runtime.createObject(withPrototype: prototype)
@@ -342,10 +347,14 @@ public final class AppContext: NSObject {
 
   // MARK: - Runtime
 
-  internal func installExpoModulesHostObject() throws {
-    guard _runtime != nil else {
-      throw RuntimeLostException()
-    }
+  internal func prepareRuntime() throws {
+    let runtime = try runtime
+    let coreObject = try coreModule.definition().build(appContext: self)
+
+    // Initialize `global.expo`.
+    try runtime.initializeCoreObject(coreObject)
+
+    // Install the modules host object as the `global.expo.modules`.
     EXJavaScriptRuntimeManager.installExpoModulesHostObject(self)
   }
 

package/ios/Swift/DevTools/CdpNetworkTypes.swift

@@ -0,0 +1,163 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+
+struct CdpNetwork {
+  // MARK: Types
+
+  typealias Headers = [String: String]?
+  typealias MonotonicTime = TimeInterval
+  typealias RequestId = String
+  typealias TimeSinceEpoch = TimeInterval
+
+  enum ResourceType: String, Encodable {
+    case image = "Image"
+    case media = "Media"
+    case font = "Font"
+    case script = "Script"
+    case fetch = "Fetch"
+    case other = "Other"
+  }
+
+  struct ConnectTiming: Encodable {
+    let requestTime: MonotonicTime
+  }
+
+  struct Request: Encodable {
+    let url: String
+    let method: String
+    let headers: Headers
+    let postData: String?
+
+    init(_ request: URLRequest) {
+      self.url = request.url?.absoluteString ?? ""
+      self.method = request.httpMethod ?? "GET"
+      self.headers = request.allHTTPHeaderFields ?? [:]
+      if let httpBody = request.httpBodyData() {
+        self.postData = String(data: httpBody, encoding: .utf8)
+      } else {
+        self.postData = nil
+      }
+    }
+  }
+
+  struct Response: Encodable {
+    let url: String
+    let status: Int
+    let statusText: String
+    let headers: Headers
+    let mimeType: String
+    let encodedDataLength: Int64
+
+    init(_ response: HTTPURLResponse) {
+      self.url = response.url?.absoluteString ?? ""
+      self.status = response.statusCode
+      self.statusText = ""
+      let headers = response.allHeaderFields.reduce(into: [String: String]()) { result, header in
+        if let key = header.key as? String, let value = header.value as? String {
+          result[key] = value
+        }
+      }
+      self.headers = headers
+      self.mimeType = response.value(forHTTPHeaderField: "Content-Type") ?? ""
+      self.encodedDataLength = response.expectedContentLength
+    }
+  }
+
+  // MARK: Events
+
+  struct RequestWillBeSentParams: EventParms {
+    let requestId: RequestId
+    var loaderId = ""
+    var documentURL = "mobile"
+    let request: Request
+    let timestamp: MonotonicTime
+    let wallTime: TimeSinceEpoch
+    var initiator = ["type": "script"]
+    var redirectHasExtraInfo: Bool {
+      return self.redirectResponse != nil
+    }
+    let redirectResponse: Response?
+    var referrerPolicy = "no-referrer"
+    let type: ResourceType
+
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest, redirectResponse: HTTPURLResponse?) {
+      self.requestId = requestId
+      self.request = Request(request)
+      self.timestamp = now
+      self.wallTime = now
+      if let redirectResponse = redirectResponse {
+        self.redirectResponse = Response(redirectResponse)
+      } else {
+        self.redirectResponse = nil
+      }
+      self.type = ResourceType.fetch
+    }
+  }
+
+  struct RequestWillBeSentExtraInfoParams: EventParms {
+    let requestId: RequestId
+    var associatedCookies = [String: String]()
+    let headers: Headers
+    let connectTiming: ConnectTiming
+
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest) {
+      self.requestId = requestId
+      self.headers = request.allHTTPHeaderFields ?? [:]
+      self.connectTiming = ConnectTiming(requestTime: now)
+    }
+  }
+
+  struct ResponseReceivedParams: EventParms {
+    let requestId: RequestId
+    var loaderId = ""
+    let timestamp: MonotonicTime
+    let type: ResourceType
+    let response: Response
+    var hasExtraInfo = false
+
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest, response: HTTPURLResponse) {
+      self.requestId = requestId
+      self.timestamp = now
+      self.type = ResourceType.fetch
+      self.response = Response(response)
+    }
+  }
+
+  struct LoadingFinishedParams: EventParms {
+    let requestId: RequestId
+    let timestamp: MonotonicTime
+    let encodedDataLength: Int64
+
+    init(now: TimeInterval, requestId: RequestId, request: URLRequest, response: HTTPURLResponse) {
+      self.requestId = requestId
+      self.timestamp = now
+      self.encodedDataLength = response.expectedContentLength
+    }
+  }
+
+  struct ExpoReceivedResponseBodyParams: EventParms {
+    let requestId: RequestId
+    let body: String
+    let base64Encoded: Bool
+
+    init(now: TimeInterval, requestId: RequestId, responseBody: Data, isText: Bool) {
+      self.requestId = requestId
+      let bodyString = isText ? String(data: responseBody, encoding: .utf8) : responseBody.base64EncodedString()
+      if let bodyString = bodyString {
+        self.body = bodyString
+        self.base64Encoded = !isText
+      } else {
+        self.body = ""
+        self.base64Encoded = false
+      }
+    }
+  }
+
+  typealias EventParms = Encodable
+
+  struct Event<T: EventParms>: Encodable {
+    let method: String
+    let params: T
+  }
+}

package/ios/Swift/DevTools/ExpoRequestCdpInterceptor.swift

@@ -0,0 +1,71 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ The `ExpoRequestInterceptorProtocolDelegate` implementation to
+ dispatch CDP (Chrome DevTools Protocol: https://chromedevtools.github.io/devtools-protocol/) events.
+ */
+@objc(EXRequestCdpInterceptor)
+public final class ExpoRequestCdpInterceptor: NSObject, ExpoRequestInterceptorProtocolDelegate {
+  private var delegate: ExpoRequestCdpInterceptorDelegate?
+  internal var dispatchQueue = DispatchQueue(label: "expo.requestCdpInterceptor")
+
+  override private init() {}
+
+  @objc
+  public static let shared = ExpoRequestCdpInterceptor()
+
+  @objc
+  public func setDelegate(_ newValue: ExpoRequestCdpInterceptorDelegate?) {
+    dispatchQueue.async {
+      self.delegate = newValue
+    }
+  }
+
+  private func dispatchEvent<T: CdpNetwork.EventParms>(_ event: CdpNetwork.Event<T>) {
+    dispatchQueue.async {
+      let encoder = JSONEncoder()
+      if let jsonData = try? encoder.encode(event), let payload = String(data: jsonData, encoding: .utf8) {
+        self.delegate?.dispatch(payload)
+      }
+    }
+  }
+
+  // MARK: ExpoRequestInterceptorProtocolDelegate implementations
+
+  func willSendRequest(requestId: String, request: URLRequest, redirectResponse: HTTPURLResponse?) {
+    let now = Date().timeIntervalSince1970
+
+    let params = CdpNetwork.RequestWillBeSentParams(now: now, requestId: requestId, request: request, redirectResponse: redirectResponse)
+    dispatchEvent(CdpNetwork.Event(method: "Network.requestWillBeSent", params: params))
+
+    let params2 = CdpNetwork.RequestWillBeSentExtraInfoParams(now: now, requestId: requestId, request: request)
+    dispatchEvent(CdpNetwork.Event(method: "Network.requestWillBeSentExtraInfo", params: params2))
+  }
+
+  func didReceiveResponse(requestId: String, request: URLRequest, response: HTTPURLResponse) {
+    let now = Date().timeIntervalSince1970
+
+    let params = CdpNetwork.ResponseReceivedParams(now: now, requestId: requestId, request: request, response: response)
+    dispatchEvent(CdpNetwork.Event(method: "Network.responseReceived", params: params))
+
+    let params2 = CdpNetwork.LoadingFinishedParams(now: now, requestId: requestId, request: request, response: response)
+    dispatchEvent(CdpNetwork.Event(method: "Network.loadingFinished", params: params2))
+  }
+
+  func didReceiveResponseBody(requestId: String, responseBody: Data, isText: Bool) {
+    let now = Date().timeIntervalSince1970
+    let params = CdpNetwork.ExpoReceivedResponseBodyParams(now: now, requestId: requestId, responseBody: responseBody, isText: isText)
+    dispatchEvent(CdpNetwork.Event(method: "Expo(Network.receivedResponseBody)", params: params))
+  }
+}
+
+/**
+ The delegate to dispatch CDP events for ExpoRequestCdpInterceptor
+ */
+@objc(EXRequestCdpInterceptorDelegate)
+public protocol ExpoRequestCdpInterceptorDelegate {
+  @objc
+  func dispatch(_ event: String)
+}

package/ios/Swift/DevTools/ExpoRequestInterceptorProtocol.swift

@@ -0,0 +1,183 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ A `URLSession` interceptor which passes network events to its delegate
+ */
+@objc(EXRequestInterceptorProtocol)
+public final class ExpoRequestInterceptorProtocol: URLProtocol, URLSessionDataDelegate {
+  private static let REQUEST_ID = "ExpoRequestInterceptorProtocol.requestId"
+  private static var requestIdProvider = RequestIdProvider()
+  private lazy var urlSession = URLSession(
+    configuration: URLSessionConfiguration.default,
+    delegate: self,
+    delegateQueue: nil
+  )
+  private var dataTask_: URLSessionDataTask?
+  private let responseBody = NSMutableData()
+  private var responseIsText = false
+  private var responseContentLength: Int64 = 0
+
+  static let MAX_BODY_SIZE = 1_048_576
+
+  // Currently keeps the delegate fixed for ExpoRequestCdpInterceptor and be thread-safe
+  static let delegate: ExpoRequestInterceptorProtocolDelegate = ExpoRequestCdpInterceptor.shared
+
+  // MARK: URLProtocol implementations
+
+  public override class func canInit(with request: URLRequest) -> Bool {
+    guard let scheme = request.url?.scheme else {
+      return false
+    }
+    if !["http", "https"].contains(scheme) {
+      return false
+    }
+    let isNewRequest = URLProtocol.property(
+      forKey: Self.REQUEST_ID,
+      in: request
+    ) == nil
+    return isNewRequest
+  }
+
+  override init(
+    request: URLRequest,
+    cachedResponse: CachedURLResponse?,
+    client: URLProtocolClient?
+  ) {
+    super.init(request: request, cachedResponse: cachedResponse, client: client)
+    // swiftlint:disable force_cast
+    let mutableRequest = request as! NSMutableURLRequest
+    // swiftlint:enable force_cast
+    let requestId = Self.requestIdProvider.create()
+    URLProtocol.setProperty(
+      requestId,
+      forKey: Self.REQUEST_ID,
+      in: mutableRequest
+    )
+    Self.delegate.willSendRequest(
+      requestId: requestId,
+      request: mutableRequest as URLRequest,
+      redirectResponse: nil
+    )
+    dataTask_ = urlSession.dataTask(with: mutableRequest as URLRequest)
+  }
+
+  public override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+    request
+  }
+
+  public override func startLoading() {
+    dataTask_?.resume()
+  }
+
+  public override func stopLoading() {
+    dataTask_?.cancel()
+  }
+
+  // MARK: URLSessionDataDelegate implementations
+
+  public func urlSession(_: URLSession, dataTask _: URLSessionDataTask, didReceive data: Data) {
+    client?.urlProtocol(self, didLoad: data)
+    if responseBody.length + data.count <= Self.MAX_BODY_SIZE {
+      responseBody.append(data)
+    }
+  }
+
+  public func urlSession(
+    _: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    if let resp = response as? HTTPURLResponse,
+      let currentRequest = dataTask.currentRequest,
+      let requestId = URLProtocol.property(
+        forKey: Self.REQUEST_ID,
+        in: currentRequest
+      ) as? String {
+      Self.delegate.didReceiveResponse(
+        requestId: requestId,
+        request: currentRequest,
+        response: resp
+      )
+
+      let contentType = resp.value(forHTTPHeaderField: "Content-Type")
+      responseIsText = (contentType?.starts(with: "text/") ?? false) || contentType == "application/json"
+      responseContentLength = resp.expectedContentLength
+    }
+    completionHandler(.allow)
+    client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .allowed)
+  }
+
+  public func urlSession(_: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    if let error = error {
+      client?.urlProtocol(self, didFailWithError: error)
+    } else {
+      if responseContentLength > 0 && responseContentLength <= Self.MAX_BODY_SIZE,
+        let currentRequest = task.currentRequest,
+        let requestId = URLProtocol.property(
+          forKey: Self.REQUEST_ID,
+          in: currentRequest
+        ) as? String {
+        Self.delegate.didReceiveResponseBody(
+          requestId: requestId, responseBody: responseBody as Data, isText: responseIsText)
+      }
+      client?.urlProtocolDidFinishLoading(self)
+    }
+  }
+
+  public func urlSession(
+    _: URLSession,
+    task _: URLSessionTask,
+    willPerformHTTPRedirection response: HTTPURLResponse,
+    newRequest request: URLRequest,
+    completionHandler: @escaping (URLRequest?) -> Void
+  ) {
+    if let requestId = URLProtocol.property(forKey: Self.REQUEST_ID, in: request) as? String {
+      Self.delegate.willSendRequest(
+        requestId: requestId,
+        request: request,
+        redirectResponse: response
+      )
+    }
+    completionHandler(request)
+  }
+
+  /**
+   Data structure to save the response for redirection
+   */
+  private struct RedirectResponse {
+    let requestId: String
+    let redirectResponse: HTTPURLResponse
+  }
+
+  /**
+   A helper class to create a unique request ID
+   */
+  private struct RequestIdProvider {
+    private var value: UInt64 = 0
+
+    mutating func create() -> String {
+      // We could ensure the increment thread safety,
+      // because we access this function from the same thread (com.apple.CFNetwork.CustomProtocols).
+      value += 1
+      return String(value)
+    }
+  }
+}
+
+/**
+ The delegate to dispatch network request events
+ */
+@objc(EXRequestInterceptorProtocolDelegate)
+protocol ExpoRequestInterceptorProtocolDelegate {
+  @objc
+  func willSendRequest(requestId: String, request: URLRequest, redirectResponse: HTTPURLResponse?)
+
+  @objc
+  func didReceiveResponse(requestId: String, request: URLRequest, response: HTTPURLResponse)
+
+  @objc
+  func didReceiveResponseBody(requestId: String, responseBody: Data, isText: Bool)
+}

package/ios/Swift/DevTools/URLRequest+httpBodyData.swift

@@ -0,0 +1,43 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+import Foundation
+
+/**
+ `URLRequest.httpBodyData()` extension to read the underlying `httpBodyStream` as Data.
+ */
+extension URLRequest {
+  func httpBodyData(limit: Int = ExpoRequestInterceptorProtocol.MAX_BODY_SIZE) -> Data? {
+    if let httpBody = self.httpBody {
+      return httpBody
+    }
+
+    if let contentLength = self.allHTTPHeaderFields?["Content-Length"],
+      let contentLengthInt = Int(contentLength),
+      contentLengthInt > limit {
+      return nil
+    }
+    guard let stream = self.httpBodyStream else {
+      return nil
+    }
+
+    let bufferSize: Int = 8192
+    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+
+    stream.open()
+    defer {
+      buffer.deallocate()
+      stream.close()
+    }
+
+    var data = Data()
+    while stream.hasBytesAvailable {
+      let chunkSize = stream.read(buffer, maxLength: bufferSize)
+      if data.count + chunkSize > limit {
+        return nil
+      }
+      data.append(buffer, count: chunkSize)
+    }
+
+    return data
+  }
+}

package/ios/Swift/ExpoRuntime.swift

@@ -0,0 +1,28 @@
+/**
+ Property name of the core object in the global scope of the Expo JS runtime.
+ */
+private let coreObjectPropertyName = "expo"
+
+@objc(ExpoRuntime)
+public final class ExpoRuntime: JavaScriptRuntime {
+  /**
+   The core object of the Expo runtime that is used to scope native Expo-specific functionalities.
+   It gets installed into the runtime as the `global.expo` object.
+   */
+  @objc
+  public private(set) var coreObject: JavaScriptObject?
+
+  internal func initializeCoreObject(_ coreObject: JavaScriptObject) throws {
+    guard self.coreObject == nil else {
+      throw CoreObjectInitializedException()
+    }
+    self.coreObject = coreObject
+    global().defineProperty(coreObjectPropertyName, value: coreObject, options: .enumerable)
+  }
+}
+
+private final class CoreObjectInitializedException: Exception {
+  override var reason: String {
+    "The core Expo object was already initialized"
+  }
+}

package/ios/Swift/Modules/CoreModule.swift

@@ -0,0 +1,7 @@
+// The core module that describes the `global.expo` object.
+internal final class CoreModule: Module {
+  internal func definition() -> ModuleDefinition {
+    // Nothing so far, but eventually we will expose some common classes
+    // and maybe even the `modules` host object.
+  }
+}

package/ios/Swift/SharedObjects/SharedRef.swift

@@ -0,0 +1,12 @@
+/**
+ Shared object (ref) that holds a pointer to any native object. Allows passing references
+ to native instances among different independent libraries.
+ */
+open class SharedRef<PointerType>: SharedObject {
+  public let pointer: PointerType
+
+  init(_ pointer: PointerType) {
+    self.pointer = pointer
+    super.init()
+  }
+}

package/ios/Swift/Views/ComponentData.swift

@@ -7,7 +7,7 @@ import React
  but it also simplifies capturing the view config so we can omit some reflections that React Native executes.
  */
 @objc(EXComponentData)
-public final class ComponentData: RCTComponentData {
+public final class ComponentData: RCTComponentDataSwiftAdapter {
   /**
    Weak pointer to the holder of a module that the component data was created for.
    */

package/ios/Tests/CoreModuleSpec.swift

@@ -0,0 +1,27 @@
+import ExpoModulesTestCore
+
+@testable import ExpoModulesCore
+
+final class CoreModuleSpec: ExpoSpec {
+  override func spec() {
+    let appContext = AppContext.create()
+    let runtime = try! appContext.runtime
+
+    describe("core module") {
+      it("is initialized") {
+        expect(appContext.coreModule).notTo(beNil())
+      }
+    }
+
+    describe("core object") {
+      it("is initialized") {
+        expect(runtime.coreObject).notTo(beNil())
+      }
+
+      it("is installed to global scope") {
+        let coreObjectValue = try runtime.eval("expo")
+        expect(coreObjectValue.kind) == .object
+      }
+    }
+  }
+}