@capacitor/background-runner 1.0.0-rc.1

package/ios/Plugin/CapacitorAPI/Reachability.swift

@@ -0,0 +1,395 @@
+/*
+ Copyright (c) 2014, Ashley Mills
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import SystemConfiguration
+import Foundation
+
+public enum ReachabilityError: Error {
+    case failedToCreateWithAddress(sockaddr, Int32)
+    case failedToCreateWithHostname(String, Int32)
+    case unableToSetCallback(Int32)
+    case unableToSetDispatchQueue(Int32)
+    case unableToGetFlags(Int32)
+}
+
+@available(*, unavailable, renamed: "Notification.Name.reachabilityChanged")
+public let reachabilityChangedNotification = NSNotification.Name("ReachabilityChangedNotification")
+
+public extension Notification.Name {
+    static let reachabilityChanged = Notification.Name("reachabilityChanged")
+}
+
+public class Reachability {
+
+    public typealias NetworkReachable = (Reachability) -> Void
+    public typealias NetworkUnreachable = (Reachability) -> Void
+
+    @available(*, unavailable, renamed: "Connection")
+    public enum NetworkStatus: CustomStringConvertible {
+        case notReachable, reachableViaWiFi, reachableViaWWAN
+        public var description: String {
+            switch self {
+            case .reachableViaWWAN: return "Cellular"
+            case .reachableViaWiFi: return "WiFi"
+            case .notReachable: return "No Connection"
+            }
+        }
+    }
+
+    public enum Connection: CustomStringConvertible {
+        case unavailable, wifi, cellular
+        public var description: String {
+            switch self {
+            case .cellular: return "Cellular"
+            case .wifi: return "WiFi"
+            case .unavailable: return "No Connection"
+            }
+        }
+
+        @available(*, deprecated, renamed: "unavailable")
+        public static let none: Connection = .unavailable
+    }
+
+    public var whenReachable: NetworkReachable?
+    public var whenUnreachable: NetworkUnreachable?
+
+    @available(*, deprecated, renamed: "allowsCellularConnection")
+    public let reachableOnWWAN: Bool = true
+
+    /// Set to `false` to force Reachability.connection to .none when on cellular connection (default value `true`)
+    public var allowsCellularConnection: Bool
+
+    // The notification center on which "reachability changed" events are being posted
+    public var notificationCenter: NotificationCenter = NotificationCenter.default
+
+    @available(*, deprecated, renamed: "connection.description")
+    public var currentReachabilityString: String {
+        return "\(connection)"
+    }
+
+    @available(*, unavailable, renamed: "connection")
+    public var currentReachabilityStatus: Connection {
+        return connection
+    }
+
+    public var connection: Connection {
+        if flags == nil {
+            try? setReachabilityFlags()
+        }
+
+        switch flags?.connection {
+        case .unavailable?, nil: return .unavailable
+        case .cellular?: return allowsCellularConnection ? .cellular : .unavailable
+        case .wifi?: return .wifi
+        }
+    }
+
+    fileprivate var isRunningOnDevice: Bool = {
+        #if targetEnvironment(simulator)
+        return false
+        #else
+        return true
+        #endif
+    }()
+
+    fileprivate(set) var notifierRunning = false
+    fileprivate let reachabilityRef: SCNetworkReachability
+    fileprivate let reachabilitySerialQueue: DispatchQueue
+    fileprivate let notificationQueue: DispatchQueue?
+    fileprivate(set) var flags: SCNetworkReachabilityFlags? {
+        didSet {
+            guard flags != oldValue else { return }
+            notifyReachabilityChanged()
+        }
+    }
+
+    public required init(reachabilityRef: SCNetworkReachability,
+                         queueQoS: DispatchQoS = .default,
+                         targetQueue: DispatchQueue? = nil,
+                         notificationQueue: DispatchQueue? = .main) {
+        self.allowsCellularConnection = true
+        self.reachabilityRef = reachabilityRef
+        self.reachabilitySerialQueue = DispatchQueue(label: "uk.co.ashleymills.reachability", qos: queueQoS, target: targetQueue)
+        self.notificationQueue = notificationQueue
+    }
+
+    public convenience init(hostname: String,
+                            queueQoS: DispatchQoS = .default,
+                            targetQueue: DispatchQueue? = nil,
+                            notificationQueue: DispatchQueue? = .main) throws {
+        guard let ref = SCNetworkReachabilityCreateWithName(nil, hostname) else {
+            throw ReachabilityError.failedToCreateWithHostname(hostname, SCError())
+        }
+        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue, notificationQueue: notificationQueue)
+    }
+
+    public convenience init(queueQoS: DispatchQoS = .default,
+                            targetQueue: DispatchQueue? = nil,
+                            notificationQueue: DispatchQueue? = .main) throws {
+        var zeroAddress = sockaddr()
+        zeroAddress.sa_len = UInt8(MemoryLayout<sockaddr>.size)
+        zeroAddress.sa_family = sa_family_t(AF_INET)
+
+        guard let ref = SCNetworkReachabilityCreateWithAddress(nil, &zeroAddress) else {
+            throw ReachabilityError.failedToCreateWithAddress(zeroAddress, SCError())
+        }
+
+        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue, notificationQueue: notificationQueue)
+    }
+
+    deinit {
+        stopNotifier()
+    }
+}
+
+public extension Reachability {
+
+    // MARK: - *** Notifier methods ***
+    func startNotifier() throws {
+        guard !notifierRunning else { return }
+
+        let callback: SCNetworkReachabilityCallBack = { (_, flags, info) in
+            guard let info = info else { return }
+
+            // `weakifiedReachability` is guaranteed to exist by virtue of our
+            // retain/release callbacks which we provided to the `SCNetworkReachabilityContext`.
+            let weakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info).takeUnretainedValue()
+
+            // The weak `reachability` _may_ no longer exist if the `Reachability`
+            // object has since been deallocated but a callback was already in flight.
+            weakifiedReachability.reachability?.flags = flags
+        }
+
+        let weakifiedReachability = ReachabilityWeakifier(reachability: self)
+        let opaqueWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.passUnretained(weakifiedReachability).toOpaque()
+
+        var context = SCNetworkReachabilityContext(
+            version: 0,
+            info: UnsafeMutableRawPointer(opaqueWeakifiedReachability),
+            retain: { (info: UnsafeRawPointer) -> UnsafeRawPointer in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                _ = unmanagedWeakifiedReachability.retain()
+                return UnsafeRawPointer(unmanagedWeakifiedReachability.toOpaque())
+            },
+            release: { (info: UnsafeRawPointer) -> Void in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                unmanagedWeakifiedReachability.release()
+            },
+            copyDescription: { (info: UnsafeRawPointer) -> Unmanaged<CFString> in
+                let unmanagedWeakifiedReachability = Unmanaged<ReachabilityWeakifier>.fromOpaque(info)
+                let weakifiedReachability = unmanagedWeakifiedReachability.takeUnretainedValue()
+                let description = weakifiedReachability.reachability?.description ?? "nil"
+                return Unmanaged.passRetained(description as CFString)
+            }
+        )
+
+        if !SCNetworkReachabilitySetCallback(reachabilityRef, callback, &context) {
+            stopNotifier()
+            throw ReachabilityError.unableToSetCallback(SCError())
+        }
+
+        if !SCNetworkReachabilitySetDispatchQueue(reachabilityRef, reachabilitySerialQueue) {
+            stopNotifier()
+            throw ReachabilityError.unableToSetDispatchQueue(SCError())
+        }
+
+        // Perform an initial check
+        try setReachabilityFlags()
+
+        notifierRunning = true
+    }
+
+    func stopNotifier() {
+        defer { notifierRunning = false }
+
+        SCNetworkReachabilitySetCallback(reachabilityRef, nil, nil)
+        SCNetworkReachabilitySetDispatchQueue(reachabilityRef, nil)
+    }
+
+    // MARK: - *** Connection test methods ***
+    @available(*, deprecated, message: "Please use `connection != .none`")
+    var isReachable: Bool {
+        return connection != .unavailable
+    }
+
+    @available(*, deprecated, message: "Please use `connection == .cellular`")
+    var isReachableViaWWAN: Bool {
+        // Check we're not on the simulator, we're REACHABLE and check we're on WWAN
+        return connection == .cellular
+    }
+
+    @available(*, deprecated, message: "Please use `connection == .wifi`")
+    var isReachableViaWiFi: Bool {
+        return connection == .wifi
+    }
+
+    var description: String {
+        return flags?.description ?? "unavailable flags"
+    }
+}
+
+fileprivate extension Reachability {
+
+    func setReachabilityFlags() throws {
+        try reachabilitySerialQueue.sync { [unowned self] in
+            var flags = SCNetworkReachabilityFlags()
+            if !SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags) {
+                self.stopNotifier()
+                throw ReachabilityError.unableToGetFlags(SCError())
+            }
+
+            self.flags = flags
+        }
+    }
+
+    func notifyReachabilityChanged() {
+        let notify = { [weak self] in
+            guard let self = self else { return }
+            self.connection != .unavailable ? self.whenReachable?(self) : self.whenUnreachable?(self)
+            self.notificationCenter.post(name: .reachabilityChanged, object: self)
+        }
+
+        // notify on the configured `notificationQueue`, or the caller's (i.e. `reachabilitySerialQueue`)
+        notificationQueue?.async(execute: notify) ?? notify()
+    }
+}
+
+extension SCNetworkReachabilityFlags {
+
+    typealias Connection = Reachability.Connection
+
+    var connection: Connection {
+        guard isReachableFlagSet else { return .unavailable }
+
+        // If we're reachable, but not on an iOS device (i.e. simulator), we must be on WiFi
+        #if targetEnvironment(simulator)
+        return .wifi
+        #else
+        var connection = Connection.unavailable
+
+        if !isConnectionRequiredFlagSet {
+            connection = .wifi
+        }
+
+        if isConnectionOnTrafficOrDemandFlagSet {
+            if !isInterventionRequiredFlagSet {
+                connection = .wifi
+            }
+        }
+
+        if isOnWWANFlagSet {
+            connection = .cellular
+        }
+
+        return connection
+        #endif
+    }
+
+    var isOnWWANFlagSet: Bool {
+        #if os(iOS)
+        return contains(.isWWAN)
+        #else
+        return false
+        #endif
+    }
+    var isReachableFlagSet: Bool {
+        return contains(.reachable)
+    }
+    var isConnectionRequiredFlagSet: Bool {
+        return contains(.connectionRequired)
+    }
+    var isInterventionRequiredFlagSet: Bool {
+        return contains(.interventionRequired)
+    }
+    var isConnectionOnTrafficFlagSet: Bool {
+        return contains(.connectionOnTraffic)
+    }
+    var isConnectionOnDemandFlagSet: Bool {
+        return contains(.connectionOnDemand)
+    }
+    var isConnectionOnTrafficOrDemandFlagSet: Bool {
+        return !intersection([.connectionOnTraffic, .connectionOnDemand]).isEmpty
+    }
+    var isTransientConnectionFlagSet: Bool {
+        return contains(.transientConnection)
+    }
+    var isLocalAddressFlagSet: Bool {
+        return contains(.isLocalAddress)
+    }
+    var isDirectFlagSet: Bool {
+        return contains(.isDirect)
+    }
+    var isConnectionRequiredAndTransientFlagSet: Bool {
+        return intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]
+    }
+
+    // swiftlint:disable identifier_name
+    var description: String {
+        let W = isOnWWANFlagSet ? "W" : "-"
+        let R = isReachableFlagSet ? "R" : "-"
+        let c = isConnectionRequiredFlagSet ? "c" : "-"
+        let t = isTransientConnectionFlagSet ? "t" : "-"
+        let i = isInterventionRequiredFlagSet ? "i" : "-"
+        let C = isConnectionOnTrafficFlagSet ? "C" : "-"
+        let D = isConnectionOnDemandFlagSet ? "D" : "-"
+        let l = isLocalAddressFlagSet ? "l" : "-"
+        let d = isDirectFlagSet ? "d" : "-"
+
+        return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)"
+    }
+    // swiftlint:enable identifier_name
+}
+
+/**
+ `ReachabilityWeakifier` weakly wraps the `Reachability` class
+ in order to break retain cycles when interacting with CoreFoundation.
+ CoreFoundation callbacks expect a pair of retain/release whenever an
+ opaque `info` parameter is provided. These callbacks exist to guard
+ against memory management race conditions when invoking the callbacks.
+ #### Race Condition
+ If we passed `SCNetworkReachabilitySetCallback` a direct reference to our
+ `Reachability` class without also providing corresponding retain/release
+ callbacks, then a race condition can lead to crashes when:
+ - `Reachability` is deallocated on thread X
+ - A `SCNetworkReachability` callback(s) is already in flight on thread Y
+ #### Retain Cycle
+ If we pass `Reachability` to CoreFoundtion while also providing retain/
+ release callbacks, we would create a retain cycle once CoreFoundation
+ retains our `Reachability` class. This fixes the crashes and his how
+ CoreFoundation expects the API to be used, but doesn't play nicely with
+ Swift/ARC. This cycle would only be broken after manually calling
+ `stopNotifier()` — `deinit` would never be called.
+ #### ReachabilityWeakifier
+ By providing both retain/release callbacks and wrapping `Reachability` in
+ a weak wrapper, we:
+ - interact correctly with CoreFoundation, thereby avoiding a crash.
+ See "Memory Management Programming Guide for Core Foundation".
+ - don't alter the public API of `Reachability.swift` in any way
+ - still allow for automatic stopping of the notifier on `deinit`.
+ */
+private class ReachabilityWeakifier {
+    weak var reachability: Reachability?
+    init(reachability: Reachability) {
+        self.reachability = reachability
+    }
+}

