nodeJavaBridge.js

"use strict";

process.env.PATH += require("../build/jvm_dll_path.json");

const path = require("path");
const fs = require("fs");
const util = require("util");

let binaryPath = null;
try {
  if (fs.statSync && fs.statSync(path.join(__dirname, "../build/Debug/nodejavabridge_bindings.node")).isFile()) {
    binaryPath = path.resolve(path.join(__dirname, "../build/Debug/nodejavabridge_bindings.node"));
    console.log("****** NODE-JAVA RUNNING IN DEBUG MODE ******");
  }
} catch (_err) {
  // do nothing fs.statSync just couldn't find the file
}
if (!binaryPath) {
  binaryPath = path.resolve(path.join(__dirname, "../build/Release/nodejavabridge_bindings.node"));
}
const bindings = require(binaryPath);

const java = (module.exports = new bindings.Java());
java.promisify = util.promisify;
java.classpath.push(path.resolve(__dirname, "../src-java/commons-lang3-node-java.jar"));
java.classpath.push(path.resolve(__dirname, __dirname, "../src-java"));
java.classpath.pushDir = function (dir) {
  fs.readdirSync(dir).forEach(function (file) {
    java.classpath.push(path.resolve(dir, file));
  });
};
java.nativeBindingLocation = binaryPath;

const callStaticMethod = java.callStaticMethod;
const callStaticMethodSync = java.callStaticMethodSync;
const newInstanceSync = java.newInstanceSync;

let syncSuffix = undefined;
let asyncSuffix = undefined;
let ifReadOnlySuffix = "_";

const SyncCall = function (obj, method) {
  if (syncSuffix === undefined) {
    throw new Error("Sync call made before jvm created");
  }
  const syncMethodName = method + syncSuffix;
  if (syncMethodName in obj) {
    return obj[syncMethodName].bind(obj);
  } else {
    throw new Error("Sync method not found:" + syncMethodName);
  }
};

java.isJvmCreated = function () {
  return typeof java.onJvmCreated !== "function";
};

const clients = [];

// We provide two methods for 'clients' of node-java to 'register' their use of java.
// By registering, a client gets the opportunity to be called asynchronously just before the JVM is created,
// and just after the JVM is created. The before hook function will typically be used to add to java.classpath.
// The function may peform asynchronous operations, such as async [glob](https://github.com/isaacs/node-glob)
// resolutions of wild-carded file system paths, and then notify when it has finished via either calling
// a node-style callback function, or by resolving a promise.

// A client can register function hooks to be called before and after the JVM is created.
// If the client doesn't need to be called back for either function, it can pass null or undefined.
// Both before and after here are assumed to be functions that accept one argument that is a node-callback function.
java.registerClient = function (before, after) {
  if (java.isJvmCreated()) {
    throw new Error("java.registerClient() called after JVM already created.");
  }
  const before_ =
    before && before.length === 0
      ? function (cb) {
          before();
          cb();
        }
      : before;

  const after_ =
    after && after.length === 0
      ? function (cb) {
          after();
          cb();
        }
      : after;

  clients.push({ before: before_, after: after_ });
};

// A client can register function hooks to be called before and after the JVM is created.
// If the client doesn't need to be called back for either function, it can pass null or undefined.
// Both before and after here are assumed to be functions that return Promises/A+ `thenable` objects.
java.registerClientP = function (beforeP, afterP) {
  if (java.isJvmCreated()) {
    throw new Error("java.registerClient() called after JVM already created.");
  }
  clients.push({ beforeP: beforeP, afterP: afterP });
};

async function runBeforeHooks() {
  for (const client of clients) {
    if (client.before) {
      await new Promise((resolve, reject) => {
        client.before((err) => {
          if (err) {
            return reject(err);
          }
          return resolve();
        });
      });
    }
    if (client.beforeP) {
      await client.beforeP();
    }
  }
}

function createJVMAsync() {
  const _ignore = java.newLong(0); // called just for the side effect that it will create the JVM
}

async function runAfterHooks() {
  for (const client of clients) {
    if (client.after) {
      await new Promise((resolve, reject) => {
        client.after((err) => {
          if (err) {
            return reject(err);
          }
          return resolve();
        });
      });
    }
    if (client.afterP) {
      await client.afterP();
    }
  }
}

async function initializeAll() {
  await runBeforeHooks();
  createJVMAsync();
  await runAfterHooks();
}

// This function ensures that the JVM has been launched, asynchronously. The application can be notified
// when the JVM is fully created via either a node callback function, or via a promise.
// If the parameter `callback` is provided, it is assume be a node callback function.
// This function may be called multiple times -- the 2nd and subsequent calls are no-ops.
// However, once this method has been called (or the JVM is launched as a side effect of calling other java
// methods), then clients can no longer use the registerClient API.
java.ensureJvm = function (callback) {
  // First see if the promise-style API should be used.
  // This must be done first in order to ensure the proper API is used.
  if (typeof callback === "undefined") {
    // Create a promisified version of this function.
    const launchJvmPromise = util.promisify(java.ensureJvm.bind(java));
    // Call the promisified function, returning its result, which should be a promise.
    return launchJvmPromise();
  }

  // If we get here, callback must be a node-style callback function. If not, throw an error.
  else if (typeof callback !== "function") {
    throw new Error("java.launchJvm(cb) requires its one argument to be a callback function.");
  }

  // Now check if the JVM has already been created. If so, we assume that the jvm was already successfully
  // launched, and we can just implement idempotent behavior, i.e. silently notify that the JVM has been created.
  else if (java.isJvmCreated()) {
    return setImmediate(callback);
  }

  // Finally, queue the initializeAll function.
  else {
    return setImmediate(async () => {
      try {
        await initializeAll();
        callback();
      } catch (err) {
        callback(err);
      }
    });
  }
};

