J2V8 | Java Bindings for V8 | Game Engine library

1. Server Side Integration:
   • Server side module for retrieving the JavaScript modules in the System and to provide code completion per imported module: dirigible/ide-monaco-extensions
   • Acorn.js Dirigible module: acorn/acornjs
   • Suggestions parser:

GraalVM's JavaScript can be used as a library with the dependencies obtained as any Maven artifact. While the recommended way to run it is to use the GraalVM distribution, there are some explanations how to run it on OpenJDK.

You can restrict things script should have access to, like Java classes, creating threads, etc:

From the documentation:

Try this :

V8 Engine can execute only pure javascript. But you mimic the same, by registering setTimeout method in the engine, when you get the call for this function, you can schedule. like following. But you have to use Executors.newSingleThreadScheduledExecutor()

For Android Studio project, either library .aar or application .apk, during the build process, there is a step stripping the debug symbols of dynamic shared libs, i.e. the .so.

If you want to keep all the symbols un-removed, then you can add below configuration into your build.gradle.

If the question is still relevant - I have created j2v8-debugger library.

It allows debugging J2V8 using Chrome DevTools.

Basic features like setting/removing breakpoints, step into, step out and step over, variables inspection, etc. are implemented.

It uses Stetho lib for communication with Chrome DevTools.

Also it's uses DebugHandler for accessing V8 debug information.

Hope it could be helpful.

Since no one is going to discuss this topic, i'll answer myself. This feature is not currently considered to be added in official J2V8 release, however there is a branch on Mizumi's pull request. So, have a look, if you've faced similar issues.

I received an answer from @dna2github, the creator of NodeBase (thanks a lot!) that I'll include here (with permission):

Hi,

Thx for your question. I will do a brief answer in my view.

pros:

• integrated with Java world; can get full control of code.

cons:

• a little hard to integrate with 3rd packages (need time to learn how).
• need to learn about NodeJS and V8 things and also J2V8 docs (it consume long time).

pros:

• focus on js dev and no need to consider android side.
• less learning time; similar to Cordova phonegap ....

cons:

• js app => apk is a black box.

pros:

• flexible

cons:

• no gui

Not familar with LiquidCore; build micro service especially from url, I think, is to resolve no direct available storage on iOS. react-native-node the Android part is based on NodeBase method and use the prebuilt binary.

For NodeBase:

pros:

• similar to 3; difference is that it has its own gui to start/stop app.
• it can be a template for everything; for example, if would like to run django, you just need to replace node to python; rails, ruby...

cons:

• native process access problem; the process cannot inherit access from Android app.
• happy toy happy open source not like a commercial app; need more design if want to distribute to customers

At first, I run node in terminal; I find only dev can easily to use it to start js app. My friends and families also wanna some tools for example make water mark on picture in batch. NodeBase is created for them to easy to start/stop app. Then they just need to open browser to use it. My another idea to create NodeBase is that we can build sharable applications that can be shared in the same Wi-Fi. When host starts an app, it can be visited by near people. Then they can work and play together. For example, we play werewolf and when there is no judge, we will start the werewolf app to have a judge for the first round. We can also share files between devices via download/upload.

For me, I can build what I want flexibly for example, I would like to make my Android as a machine learning runner; it can help me run machine learning programs at anytime (with node and python, thus in my another repo: dna2oslab is focus on building binaries) to make use of phone running time.

For you, if wanna port your app in a short time, I recommend 2; if you have time and other resources, 1 is better. 3 if you just make a toy/demo. 4 other is always possible and just do your imagination to create works.

Best wishes, Seven

The corda.jar is the node JAR that your applications are intended to run on/against and it isn't intended to be modified for apps.

Your own CorDapp JAR should be generated automatically by the "jar" task if you're applying the correct gradle plugin (cordformation for V1, cordapp for later versions). This JAR will be on the classpath and contain all of the files in your resources directory. For example "src/main/resources/js_library" will be available in the root of the CorDapp JAR and can be accessed directly during runtime from the classloader of any of the classes in your CorDapp. See the answer here to learn how to access files within a JAR.