@capawesome/capacitor-nodejs 0.0.1

package/ios/PluginNative/bridge.cpp

@@ -0,0 +1,225 @@
+/*
+  Implements the bridge APIs between the plugin's native layer and the
+  Node.js engine.
+
+  Based on the bridge of the `nodejs-mobile-react-native` project
+  (MIT licensed, https://github.com/nodejs-mobile/nodejs-mobile-react-native).
+*/
+#include "node.h"
+#include "uv.h"
+#include "bridge.h"
+
+#include <map>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <cstring>
+#include <cstdlib>
+
+void FlushMessageQueue(uv_async_t* handle);
+class Channel;
+
+std::mutex channelsMutex;
+std::map<std::string, Channel*> channels;
+
+/**
+ * Channel class. Messages sent from the native layer to the Node.js
+ * engine are queued per channel and delivered on the main libuv loop
+ * thread.
+ */
+class Channel {
+private:
+    v8::Isolate* isolate = nullptr;
+    v8::Persistent<v8::Function> function;
+    uv_async_t* queue_uv_handle = nullptr;
+    std::mutex uvhandleMutex;
+    std::mutex queueMutex;
+    std::queue<char*> messageQueue;
+    std::string name;
+    bool initialized = false;
+
+public:
+    Channel(std::string name) : name(name) {};
+
+    // Set up the channel's V8 data. This method can be called
+    // only once per channel.
+    void setV8Function(v8::Isolate* isolate, v8::Local<v8::Function> func) {
+        this->isolate = isolate;
+        this->function.Reset(isolate, func);
+        this->uvhandleMutex.lock();
+        if (this->queue_uv_handle == nullptr) {
+            this->queue_uv_handle = (uv_async_t*)malloc(sizeof(uv_async_t));
+            uv_async_init(uv_default_loop(), this->queue_uv_handle, FlushMessageQueue);
+            this->queue_uv_handle->data = (void*)this;
+            initialized = true;
+            uv_async_send(this->queue_uv_handle);
+        } else {
+            isolate->ThrowException(v8::Exception::TypeError(
+                v8::String::NewFromUtf8(isolate, "Channel already exists.").ToLocalChecked()
+            ));
+        }
+        this->uvhandleMutex.unlock();
+    };
+
+    // Add a new message to the channel's queue and notify libuv to
+    // call us back to do the actual message delivery.
+    void queueMessage(char* msg) {
+        this->queueMutex.lock();
+        this->messageQueue.push(msg);
+        this->queueMutex.unlock();
+
+        if (initialized) {
+            uv_async_send(this->queue_uv_handle);
+        }
+    };
+
+    // Process one message at the time, to simplify synchronization
+    // between threads and minimize lock retention.
+    void flushQueue() {
+        char* message = nullptr;
+        bool empty = true;
+
+        this->queueMutex.lock();
+        if (!(this->messageQueue.empty())) {
+            message = this->messageQueue.front();
+            this->messageQueue.pop();
+            empty = this->messageQueue.empty();
+        }
+        this->queueMutex.unlock();
+
+        if (message != nullptr) {
+            this->invokeNodeListener(message);
+            free(message);
+        }
+
+        if (!empty) {
+            uv_async_send(this->queue_uv_handle);
+        }
+    };
+
+    // Calls into Node.js to execute the registered listener.
+    // This method is always executed on the main libuv loop thread.
+    void invokeNodeListener(char* msg) {
+        v8::HandleScope scope(isolate);
+
+        v8::Local<v8::Function> node_function = v8::Local<v8::Function>::New(isolate, function);
+        v8::Local<v8::Value> global = isolate->GetCurrentContext()->Global();
+
+        v8::Local<v8::String> channel_name = v8::String::NewFromUtf8(isolate, this->name.c_str(), v8::NewStringType::kNormal).ToLocalChecked();
+        v8::Local<v8::String> message = v8::String::NewFromUtf8(isolate, msg, v8::NewStringType::kNormal).ToLocalChecked();
+
+        const int argc = 2;
+        v8::Local<v8::Value> argv[argc] = { channel_name, message };
+
+        v8::MaybeLocal<v8::Value> result = node_function->Call(isolate->GetCurrentContext(), global, argc, argv);
+        (void)result;
+    };
+};
+
+char* datadir_path = nullptr;
+
+void capacitor_register_node_data_dir_path(const char* path) {
+    size_t pathLength = strlen(path);
+    datadir_path = (char*)calloc(sizeof(char), pathLength + 1);
+    strncpy(datadir_path, path, pathLength);
+}
+
+capacitor_bridge_cb embedder_callback = nullptr;
+
+void capacitor_register_bridge_cb(capacitor_bridge_cb cb) {
+    embedder_callback = cb;
+}
+
+Channel* GetOrCreateChannel(std::string channelName) {
+    channelsMutex.lock();
+    Channel* channel = nullptr;
+    auto it = channels.find(channelName);
+    if (it != channels.end()) {
+        channel = it->second;
+    } else {
+        channel = new Channel(channelName);
+        channels[channelName] = channel;
+    }
+    channelsMutex.unlock();
+    return channel;
+};
+
+void FlushMessageQueue(uv_async_t* handle) {
+    Channel* channel = (Channel*)handle->data;
+    channel->flushQueue();
+}
+
+void Method_RegisterChannel(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() != 2) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Wrong number of arguments.").ToLocalChecked()
+        ));
+        return;
+    }
+
+    v8::String::Utf8Value channel_name(isolate, args[0]);
+    std::string channel_name_str(*channel_name);
+
+    if (!args[1]->IsFunction()) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Expected a function.").ToLocalChecked()
+        ));
+        return;
+    }
+
+    v8::Local<v8::Function> listener = v8::Local<v8::Function>::Cast(args[1]);
+
+    Channel* channel = GetOrCreateChannel(channel_name_str);
+    channel->setV8Function(isolate, listener);
+}
+
+void Method_SendMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Isolate* isolate = args.GetIsolate();
+    if (args.Length() != 2) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Wrong number of arguments.").ToLocalChecked()
+        ));
+        return;
+    }
+
+    v8::String::Utf8Value channel_name(isolate, args[0]);
+    std::string channel_name_str(*channel_name);
+
+    v8::String::Utf8Value message(isolate, args[1]);
+    std::string message_str(*message);
+
+    if (embedder_callback) {
+        embedder_callback(channel_name_str.c_str(), message_str.c_str());
+    }
+}
+
+void Method_GetDataDir(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Isolate* isolate = args.GetIsolate();
+    if (datadir_path == nullptr) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "Data directory not set from native side.").ToLocalChecked()
+        ));
+        return;
+    }
+
+    v8::Local<v8::String> return_datadir = v8::String::NewFromUtf8(isolate, datadir_path, v8::NewStringType::kNormal).ToLocalChecked();
+    args.GetReturnValue().Set(return_datadir);
+}
+
+void Init(v8::Local<v8::Object> exports) {
+    NODE_SET_METHOD(exports, "sendMessage", Method_SendMessage);
+    NODE_SET_METHOD(exports, "registerChannel", Method_RegisterChannel);
+    NODE_SET_METHOD(exports, "getDataDir", Method_GetDataDir);
+}
+
+void capacitor_bridge_notify(const char* channelName, const char* message) {
+    size_t messageLength = strlen(message);
+    char* messageCopy = (char*)calloc(sizeof(char), messageLength + 1);
+    strncpy(messageCopy, message, messageLength);
+
+    Channel* channel = GetOrCreateChannel(std::string(channelName));
+    channel->queueMessage(messageCopy);
+}
+
+NODE_MODULE_LINKED(capacitor_bridge, Init)