package/ios/Plugin/CapacitorAPI/Wearable.swift

@@ -0,0 +1,48 @@
+import Foundation
+import JavaScriptCore
+import WatchConnectivity
+
+@objc protocol CapacitorWearableExports: JSExport {
+    func send(_ dataDict: JSValue) -> JSValue
+    func transferUserInfo(_ userInfo: JSValue) -> JSValue
+    func isReachable() -> JSValue
+}
+
+class CapacitorWearable: NSObject, CapacitorWearableExports {
+    func send(_ dataDict: JSValue) -> JSValue {
+        var dict: [String: Any] = [:]
+
+        if dataDict.isObject {
+            if let convertedDict = dataDict.toDictionary() as? [String: Any] {
+                dict = convertedDict
+            }
+        }
+
+        WCSession.default.sendMessage(dict, replyHandler: nil)
+
+        return JSValue(undefinedIn: JSContext.current())
+    }
+
+    func transferUserInfo(_ userInfo: JSValue) -> JSValue {
+        var dict: [String: Any] = [:]
+
+        if userInfo.isObject {
+            if let convertedDict = userInfo.toDictionary() as? [String: Any] {
+                dict = convertedDict
+            }
+        }
+
+        _ = WCSession.default.transferUserInfo(dict)
+
+        return JSValue(undefinedIn: JSContext.current())
+    }
+
+    func isReachable() -> JSValue {
+        if WCSession.default.isReachable {
+            return JSValue(bool: true, in: JSContext.current())
+        }
+
+        return JSValue(bool: false, in: JSContext.current())
+    }
+
+}

