RetroZilla/extensions/java/xpcom/interfaces/Mozilla.java

1068 lines
36 KiB
Java
Raw Normal View History

2015-10-21 05:03:22 +02:00
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Java XPCOM Bindings.
*
* The Initial Developer of the Original Code is IBM Corporation.
* Portions created by the Initial Developer are Copyright (C) 2006
* IBM Corporation. All Rights Reserved.
*
* Contributor(s):
* Javier Pedemonte (jhpedemonte@gmail.com)
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
package org.mozilla.xpcom;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import org.mozilla.interfaces.nsIComponentManager;
import org.mozilla.interfaces.nsIComponentRegistrar;
import org.mozilla.interfaces.nsILocalFile;
import org.mozilla.interfaces.nsIServiceManager;
import org.mozilla.interfaces.nsISupports;
/**
* A singleton class which provides access to the Mozilla browser. Requires
* that XULRunner be installed on the user's system.
* <p>
* You would use to class to find a XULRunner installation, setup a profile (if
* necessary), and initialize embedding. A typical scenario would look like
* this:
* </p><pre>
* Mozilla mozilla = Mozilla.getInstance();
* GREVersionRange[] range = new GREVersionRange[1];
* range[0] = new GREVersionRange("1.8.0.*", false, "1.8.1.*", true);
* try {
* File grePath = Mozilla.getGREPathWithProperties(range, null);
* mozilla.initialize(grePath);
* profLock = mozilla.lockProfileDirectory(profileDir);
* // LocationProvider is a user class that implements IAppFileLocProvider
* LocationProvider locProvider = new LocationProvider(grePath, profileDir);
* mozilla.initEmbedding(grePath, grePath, locProvider);
* mozilla.notifyProfile();
* } catch (XPCOMInitializationException xie) {
* // handle exception
* } catch (XPCOMException xe) {
* // handle exception
* }
* </pre>
*
* @see http://www.mozilla.org/projects/embedding/GRE.html
*/
public class Mozilla implements IMozilla, IGRE, IXPCOM, IJavaXPCOMUtils,
IXPCOMError {
private static Mozilla mozillaInstance = new Mozilla();
private static final String JAVAXPCOM_JAR = "javaxpcom.jar";
private IMozilla mozilla = null;
private IGRE gre = null;
private IXPCOM xpcom = null;
private IJavaXPCOMUtils jxutils = null;
/**
* @return
*/
public static Mozilla getInstance() {
return mozillaInstance;
}
/**
*
*/
private Mozilla() {
}
/**
* Locates the path of a GRE with the specified properties. This method
* will only return GREs that support Java embedding (looks for the
* presence of "javaxpcom.jar").
* <p>
* Currently this uses a "first-fit" algorithm, it does not select
* the newest available GRE.
*
* @param aVersions An array of version ranges: if any version range
* matches, the GRE is considered acceptable.
* @param aProperties A list of GRE property/value pairs which must
* all be satisfied. This parameter is ignored on
* Macintosh, because of the manner in which the
* XUL frameworks are installed.
*
* @return A file object of the appropriate path. If
* the "local" GRE is specified (via the USE_LOCAL_GRE
* environment variable, for example), returns
* <code>null</code>.
*
* @throws FileNotFoundException if an appropriate GRE could not be found
*/
public static File getGREPathWithProperties(GREVersionRange[] aVersions,
Properties aProperties) throws FileNotFoundException {
File grePath = null;
// if GRE_HOME is in the environment, use that GRE
String env = System.getProperty("GRE_HOME");
if (env != null) {
try {
grePath = new File(env).getCanonicalFile();
} catch (IOException e) {
throw new FileNotFoundException("cannot access GRE_HOME");
}
if (!grePath.exists()) {
throw new FileNotFoundException("GRE_HOME doesn't exist");
}
return grePath;
}
// the Gecko bits that sit next to the application or in the PATH
env = System.getProperty("USE_LOCAL_GRE");
if (env != null) {
return null;
}
// Search for GRE in platform specific locations. We want a GRE that
// supports Java, so we look for the "javaxpcom" property by default.
if (aProperties == null) {
aProperties = new Properties();
}
aProperties.setProperty("javaxpcom", "1");
String osName = System.getProperty("os.name").toLowerCase();
if (osName.startsWith("mac os x")) {
grePath = getGREPathMacOSX(aVersions);
} else if (osName.startsWith("windows")) {
grePath = getGREPathWindows(aVersions, aProperties);
} else {
// assume everything else is Unix/Linux
grePath = getGREPathUnix(aVersions, aProperties);
}
if (grePath == null) {
throw new FileNotFoundException("GRE not found");
}
return grePath;
}
/**
* @param aVersions
* @return
*/
private static File getGREPathMacOSX(GREVersionRange[] aVersions) {
/*
* Check the application bundle first, for
* <bundle>/Contents/Frameworks/XUL.framework/libxpcom.dylib.
*/
File grePath = findGREBundleFramework();
if (grePath != null) {
return grePath;
}
// Check ~/Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
String home = System.getProperty("user.home");
if (home != null) {
grePath = findGREFramework(home, aVersions);
if (grePath != null) {
return grePath;
}
}
// Check /Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib
return findGREFramework("", aVersions);
}
/**
* @return
*/
private static File findGREBundleFramework() {
/*
* Use reflection to get Apple's NSBundle class, which can be used
* to get the bundle's "Frameworks" directory.
*/
try {
URL[] urls = new URL[1];
urls[0] = new File("/System/Library/Java/").toURL();
ClassLoader loader = new URLClassLoader(urls);
Class bundleClass = Class.forName("com.apple.cocoa.foundation.NSBundle",
true, loader);
// Get the bundle for this app. If this is not executing from
// a bundle, this will return null.
Method mainBundleMethod = bundleClass.getMethod("mainBundle", null);
Object bundle = mainBundleMethod.invoke(null, null);
if (bundle != null) {
// Get the path to the bundle's "Frameworks" directory
Method fwPathMethod = bundleClass.getMethod("privateFrameworksPath",
null);
String path = (String) fwPathMethod.invoke(bundle, null);
// look for libxpcom.dylib
if (path.length() != 0) {
File xulDir = new File(path, "XUL.framework");
if (xulDir.isDirectory()) {
File xpcomLib = new File(xulDir, "libxpcom.dylib");
if (xpcomLib.canRead()) {
File grePath = xpcomLib.getCanonicalFile().getParentFile();
// Since GRE Properties aren't supported on Mac OS X, we check
// for the existence of the "javaxpcom.jar" file in the GRE.
File jar = new File(grePath, JAVAXPCOM_JAR);
if (jar.canRead()) {
// found GRE
return grePath;
}
}
}
}
}
} catch (Exception e) { }
return null;
}
/**
* @param aRootPath
* @param aVersions
* @return
*/
private static File findGREFramework(String aRootPath,
GREVersionRange[] aVersions) {
File frameworkDir = new File(aRootPath +
"/Library/Frameworks/XUL.framework/Versions");
if (!frameworkDir.exists())
return null;
File[] files = frameworkDir.listFiles();
for (int i = 0; i < files.length; i++) {
if (checkVersion(files[i].getName(), aVersions)) {
File xpcomLib = new File(files[i], "libxpcom.dylib");
// Since GRE Properties aren't supported on Mac OS X, we check
// for the existence of the "javaxpcom.jar" file in the GRE.
File jar = new File(files[i], JAVAXPCOM_JAR);
if (xpcomLib.canRead() && jar.canRead()) {
return files[i];
}
}
}
return null;
}
/**
* @param aVersions
* @param aProperties
* @return
*/
private static File getGREPathWindows(GREVersionRange[] aVersions,
Properties aProperties) {
/*
* Note the usage of the "Software\\mozilla.org\\GRE" subkey - this allows
* us to have multiple versions of GREs on the same machine by having
* subkeys such as 1.0, 1.1, 2.0 etc. under it.
*
* Please see http://www.mozilla.org/projects/embedding/GRE.html for
* more info.
*/
final String greKey = "Software\\mozilla.org\\GRE";
// See if there is a GRE registered for the current user.
// If not, look for one on the system.
String key = "HKEY_CURRENT_USER" + "\\" + greKey;
File grePath = getGREPathFromRegKey(key, aVersions, aProperties);
if (grePath == null) {
key = "HKEY_LOCAL_MACHINE" + "\\" + greKey;
grePath = getGREPathFromRegKey(key, aVersions, aProperties);
}
return grePath;
}
/**
* @param aRegKey
* @param aVersions
* @param aProperties
* @return
*/
private static File getGREPathFromRegKey(String aRegKey,
GREVersionRange[] aVersions, Properties aProperties) {
// create a temp file for the registry export
File tempFile;
try {
tempFile = File.createTempFile("jx_registry", null);
} catch (IOException e) {
// failed to create temp file. ABORT
return null;
}
Process proc;
try {
proc = Runtime.getRuntime().exec("regedit /e " + "\"" + tempFile.getPath()
+ "\" \"" + aRegKey + "\"");
proc.waitFor();
} catch (Exception e) {
// Failed to run regedit.exe. Length of temp file is zero, and that's
// handled next.
}
// If there is a key by that name in the registry, then the file length
// will not be zero.
File grePath = null;
if (tempFile.length() != 0) {
grePath = getGREPathFromRegistryFile(tempFile.getPath(),
aRegKey, aVersions, aProperties);
}
tempFile.delete();
return grePath;
}
/**
* @param aFileName
* @param aCharset
* @param aKeyName
* @param aVersions
* @param aProperties
* @return
*/
private static File getGREPathFromRegistryFile(String aFileName,
String aKeyName, GREVersionRange[] aVersions,
Properties aProperties) {
INIParser parser;
try {
parser = new INIParser(aFileName, Charset.forName("UTF-16"));
} catch (Exception e) {
// Problem reading from file. Bail out.
return null;
}
Iterator sectionsIter = parser.getSections();
while (sectionsIter.hasNext()) {
// get 'section' name, which will be a registry key name
String section = (String) sectionsIter.next();
// Skip over GRE key ("<root>\Software\mozilla.org\GRE")
int gre_len = aKeyName.length();
if (section.length() <= gre_len) {
continue;
}
// Get the GRE subkey; that is, everything after
// "<root>\Software\mozilla.org\GRE\"
String subkeyName = section.substring(gre_len + 1);
// We are only interested in _immediate_ subkeys. We want
// "<root>\Software\mozilla.org\GRE\<version>" but not
// "<root>\Software\mozilla.org\GRE\<version>\<moretext>".
if (subkeyName.indexOf('\\') != -1) {
continue;
}
// See if this registry key has a "Version" value, and if so, compare
// it to our desired versions.
String version = parser.getString(section, "\"Version\"");
if (version == null) {
continue;
}
// remove quotes around string
version = version.substring(1, version.length() - 1);
if (!checkVersion(version, aVersions)) {
continue;
}
// All properties must match, keeping in mind that the propery/value
// pairs returned by regedit.exe have quotes around them.
if (aProperties != null) {
boolean ok = true;
Enumeration e = aProperties.propertyNames();
while (ok && e.hasMoreElements()) {
String prop = (String) e.nextElement();
String greValue = parser.getString(section, "\"" + prop + "\"");
if (greValue == null) {
// No such property is set for this GRE. Go on to next GRE.
ok = false;
} else {
// See if the value of the property for the GRE matches
// the given value.
String value = aProperties.getProperty(prop);
if (!greValue.equals("\"" + value + "\"")) {
ok = false;
}
}
}
if (!ok) {
continue;
}
}
String pathStr = parser.getString(section, "\"GreHome\"");
if (pathStr != null) {
// remove quotes around string
pathStr = pathStr.substring(1, pathStr.length() - 1);
File grePath = new File(pathStr);
if (grePath.exists()) {
File xpcomLib = new File(grePath, "xpcom.dll");
if (xpcomLib.canRead()) {
// found a good GRE
return grePath;
}
}
}
}
return null;
}
/**
* @param aVersions
* @param aProperties
* @return
*/
private static File getGREPathUnix(GREVersionRange[] aVersions,
Properties aProperties) {
File grePath = null;
String env = System.getProperty("MOZ_GRE_CONF");
if (env != null) {
grePath = getPathFromConfigFile(env, aVersions, aProperties);
if (grePath != null) {
return grePath;
}
}
final String greUserConfFile = ".gre.config";
final String greUserConfDir = ".gre.d";
final String greConfPath = "/etc/gre.conf";
final String greConfDir = "/etc/gre.d";
env = System.getProperty("user.home");
if (env != null) {
// Look in ~/.gre.config
grePath = getPathFromConfigFile(env + File.separator + greUserConfFile,
aVersions, aProperties);
if (grePath != null) {
return grePath;
}
// Look in ~/.gre.d/*.conf
grePath = getPathFromConfigDir(env + File.separator + greUserConfDir,
aVersions, aProperties);
if (grePath != null) {
return grePath;
}
}
// Look for a global /etc/gre.conf file
grePath = getPathFromConfigFile(greConfPath, aVersions, aProperties);
if (grePath != null) {
return grePath;
}
// Look for a group of config files in /etc/gre.d/
grePath = getPathFromConfigDir(greConfDir, aVersions, aProperties);
return grePath;
}
/**
* @param aFileName
* @param aVersions
* @param aProperties
* @return
*/
private static File getPathFromConfigFile(String aFileName,
GREVersionRange[] aVersions, Properties aProperties) {
INIParser parser;
try {
parser = new INIParser(aFileName);
} catch (Exception e) {
// Problem reading from file. Bail out.
return null;
}
Iterator sectionsIter = parser.getSections();
while (sectionsIter.hasNext()) {
// get 'section' name, which will be a version string
String section = (String) sectionsIter.next();
// if this isn't one of the versions we are looking for, move
// on to next section
if (!checkVersion(section, aVersions)) {
continue;
}
// all properties must match
if (aProperties != null) {
boolean ok = true;
Enumeration e = aProperties.propertyNames();
while (ok && e.hasMoreElements()) {
String prop = (String) e.nextElement();
String greValue = parser.getString(section, prop);
if (greValue == null) {
// No such property is set for this GRE. Go on to next GRE.
ok = false;
} else {
// See if the value of the property for the GRE matches
// the given value.
if (!greValue.equals(aProperties.getProperty(prop))) {
ok = false;
}
}
}
if (!ok) {
continue;
}
}
String pathStr = parser.getString(section, "GRE_PATH");
if (pathStr != null) {
File grePath = new File(pathStr);
if (grePath.exists()) {
File xpcomLib = new File(grePath, "libxpcom.so");
if (xpcomLib.canRead()) {
// found a good GRE
return grePath;
}
}
}
}
return null;
}
/**
* @param aDirName
* @param aVersions
* @param aProperties
* @return
*/
private static File getPathFromConfigDir(String aDirName,
GREVersionRange[] aVersions, Properties aProperties) {
/*
* Open the directory provided and try to read any files in that
* directory that end with .conf. We look for an entry that might
* point to the GRE that we're interested in.
*/
File dir = new File(aDirName);
if (!dir.isDirectory()) {
return null;
}
File grePath = null;
File[] files = dir.listFiles();
for (int i = 0; i < files.length && grePath == null; i++) {
// only look for files that end in '.conf'
if (!files[i].getName().endsWith(".conf")) {
continue;
}
grePath = getPathFromConfigFile(files[i].getPath(), aVersions,
aProperties);
}
return grePath;
}
/**
* @param aVersionToCheck
* @param aVersions
* @return
*/
private static boolean checkVersion(String aVersionToCheck,
GREVersionRange[] aVersions) {
for (int i = 0; i < aVersions.length; i++) {
if (aVersions[i].check(aVersionToCheck)) {
return true;
}
}
return false;
}
/**
* Initialize the Mozilla object with the given XULRunner path. All
* subsequent Mozilla method invocations be done against the given XULRunner
* version.
*
* @param aLibXULDirectory path of XULRunner build to use
*
* @throws XPCOMInitializationException if failure occurred during
* initialization
*/
public void initialize(File aLibXULDirectory)
throws XPCOMInitializationException {
File jar = new File(aLibXULDirectory, JAVAXPCOM_JAR);
if (!jar.exists()) {
throw new XPCOMInitializationException("Could not find " + JAVAXPCOM_JAR +
" in " + aLibXULDirectory);
}
URL[] urls = new URL[1];
try {
urls[0] = jar.toURL();
} catch (MalformedURLException e) {
throw new XPCOMInitializationException(e);
}
ClassLoader loader = new URLClassLoader(urls,
this.getClass().getClassLoader());
try {
Class mozillaClass = Class.forName("org.mozilla.xpcom.internal.MozillaImpl",
true, loader);
mozilla = (IMozilla) mozillaClass.newInstance();
Class greClass = Class.forName("org.mozilla.xpcom.internal.GREImpl",
true, loader);
gre = (IGRE) greClass.newInstance();
Class xpcomClass = Class.forName("org.mozilla.xpcom.internal.XPCOMImpl",
true, loader);
xpcom = (IXPCOM) xpcomClass.newInstance();
Class javaXPCOMClass =
Class.forName("org.mozilla.xpcom.internal.JavaXPCOMMethods",
true, loader);
jxutils = (IJavaXPCOMUtils) javaXPCOMClass.newInstance();
} catch (Exception e) {
throw new XPCOMInitializationException("Could not load " +
"org.mozilla.xpcom.internal.* classes", e);
}
mozilla.initialize(aLibXULDirectory);
}
/**
* Initializes libXUL for embedding purposes.
* <p>
* NOTE: This function must be called from the "main" thread.
* <p>
* NOTE: At the present time, this function may only be called once in
* a given process. Use <code>termEmbedding</code> to clean up and free
* resources allocated by <code>initEmbedding</code>.
*
* @param aLibXULDirectory The directory in which the libXUL shared library
* was found.
* @param aAppDirectory The directory in which the application components
* and resources can be found. This will map to
* the "resource:app" directory service key.
* @param aAppDirProvider A directory provider for the application. This
* provider will be aggregated by a libXUL provider
* which will provide the base required GRE keys.
*
* @throws XPCOMException if a failure occurred during initialization
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public void initEmbedding(File aLibXULDirectory, File aAppDirectory,
IAppFileLocProvider aAppDirProvider) throws XPCOMException {
try {
gre.initEmbedding(aLibXULDirectory, aAppDirectory, aAppDirProvider);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Terminates libXUL embedding.
* <p>
* NOTE: Release any references to XPCOM objects that you may be holding
* before calling this function.
*
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public void termEmbedding() {
try {
gre.termEmbedding();
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
} finally {
mozilla = null;
gre = null;
xpcom = null;
}
}
/**
* Lock a profile directory using platform-specific semantics.
*
* @param aDirectory The profile directory to lock.
*
* @return A lock object. The directory will remain locked until the lock is
* released by invoking the <code>release</code> method, or by the
* termination of the JVM, whichever comes first.
*
* @throws XPCOMException if profile is already locked (with
* <code>errorcode</code> == <code>NS_ERROR_FILE_ACCESS_DENIED</code>);
* or if a failure occurred
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public ProfileLock lockProfileDirectory(File aDirectory)
throws XPCOMException {
try {
return gre.lockProfileDirectory(aDirectory);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Fire notifications to inform the toolkit about a new profile. This
* method should be called after <code>initEmbedding</code> if the
* embedder wishes to run with a profile.
* <p>
* Normally the embedder should call <code>lockProfileDirectory</code>
* to lock the directory before calling this method.
* <p>
* NOTE: There are two possibilities for selecting a profile:
* <ul>
* <li>
* Select the profile before calling <code>initEmbedding</code>.
* The aAppDirProvider object passed to <code>initEmbedding</code>
* should provide the NS_APP_USER_PROFILE_50_DIR key, and
* may also provide the following keys:
* <ul>
* <li>NS_APP_USER_PROFILE_LOCAL_50_DIR
* <li>NS_APP_PROFILE_DIR_STARTUP
* <li>NS_APP_PROFILE_LOCAL_DIR_STARTUP
* </ul>
* In this scenario <code>notifyProfile</code> should be called
* immediately after <code>initEmbedding</code>. Component
* registration information will be stored in the profile and
* JS components may be stored in the fastload cache.
* </li>
* <li>
* Select a profile some time after calling <code>initEmbedding</code>.
* In this case the embedder must install a directory service
* provider which provides NS_APP_USER_PROFILE_50_DIR and optionally
* NS_APP_USER_PROFILE_LOCAL_50_DIR. Component registration information
* will be stored in the application directory and JS components will not
* fastload.
* </li>
* </ul>
*
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public void notifyProfile() {
try {
gre.notifyProfile();
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Initializes XPCOM. You must call this method before proceeding
* to use XPCOM.
*
* @param aMozBinDirectory The directory containing the component
* registry and runtime libraries;
* or use <code>null</code> to use the working
* directory.
*
* @param aAppFileLocProvider The object to be used by Gecko that specifies
* to Gecko where to find profiles, the component
* registry preferences and so on; or use
* <code>null</code> for the default behaviour.
*
* @return the service manager
*
* @throws XPCOMException <ul>
* <li> NS_ERROR_NOT_INITIALIZED - if static globals were not initialied,
* which can happen if XPCOM is reloaded, but did not completly
* shutdown. </li>
* <li> Other error codes indicate a failure during initialisation. </li>
* </ul>
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public nsIServiceManager initXPCOM(File aMozBinDirectory,
IAppFileLocProvider aAppFileLocProvider) throws XPCOMException {
try {
return xpcom.initXPCOM(aMozBinDirectory, aAppFileLocProvider);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Shutdown XPCOM. You must call this method after you are finished
* using xpcom.
*
* @param aServMgr The service manager which was returned by initXPCOM.
* This will release servMgr.
*
* @throws XPCOMException if a failure occurred during termination
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public void shutdownXPCOM(nsIServiceManager aServMgr) throws XPCOMException {
try {
xpcom.shutdownXPCOM(aServMgr);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
} finally {
mozilla = null;
gre = null;
xpcom = null;
}
}
/**
* Public Method to access to the service manager.
*
* @return the service manager
*
* @throws XPCOMException if a failure occurred
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public nsIServiceManager getServiceManager() throws XPCOMException {
try {
return xpcom.getServiceManager();
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Public Method to access to the component manager.
*
* @return the component manager
*
* @throws XPCOMException if a failure occurred
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public nsIComponentManager getComponentManager() throws XPCOMException {
try {
return xpcom.getComponentManager();
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Public Method to access to the component registration manager.
*
* @return the component registration manager
*
* @throws XPCOMException if a failure occurred
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public nsIComponentRegistrar getComponentRegistrar() throws XPCOMException {
try {
return xpcom.getComponentRegistrar();
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* Public Method to create an instance of a nsILocalFile.
*
* @param aPath A string which specifies a full file path to a
* location. Relative paths will be treated as an
* error (NS_ERROR_FILE_UNRECOGNIZED_PATH).
* @param aFollowLinks This attribute will determine if the nsLocalFile will
* auto resolve symbolic links. By default, this value
* will be false on all non unix systems. On unix, this
* attribute is effectively a noop.
*
* @return an instance of an nsILocalFile that points to given path
*
* @throws XPCOMException <ul>
* <li> NS_ERROR_FILE_UNRECOGNIZED_PATH - raised for unrecognized paths
* or relative paths (must supply full file path) </li>
* </ul>
* @throws XPCOMInitializationException if Mozilla was not properly
* initialized
*/
public nsILocalFile newLocalFile(String aPath, boolean aFollowLinks)
throws XPCOMException {
try {
return xpcom.newLocalFile(aPath, aFollowLinks);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
/**
* If you create a class that implements nsISupports, you will need to provide
* an implementation of the <code>queryInterface</code> method. This helper
* function provides a simple implementation. Therefore, if your class does
* not need to do anything special with <code>queryInterface</code>, your
* implementation would look like:
* <pre>
* public nsISupports queryInterface(String aIID) {
* return XPCOM.queryInterface(this, aIID);
* }
* </pre>
*
* @param aObject object to query
* @param aIID requested interface IID
*
* @return <code>aObject</code> if the given object supports that
* interface;
* <code>null</code> otherwise.
*/
public static nsISupports queryInterface(nsISupports aObject, String aIID) {
ArrayList classes = new ArrayList();
classes.add(aObject.getClass());
while (!classes.isEmpty()) {
Class clazz = (Class) classes.remove(0);
// Skip over any class/interface in the "java.*" and "javax.*" domains.
String className = clazz.getName();
if (className.startsWith("java.") || className.startsWith("javax.")) {
continue;
}
// If given IID matches that of the current interface, then we
// know that aObject implements the interface specified by the given IID.
if (clazz.isInterface() && className.startsWith("org.mozilla")) {
String iid = Mozilla.getInterfaceIID(clazz);
if (iid != null && aIID.equals(iid)) {
return aObject;
}
}
// clazz didn't match, so add the interfaces it implements
Class[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length; i++ ) {
classes.add(interfaces[i]);
}
// Also add its superclass
Class superclass = clazz.getSuperclass();
if (superclass != null) {
classes.add(superclass);
}
}
return null;
}
/**
* Gets the interface IID for a particular Java interface. This is similar
* to NS_GET_IID in the C++ Mozilla files.
*
* @param aInterface interface which has defined an IID
*
* @return IID for given interface
*/
public static String getInterfaceIID(Class aInterface) {
// Get short class name (i.e. "bar", not "org.blah.foo.bar")
StringBuffer iidName = new StringBuffer();
String fullClassName = aInterface.getName();
int index = fullClassName.lastIndexOf(".");
String className = index > 0 ? fullClassName.substring(index + 1)
: fullClassName;
// Create iid field name
if (className.startsWith("ns")) {
iidName.append("NS_");
iidName.append(className.substring(2).toUpperCase());
} else {
iidName.append(className.toUpperCase());
}
iidName.append("_IID");
String iid;
try {
Field iidField = aInterface.getDeclaredField(iidName.toString());
iid = (String) iidField.get(null);
} catch (NoSuchFieldException e) {
// Class may implement non-Mozilla interfaces, which would not have an
// IID method. In that case, just null.
iid = null;
} catch (IllegalAccessException e) {
// Not allowed to access that field for some reason. Write out an
// error message, but don't fail.
System.err.println("ERROR: Could not get field " + iidName.toString());
iid = null;
}
return iid;
}
public long getNativeHandleFromAWT(Object widget) {
try {
return mozilla.getNativeHandleFromAWT(widget);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
public long wrapJavaObject(Object aJavaObject, String aIID) {
try {
return jxutils.wrapJavaObject(aJavaObject, aIID);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
public Object wrapXPCOMObject(long aXPCOMObject, String aIID) {
try {
return jxutils.wrapXPCOMObject(aXPCOMObject, aIID);
} catch (NullPointerException e) {
throw new XPCOMInitializationException("Must call " +
"Mozilla.getInstance().initialize() before using this method", e);
}
}
}