@capawesome/capacitor-nodejs 0.0.1

package/ios/Plugin/Classes/Events/MessageEvent.swift

@@ -0,0 +1,19 @@
+import Foundation
+import Capacitor
+
+@objc public class MessageEvent: NSObject {
+    let args: [Any]
+    let eventName: String
+
+    init(eventName: String, args: [Any]) {
+        self.args = args
+        self.eventName = eventName
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["args"] = JSTypes.coerceArrayToJSArray(args) ?? []
+        result["eventName"] = eventName
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Classes/Options/SendOptions.swift

@@ -0,0 +1,19 @@
+import Foundation
+import Capacitor
+
+@objc public class SendOptions: NSObject {
+    let args: [Any]
+    let eventName: String
+
+    init(_ call: CAPPluginCall) throws {
+        self.args = call.getArray("args") ?? []
+        self.eventName = try SendOptions.getEventNameFromCall(call)
+    }
+
+    private static func getEventNameFromCall(_ call: CAPPluginCall) throws -> String {
+        guard let eventName = call.getString("eventName") else {
+            throw CustomError.eventNameMissing
+        }
+        return eventName
+    }
+}

package/ios/Plugin/Classes/Options/StartOptions.swift

@@ -0,0 +1,32 @@
+import Foundation
+import Capacitor
+
+@objc public class StartOptions: NSObject {
+    let args: [String]
+    let env: [String: String]
+    let script: String?
+
+    override init() {
+        self.args = []
+        self.env = [:]
+        self.script = nil
+    }
+
+    init(_ call: CAPPluginCall) {
+        self.args = call.getArray("args", String.self) ?? []
+        self.env = StartOptions.getEnvFromCall(call)
+        self.script = call.getString("script")
+    }
+
+    private static func getEnvFromCall(_ call: CAPPluginCall) -> [String: String] {
+        var env: [String: String] = [:]
+        if let envObject = call.getObject("env") {
+            for (key, value) in envObject {
+                if let value = value as? String {
+                    env[key] = value
+                }
+            }
+        }
+        return env
+    }
+}

package/ios/Plugin/Classes/Results/IsReadyResult.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Capacitor
+
+@objc public class IsReadyResult: NSObject, Result {
+    let ready: Bool
+
+    init(ready: Bool) {
+        self.ready = ready
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["ready"] = ready
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Enums/CustomError.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+enum CustomError: Error {
+    case eventNameMissing
+    case nodeAlreadyRunning
+    case nodeNotReady
+    case projectNotFound
+    case scriptNotFound
+    case startModeNotManual
+
+    var code: String? {
+        switch self {
+        case .eventNameMissing:
+            return "EVENT_NAME_MISSING"
+        case .nodeAlreadyRunning:
+            return "NODE_ALREADY_RUNNING"
+        case .nodeNotReady:
+            return "NODE_NOT_READY"
+        case .projectNotFound:
+            return "PROJECT_NOT_FOUND"
+        case .scriptNotFound:
+            return "SCRIPT_NOT_FOUND"
+        case .startModeNotManual:
+            return "START_MODE_NOT_MANUAL"
+        }
+    }
+}
+
+extension CustomError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .eventNameMissing:
+            return NSLocalizedString("eventName must be provided.", comment: "eventNameMissing")
+        case .nodeAlreadyRunning:
+            return NSLocalizedString("The Node.js runtime is already running.", comment: "nodeAlreadyRunning")
+        case .nodeNotReady:
+            return NSLocalizedString("The Node.js runtime is not ready to receive messages.", comment: "nodeNotReady")
+        case .projectNotFound:
+            return NSLocalizedString("The Node.js project directory was not found.", comment: "projectNotFound")
+        case .scriptNotFound:
+            return NSLocalizedString("The script file was not found.", comment: "scriptNotFound")
+        case .startModeNotManual:
+            return NSLocalizedString("The startMode configuration option must be set to 'manual'.", comment: "startModeNotManual")
+        }
+    }
+}

package/ios/Plugin/Nodejs.swift

@@ -0,0 +1,148 @@
+import Foundation
+import Capacitor
+import NodejsPluginNative
+
+@objc public class Nodejs: NSObject {
+    private static let channelEvents = "_EVENTS_"
+    private static let channelSystem = "_SYSTEM_"
+    private static let systemMessageReady = "ready-for-app-events"
+
+    private let config: NodejsConfig
+    private weak var plugin: NodejsPlugin?
+
+    private var ready = false
+    private var started = false
+
+    init(plugin: NodejsPlugin, config: NodejsConfig) {
+        self.config = config
+        self.plugin = plugin
+        super.init()
+        NodeRunner.setMessageHandler { [weak self] channelName, message in
+            self?.handleMessage(channelName: channelName, message: message)
+        }
+        if let dataDirPath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true).first {
+            NodeRunner.registerDataDirPath(dataDirPath)
+        }
+    }
+
+    @objc public func isReady() -> Bool {
+        return ready
+    }
+
+    @objc public func send(_ options: SendOptions) throws {
+        guard ready else {
+            throw CustomError.nodeNotReady
+        }
+        guard JSONSerialization.isValidJSONObject(options.args) else {
+            throw NSError(domain: "NodejsPlugin", code: 0, userInfo: [NSLocalizedDescriptionKey: "args must be JSON-serializable."])
+        }
+        let payload = try JSONSerialization.data(withJSONObject: options.args)
+        let envelope: [String: Any] = [
+            "event": options.eventName,
+            "payload": String(data: payload, encoding: .utf8) ?? "[]"
+        ]
+        let envelopeData = try JSONSerialization.data(withJSONObject: envelope)
+        guard let message = String(data: envelopeData, encoding: .utf8) else {
+            return
+        }
+        NodeRunner.sendMessage(Nodejs.channelEvents, message: message)
+    }
+
+    @objc public func start(_ options: StartOptions, completion: @escaping (_ error: Error?) -> Void) {
+        objc_sync_enter(self)
+        defer {
+            objc_sync_exit(self)
+        }
+        guard !started else {
+            completion(CustomError.nodeAlreadyRunning)
+            return
+        }
+        started = true
+        let thread = Thread { [self] in
+            do {
+                let projectPath = try self.getProjectPath()
+                let builtinModulesPath = self.getBuiltinModulesPath()
+                let scriptPath = try self.resolveScriptPath(projectPath: projectPath, script: options.script)
+                for (key, value) in options.env {
+                    setenv(key, value, 1)
+                }
+                setenv("TMPDIR", NSTemporaryDirectory(), 1)
+                var arguments = ["node", scriptPath]
+                arguments.append(contentsOf: options.args)
+                var nodePath = projectPath
+                if let builtinModulesPath = builtinModulesPath {
+                    nodePath += ":" + builtinModulesPath
+                }
+                completion(nil)
+                NodeRunner.startEngine(withArguments: arguments, nodePath: nodePath)
+            } catch {
+                self.started = false
+                completion(error)
+            }
+        }
+        thread.name = "NodejsPlugin"
+        thread.stackSize = 2 * 1024 * 1024
+        thread.start()
+    }
+
+    private func handleMessage(channelName: String, message: String) {
+        if channelName == Nodejs.channelSystem {
+            if message == Nodejs.systemMessageReady {
+                ready = true
+                plugin?.notifyReadyListeners()
+            }
+        } else if channelName == Nodejs.channelEvents {
+            guard let envelopeData = message.data(using: .utf8),
+                  let envelope = try? JSONSerialization.jsonObject(with: envelopeData) as? [String: Any],
+                  let eventName = envelope["event"] as? String else {
+                return
+            }
+            var args: [Any] = []
+            if let payload = envelope["payload"] as? String, let payloadData = payload.data(using: .utf8) {
+                args = (try? JSONSerialization.jsonObject(with: payloadData) as? [Any]) ?? []
+            }
+            plugin?.notifyMessageListeners(MessageEvent(eventName: eventName, args: args))
+        }
+    }
+
+    private func getProjectPath() throws -> String {
+        let projectPath = Bundle.main.bundlePath + "/public/" + config.nodeDir
+        guard FileManager.default.fileExists(atPath: projectPath) else {
+            throw CustomError.projectNotFound
+        }
+        return projectPath
+    }
+
+    private func getBuiltinModulesPath() -> String? {
+        #if SWIFT_PACKAGE
+        return Bundle.module.path(forResource: "builtin_modules", ofType: nil)
+        #else
+        return Bundle(for: Nodejs.self).path(forResource: "builtin_modules", ofType: nil)
+            ?? Bundle.main.path(forResource: "builtin_modules", ofType: nil)
+        #endif
+    }
+
+    private func resolveScriptPath(projectPath: String, script: String?) throws -> String {
+        var scriptFile = script
+        if scriptFile == nil {
+            scriptFile = getMainFromPackageJson(projectPath: projectPath)
+        }
+        if scriptFile == nil {
+            scriptFile = "index.js"
+        }
+        let scriptPath = projectPath + "/" + (scriptFile ?? "index.js")
+        guard FileManager.default.fileExists(atPath: scriptPath) else {
+            throw CustomError.scriptNotFound
+        }
+        return scriptPath
+    }
+
+    private func getMainFromPackageJson(projectPath: String) -> String? {
+        let packageJsonPath = projectPath + "/package.json"
+        guard let packageJsonData = FileManager.default.contents(atPath: packageJsonPath),
+              let packageJson = try? JSONSerialization.jsonObject(with: packageJsonData) as? [String: Any] else {
+            return nil
+        }
+        return packageJson["main"] as? String
+    }
+}

