jogamp - Re: Initialising Joal

jogamp › joal

Re: Initialising Joal

Posted by TheLittleP on Apr 09, 2014; 1:58pm
URL: https://forum.jogamp.org/Initialising-Joal-tp4032105p4032132.html

Hi,

I will post my changes to JNILibLoaderBase below.

JNILibLoader goes progressively through a number of attempts to unpack the natives and load them. I presume the fat natives fail because of the mismatch in architecture.

However, as a last ditch attempt JNILibLoader searches the system path. This is the only place where I could determine the name of the native it is attempting to load.

during loadLibraryInternal and after the UnsatisfiedLinkError it enters mode 4.

At this point I determine the TempCache directory, the platform os & arch.
I query the posiblePaths to determine the file name of the native.

With this information I make a call to my ClassLoader with these 3 bits of information and if it finds the native it unpacks it to the temp cache location and returns true if successful.

if successful I load the native into the system and return success.

Its very hacky but it works.

The problem I have at the moment is that joal doesn't seem to get as far as the last ditch attempt to load its natives so I might try loading the joal natives as part of the course during gluegen load, which is currently remed out due to other testing, and when joal attempts to load its natives, if I have previously loaded them I will simply return successful and hope it works...

/*
* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistribution of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistribution in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* This software is provided "AS IS," without a warranty of any kind. ALL
* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
* MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
* ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
* DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use
* in the design, construction, operation or maintenance of any nuclear
* facility.
*
* Sun gratefully acknowledges that this software was originally authored
* and developed by Kenneth Bradley Russell and Christopher John Kline.
*/

package com.jogamp.common.jvm;

import com.arxary.load.iNativer;
import java.io.File;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import com.jogamp.common.os.NativeLibrary;
import com.jogamp.common.util.IOUtil;
import com.jogamp.common.util.JarUtil;
import com.jogamp.common.util.PropertyAccess;
import com.jogamp.common.util.cache.TempJarCache;

import jogamp.common.Debug;
import jogamp.common.os.PlatformPropsImpl;
import com.jogamp.common.os.Platform.OSType;