package/ios/Plugin/Context+CapacitorAPI.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+extension Context {
+    public func setupCapacitorAPI() {
+        ctx.setObject(CapacitorKVStore.self, forKeyedSubscript: "CapacitorKV" as NSString)
+        ctx.setObject(CapacitorGeolocation(context: self), forKeyedSubscript: "CapacitorGeolocation" as NSString)
+        ctx.setObject(CapacitorWearable(), forKeyedSubscript: "CapacitorWearable" as NSString)
+        ctx.setObject(CapacitorNotifications.self, forKeyedSubscript: "CapacitorNotifications" as NSString)
+        ctx.setObject(CapacitorDevice(), forKeyedSubscript: "CapacitorDevice" as NSString)
+    }
+}

package/ios/Plugin/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/ios/Plugin/RunnerConfig.swift

@@ -0,0 +1,36 @@
+import Foundation
+import Capacitor
+
+public struct RunnerConfig {
+    let label: String
+    let src: String
+    var autoSchedule: Bool
+    let event: String?
+    let repeats: Bool?
+    let enableWatchConnectivity: Bool
+
+    let interval: Int?
+
+    public init(from jsObject: JSObject) throws {
+        guard let label = jsObject["label"] as? String else {
+            throw BackgroundRunnerPluginError.invalidRunnerConfig(reason: "runner label is missing or invalid")
+        }
+
+        guard let src = jsObject["src"] as? String else {
+            throw BackgroundRunnerPluginError.invalidRunnerConfig(reason: "runner source file path is missing or invalid")
+        }
+
+        let event = jsObject["event"] as? String
+        let repeats = jsObject["repeat"] as? Bool
+        let interval = jsObject["interval"] as? Int
+        let autoStart = jsObject["autoStart"] as? Bool
+
+        self.label = label
+        self.src = src
+        self.event = event
+        self.repeats = repeats
+        self.interval = interval
+        self.autoSchedule = autoStart ?? false
+        self.enableWatchConnectivity = jsObject["enableWatchConnectivity"] as? Bool ?? false
+    }
+}

