();
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;
}
/* pp */ static final boolean addNativeJarLibsImpl(Class> classFromJavaJar, URL classJarURL, String nativeJarBasename, StringBuilder msg)
throws IOException, IllegalArgumentException, SecurityException
{
msg.setLength(0); // reset
msg.append("addNativeJarLibsImpl(classFromJavaJar ").append(classFromJavaJar).append(", classJarURL ").append(classJarURL).append(", nativeJarBaseName ").append(nativeJarBasename).append("): ");
boolean ok = false;
if(TempJarCache.isInitialized()) {
final String nativeJarName = nativeJarBasename+"-natives-"+PlatformPropsImpl.os_and_arch+".jar";
msg.append(nativeJarName);
final URL jarUrlRoot = JarUtil.getURLDirname( JarUtil.getJarSubURL( classJarURL ) );
msg.append(" + ").append(jarUrlRoot);
final URL nativeJarURL = JarUtil.getJarFileURL(jarUrlRoot, nativeJarName);
msg.append(" -> ").append(nativeJarURL);
if(DEBUG) {
System.err.println(msg.toString());
}
TempJarCache.addNativeLibs(classFromJavaJar, nativeJarURL);
ok = true;
}
return ok;
}
/**
* Loads and adds a JAR file's native library to the TempJarCache.
* The native library JAR file's URL is derived as follows:
*
* - [1]
GLProfile.class
->
* - [2]
http://lala/
->
* - [4]
http://lala/'nativeJarBaseName'-'os.and.arch'.jar
*
* Where:
*
* - [1] is the
classFromJavaJar
* - [2] is it's URL path
* - [4] is the derived native JAR filename
*
*
* @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 URL classJarURL = JarUtil.getJarURL(classFromJavaJar.getName(), classFromJavaJar.getClassLoader());
return addNativeJarLibsImpl(classFromJavaJar, classJarURL, nativeJarBasename, 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.
* The native library JAR file's URL 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 URL
* - [3] is it's base URL
* - [4] is the derived native JAR filename
*
*
* Examples:
*
* JOCL:
*
// only: jocl.jar -> jocl-natives-'os.and.arch'.jar
addNativeJarLibs(new Class>[] { JOCLJNILibLoader.class }, null, null );
*
*
* Newt Only:
*
// either: [jogl-all.jar, jogl-all-noawt.jar, jogl-all-mobile.jar] -> jogl-all-natives-.jar
// or: nativewindow-core.jar -> nativewindow-natives-.jar,
// newt-core.jar -> newt-natives-.jar
JNILibLoaderBase.addNativeJarLibs(new Class>[] { NWJNILibLoader.class, NEWTJNILibLoader.class }, "-all", new String[] { "-noawt", "-mobile", "-core" } );
*
*
* JOGL:
*
final ClassLoader cl = GLProfile.class.getClassLoader();
// either: [jogl-all.jar, jogl-all-noawt.jar, jogl-all-mobile.jar] -> jogl-all-natives-.jar
// or: nativewindow-core.jar -> nativewindow-natives-.jar,
// jogl-core.jar -> jogl-natives-.jar,
// (newt-core.jar -> newt-natives-.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" } );
*
*
* @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 URL
*
* @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
*/
public static boolean addNativeJarLibs(Class>[] classesFromJavaJars, String singleJarMarker, String[] stripBasenameSuffixes) {
if(DEBUG) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0(classesFromJavaJars "+Arrays.asList(classesFromJavaJars)+", singleJarMarker "+singleJarMarker+", stripBasenameSuffixes "+Arrays.asList(stripBasenameSuffixes));
}
boolean ok = false;
if(TempJarCache.isInitialized()) {
final StringBuilder msg = new StringBuilder();
int count = 0;
try {
boolean done = false;
ok = true;
for(int i=0; !done && ok && i= 0; // done if single-jar ('all' variant)
ok = JNILibLoaderBase.addNativeJarLibsImpl(classesFromJavaJars[i], classJarURL, nativeJarBasename, msg);
if(ok) { count++; }
if(DEBUG && done) {
System.err.println("JNILibLoaderBase: addNativeJarLibs0: end after all-in-one JAR: "+jarBasename);
}
}
}
} catch (Exception 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
* 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;
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() {
public Method run() {
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, null);
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 void loadLibraryInternal(String libraryName, ClassLoader cl) {
// Note: special-casing JAWT which is built in to the JDK
if (null!=customLoadLibraryMethod && !libraryName.equals("jawt")) {
try {
customLoadLibraryMethod.invoke(null, new Object[] { libraryName });
} 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 {
if(TempJarCache.isInitialized()) {
final String libraryPath = TempJarCache.findLibrary(libraryName);
if(null != libraryPath) {
if(DEBUG) {
System.err.println("JNILibLoaderBase: loadLibraryInternal("+libraryName+") -> System.load("+libraryPath+") (TempJarCache)");
}
System.load(libraryPath);
return; // done
} else if(DEBUG) {
System.err.println("JNILibLoaderBase: loadLibraryInternal("+libraryName+") -> TempJarCache not mapped");
}
}
// System.err.println("sun.boot.library.path=" + Debug.getProperty("sun.boot.library.path", false));
final String libraryPath = NativeLibrary.findLibrary(libraryName, cl);
if(DEBUG) {
System.err.print("JNILibLoaderBase: loadLibraryInternal("+libraryName+"): CL: "+libraryPath);
}
if(null != libraryPath) {
if(DEBUG) {
System.err.println(" -> System.load("+libraryPath+")");
}
System.load(libraryPath);
} else {
if(DEBUG) {
System.err.println(" -> System.loadLibrary("+libraryName+")");
}
System.loadLibrary(libraryName);
}
}
}
}