public class JNILibLoaderBase {
public static final boolean DEBUG = Debug.debug("JNILibLoader");

public interface LoaderAction {
/**
* Loads the library specified by libname. 
* The implementation should ignore, if the library has been loaded already. 
* @param libname the library to load
* @param ignoreError if true, errors during loading the library should be ignored
* @param cl optional ClassLoader, used to locate the library
* @return true if library loaded successful
*/
boolean loadLibrary(String libname, boolean ignoreError, ClassLoader cl);

/**
* Loads the library specified by libname. 
* Optionally preloads the libraries specified by preload. 
* The implementation should ignore, if any library has been loaded already. 
* @param libname the library to load
* @param preload the libraries to load before loading the main library if not null
* @param preloadIgnoreError if true, errors during loading the preload-libraries should be ignored
* @param cl optional ClassLoader, used to locate the library
*/
void loadLibrary(String libname, String[] preload, boolean preloadIgnoreError, ClassLoader cl);
}

private static class DefaultAction implements LoaderAction {
@Override
public boolean loadLibrary(String libname, boolean ignoreError, ClassLoader cl) {
boolean res = true;
if(!isLoaded(libname)) {
try {
loadLibraryInternal(libname, cl);
addLoaded(libname);
if(DEBUG) {
System.err.println("JNILibLoaderBase: loaded "+libname);
}
} catch (UnsatisfiedLinkError e) {
res = false;
if(DEBUG) {
e.printStackTrace();
}
if (!ignoreError && e.getMessage().indexOf("already loaded") < 0) {
throw e;
}
}
}
return res;
}

@Override
public void loadLibrary(String libname, String[] preload, boolean preloadIgnoreError, ClassLoader cl) {
if(!isLoaded(libname)) {
if (null!=preload) {
for (int i=0; i<preload.length; i++) {
loadLibrary(preload[i], preloadIgnoreError, cl);
}
}
loadLibrary(libname, false, cl);
}
}
}

private static final HashSet<String> loaded = new HashSet<String>();
private static LoaderAction loaderAction = new DefaultAction();

public static boolean isLoaded(String libName) {
return loaded.contains(libName);
}

public static void addLoaded(String libName) {
loaded.add(libName);
if(DEBUG) {
System.err.println("JNILibLoaderBase: Loaded Native Library: "+libName);
}
}

public static void disableLoading() {
setLoadingAction(null);
}

public static void enableLoading() {
setLoadingAction(new DefaultAction());
}

public static synchronized void setLoadingAction(LoaderAction action) {
loaderAction = action;
}

public static String getURIDirname(String uriS) throws IllegalArgumentException, URISyntaxException {
if(null == uriS) {
throw new IllegalArgumentException("uriS is null");
}
// from
// file:/some/path/gluegen-rt.jar _or_ rsrc:gluegen-rt.jar
// to
// file:/some/path/ _or_ rsrc:
int idx = uriS.lastIndexOf('/');
if(0 > idx) {
// no abs-path, check for protocol terminator ':'
idx = uriS.lastIndexOf(':');
if(0 > idx) {
throw new IllegalArgumentException("URI does not contain protocol terminator ':', in <"+uriS+">");
}
}
uriS = uriS.substring(0, idx+1); // exclude jar name, include terminal '/' or ':'

if( DEBUG ) {
System.out.println("getJarURIDirname res: "+uriS);
}
return uriS;
}

/**
*
* @param classFromJavaJar
* @param classJarURI
* @param jarBasename jar basename w/ suffix
* @param nativeJarBasename native jar basename w/ suffix
* @param msg
* @return
* @throws IOException
* @throws SecurityException
* @throws URISyntaxException
*/
/* pp */ static final boolean addNativeJarLibsImpl(Class<?> classFromJavaJar, URI classJarURI, String jarBasename, String nativeJarBasename, StringBuilder msg)
throws IOException, SecurityException, URISyntaxException
{
boolean ok = false;
if(TempJarCache.isInitialized()) {

DB.print("classJarURI="+classJarURI);

final URI jarSubURI = JarUtil.getJarSubURI( classJarURI );
DB.print("jarSubURI="+jarSubURI);

if(null == jarSubURI) {
throw new IllegalArgumentException("JarSubURI is null of: "+classJarURI);
}
//final String jarUriRoot_s = jarSubURI.toString();

final String jarUriRoot_s = getURIDirname( jarSubURI.toString() );

final String nativeLibraryPath = "natives/"+PlatformPropsImpl.os_and_arch+"/";
final ClassLoader cl = classFromJavaJar.getClassLoader();

DB.print("ClassLoader="+cl);
DB.print("nativeLibraryPath="+nativeLibraryPath);
DB.print("jarUriRoot_s="+jarUriRoot_s);

final URL nativeLibraryURI = cl.getResource(nativeLibraryPath);

DB.print("nativeLibraryURI="+nativeLibraryURI);

if( null != nativeLibraryURI ) {
// We probably have one big-fat jar file, containing java classes
// and all native platform libraries under 'natives/os.and.arch'!
DB.print("jarUriRoot_s="+jarUriRoot_s);

final URI nativeJarURI = nativeLibraryURI.toURI();
// final URI nativeJarURI = JarUtil.getJarFileURI(null,jarUriRoot_s+jarBasename);

DB.print("nativeJarURI="+nativeJarURI);

DB.print("classFromJavaJar="+classFromJavaJar);

TempJarCache.addNativeLibs(classFromJavaJar, nativeJarURI);

// TempJarCache.addNativeLibs(classFromJavaJar, nativeJarURI);
ok = true;
DB.print("SUCCESS!");
// msg.append(jarBasename).append(" -> fat: ").append(nativeJarURI);
// }
}
if( !ok ) {
// We assume one slim native jar file per 'os.and.arch'!
final URI nativeJarURI = JarUtil.getJarFileURI(jarUriRoot_s+nativeJarBasename,cl);
msg.append(nativeJarBasename).append(" -> slim: ").append(nativeJarURI);
TempJarCache.addNativeLibs(classFromJavaJar, nativeJarURI);
// ok = TempJarCache.addNativeLibs(classFromJavaJar, nativeJarURI, null /* nativeLibraryPath */);
}
} else {
msg.append("TempJarCache n/a");
}
if(DEBUG) {
System.err.println(msg.toString()+" - OK "+ok);
}
return ok;
}

/**
* Loads and adds a JAR file's native library to the TempJarCache. 
* The native library JAR file's URI is derived as follows:
* <ul>
* <li> [1] <code>GLProfile.class</code> -> </li>
* <li> [2] <code>http://lala/</code> -> </li>
* <li> [4] <code>http://lala/'nativeJarBaseName'-'os.and.arch'.jar</code> </li>
* </ul>
* Where:
* <ul>
* <li> [1] is the <code>classFromJavaJar</code></li>
* <li> [2] is it's URI path</li>
* <li> [4] is the derived native JAR filename</li>
* </ul>
*
* @param classFromJavaJar GLProfile
* @param nativeJarBasename jogl-all
* @return true if the native JAR file loaded successful or were loaded already, false in case of an error
*/
public static final boolean addNativeJarLibs(Class<?> classFromJavaJar, String nativeJarBasename) {

if(TempJarCache.isInitialized()) {
final StringBuilder msg = new StringBuilder();
try {
final URI classJarURI = JarUtil.getJarURI(classFromJavaJar.getName(), classFromJavaJar.getClassLoader());
final String jarName = JarUtil.getJarBasename(classJarURI);
return addNativeJarLibsImpl(classFromJavaJar, classJarURI, jarName, nativeJarBasename+"-natives-"+PlatformPropsImpl.os_and_arch+".jar", msg);
} catch (Exception e0) {
// IllegalArgumentException, IOException
System.err.println("Catched "+e0.getClass().getSimpleName()+": "+e0.getMessage()+", while "+msg.toString());
if(DEBUG) {
e0.printStackTrace();
}
}
} else if(DEBUG) {
System.err.println("JNILibLoaderBase: addNativeJarLibs1: disabled due to uninitialized TempJarCache");
}
return false;
}

/**
* Loads and adds a JAR file's native library to the TempJarCache,
* calling {@link JNILibLoaderBase#addNativeJarLibs(Class[], String, String[])}
* with default JOGL deployment configuration:
* <pre>
return JNILibLoaderBase.addNativeJarLibs(classesFromJavaJars, "-all", new String[] { "-noawt", "-mobile", "-core", "-android" } );
* </pre>
* If <code>Class1.class</code> is contained in a JAR file which name includes <code>singleJarMarker</code> -all,
* implementation will attempt to resolve the native JAR file as follows:
* <ul>
* <li>ClassJar-all[-noawt,-mobile,-android]?.jar to ClassJar-all-natives-os.and.arch.jar</li>
* </ul>
* Otherwise the native JAR files will be resolved for each class's JAR file:
* <ul>
* <li>ClassJar1[-noawt,-mobile,-core,-android]?.jar to ClassJar1-natives-os.and.arch.jar</li>
* <li>ClassJar2[-noawt,-mobile,-core,-android]?.jar to ClassJar2-natives-os.and.arch.jar</li>
* <li>..</li>
* </ul>
*/
public static final boolean addNativeJarLibsJoglCfg(final Class<?>[] classesFromJavaJars) {
return addNativeJarLibs(classesFromJavaJars, "-all", joglDeployCfg);
}
private static final String[] joglDeployCfg = new String[] { "-noawt", "-mobile", "-core", "-android" };

/**
* Loads and adds a JAR file's native library to the TempJarCache. 
* The native library JAR file's URI is derived as follows:
* <ul>
* <li> [1] <code>GLProfile.class</code> -> </li>
* <li> [2] <code>http://lala/gluegen-rt.jar</code> -> </li>
* <li> [3] <code>http://lala/gluegen-rt</code> -> </li>
* <li> [4] <code>http://lala/gluegen-rt-natives-'os.and.arch'.jar</code> </li>
* </ul>
* Where:
* <ul>
* <li> [1] is one of <code>classesFromJavaJars</code></li>
* <li> [2] is it's complete URI</li>
* <li> [3] is it's base URI</li>
* <li> [4] is the derived native JAR filename</li>
* </ul>
* 
* Generic description:
* <pre>
final ClassLoader cl = GLProfile.class.getClassLoader();
final String newtFactoryClassName = "com.jogamp.newt.NewtFactory";
final Class<?>[] classesFromJavaJars = new Class<?>[] { Class1.class, Class2.class };
JNILibLoaderBase.addNativeJarLibs(classesFromJavaJars, "-all", new String[] { "-suff1", "-suff2" } );
* </pre>
* If <code>Class1.class</code> is contained in a JAR file which name includes <code>singleJarMarker</code>, here -all,
* implementation will attempt to resolve the native JAR file as follows:
* <ul>
* <li>ClassJar-all[-suff1,-suff2]?.jar to ClassJar-all-natives-os.and.arch.jar</li>
* </ul>
* Otherwise the native JAR files will be resolved for each class's JAR file:
* <ul>
* <li>Class1Jar[-suff1,-suff2]?.jar to Class1Jar-natives-os.and.arch.jar</li>
* <li>Class2Jar[-suff1,-suff2]?.jar to Class2Jar-natives-os.and.arch.jar</li>
* </ul>
* 
* 
* Examples:
* 
* 
* JOCL:
* <pre>
// only: jocl.jar -> jocl-natives-os.and.arch.jar
addNativeJarLibs(new Class<?>[] { JOCLJNILibLoader.class }, null, null );
* </pre>
*
* Newt Only:
* <pre>
// either: [jogl-all.jar, jogl-all-noawt.jar, jogl-all-mobile.jar, jogl-all-android.jar] -> jogl-all-natives-os.and.arch.jar
// or: nativewindow-core.jar -> nativewindow-natives-os.and.arch.jar,
// newt-core.jar -> newt-natives-os.and.arch.jar
JNILibLoaderBase.addNativeJarLibs(new Class<?>[] { NWJNILibLoader.class, NEWTJNILibLoader.class }, "-all", new String[] { "-noawt", "-mobile", "-core", "-android" } );
* </pre>
* 
* 
* JOGL:
* <pre>
final ClassLoader cl = GLProfile.class.getClassLoader();
// either: [jogl-all.jar, jogl-all-noawt.jar, jogl-all-mobile.jar, jogl-all-android.jar] -> jogl-all-natives-os.and.arch.jar
// or: nativewindow-core.jar -> nativewindow-natives-os.and.arch.jar,
// jogl-core.jar -> jogl-natives-os.and.arch.jar,
// (newt-core.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", new String[] { "-noawt", "-mobile", "-core", "-android" } );
* </pre>
* 
*
* @param classesFromJavaJars For each given Class, load the native library JAR.
* @param singleJarMarker Optional string marker like "-all" to identify the single 'all-in-one' JAR file
* after which processing of the class array shall stop.
* @param stripBasenameSuffixes Optional substrings to be stripped of the base URI
*
* @return 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
*/

private static void printClassArray(Class<?>[] _ca)
{
if(_ca==null)
{
DB.print("Class Array is NULL");
return;
}
DB.print("Class Array length="+_ca.length);
for(int i=0;i<_ca.length;i++)
{
DB.print("["+i+"]="+_ca[i]);
}
}

private static void printStringArray(String[] _sa)
{
if(_sa==null)
{
DB.print("String Array is NULL");
return;
}
DB.print("String Array length="+_sa.length);
for(int i=0;i<_sa.length;i++)
{
DB.print("["+i+"]="+_sa[i]);
}
}

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

DB.print("JNILibLoaderBAse.addNativeJarLibs #2");

if(DEBUG) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0(classesFromJavaJars "+Arrays.asList(classesFromJavaJars)+", singleJarMarker "+singleJarMarker+", stripBasenameSuffixes "+(null!=stripBasenameSuffixes?Arrays.asList(stripBasenameSuffixes):"none"));
}
boolean ok = false;
if(TempJarCache.isInitialized()) {

DB.print("TempJarCache.isInitialized="+TempJarCache.isInitialized());
printClassArray(classesFromJavaJars);

final StringBuilder msg = new StringBuilder();
int count = 0;
try {
boolean done = false;
ok = true;
for(int i=0; !done && ok && i<classesFromJavaJars.length && null!=classesFromJavaJars[i]; i++) {
final ClassLoader cl = classesFromJavaJars[i].getClassLoader();
final URI classJarURI = JarUtil.getJarURI(classesFromJavaJars[i].getName(), cl);
final String jarName = JarUtil.getJarBasename(classJarURI);
DB.print("jarName="+jarName);

ok = null != jarName;
if(ok) {
final String jarBasename = jarName.substring(0, jarName.indexOf(".jar")); // ".jar" already validated w/ JarUtil.getJarBasename(..)
final String nativeJarBasename = stripName(jarBasename, stripBasenameSuffixes)+"-natives-"+PlatformPropsImpl.os_and_arch+".jar";

DB.print("jarBasename="+jarBasename);
DB.print("nativeJarBasename="+nativeJarBasename);

done = null != singleJarMarker && jarBasename.indexOf(singleJarMarker) >= 0; // done if single-jar ('all' variant)
ok = JNILibLoaderBase.addNativeJarLibsImpl(classesFromJavaJars[i], classJarURI, jarName, nativeJarBasename, msg);
if(ok) { count++; }
if(DEBUG && done) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0: end after all-in-one JAR: "+jarBasename);
}
}
}
} catch (Exception e0) {

DB.handle(e0);
// IllegalArgumentException, IOException
System.err.println("Catched "+e0.getClass().getSimpleName()+": "+e0.getMessage()+", while "+msg.toString());
if(DEBUG) {
e0.printStackTrace();
}
ok = false;
}
if(DEBUG) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0(..) done, count "+count+", ok "+ok);
}
} else if(DEBUG) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0: disabled due to uninitialized TempJarCache");
}
return ok;
}