package/ios/PluginNative/bridge.h

@@ -0,0 +1,15 @@
+/*
+  Bridge APIs between the plugin's native layer and the Node.js engine.
+
+  Based on the bridge of the `nodejs-mobile-react-native` project
+  (MIT licensed, https://github.com/nodejs-mobile/nodejs-mobile-react-native).
+*/
+#ifndef CAPACITOR_NODEJS_BRIDGE_H_
+#define CAPACITOR_NODEJS_BRIDGE_H_
+
+typedef void (*capacitor_bridge_cb)(const char* channelName, const char* message);
+void capacitor_register_bridge_cb(capacitor_bridge_cb cb);
+void capacitor_bridge_notify(const char* channelName, const char* message);
+void capacitor_register_node_data_dir_path(const char* path);
+
+#endif // CAPACITOR_NODEJS_BRIDGE_H_

package/ios/PluginNative/include/NodeRunner.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+
+typedef void (^NodeRunnerMessageHandler)(NSString *_Nonnull channelName, NSString *_Nonnull message);
+
+@interface NodeRunner : NSObject
+
++ (void)registerDataDirPath:(NSString *_Nonnull)path;
++ (void)sendMessage:(NSString *_Nonnull)channelName message:(NSString *_Nonnull)message;
++ (void)setMessageHandler:(NodeRunnerMessageHandler _Nonnull)handler;
++ (void)startEngineWithArguments:(NSArray<NSString *> *_Nonnull)arguments nodePath:(NSString *_Nonnull)nodePath;
+
+@end

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@capawesome/capacitor-nodejs",
+  "version": "0.0.1",
+  "description": "Capacitor plugin for running Node.js in mobile apps.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "android/CMakeLists.txt",
+    "dist/",
+    "ios/Plugin/",
+    "ios/PluginNative/",
+    "scripts/",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "homepage": "https://capawesome.io/docs/plugins/nodejs/",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "node scripts/postinstall.js && xcodebuild -scheme CapawesomeCapacitorNodejs -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api NodejsPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "postinstall": "node scripts/postinstall.js",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "eslint": "8.57.0",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,109 @@
+/**
+ * Downloads the Node.js for Mobile Apps iOS artifacts (NodeMobile.xcframework
+ * and the Node.js headers) into `ios/libnode`. The Android artifacts are
+ * downloaded by the Gradle build (see `android/build.gradle`).
+ *
+ * Environment variables:
+ * - `CAPACITOR_NODEJS_SKIP_DOWNLOAD`: Set to `1` to skip the download.
+ * - `CAPACITOR_NODEJS_IOS_URL`: Overwrite the download URL.
+ * - `CAPACITOR_NODEJS_IOS_SHA256`: Overwrite the checksum of the download.
+ */
+const { execFileSync } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+
+const version = '18.20.4-capawesome.1';
+const url =
+  process.env.CAPACITOR_NODEJS_IOS_URL ||
+  `https://github.com/capawesome-team/nodejs-mobile/releases/download/v${version}/nodejs-mobile-v${version}-ios.zip`;
+const sha256 =
+  process.env.CAPACITOR_NODEJS_IOS_SHA256 ||
+  '8c5ca3a0d1e38de7f182a5642593e82593b820efd375a14b3ecafc4bcfee620e';
+
+const libnodeDir = path.join(__dirname, '..', 'ios', 'libnode');
+const cacheDir = path.join(
+  os.homedir(),
+  '.cache',
+  'capawesome-capacitor-nodejs',
+);
+const zipFile = path.join(cacheDir, `nodejs-mobile-v${version}-ios.zip`);
+
+function download(downloadUrl, targetFile, redirectCount = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirectCount > 5) {
+      reject(new Error('Too many redirects.'));
+      return;
+    }
+    https
+      .get(downloadUrl, response => {
+        if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          response.resume();
+          resolve(
+            download(response.headers.location, targetFile, redirectCount + 1),
+          );
+          return;
+        }
+        if (response.statusCode !== 200) {
+          reject(
+            new Error(
+              `Download failed with status code ${response.statusCode}.`,
+            ),
+          );
+          return;
+        }
+        const fileStream = fs.createWriteStream(targetFile);
+        response.pipe(fileStream);
+        fileStream.on('finish', () => fileStream.close(resolve));
+        fileStream.on('error', reject);
+      })
+      .on('error', reject);
+  });
+}
+
+function calculateSha256(file) {
+  const hash = crypto.createHash('sha256');
+  hash.update(fs.readFileSync(file));
+  return hash.digest('hex');
+}
+
+async function run() {
+  if (process.env.CAPACITOR_NODEJS_SKIP_DOWNLOAD === '1') {
+    return;
+  }
+  if (process.platform !== 'darwin') {
+    return;
+  }
+  if (
+    fs.existsSync(path.join(libnodeDir, 'NodeMobile.xcframework')) &&
+    fs.existsSync(path.join(libnodeDir, 'include'))
+  ) {
+    return;
+  }
+  fs.mkdirSync(cacheDir, { recursive: true });
+  if (!fs.existsSync(zipFile) || calculateSha256(zipFile) !== sha256) {
+    console.log(`Downloading Node.js for Mobile Apps from ${url}...`);
+    await download(url, zipFile);
+  }
+  const actualSha256 = calculateSha256(zipFile);
+  if (actualSha256 !== sha256) {
+    fs.rmSync(zipFile);
+    throw new Error(
+      `Checksum verification failed for ${zipFile}. Expected ${sha256} but got ${actualSha256}.`,
+    );
+  }
+  fs.rmSync(libnodeDir, { recursive: true, force: true });
+  fs.mkdirSync(libnodeDir, { recursive: true });
+  execFileSync('unzip', ['-q', zipFile, '-d', libnodeDir]);
+}
+
+run().catch(error => {
+  console.error(error.message || error);
+  process.exit(1);
+});