package/ios/Plugin/RunnerEngine/Context.swift

@@ -0,0 +1,151 @@
+import Foundation
+import JavaScriptCore
+
+public class Context {
+    let name: String
+    let ctx: JSContext
+
+    private var timers = [Int: Timer]()
+    private var eventListeners = [String: [JSValue]]()
+
+    // swiftlint:disable:next identifier_name
+    public init(vm: JSVirtualMachine, ctxName: String) throws {
+        guard let newCtx = JSContext(virtualMachine: vm) else {
+            throw EngineError.jsCoreError
+        }
+
+        newCtx.name = ctxName
+
+        name = ctxName
+        ctx = newCtx
+
+        try setupWebAPI()
+    }
+
+    public func execute(code: String) throws -> JSValue? {
+        var thrownException: JSValue?
+
+        ctx.exceptionHandler = { _, exception in
+            thrownException = exception
+        }
+
+        let value = ctx.evaluateScript(code)
+
+        if let exception = thrownException {
+            throw EngineError.jsException(details: String(describing: exception))
+        }
+
+        return value
+    }
+
+    public func dispatchEvent(event: String, details: [String: Any]? = nil) throws {
+        if let callbacks = eventListeners[event] {
+            try callbacks.forEach { jsFunc in
+                var thrownException: JSValue?
+
+                self.ctx.exceptionHandler = { _, exception in
+                    thrownException = exception
+                }
+
+                if let detailsObj = details {
+                    var callbackFunctions: [String: Any] = [:]
+
+                    detailsObj.keys.forEach { key in
+                        if key.hasPrefix("__ebr::") {
+                            let funcName = key.replacingOccurrences(of: "__ebr::", with: "")
+                            callbackFunctions[funcName] = detailsObj[key]
+                        }
+                    }
+
+                    guard let jsDetailsObj = JSValue(object: detailsObj, in: self.ctx) else {
+                        throw EngineError.jsValueError
+                    }
+
+                    callbackFunctions.forEach { (funcName: String, jsFunc: Any) in
+                        jsDetailsObj.setValue(jsFunc, forProperty: funcName)
+                    }
+
+                    jsFunc.call(withArguments: [jsDetailsObj])
+                } else {
+                    jsFunc.call(withArguments: [])
+                }
+
+                if let exception = thrownException {
+                    throw EngineError.jsException(details: String(describing: exception))
+                }
+            }
+        }
+    }
+    private func setupWebAPI() throws {
+        let consoleObj = JSConsole(name: name)
+        let addEventListenerFunc: @convention(block)(String, JSValue) -> Void = { type, listener in
+            return self.addEventListener(eventName: type, callback: listener)
+        }
+        let setTimeoutFunc: @convention(block) (JSValue, Int) -> Int = { callback, timeout in
+            return self.setTimeout(callback: callback, timeout: timeout)
+        }
+        let setIntervalFunc: @convention(block) (JSValue, Int) -> Int = { callback, timeout in
+            return self.setInterval(callback: callback, timeout: timeout)
+        }
+        let clearTimeoutFunc: @convention(block) (Int) -> Void = { id in
+            return self.clearTimeout(id: id)
+        }
+        let fetchFunc: @convention(block) (JSValue, JSValue) -> JSValue = { resource, options in
+            return fetch(resource: resource, options: options)
+        }
+        let newTextEncoderConst: @convention(block) () -> JSTextEncoder = JSTextEncoder.init
+        let newTextDecoderConst: @convention(block) (String?, [AnyHashable: Any]?) -> JSTextDecoder = JSTextDecoder.init
+
+        ctx.setObject(consoleObj, forKeyedSubscript: "console" as NSString)
+        ctx.setObject(fetchFunc, forKeyedSubscript: "fetch" as NSString)
+        ctx.setObject(JSCrypto.self, forKeyedSubscript: "crypto" as NSString)
+        ctx.setObject(addEventListenerFunc, forKeyedSubscript: "addEventListener" as NSString)
+        ctx.setObject(setTimeoutFunc, forKeyedSubscript: "setTimeout" as NSString)
+        ctx.setObject(setIntervalFunc, forKeyedSubscript: "setInterval" as NSString)
+        ctx.setObject(clearTimeoutFunc, forKeyedSubscript: "clearTimeout" as NSString)
+        ctx.setObject(clearTimeoutFunc, forKeyedSubscript: "clearInterval" as NSString)
+        ctx.setObject(newTextEncoderConst, forKeyedSubscript: "TextEncoder" as NSString)
+        ctx.setObject(newTextDecoderConst, forKeyedSubscript: "TextDecoder" as NSString)
+
+    }
+
+    private func addEventListener(eventName: String, callback: JSValue) {
+        if eventListeners[eventName] == nil {
+            eventListeners[eventName] = [callback]
+        } else {
+            eventListeners[eventName]?.append(callback)
+        }
+    }
+
+    private func initTimer(callback: JSValue, timeout: Int, isInterval: Bool) -> Int {
+        let timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(timeout / 1000), repeats: isInterval) { t in
+            callback.call(withArguments: [])
+            if !isInterval {
+                let timerId = Int(Int32.init(truncatingIfNeeded: t.hashValue))
+                self.timers.removeValue(forKey: timerId)
+            }
+        }
+
+        let timerId = Int(Int32.init(truncatingIfNeeded: timer.hashValue))
+
+        RunLoop.current.add(timer, forMode: .common)
+
+        timers[timerId] = timer
+
+        return timerId
+    }
+
+    private func setTimeout(callback: JSValue, timeout: Int) -> Int {
+        return initTimer(callback: callback, timeout: timeout, isInterval: false)
+    }
+
+    private func setInterval(callback: JSValue, timeout: Int) -> Int {
+        return initTimer(callback: callback, timeout: timeout, isInterval: true)
+    }
+
+    private func clearTimeout(id: Int) {
+        if let timer = timers.removeValue(forKey: id) {
+            timer.invalidate()
+        }
+    }
+}

package/ios/Plugin/RunnerEngine/Errors.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+public enum EngineError: Error {
+    case jsCoreError
+    case jsValueError
+    case sourceNotFound
+    case jsException(details: String)
+}