private static final String stripName(String name, String[] suffixes) {
if(null != suffixes) {
for(int i=0; i<suffixes.length && null != suffixes[i]; i++) {
int idx = name.indexOf(suffixes[i]);
if(0 < idx) {
return name.substring(0, idx);
}
}
}
return name;
}

/**
* Loads the library specified by libname, using the {@link LoaderAction} set by {@link #setLoadingAction(LoaderAction)}. 
* The implementation should ignore, if the library has been loaded already. 
* @param libname the library to load
* @param ignoreError if true, errors during loading the library should be ignored
* @param cl optional ClassLoader, used to locate the library
* @return true if library loaded successful
*/
protected static synchronized boolean loadLibrary(String libname, boolean ignoreError, ClassLoader cl) {
if (loaderAction != null) {
return loaderAction.loadLibrary(libname, ignoreError, cl);
}
return false;
}

/**
* Loads the library specified by libname, using the {@link LoaderAction} set by {@link #setLoadingAction(LoaderAction)}. 
* Optionally preloads the libraries specified by preload. 
* The implementation should ignore, if any library has been loaded already. 
* @param libname the library to load
* @param preload the libraries to load before loading the main library if not null
* @param preloadIgnoreError if true, errors during loading the preload-libraries should be ignored
* @param cl optional ClassLoader, used to locate the library
*/
protected static synchronized void loadLibrary(String libname, String[] preload, boolean preloadIgnoreError, ClassLoader cl) {
if (loaderAction != null) {
loaderAction.loadLibrary(libname, preload, preloadIgnoreError, cl);
}
}

