Apertus
HomeForumBlogGitHub repository
Search…
Documentation
Introduction
Definitions
Features
Developers
Development Cycle
Architecture
API
Getting Started
Contribute
Report a Bug
Suggest a Feature
Tutorial - How to visualize CAD models in VR
Introduction
Import CAD Models
Convert CAD Models
Create Low-poly from CAD Models
Create Photorealistic CAD Models
Plugins - Photorealistic Render
Plugins - Physics
Tutorial - How to visualize Tensorflow training in VR
Tutorial - Virtual Learning Factory Toolkit Gamification
Overview
Introduction
Architecture
Use Cases
Installation
Windows
Android
MacOS
Build
Windows
Android
MacOS
Plugins on Windows
Photorealistic Render
Physics
Plugins on Android
Java Native Interface
How to use
Extending the API
Filament render
Plugins on MacOS
Untitled
Samples on Windows
Deep learning
Virtual Learning Factory Toolkit Gamification
Virtual Learning Factory Toolkit Gamification 2
Powered By GitBook
Java Native Interface
This chapter introduces the JNI-Plugin, which is responsible for supporting the Java when using the ApertusVR library, and is used by the Android apps to cooperate with ApertusVR.

The Java Native Interface

The Java Native Interface (JNI) is a native language support, which allows Java code (running on JVM) to interoperate with applications and libraries written in C and C++. JNI provides a one-way access to call C/C++ functions from Java. Therefore it helps to use ApertusVR's features from Java codes, which is indispensably important, when programming on Android.
To learn more about the JNI interface see the official documentation on Oracle's website. For an easy to follow tutorial check NTU Signapore's guide.

Overview of the plugin

ApertusVR uses the JNI language support as a plugin, which helps distribute the events, and implements wrapper functionality for ApertusVR entities. The JNI-plugin consists of three layers:
    1.
    The C++ layer (apeJNIPlugin shared library)
    2.
    Java static native functions (ApertusJNI.java)
    3.
    Wrapper classes (ape<CppClassName>.java)

1. The C++ layer

This layer is an ordinary ape::IPlugin implementation, which gather the events into its event queue, then when somebody calls the appropriate function in Java (ApertusJNI.processEventDoubleQueue()), the plugin fires the events on the Java side, using the JNI's callback possibilities.

2. ApertusJNI

This is a static Java class, which contains the Java "headers" of the C++ JNI functions, and everything else needed to use the plugin in Java.

3. Wrapper classes

For each subclass of ape::Entity in ApertusVR, there is a corresponding Java class (the ape::Entity is also included), which provides an interface to access, query, and modify an object on the C++ side. These wrapper classes contains only a String, and a apeEntity.Type member variables, which makes it available to identify the entity related to the interface object. Then it calls the static nativefunctions in ApertusJNI, to access the entity in C++.
​
Previous
Demo video
Next
How to use
Last modified 1yr ago
Copy link
Contents
The Java Native Interface
Overview of the plugin