package/ios/Plugin/NodejsConfig.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public struct NodejsConfig {
+    var nodeDir = "nodejs"
+    var startMode = "auto"
+}

package/ios/Plugin/NodejsPlugin.swift

@@ -0,0 +1,102 @@
+import Foundation
+import Capacitor
+
+@objc(NodejsPlugin)
+public class NodejsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "NodejsPlugin"
+    public let jsName = "Nodejs"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "isReady", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "send", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise)
+    ]
+
+    public static let eventMessage = "message"
+    public static let eventReady = "ready"
+    public static let startModeAuto = "auto"
+    public static let startModeManual = "manual"
+    public static let tag = "NodejsPlugin"
+
+    private var config = NodejsConfig()
+    private var implementation: Nodejs?
+
+    override public func load() {
+        config = getNodejsConfig()
+        implementation = Nodejs(plugin: self, config: config)
+        if config.startMode == NodejsPlugin.startModeAuto {
+            implementation?.start(StartOptions()) { error in
+                if let error = error {
+                    CAPLog.print("[", NodejsPlugin.tag, "] ", error)
+                }
+            }
+        }
+    }
+
+    @objc func isReady(_ call: CAPPluginCall) {
+        let result = IsReadyResult(ready: implementation?.isReady() == true)
+        resolveCall(call, result)
+    }
+
+    @objc func send(_ call: CAPPluginCall) {
+        do {
+            let options = try SendOptions(call)
+
+            try implementation?.send(options)
+            resolveCall(call)
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func start(_ call: CAPPluginCall) {
+        guard config.startMode == NodejsPlugin.startModeManual else {
+            rejectCall(call, CustomError.startModeNotManual)
+            return
+        }
+        let options = StartOptions(call)
+
+        implementation?.start(options) { error in
+            if let error = error {
+                self.rejectCall(call, error)
+            } else {
+                self.resolveCall(call)
+            }
+        }
+    }
+
+    func notifyMessageListeners(_ event: MessageEvent) {
+        notifyListeners(NodejsPlugin.eventMessage, data: event.toJSObject() as? JSObject ?? JSObject(), retainUntilConsumed: true)
+    }
+
+    func notifyReadyListeners() {
+        notifyListeners(NodejsPlugin.eventReady, data: JSObject(), retainUntilConsumed: true)
+    }
+
+    private func getNodejsConfig() -> NodejsConfig {
+        var config = NodejsConfig()
+        if let nodeDir = getConfig().getString("nodeDir") {
+            config.nodeDir = nodeDir
+        }
+        if let startMode = getConfig().getString("startMode") {
+            config.startMode = startMode
+        }
+        return config
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", NodejsPlugin.tag, "] ", error)
+        call.reject(error.localizedDescription, (error as? CustomError)?.code)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,6 @@
+import Foundation
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/ios/PluginNative/NodeRunner.mm

@@ -0,0 +1,221 @@
+/*
+  Runs the Node.js engine and handles the system channel messages.
+
+  Based on the `NodeRunner` of the `nodejs-mobile-react-native` project
+  (MIT licensed, https://github.com/nodejs-mobile/nodejs-mobile-react-native).
+*/
+#import <UIKit/UIKit.h>
+#import "NodeRunner.h"
+#include <NodeMobile/NodeMobile.h>
+#include <string>
+#include "bridge.h"
+
+static NSString *const SYSTEM_CHANNEL = @"_SYSTEM_";
+
+static NodeRunnerMessageHandler _messageHandler = nil;
+
+// Flag to indicate if the Node.js engine is ready to receive app events.
+static bool nodeIsReadyForAppEvents = false;
+
+// Condition to wait on pause event handling on the Node.js side.
+static NSCondition *appEventBeingProcessedCondition = nil;
+
+// Set to keep ids for called pause events, so they can be unlocked later.
+static NSMutableSet *appPauseEventsManagerSet = nil;
+
+// Lock to manipulate the app pause events manager set.
+static id appPauseEventsManagerSetLock = nil;
+
+@interface NodeRunner ()
+
++ (void)handleSystemChannelMessage:(NSString *)msg;
++ (void)onPause;
++ (void)onResume;
++ (void)releasePauseEvent:(NSString *)eventId;
++ (void)sendPauseEventAndWaitForRelease:(NSDate *)expectedFinishTime;
+
+@end
+
+static void rcv_message(const char *channelName, const char *msg) {
+    @autoreleasepool {
+        NSString *objectiveCChannelName = [NSString stringWithUTF8String:channelName];
+        NSString *objectiveCMessage = [NSString stringWithUTF8String:msg];
+
+        if ([objectiveCChannelName isEqualToString:SYSTEM_CHANNEL]) {
+            [NodeRunner handleSystemChannelMessage:objectiveCMessage];
+        }
+        if (_messageHandler) {
+            _messageHandler(objectiveCChannelName, objectiveCMessage);
+        }
+    }
+}
+
+@implementation NodeRunner
+
++ (void)registerDataDirPath:(NSString *)path {
+    capacitor_register_node_data_dir_path([path UTF8String]);
+}
+
++ (void)sendMessage:(NSString *)channelName message:(NSString *)message {
+    capacitor_bridge_notify([channelName UTF8String], [message UTF8String]);
+}
+
++ (void)setMessageHandler:(NodeRunnerMessageHandler)handler {
+    _messageHandler = handler;
+}
+
++ (void)handleSystemChannelMessage:(NSString *)msg {
+    if ([msg hasPrefix:@"release-pause-event"]) {
+        // The Node.js engine has signaled it has finished handling a pause event.
+        // The expected format for this message is "release-pause-event|{eventId}".
+        NSArray *eventArguments = [msg componentsSeparatedByString:@"|"];
+        if (eventArguments.count >= 2) {
+            [NodeRunner releasePauseEvent:eventArguments[1]];
+        }
+    } else if ([msg isEqualToString:@"ready-for-app-events"]) {
+        nodeIsReadyForAppEvents = true;
+    }
+}
+
++ (void)onPause {
+    if (!nodeIsReadyForAppEvents) {
+        return;
+    }
+    UIApplication *application = [UIApplication sharedApplication];
+    // Inform the app intends to run something in the background. In this
+    // case we'll try to wait for the pause event to be properly taken
+    // care of by the Node.js engine.
+    __block UIBackgroundTaskIdentifier backgroundWaitForPauseHandlerTask = [application beginBackgroundTaskWithExpirationHandler:^{
+        // Expiration handler to avoid app crashes if the task doesn't end
+        // in the iOS allowed background duration time.
+        [application endBackgroundTask:backgroundWaitForPauseHandlerTask];
+        backgroundWaitForPauseHandlerTask = UIBackgroundTaskInvalid;
+    }];
+
+    NSTimeInterval intendedMaxDuration = [application backgroundTimeRemaining] + 1;
+    // Calls the event in a background thread, to let the
+    // UIApplicationDidEnterBackgroundNotification return as soon as possible.
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSDate *targetMaximumFinishTime = [[NSDate date] dateByAddingTimeInterval:intendedMaxDuration];
+        [NodeRunner sendPauseEventAndWaitForRelease:targetMaximumFinishTime];
+        [application endBackgroundTask:backgroundWaitForPauseHandlerTask];
+        backgroundWaitForPauseHandlerTask = UIBackgroundTaskInvalid;
+    });
+}
+
++ (void)onResume {
+    if (!nodeIsReadyForAppEvents) {
+        return;
+    }
+    [NodeRunner sendMessage:SYSTEM_CHANNEL message:@"resume"];
+}
+
+// Sends the pause event to the Node.js engine and returns only after the
+// engine signals the event has been handled explicitly or the background
+// time is running out.
++ (void)sendPauseEventAndWaitForRelease:(NSDate *)expectedFinishTime {
+    NSString *eventId = [[NSUUID UUID] UUIDString];
+    NSString *event = [NSString stringWithFormat:@"pause|%@", eventId];
+
+    [appEventBeingProcessedCondition lock];
+
+    @synchronized(appPauseEventsManagerSetLock) {
+        [appPauseEventsManagerSet addObject:eventId];
+    }
+
+    [NodeRunner sendMessage:SYSTEM_CHANNEL message:event];
+
+    while (YES) {
+        // Looping to avoid unintended spurious wake ups.
+        @synchronized(appPauseEventsManagerSetLock) {
+            if (![appPauseEventsManagerSet containsObject:eventId]) {
+                // The id for this event has been released.
+                break;
+            }
+        }
+        if ([expectedFinishTime timeIntervalSinceNow] <= 0) {
+            // We blocked the background thread long enough.
+            break;
+        }
+        [appEventBeingProcessedCondition waitUntilDate:expectedFinishTime];
+    }
+    [appEventBeingProcessedCondition unlock];
+
+    @synchronized(appPauseEventsManagerSetLock) {
+        [appPauseEventsManagerSet removeObject:eventId];
+    }
+}
+
+// Signals the pause event has been handled by the Node.js side.
++ (void)releasePauseEvent:(NSString *)eventId {
+    [appEventBeingProcessedCondition lock];
+    @synchronized(appPauseEventsManagerSetLock) {
+        [appPauseEventsManagerSet removeObject:eventId];
+    }
+    [appEventBeingProcessedCondition broadcast];
+    [appEventBeingProcessedCondition unlock];
+}
+
+// Node's libuv requires all arguments being on contiguous memory.
++ (void)startEngineWithArguments:(NSArray<NSString *> *)arguments nodePath:(NSString *)nodePath {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        appEventBeingProcessedCondition = [[NSCondition alloc] init];
+        appPauseEventsManagerSet = [[NSMutableSet alloc] init];
+        appPauseEventsManagerSetLock = [[NSObject alloc] init];
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[NSNotificationCenter defaultCenter] addObserver:[NodeRunner class]
+                                                     selector:@selector(onPause)
+                                                         name:UIApplicationDidEnterBackgroundNotification
+                                                       object:nil];
+            [[NSNotificationCenter defaultCenter] addObserver:[NodeRunner class]
+                                                     selector:@selector(onResume)
+                                                         name:UIApplicationWillEnterForegroundNotification
+                                                       object:nil];
+        });
+    });
+
+    setenv("NODE_PATH", [nodePath UTF8String], 1);
+
+    int c_arguments_size = 0;
+
+    // Compute the byte size needed for all arguments in contiguous memory.
+    for (id argElement in arguments) {
+        c_arguments_size += strlen([argElement UTF8String]);
+        c_arguments_size++; // for '\0'
+    }
+
+    // Store the arguments in contiguous memory.
+    char *args_buffer = (char *)calloc(c_arguments_size, sizeof(char));
+
+    // The argv to pass into Node.js.
+    char *argv[[arguments count]];
+
+    // Iterate through the expected start position of each argument in args_buffer.
+    char *current_args_position = args_buffer;
+
+    int argument_count = 0;
+
+    // Populate the args_buffer and argv.
+    for (id argElement in arguments) {
+        const char *current_argument = [argElement UTF8String];
+
+        // Copy the current argument to its expected position in args_buffer.
+        strncpy(current_args_position, current_argument, strlen(current_argument));
+
+        // Save the current argument start position in argv and increment argc.
+        argv[argument_count] = current_args_position;
+        argument_count++;
+
+        // Increment to the next argument's expected position.
+        current_args_position += strlen(current_args_position) + 1;
+    }
+
+    capacitor_register_bridge_cb(rcv_message);
+
+    // Start Node.js, with argc and argv. This call blocks until the
+    // Node.js event loop exits.
+    node_start(argument_count, argv);
+}
+
+@end