// private static final Class<?> customLauncherClass; // FIXME: remove
private static final Method customLoadLibraryMethod;

static {
final String sunAppletLauncherProperty = "sun.jnlp.applet.launcher";
final String sunAppletLauncherClassName = "org.jdesktop.applet.util.JNLPAppletLauncher";

final Method loadLibraryMethod = AccessController.doPrivileged(new PrivilegedAction<Method>() {
@Override
public Method run() {
// FIXME: remove
final boolean usingJNLPAppletLauncher = Debug.getBooleanProperty(sunAppletLauncherProperty, true);

Class<?> launcherClass = null;
Method loadLibraryMethod = null;

if (usingJNLPAppletLauncher) {
try {
launcherClass = Class.forName(sunAppletLauncherClassName);
} catch (ClassNotFoundException cnfe) {
// oops .. look like JNLPAppletLauncher doesn't exist, despite property
// this may happen if a previous applet was using JNLPAppletLauncher in the same JVM
System.err.println("JNILibLoaderBase: <"+sunAppletLauncherClassName+"> not found, despite enabled property <"+sunAppletLauncherProperty+">, JNLPAppletLauncher was probably used before");
System.setProperty(sunAppletLauncherProperty, Boolean.FALSE.toString());
} catch (LinkageError le) {
throw le;
}
if(null != launcherClass) {
try {
loadLibraryMethod = launcherClass.getDeclaredMethod("loadLibrary", new Class[] { String.class });
} catch (NoSuchMethodException ex) {
if(DEBUG) {
ex.printStackTrace();
}
launcherClass = null;
}
}
}
if(null==launcherClass) {
String launcherClassName = PropertyAccess.getProperty("jnlp.launcher.class", false);
if(null!=launcherClassName) {
try {
launcherClass = Class.forName(launcherClassName);
loadLibraryMethod = launcherClass.getDeclaredMethod("loadLibrary", new Class[] { String.class });
} catch (ClassNotFoundException ex) {
if(DEBUG) {
ex.printStackTrace();
}
} catch (NoSuchMethodException ex) {
if(DEBUG) {
ex.printStackTrace();
}
launcherClass = null;
}
}
}
return loadLibraryMethod;
} } );
customLoadLibraryMethod = loadLibraryMethod;
}

