| /* Preferences -- Preference node containing key value entries and subnodes |
| Copyright (C) 2001, 2004, 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| package java.util.prefs; |
| |
| import gnu.classpath.ServiceFactory; |
| import gnu.java.util.prefs.NodeReader; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.security.AccessController; |
| import java.security.Permission; |
| import java.security.PrivilegedAction; |
| import java.util.Iterator; |
| |
| /** |
| * Preference node containing key value entries and subnodes. |
| * <p> |
| * There are two preference node trees, a system tree which can be accessed |
| * by calling <code>systemRoot()</code> containing system preferences usefull |
| * for all users, and a user tree that can be accessed by calling |
| * <code>userRoot()</code> containing preferences that can differ between |
| * different users. How different users are identified is implementation |
| * depended. It can be determined by Thread, Access Control Context or Subject. |
| * <p> |
| * This implementation uses the "java.util.prefs.PreferencesFactory" system |
| * property to find a class that implement <code>PreferencesFactory</code> |
| * and initialized that class (if it has a public no arguments contructor) |
| * to get at the actual system or user root. If the system property is not set, |
| * or the class cannot be initialized it uses the default implementation |
| * <code>gnu.java.util.prefs.FileBasedFactory</code>. |
| * <p> |
| * Besides the two static method above to get the roots of the system and user |
| * preference node trees there are also two convenience methods to access the |
| * default preference node for a particular package an object is in. These are |
| * <code>userNodeForPackage()</code> and <code>systemNodeForPackage()</code>. |
| * Both methods take an Object as an argument so accessing preferences values |
| * can be as easy as calling <code>Preferences.userNodeForPackage(this)</code>. |
| * <p> |
| * Note that if a security manager is installed all static methods check for |
| * <code>RuntimePermission("preferences")</code>. But if this permission is |
| * given to the code then it can access and change all (user) preference nodes |
| * and entries. So you should be carefull not to store to sensitive information |
| * or make security decissions based on preference values since there is no |
| * more fine grained control over what preference values can be changed once |
| * code has been given the correct runtime permission. |
| * <p> |
| * XXX |
| * |
| * @since 1.4 |
| * @author Mark Wielaard (mark@klomp.org) |
| */ |
| public abstract class Preferences { |
| |
| // Static Fields |
| |
| /** |
| * Default PreferencesFactory class used when the system property |
| * "java.util.prefs.PreferencesFactory" is not set. |
| */ |
| private static final String defaultFactoryClass |
| = "gnu.java.util.prefs.FileBasedFactory"; |
| |
| /** Permission needed to access system or user root. */ |
| private static final Permission prefsPermission |
| = new RuntimePermission("preferences"); |
| |
| /** |
| * The preferences factory object that supplies the system and user root. |
| * Set and returned by the getFactory() method. |
| */ |
| private static PreferencesFactory factory; |
| |
| /** Maximum node name length. 80 characters. */ |
| public static final int MAX_NAME_LENGTH = 80; |
| |
| /** Maximum entry key length. 80 characters. */ |
| public static final int MAX_KEY_LENGTH = 80; |
| |
| /** Maximum entry value length. 8192 characters. */ |
| public static final int MAX_VALUE_LENGTH = 8192; |
| |
| // Constructors |
| |
| /** |
| * Creates a new Preferences node. Can only be used by subclasses. |
| * Empty implementation. |
| */ |
| protected Preferences() {} |
| |
| // Static methods |
| |
| /** |
| * Returns the system preferences root node containing usefull preferences |
| * for all users. It is save to cache this value since it should always |
| * return the same preference node. |
| * |
| * @return the root system preference node |
| * @exception SecurityException when a security manager is installed and |
| * the caller does not have <code>RuntimePermission("preferences")</code>. |
| */ |
| public static Preferences systemRoot() throws SecurityException { |
| // Get the preferences factory and check for permission |
| PreferencesFactory factory = getFactory(); |
| |
| return factory.systemRoot(); |
| } |
| |
| /** |
| * Returns the user preferences root node containing preferences for the |
| * the current user. How different users are identified is implementation |
| * depended. It can be determined by Thread, Access Control Context or |
| * Subject. |
| * |
| * @return the root user preference node |
| * @exception SecurityException when a security manager is installed and |
| * the caller does not have <code>RuntimePermission("preferences")</code>. |
| */ |
| public static Preferences userRoot() throws SecurityException { |
| // Get the preferences factory and check for permission |
| PreferencesFactory factory = getFactory(); |
| return factory.userRoot(); |
| } |
| |
| /** |
| * Private helper method for <code>systemRoot()</code> and |
| * <code>userRoot()</code>. Checks security permission and instantiates the |
| * correct factory if it has not yet been set. |
| * <p> |
| * When the preferences factory has not yet been set this method first |
| * tries to get the system propery "java.util.prefs.PreferencesFactory" |
| * and tries to initializes that class. If the system property is not set |
| * or initialization fails it returns an instance of the default factory |
| * <code>gnu.java.util.prefs.FileBasedPreferencesFactory</code>. |
| * |
| * @return the preferences factory to use |
| * @exception SecurityException when a security manager is installed and |
| * the caller does not have <code>RuntimePermission("preferences")</code>. |
| */ |
| private static PreferencesFactory getFactory() throws SecurityException { |
| |
| // First check for permission |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(prefsPermission); |
| } |
| |
| // Get the factory |
| if (factory == null) { |
| // Caller might not have enough permissions |
| factory = (PreferencesFactory) AccessController.doPrivileged( |
| new PrivilegedAction() { |
| public Object run() { |
| PreferencesFactory pf = null; |
| String className = System.getProperty |
| ("java.util.prefs.PreferencesFactory"); |
| if (className != null) { |
| try { |
| Class fc = Class.forName(className); |
| Object o = fc.newInstance(); |
| pf = (PreferencesFactory) o; |
| } catch (ClassNotFoundException cnfe) |
| {/*ignore*/} |
| catch (InstantiationException ie) |
| {/*ignore*/} |
| catch (IllegalAccessException iae) |
| {/*ignore*/} |
| catch (ClassCastException cce) |
| {/*ignore*/} |
| } |
| return pf; |
| } |
| }); |
| |
| // Still no factory? Try to see if we have one defined |
| // as a System Preference |
| if (factory == null) |
| { |
| Iterator iter = ServiceFactory.lookupProviders |
| (PreferencesFactory.class, null); |
| |
| if (iter != null && iter.hasNext()) |
| factory = (PreferencesFactory) iter.next(); |
| } |
| |
| // Still no factory? Use our default. |
| if (factory == null) |
| { |
| try |
| { |
| Class cls = Class.forName (defaultFactoryClass); |
| factory = (PreferencesFactory) cls.newInstance(); |
| } |
| catch (Exception e) |
| { |
| throw new RuntimeException ("Couldn't load default factory" |
| + " '"+ defaultFactoryClass +"'", e); |
| } |
| } |
| |
| } |
| |
| return factory; |
| } |
| |
| /** |
| * Returns the system preferences node for the package of a class. |
| * The package node name of the class is determined by dropping the |
| * final component of the fully qualified class name and |
| * changing all '.' to '/' in the package name. If the class of the |
| * object has no package then the package node name is "<unnamed>". |
| * The returned node is <code>systemRoot().node(packageNodeName)</code>. |
| * |
| * @param c Object whose default system preference node is requested |
| * @returns system preferences node that should be used by class c |
| * @exception SecurityException when a security manager is installed and |
| * the caller does not have <code>RuntimePermission("preferences")</code>. |
| */ |
| public static Preferences systemNodeForPackage(Class c) |
| throws SecurityException |
| { |
| return nodeForPackage(c, systemRoot()); |
| } |
| |
| /** |
| * Returns the user preferences node for the package of a class. |
| * The package node name of the class is determined by dropping the |
| * final component of the fully qualified class name and |
| * changing all '.' to '/' in the package name. If the class of the |
| * object has no package then the package node name is "<unnamed>". |
| * The returned node is <code>userRoot().node(packageNodeName)</code>. |
| * |
| * @param c Object whose default userpreference node is requested |
| * @returns userpreferences node that should be used by class c |
| * @exception SecurityException when a security manager is installed and |
| * the caller does not have <code>RuntimePermission("preferences")</code>. |
| */ |
| public static Preferences userNodeForPackage(Class c) |
| throws SecurityException |
| { |
| return nodeForPackage(c, userRoot()); |
| } |
| |
| /** |
| * Private helper method for <code>systemNodeForPackage()</code> and |
| * <code>userNodeForPackage()</code>. Given the correct system or user |
| * root it returns the correct Preference node for the package node name |
| * of the given object. |
| */ |
| private static Preferences nodeForPackage(Class c, Preferences root) { |
| // Get the package path |
| String className = c.getName(); |
| String packagePath; |
| int index = className.lastIndexOf('.'); |
| if(index == -1) { |
| packagePath = "<unnamed>"; |
| } else { |
| packagePath = className.substring(0,index).replace('.','/'); |
| } |
| |
| return root.node(packagePath); |
| } |
| |
| /** |
| * Import preferences from the given input stream. This expects |
| * preferences to be represented in XML as emitted by |
| * {@link #exportNode(OutputStream)} and |
| * {@link #exportSubtree(OutputStream)}. |
| * @throws IOException if there is an error while reading |
| * @throws InvalidPreferencesFormatException if the XML is not properly |
| * formatted |
| */ |
| public static void importPreferences(InputStream is) |
| throws InvalidPreferencesFormatException, |
| IOException |
| { |
| PreferencesFactory factory = getFactory(); |
| NodeReader reader = new NodeReader(is, factory); |
| reader.importPreferences(); |
| } |
| |
| // abstract methods (identification) |
| |
| /** |
| * Returns the absolute path name of this preference node. |
| * The absolute path name of a node is the path name of its parent node |
| * plus a '/' plus its own name. If the node is the root node and has no |
| * parent then its name is "" and its absolute path name is "/". |
| */ |
| public abstract String absolutePath(); |
| |
| /** |
| * Returns true if this node comes from the user preferences tree, false |
| * if it comes from the system preferences tree. |
| */ |
| public abstract boolean isUserNode(); |
| |
| /** |
| * Returns the name of this preferences node. The name of the node cannot |
| * be null, can be mostly 80 characters and cannot contain any '/' |
| * characters. The root node has as name "". |
| */ |
| public abstract String name(); |
| |
| /** |
| * Returns the String given by |
| * <code> |
| * (isUserNode() ? "User":"System") + " Preference Node: " + absolutePath() |
| * </code> |
| */ |
| public abstract String toString(); |
| |
| // abstract methods (navigation) |
| |
| /** |
| * Returns all the direct sub nodes of this preferences node. |
| * Needs access to the backing store to give a meaningfull answer. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract String[] childrenNames() throws BackingStoreException; |
| |
| /** |
| * Returns a sub node of this preferences node if the given path is |
| * relative (does not start with a '/') or a sub node of the root |
| * if the path is absolute (does start with a '/'). |
| * |
| * @exception IllegalStateException if this node has been removed |
| * @exception IllegalArgumentException if the path contains two or more |
| * consecutive '/' characters, ends with a '/' charactor and is not the |
| * string "/" (indicating the root node) or any name on the path is more |
| * then 80 characters long |
| */ |
| public abstract Preferences node(String path); |
| |
| /** |
| * Returns true if the node that the path points to exists in memory or |
| * in the backing store. Otherwise it returns false or an exception is |
| * thrown. When this node is removed the only valid parameter is the |
| * empty string (indicating this node), the return value in that case |
| * will be false. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has been removed |
| * and the path is not the empty string (indicating this node) |
| * @exception IllegalArgumentException if the path contains two or more |
| * consecutive '/' characters, ends with a '/' charactor and is not the |
| * string "/" (indicating the root node) or any name on the path is more |
| * then 80 characters long |
| */ |
| public abstract boolean nodeExists(String path) |
| throws BackingStoreException; |
| |
| /** |
| * Returns the parent preferences node of this node or null if this is |
| * the root of the preferences tree. |
| * |
| * @exception IllegalStateException if this node has been removed |
| */ |
| public abstract Preferences parent(); |
| |
| // abstract methods (export) |
| |
| /** |
| * Export this node, but not its descendants, as XML to the |
| * indicated output stream. The XML will be encoded using UTF-8 |
| * and will use a specified document type:<br> |
| * <code><!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd"></code><br> |
| * @param os the output stream to which the XML is sent |
| * @throws BackingStoreException if preference data cannot be read |
| * @throws IOException if an error occurs while writing the XML |
| * @throws IllegalStateException if this node or an ancestor has been removed |
| */ |
| public abstract void exportNode(OutputStream os) |
| throws BackingStoreException, |
| IOException; |
| |
| /** |
| * Export this node and all its descendants as XML to the |
| * indicated output stream. The XML will be encoded using UTF-8 |
| * and will use a specified document type:<br> |
| * <code><!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd"></code><br> |
| * @param os the output stream to which the XML is sent |
| * @throws BackingStoreException if preference data cannot be read |
| * @throws IOException if an error occurs while writing the XML |
| * @throws IllegalStateException if this node or an ancestor has been removed |
| */ |
| public abstract void exportSubtree(OutputStream os) |
| throws BackingStoreException, |
| IOException; |
| |
| // abstract methods (preference entry manipulation) |
| |
| /** |
| * Returns an (possibly empty) array with all the keys of the preference |
| * entries of this node. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has been removed |
| */ |
| public abstract String[] keys() throws BackingStoreException; |
| |
| /** |
| * Returns the value associated with the key in this preferences node. If |
| * the default value of the key cannot be found in the preferences node |
| * entries or something goes wrong with the backing store the supplied |
| * default value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract String get(String key, String defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as a boolean. |
| * When the string representation of the requested entry is either |
| * "true" or "false" (ignoring case) then that value is returned, |
| * otherwise the given default boolean value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract boolean getBoolean(String key, boolean defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as a byte array. |
| * When the string representation of the requested entry is a valid |
| * Base64 encoded string (without any other characters, such as newlines) |
| * then the decoded Base64 string is returned as byte array, |
| * otherwise the given default byte array value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract byte[] getByteArray(String key, byte[] defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as a double. |
| * When the string representation of the requested entry can be decoded |
| * with <code>Double.parseDouble()</code> then that double is returned, |
| * otherwise the given default double value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract double getDouble(String key, double defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as a float. |
| * When the string representation of the requested entry can be decoded |
| * with <code>Float.parseFloat()</code> then that float is returned, |
| * otherwise the given default float value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract float getFloat(String key, float defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as an integer. |
| * When the string representation of the requested entry can be decoded |
| * with <code>Integer.parseInt()</code> then that integer is returned, |
| * otherwise the given default integer value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract int getInt(String key, int defaultVal); |
| |
| /** |
| * Convenience method for getting the given entry as a long. |
| * When the string representation of the requested entry can be decoded |
| * with <code>Long.parseLong()</code> then that long is returned, |
| * otherwise the given default long value is returned. |
| * |
| * @exception IllegalArgumentException if key is larger then 80 characters |
| * @exception IllegalStateException if this node has been removed |
| * @exception NullPointerException if key is null |
| */ |
| public abstract long getLong(String key, long defaultVal); |
| |
| /** |
| * Sets the value of the given preferences entry for this node. |
| * Key and value cannot be null, the key cannot exceed 80 characters |
| * and the value cannot exceed 8192 characters. |
| * <p> |
| * The result will be immediatly visible in this VM, but may not be |
| * immediatly written to the backing store. |
| * |
| * @exception NullPointerException if either key or value are null |
| * @exception IllegalArgumentException if either key or value are to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void put(String key, String value); |
| |
| /** |
| * Convenience method for setting the given entry as a boolean. |
| * The boolean is converted with <code>Boolean.toString(value)</code> |
| * and then stored in the preference entry as that string. |
| * |
| * @exception NullPointerException if key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putBoolean(String key, boolean value); |
| |
| /** |
| * Convenience method for setting the given entry as an array of bytes. |
| * The byte array is converted to a Base64 encoded string |
| * and then stored in the preference entry as that string. |
| * <p> |
| * Note that a byte array encoded as a Base64 string will be about 1.3 |
| * times larger then the original length of the byte array, which means |
| * that the byte array may not be larger about 6 KB. |
| * |
| * @exception NullPointerException if either key or value are null |
| * @exception IllegalArgumentException if either key or value are to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putByteArray(String key, byte[] value); |
| |
| /** |
| * Convenience method for setting the given entry as a double. |
| * The double is converted with <code>Double.toString(double)</code> |
| * and then stored in the preference entry as that string. |
| * |
| * @exception NullPointerException if the key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putDouble(String key, double value); |
| |
| /** |
| * Convenience method for setting the given entry as a float. |
| * The float is converted with <code>Float.toString(float)</code> |
| * and then stored in the preference entry as that string. |
| * |
| * @exception NullPointerException if the key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putFloat(String key, float value); |
| |
| /** |
| * Convenience method for setting the given entry as an integer. |
| * The integer is converted with <code>Integer.toString(int)</code> |
| * and then stored in the preference entry as that string. |
| * |
| * @exception NullPointerException if the key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putInt(String key, int value); |
| |
| /** |
| * Convenience method for setting the given entry as a long. |
| * The long is converted with <code>Long.toString(long)</code> |
| * and then stored in the preference entry as that string. |
| * |
| * @exception NullPointerException if the key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void putLong(String key, long value); |
| |
| /** |
| * Removes the preferences entry from this preferences node. |
| * <p> |
| * The result will be immediatly visible in this VM, but may not be |
| * immediatly written to the backing store. |
| * |
| * @exception NullPointerException if the key is null |
| * @exception IllegalArgumentException if the key length is to large |
| * @exception IllegalStateException when this node has been removed |
| */ |
| public abstract void remove(String key); |
| |
| // abstract methods (preference node manipulation) |
| |
| /** |
| * Removes all entries from this preferences node. May need access to the |
| * backing store to get and clear all entries. |
| * <p> |
| * The result will be immediatly visible in this VM, but may not be |
| * immediatly written to the backing store. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has been removed |
| */ |
| public abstract void clear() throws BackingStoreException; |
| |
| /** |
| * Writes all preference changes on this and any subnode that have not |
| * yet been written to the backing store. This has no effect on the |
| * preference entries in this VM, but it makes sure that all changes |
| * are visible to other programs (other VMs might need to call the |
| * <code>sync()</code> method to actually see the changes to the backing |
| * store. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has been removed |
| */ |
| public abstract void flush() throws BackingStoreException; |
| |
| /** |
| * Writes and reads all preference changes to and from this and any |
| * subnodes. This makes sure that all local changes are written to the |
| * backing store and that all changes to the backing store are visible |
| * in this preference node (and all subnodes). |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has been removed |
| */ |
| public abstract void sync() throws BackingStoreException; |
| |
| /** |
| * Removes this and all subnodes from the backing store and clears all |
| * entries. After removal this instance will not be useable (except for |
| * a few methods that don't throw a <code>InvalidStateException</code>), |
| * even when a new node with the same path name is created this instance |
| * will not be usable again. The root (system or user) may never be removed. |
| * <p> |
| * Note that according to the specification an implementation may delay |
| * removal of the node from the backing store till the <code>flush()</code> |
| * method is called. But the <code>flush()</code> method may throw a |
| * <code>IllegalStateException</code> when the node has been removed. |
| * So most implementations will actually remove the node and any subnodes |
| * from the backing store immediatly. |
| * |
| * @exception BackingStoreException when the backing store cannot be |
| * reached |
| * @exception IllegalStateException if this node has already been removed |
| * @exception UnsupportedOperationException if this is a root node |
| */ |
| public abstract void removeNode() throws BackingStoreException; |
| |
| // abstract methods (listeners) |
| |
| public abstract void addNodeChangeListener(NodeChangeListener listener); |
| |
| public abstract void addPreferenceChangeListener |
| (PreferenceChangeListener listener); |
| |
| public abstract void removeNodeChangeListener(NodeChangeListener listener); |
| |
| public abstract void removePreferenceChangeListener |
| (PreferenceChangeListener listener); |
| } |
| |
