com.jogamp.common.jvm

## Class JNILibLoaderBase

- java.lang.Object
- - com.jogamp.common.jvm.JNILibLoaderBase

-     public class JNILibLoaderBase
      extends Object

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `JNILibLoaderBase.LoaderAction`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static boolean` | `DEBUG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JNILibLoaderBase()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `addLoaded(String libName)`
    `static boolean` | `addNativeJarLibs(Class<?>[] classesFromJavaJars, String singleJarMarker)` Loads and adds a JAR file's native library to the TempJarCache. The native library JAR file's URI is derived as follows: [1] `GLProfile.class` -> [2] `http://lala/gluegen-rt.jar` -> [3] `http://lala/gluegen-rt` -> [4] `http://lala/gluegen-rt-natives-'os.and.arch'.jar` Where: [1] is one of `classesFromJavaJars` [2] is it's complete URI [3] is it's base URI [4] is the derived native JAR filename
    `static boolean` | `addNativeJarLibsJoglCfg(Class<?>[] classesFromJavaJars)` Loads and adds a JAR file's native library to the TempJarCache, calling `addNativeJarLibs(Class[], String)` with default JOGL deployment configuration:
    `static void` | `disableLoading()`
    `static void` | `enableLoading()`
    `static boolean` | `isLoaded(String libName)`
    `protected static boolean` | `loadLibrary(String libname, boolean ignoreError, ClassLoader cl)` Loads the library specified by libname, using the `JNILibLoaderBase.LoaderAction` set by `setLoadingAction(LoaderAction)`. The implementation should ignore, if the library has been loaded already.
    `protected static void` | `loadLibrary(String libname, String[] preload, boolean preloadIgnoreError, ClassLoader cl)` Loads the library specified by libname, using the `JNILibLoaderBase.LoaderAction` set by `setLoadingAction(LoaderAction)`. Optionally preloads the libraries specified by preload. The implementation should ignore, if any library has been loaded already.
    `static void` | `setLoadingAction(JNILibLoaderBase.LoaderAction action)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### DEBUG

          public static final boolean DEBUG

  - ### Constructor Detail

    - #### JNILibLoaderBase

          public JNILibLoaderBase()

  - ### Method Detail

    - #### isLoaded

          public static boolean isLoaded(String libName)

    - #### addLoaded

          public static void addLoaded(String libName)

    - #### disableLoading

          public static void disableLoading()

    - #### enableLoading

          public static void enableLoading()

    - #### setLoadingAction

          public static void setLoadingAction(JNILibLoaderBase.LoaderAction action)

    - #### addNativeJarLibsJoglCfg

          public static final boolean addNativeJarLibsJoglCfg(Class<?>[] classesFromJavaJars)

      Loads and adds a JAR file's native library to the TempJarCache, calling `addNativeJarLibs(Class[], String)` with default JOGL deployment configuration:

                  return JNILibLoaderBase.addNativeJarLibs(classesFromJavaJars, "-all");

      If `Class1.class` is contained in a JAR file which name includes `singleJarMarker` -all, implementation will attempt to resolve the native JAR file as follows:
      - ClassJar-all.jar to ClassJar-all-natives-os.and.arch.jar
      Otherwise the native JAR files will be resolved for each class's JAR file:
      - ClassJar1.jar to ClassJar1-natives-os.and.arch.jar
      - ClassJar2.jar to ClassJar2-natives-os.and.arch.jar
      - ..

    - #### addNativeJarLibs

          public static boolean addNativeJarLibs(Class<?>[] classesFromJavaJars,
                                 String singleJarMarker)

      Loads and adds a JAR file's native library to the TempJarCache.
      The native library JAR file's URI is derived as follows:
      - [1] `GLProfile.class` ->
      - [2] `http://lala/gluegen-rt.jar` ->
      - [3] `http://lala/gluegen-rt` ->
      - [4] `http://lala/gluegen-rt-natives-'os.and.arch'.jar`
      Where:
      - [1] is one of `classesFromJavaJars`
      - [2] is it's complete URI
      - [3] is it's base URI
      - [4] is the derived native JAR filename

      Generic description:

                 final Class[] classesFromJavaJars = new Class[] { Class1.class, Class2.class };
                 JNILibLoaderBase.addNativeJarLibs(classesFromJavaJars, "-all");

      If `Class1.class` is contained in a JAR file which name includes `singleJarMarker`, here -all, implementation will attempt to resolve the native JAR file as follows:
      - ClassJar-all.jar to ClassJar-all-natives-os.and.arch.jar
      Otherwise the native JAR files will be resolved for each class's JAR file:
      - Class1Jar.jar to Class1Jar-natives-os.and.arch.jar
      - Class2Jar.jar to Class2Jar-natives-os.and.arch.jar

      Examples:

      JOCL:

                  // only: jocl.jar -> jocl-natives-os.and.arch.jar
                  addNativeJarLibs(new Class[] { JOCLJNILibLoader.class }, null, null );

      JOGL:

                 final ClassLoader cl = GLProfile.class.getClassLoader();
                 // jogl-all.jar         -> jogl-all-natives-os.and.arch.jar
                 // jogl-all-noawt.jar   -> jogl-all-noawt-natives-os.and.arch.jar
                 // jogl-all-mobile.jar  -> jogl-all-mobile-natives-os.and.arch.jar
                 // jogl-all-android.jar -> jogl-all-android-natives-os.and.arch.jar
                 // nativewindow.jar     -> nativewindow-natives-os.and.arch.jar
                 // jogl.jar             -> jogl-natives-os.and.arch.jar
                 // newt.jar             -> newt-natives-os.and.arch.jar (if available)
                 final String newtFactoryClassName = "com.jogamp.newt.NewtFactory";
                 final Class[] classesFromJavaJars = new Class[] { NWJNILibLoader.class, GLProfile.class, null };
                 if( ReflectionUtil.isClassAvailable(newtFactoryClassName, cl) ) {
                     classesFromJavaJars[2] = ReflectionUtil.getClass(newtFactoryClassName, false, cl);
                 }
                 JNILibLoaderBase.addNativeJarLibs(classesFromJavaJars, "-all");

      Parameters:
        `classesFromJavaJars` - For each given Class, load the native library JAR.
        `singleJarMarker` - Optional string marker like "-all" to identify the single 'all-in-one' JAR file after which processing of the class array shall stop.
      Returns:
        true if either the 'all-in-one' native JAR or all native JARs loaded successful or were loaded already, false in case of an error

    - #### loadLibrary

          protected static boolean loadLibrary(String libname,
                            boolean ignoreError,
                            ClassLoader cl)

      Loads the library specified by libname, using the `JNILibLoaderBase.LoaderAction` set by `setLoadingAction(LoaderAction)`.
      The implementation should ignore, if the library has been loaded already.
      Parameters:
        `libname` - the library to load
        `ignoreError` - if true, errors during loading the library should be ignored
        `cl` - optional ClassLoader, used to locate the library
      Returns:
        true if library loaded successful

    - #### loadLibrary

          protected static void loadLibrary(String libname,
                         String[] preload,
                         boolean preloadIgnoreError,
                         ClassLoader cl)

      Loads the library specified by libname, using the `JNILibLoaderBase.LoaderAction` set by `setLoadingAction(LoaderAction)`.
      Optionally preloads the libraries specified by preload.
      The implementation should ignore, if any library has been loaded already.
      Parameters:
        `libname` - the library to load
        `preload` - the libraries to load before loading the main library if not null
        `preloadIgnoreError` - if true, errors during loading the preload-libraries should be ignored
        `cl` - optional ClassLoader, used to locate the library