private static boolean nativesWaiting=true;
private static String nativeDir=null;
private static String nativeArch=null;
// private static int nativeType=-1;
// private static iNativer nativeCL=null;

private static void loadLibraryInternal(String libraryName, ClassLoader cl) {

DB.print("loadLibraryInternal libraryName="+libraryName+" ClassLoader="+cl);

// Note: special-casing JAWT which is built in to the JDK
int mode = 0; // 1 - custom, 2 - System.load( TempJarCache ), 3 - System.loadLibrary( name ), 4 - System.load( enumLibNames )
if (null!=customLoadLibraryMethod && !libraryName.equals("jawt")) {
// FIXME: remove
if(DEBUG) {
System.err.println("JNILibLoaderBase: customLoad("+libraryName+") - mode 1");
}
try {
customLoadLibraryMethod.invoke(null, new Object[] { libraryName });
mode = 1;
} catch (Exception e) {
Throwable t = e;
if (t instanceof InvocationTargetException) {
t = ((InvocationTargetException) t).getTargetException();
}
if (t instanceof Error) {
throw (Error) t;
}
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
}
// Throw UnsatisfiedLinkError for best compatibility with System.loadLibrary()
throw (UnsatisfiedLinkError) new UnsatisfiedLinkError("can not load library "+libraryName).initCause(e);
}
} else {
// System.err.println("sun.boot.library.path=" + Debug.getProperty("sun.boot.library.path", false));
final String libraryPath = NativeLibrary.findLibrary(libraryName, cl); // implicit TempJarCache usage if used/initialized
if(DEBUG) {
System.err.println("JNILibLoaderBase: loadLibraryInternal("+libraryName+"), TempJarCache: "+libraryPath);
}
if(null != libraryPath) {
if(DEBUG) {
System.err.println("JNILibLoaderBase: System.load("+libraryPath+") - mode 2");
}
System.load(libraryPath);
mode = 2;
} else {
if(DEBUG) {
System.err.println("JNILibLoaderBase: System.loadLibrary("+libraryName+") - mode 3");
}
try {
System.loadLibrary(libraryName);
mode = 3;
} catch (UnsatisfiedLinkError ex1) {

if(nativesWaiting)
{
nativesWaiting=false;
if(PlatformPropsImpl.OS_TYPE!=OSType.ANDROID)
{
DB.print("TempJarCache.isInitialized()="+TempJarCache.isInitialized());
if(!TempJarCache.isInitialized())
{
try{
TempJarCache.initSingleton();
}catch(Throwable t){}
}
if(TempJarCache.isInitialized())
{
nativeDir=TempJarCache.getTempFileCache().getTempDir().getAbsolutePath();
nativeArch="natives/"+PlatformPropsImpl.os_and_arch+"/";
}
//String oa=PlatformPropsImpl.os_and_arch;
//if(oa.equals("android-armv6"))nativeType=1;
//if(oa.equals("linux-amd64"))nativeType=2;
//if(oa.equals("linux-armv6"))nativeType=3;
//if(oa.equals("linux-armv6hf"))nativeType=4;
//if(oa.equals("linux-i586"))nativeType=5;
//if(oa.equals("macoxs-universe"))nativeType=6;
//if(oa.equals("solaris-amd64"))nativeType=7;
//if(oa.equals("solaris-i586"))nativeType=8;
//if(oa.equals("windows-amd64"))nativeType=9;
//if(oa.equals("windows-i586"))nativeType=10;
//nativeCL=(iNativer)cl;
// }catch(Throwable t){}
}
}
boolean ok=false;
DB.print("nativeDir="+nativeDir);
DB.print("nativeArch="+nativeArch);
DB.print("(cl instanceof iNativer)="+(cl instanceof iNativer));

if(nativeDir!=null&&nativeArch!=null)
{
DB.print("here #1");
if(cl instanceof iNativer)
{
DB.print("here #2");
List<String> possiblePaths=NativeLibrary.enumerateLibraryPaths(libraryName,libraryName,libraryName,true,cl);
Iterator<String> iter=possiblePaths.iterator();
DB.print("here #3");

if(iter.hasNext())
{
DB.print("here #5");

String path=iter.next();
String name=path.substring(path.indexOf(libraryName));
ok=((iNativer)cl).loadNative(name,nativeArch,nativeDir);
if(ok)
{
try{
DB.print("here #5");

File f=new File(nativeDir,name);
System.load(f.getAbsolutePath());
}catch(Throwable t){
ok=false;
}
}
}
}
if(ok)mode=4;
}

if(DEBUG) {
System.err.println("ERROR (retry w/ enumLibPath) - "+ex1.getMessage());
}
List<String> possiblePaths = NativeLibrary.enumerateLibraryPaths(libraryName, libraryName, libraryName, true, cl);
// Iterate down these and see which one if any we can actually find.
for (Iterator<String> iter = possiblePaths.iterator(); 0 == mode && iter.hasNext(); ) {
String path = iter.next();
if (DEBUG) {
System.err.println("JNILibLoaderBase: System.load("+path+") - mode 4");
}
try {
System.load(path);
mode = 4;
} catch (UnsatisfiedLinkError ex2) {
if(DEBUG) {
System.err.println("n/a - "+ex2.getMessage());
}
if(!iter.hasNext()) {
throw ex2;
}
}
}
}
}
}
if(DEBUG) {
System.err.println("JNILibLoaderBase: loadLibraryInternal("+libraryName+"): OK - mode "+mode);
}
}

//public static void joalNativesLoad() throws Throwable
// {
// if(nativeType==-1)throw new Error("Not Ready!");
// String fn1="libjoal.so",fn2="libopenal.so";
// if(nativeType==6)
// {
// fn1="libjoal.jnilib";
// fn2="libopenal.dylib";
// }
// if(nativeType==7||nativeType==8)
// {
// fn2="";
// }
// if(nativeType>8)
// {
// fn1="joal.dll";
// fn2="soft_oal.dll";
// }
// if(fn2!="")joalLoad(fn2);
// joalLoad(fn1);
// }
//private static void joalLoad(String _name)
// {
//DB.print("joalLoad["+_name+"]");
// try{
// nativeCL.loadNative(_name,nativeArch,nativeDir);
// File f=new File(nativeDir,_name);
// System.load(f.getAbsolutePath());
// }catch(Throwable t){
//DB.handle(t);
// }
// }

}