java.onJvmCreated = function () {
  if (java.asyncOptions) {
    syncSuffix = java.asyncOptions.syncSuffix;
    asyncSuffix = java.asyncOptions.asyncSuffix;
    if (typeof syncSuffix !== "string") {
      throw new Error("In asyncOptions, syncSuffix must be defined and must a string");
    }
    const promiseSuffix = java.asyncOptions.promiseSuffix;
    if (typeof promiseSuffix === "string") {
      const methods = ["newInstance", "callMethod", "callStaticMethod"];
      methods.forEach(function (name) {
        java[name + promiseSuffix] = util.promisify(java[name]);
      });
    }

    if (typeof java.asyncOptions.ifReadOnlySuffix === "string" && java.asyncOptions.ifReadOnlySuffix !== "") {
      ifReadOnlySuffix = java.asyncOptions.ifReadOnlySuffix;
    }
  } else {
    syncSuffix = "Sync";
    asyncSuffix = "";
  }
};

const MODIFIER_PUBLIC = 1;
const MODIFIER_STATIC = 8;

function isWritable(prop) {
  // If the property has no descriptor, or wasn't explicitly marked as not writable or not configurable, assume it is.
  // We check both desc.writable and desc.configurable, since checking desc.writable alone is not sufficient
  // (e.g. for either .caller or .arguments).
  // It may be that checking desc.configurable is sufficient, but the specification doesn't make this definitive,
  // and there is no harm in checking both.
  if (prop === "caller" || prop === "arguments") {
    return false;
  }

  const desc = Object.getOwnPropertyDescriptor(function () {}, prop) || {};
  return desc.writable !== false && desc.configurable !== false;
}

function usableName(name) {
  if (!isWritable(name)) {
    name = name + ifReadOnlySuffix;
  }
  return name;
}

java.import = function (name) {
  const clazz = java.findClassSync(name); // TODO: change to Class.forName when classloader issue is resolved.
  const result = function javaClassConstructorProxy() {
    const args = [name];
    for (let i = 0; i < arguments.length; i++) {
      args.push(arguments[i]);
    }
    return newInstanceSync.apply(java, args);
  };

  result.class = clazz;

  // copy static fields
  const fields = SyncCall(clazz, "getDeclaredFields")();
  for (let i = 0; i < fields.length; i++) {
    const modifiers = SyncCall(fields[i], "getModifiers")();
    if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) {
      const fieldName = SyncCall(fields[i], "getName")();
      const jsfieldName = usableName(fieldName);
      result.__defineGetter__(
        jsfieldName,
        function (name, fieldName) {
          return java.getStaticFieldValue(name, fieldName);
        }.bind(this, name, fieldName)
      );
      result.__defineSetter__(
        jsfieldName,
        function (name, fieldName, val) {
          java.setStaticFieldValue(name, fieldName, val);
        }.bind(this, name, fieldName)
      );
    }
  }

  let promiseSuffix;
  if (java.asyncOptions) {
    promiseSuffix = java.asyncOptions.promiseSuffix;
  }

  // copy static methods
  const methods = SyncCall(clazz, "getDeclaredMethods")();
  for (let i = 0; i < methods.length; i++) {
    const modifiers = SyncCall(methods[i], "getModifiers")();
    if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) {
      const methodName = SyncCall(methods[i], "getName")();

      if (typeof syncSuffix === "string") {
        const syncName = usableName(methodName + syncSuffix);
        result[syncName] = callStaticMethodSync.bind(java, name, methodName);
      }

      if (typeof asyncSuffix === "string") {
        const asyncName = usableName(methodName + asyncSuffix);
        result[asyncName] = callStaticMethod.bind(java, name, methodName);
      }

      if (typeof promiseSuffix === "string") {
        const promiseName = usableName(methodName + promiseSuffix);
        result[promiseName] = util.promisify(callStaticMethod.bind(java, name, methodName));
      }
    }
  }

  // copy static classes/enums
  const classes = SyncCall(clazz, "getDeclaredClasses")();
  for (let i = 0; i < classes.length; i++) {
    const modifiers = SyncCall(classes[i], "getModifiers")();
    if ((modifiers & MODIFIER_PUBLIC) === MODIFIER_PUBLIC && (modifiers & MODIFIER_STATIC) === MODIFIER_STATIC) {
      const className = SyncCall(classes[i], "getName")();
      const simpleName = SyncCall(classes[i], "getSimpleName")();
      Object.defineProperty(result, simpleName, {
        get: function (result, simpleName, className) {
          const c = java.import(className);

          // memoize the import
          const d = Object.getOwnPropertyDescriptor(result, simpleName);
          d.get = function (c) {
            return c;
          }.bind(null, c);
          Object.defineProperty(result, simpleName, d);

          return c;
        }.bind(this, result, simpleName, className),
        enumerable: true,
        configurable: true,
      });
    }
  }

  return result;
};