| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.util.logging; |
| |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| import java.util.StringTokenizer; |
| |
| import org.apache.harmony.logging.internal.nls.Messages; |
| |
| /** |
| * Loggers are used to log records to certain outputs, including file, console, |
| * etc. They use various handlers to actually do the output-dependent |
| * operations. |
| * <p> |
| * Client applications can get named loggers by calling the {@code getLogger} |
| * methods. They can also get anonymous loggers by calling the |
| * {@code getAnonymousLogger} methods. Named loggers are organized in a |
| * namespace hierarchy managed by a log manager. The naming convention is |
| * usually the same as java package's naming convention, that is using |
| * dot-separated strings. Anonymous loggers do not belong to any namespace. |
| * </p> |
| * <p> |
| * Loggers "inherit" log level setting from their parent if their own level is |
| * set to {@code null}. This is also true for the resource bundle. The logger's |
| * resource bundle is used to localize the log messages if no resource bundle |
| * name is given when a log method is called. If {@code getUseParentHandlers()} |
| * returns {@code true}, loggers also inherit their parent's handlers. In this |
| * context, "inherit" only means that "behavior" is inherited. The internal |
| * field values will not change, for example, {@code getLevel()} still returns |
| * {@code null}. |
| * </p> |
| * <p> |
| * When loading a given resource bundle, the logger first tries to use the |
| * context classloader. If that fails, it tries the system classloader. And if |
| * that still fails, it searches up the class stack and uses each class's |
| * classloader to try to locate the resource bundle. |
| * </p> |
| * <p> |
| * Some log methods accept log requests that do not specify the source class and |
| * source method. In these cases, the logging framework will automatically infer |
| * the calling class and method, but this is not guaranteed to be accurate. |
| * </p> |
| * <p> |
| * Once a {@code LogRecord} object has been passed into the logging framework, |
| * it is owned by the logging framework and the client applications should not |
| * use it any longer. |
| * </p> |
| * <p> |
| * All methods of this class are thread-safe. |
| * </p> |
| * |
| * @see LogManager |
| * @since Android 1.0 |
| */ |
| public class Logger { |
| |
| /** |
| * The global logger is provided as convenience for casual use. |
| * |
| * @since Android 1.0 |
| */ |
| public final static Logger global = new Logger("global", null); //$NON-NLS-1$ |
| |
| // the name of this logger |
| private volatile String name; |
| |
| // the parent logger of this logger |
| private Logger parent; |
| |
| // the logging level of this logger |
| private volatile Level levelObjVal; |
| |
| // the logging level as int of this logger |
| private volatile int levelIntVal; |
| |
| // the filter |
| private Filter filter; |
| |
| // the name of the resource bundle used to localize logging messages |
| private String resBundleName; |
| |
| // the loaded resource bundle according to the specified name |
| private ResourceBundle resBundle; |
| |
| // the handlers attached to this logger |
| private List<Handler> handlers; |
| |
| /* |
| * flag indicating whether to notify parent's handlers on receiving a log |
| * request |
| */ |
| private boolean notifyParentHandlers; |
| |
| // flag indicating whether this logger is named or anonymous |
| private boolean isNamed; |
| |
| private List<Logger> childs; |
| |
| private LogManager manager; |
| |
| // BEGIN android-changed |
| private volatile boolean handlerInited; |
| // END android-changed |
| |
| |
| /* |
| * ------------------------------------------------------------------- |
| * Constructors |
| * ------------------------------------------------------------------- |
| */ |
| |
| /** |
| * Constructs a {@code Logger} object with the supplied name and resource |
| * bundle name; {@code notifiyParentHandlers} is set to {@code true}. |
| * <p> |
| * Notice : Loggers use a naming hierarchy. Thus "z.x.y" is a child of "z.x". |
| * </p> |
| * |
| * @param name |
| * the name of this logger, may be {@code null} for anonymous |
| * loggers. |
| * @param resourceBundleName |
| * the name of the resource bundle used to localize logging |
| * messages, may be {@code null}. |
| * @throws MissingResourceException |
| * if the specified resource bundle can not be loaded. |
| * @since Android 1.0 |
| */ |
| protected Logger(String name, String resourceBundleName) { |
| // try to load the specified resource bundle first |
| if (null == resourceBundleName) { |
| this.resBundleName = null; |
| this.resBundle = null; |
| } else { |
| this.resBundle = loadResourceBundle(resourceBundleName); |
| this.resBundleName = resourceBundleName; |
| } |
| this.name = name; |
| this.parent = null; |
| this.filter = null; |
| this.childs = new ArrayList<Logger>(); |
| this.notifyParentHandlers = true; |
| // any logger is not anonymous by default |
| this.isNamed = true; |
| |
| //-- 'null' means that level will be inherited from parent (see getLevel) |
| //-- Level.INFO is default level if we don't set it. It will be |
| //-- changed to parent level or to configLevel after adding to the |
| //-- family tree. As of this, actually, setting to Level.INFO is |
| //-- not needed here. |
| this.levelObjVal = null; |
| this.levelIntVal = Level.INFO.intValue(); |
| } |
| |
| //-- should be called under the lm lock |
| private void setLevelImpl(Level newLevel) { |
| // update levels for the whole hierarchy |
| int oldVal = levelIntVal; |
| levelObjVal = newLevel; |
| if (null == newLevel) { |
| levelIntVal = null != parent |
| ? parent.levelIntVal |
| : Level.INFO.intValue(); |
| } else { |
| levelIntVal = newLevel.intValue(); |
| } |
| if (oldVal != levelIntVal) { |
| forceChildsToInherit(); |
| } |
| } |
| |
| //-- should be called under the lm lock |
| private void forceChildsToInherit() { |
| for (Logger child : childs) { |
| if (null == child.levelObjVal) { // should inherit |
| child.setLevelImpl(null); |
| } |
| } |
| } |
| |
| /* |
| * ------------------------------------------------------------------- |
| * Methods |
| * ------------------------------------------------------------------- |
| */ |
| |
| /** |
| * Load the specified resource bundle, use privileged code. |
| * |
| * @param resourceBundleName |
| * the name of the resource bundle to load, cannot be {@code null}. |
| * @return the loaded resource bundle. |
| * @throws MissingResourceException |
| * if the specified resource bundle can not be loaded. |
| */ |
| static ResourceBundle loadResourceBundle(String resourceBundleName) { |
| // try context class loader to load the resource |
| ClassLoader cl = AccessController.doPrivileged( |
| new PrivilegedAction<ClassLoader>() { |
| public ClassLoader run() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| }); |
| if (null != cl) { |
| try { |
| return ResourceBundle.getBundle(resourceBundleName, Locale |
| .getDefault(), cl); |
| } catch (MissingResourceException e) { |
| // Failed to load using context classloader, ignore |
| } |
| } |
| // try system class loader to load the resource |
| cl = AccessController.doPrivileged( |
| new PrivilegedAction<ClassLoader>() { |
| public ClassLoader run() { |
| return ClassLoader.getSystemClassLoader(); |
| } |
| }); |
| if (null != cl) { |
| try { |
| return ResourceBundle.getBundle(resourceBundleName, Locale |
| .getDefault(), cl); |
| } catch (MissingResourceException e) { |
| // Failed to load using system classloader, ignore |
| } |
| } |
| // try all class loaders up the class stack |
| final Class<?>[] classes = AccessController |
| .doPrivileged(new PrivilegedAction<Class<?>[]>() { |
| public Class<?>[] run() { |
| return (new PrivateSecurityManager()) |
| .privateGetClassContext(); |
| } |
| }); |
| // the first class, which is PrivateSecurityManager, is skipped |
| for (int i = 1; i < classes.length; i++) { |
| final int index = i; |
| try { |
| cl = AccessController.doPrivileged( |
| new PrivilegedAction<ClassLoader>() { |
| public ClassLoader run() { |
| return classes[index].getClassLoader(); |
| } |
| }); |
| if (null == cl) { |
| continue; |
| } |
| return ResourceBundle.getBundle(resourceBundleName, Locale |
| .getDefault(), cl); |
| } catch (MissingResourceException e) { |
| // Failed to load using the current class's classloader, ignore |
| } |
| } |
| // logging.8=Failed to load the specified resource bundle "{0}". |
| throw new MissingResourceException(Messages.getString("logging.8", //$NON-NLS-1$ |
| resourceBundleName), resourceBundleName, null); |
| } |
| |
| /** |
| * Gets an anonymous logger to use internally in a thread. Anonymous loggers |
| * are not registered in the log manager's namespace. No security checks |
| * will be performed when updating an anonymous logger's control settings. |
| * <p> |
| * The anonymous loggers' parent is set to be the root logger. This way it |
| * inherits the default logging level and handlers from the root logger. |
| * </p> |
| * |
| * @return a new instance of anonymous logger. |
| * @since Android 1.0 |
| */ |
| public static Logger getAnonymousLogger() { |
| return getAnonymousLogger(null); |
| } |
| |
| /** |
| * Gets an anonymous logger to use internally in a thread. Anonymous loggers |
| * are not registered in the log manager's namespace. No security checks |
| * will be performed when updating an anonymous logger's control settings. |
| * <p> |
| * The anonymous loggers' parent is set to be the root logger. This way it |
| * inherits default logging level and handlers from the root logger. |
| * </p> |
| * |
| * @param resourceBundleName |
| * the name of the resource bundle used to localize log messages. |
| * @return a new instance of anonymous logger. |
| * @throws MissingResourceException |
| * if the specified resource bundle can not be loaded. |
| * @since Android 1.0 |
| */ |
| public static Logger getAnonymousLogger(String resourceBundleName) { |
| final Logger l = new Logger(null, resourceBundleName); |
| l.isNamed = false; |
| l.internalSetParent(LogManager.getLogManager().getLogger("")); //$NON-NLS-1$ |
| return l; |
| } |
| |
| /* |
| * Check whether the same resource bundle has been specified. |
| * Synchronize to ensure the consistency between resource bundle |
| * and its name. |
| */ |
| private static void updateResourceBundle(Logger l, String resourceBundleName) { |
| synchronized (l) { |
| if (null == l.getResourceBundleName()) { |
| if(null == resourceBundleName){ |
| return; |
| } |
| /* |
| * load the resource bundle if none is specified |
| * before |
| */ |
| l.resBundle = loadResourceBundle(resourceBundleName); |
| l.resBundleName = resourceBundleName; |
| } else if (!l.getResourceBundleName().equals(resourceBundleName)) { |
| /* |
| * throw exception if the specified resource bundles |
| * are inconsistent with each other, i.e., different |
| * names |
| */ |
| // logging.9=The specified resource bundle name "{0}" is |
| // inconsistent with the existing one "{1}". |
| throw new IllegalArgumentException(Messages.getString( |
| "logging.9", //$NON-NLS-1$ |
| resourceBundleName, l.getResourceBundleName())); |
| } |
| } |
| } |
| |
| /* |
| * Gets a named logger associated with the supplied resource bundle. This |
| * method accepts null resource bundle name. The method body is synchronized |
| * on the instance of the LogManager to insure the consistency of the whole |
| * operation. |
| */ |
| private static Logger getLoggerWithRes(String name, |
| String resourceBundleName, boolean hasResourceName) { |
| LogManager man = LogManager.getLogManager(); |
| Logger l = null; |
| synchronized (man) { |
| // Try to find an existing logger with the specified name |
| l = man.getLogger(name); |
| // If no existing logger with the same name, create a new one |
| if (null == l) { |
| l = new Logger(name, resourceBundleName); |
| man.addLogger(l); |
| return l; |
| } |
| } |
| if (hasResourceName) { |
| updateResourceBundle(l, resourceBundleName); |
| } |
| return l; |
| } |
| |
| /** |
| * Gets a named logger. The returned logger may already exist or may be |
| * newly created. In the latter case, its level will be set to the |
| * configured level according to the {@code LogManager}'s properties. |
| * |
| * @param name |
| * the name of the logger to get, cannot be {@code null}. |
| * @return a named logger. |
| * @since Android 1.0 |
| */ |
| public static Logger getLogger(String name) { |
| return getLoggerWithRes(name, null, false); |
| } |
| |
| /** |
| * Gets a named logger associated with the supplied resource bundle. The |
| * resource bundle will be used to localize logging messages. |
| * |
| * @param name |
| * the name of the logger to get, cannot be {@code null}. |
| * @param resourceBundleName |
| * the name of the resource bundle, may be {@code null}. |
| * @throws IllegalArgumentException |
| * if the logger identified by {@code name} is associated with a |
| * resource bundle and its name is not equal to |
| * {@code resourceBundleName}. |
| * @throws MissingResourceException |
| * if the name of the resource bundle cannot be found. |
| * @return a named logger. |
| * @since Android 1.0 |
| */ |
| public static Logger getLogger(String name, String resourceBundleName) { |
| return getLoggerWithRes(name, resourceBundleName, true); |
| } |
| |
| /** |
| * Adds a handler to this logger. The {@code name} will be fed with log |
| * records received by this logger. |
| * |
| * @param handler |
| * the handler object to add, cannot be {@code null}. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void addHandler(Handler handler) { |
| if (null == handler) { |
| // logging.A=The 'handler' parameter is null. |
| throw new NullPointerException(Messages.getString("logging.A")); //$NON-NLS-1$ |
| } |
| // Anonymous loggers can always add handlers |
| if (this.isNamed) { |
| LogManager.getLogManager().checkAccess(); |
| } |
| initHandler(); |
| synchronized(this){ |
| this.handlers.add(handler); |
| } |
| } |
| |
| /* |
| * Be cautious to avoid deadlock when using this method, it gets lock on manager |
| * at first, and then gets lock on this Logger, so any methods should not hold |
| * lock on this Logger when invoking this method. |
| */ |
| private void initHandler() { |
| if(!handlerInited){ |
| synchronized (this) { |
| if (!handlerInited) { |
| // BEGIN android-added |
| /* |
| * Force LogManager to be initialized, since its |
| * class init code performs necessary one-time setup. |
| */ |
| LogManager.getLogManager(); |
| // END android-added |
| if (handlers == null) { |
| handlers = new ArrayList<Handler>(); |
| } |
| if (manager == null) { |
| return; |
| } |
| |
| String handlerStr = manager |
| .getProperty("".equals(name) ? "handlers" : name + ".handlers"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| if (null == handlerStr) { |
| return; |
| } |
| StringTokenizer st = new StringTokenizer(handlerStr, " "); //$NON-NLS-1$ |
| while (st.hasMoreTokens()) { |
| String handlerName = st.nextToken(); |
| // BEGIN android-changed |
| // deal with non-existing handler |
| try { |
| Handler handler = (Handler) LogManager |
| .getInstanceByClass(handlerName); |
| handlers.add(handler); |
| String level = manager.getProperty(handlerName |
| + ".level"); //$NON-NLS-1$ |
| if (null != level) { |
| handler.setLevel(Level.parse(level)); |
| } |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| } |
| // END android-changed |
| } |
| handlerInited = true; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Gets all the handlers associated with this logger. |
| * |
| * @return an array of all the handlers associated with this logger. |
| * @since Android 1.0 |
| */ |
| public Handler[] getHandlers() { |
| initHandler(); |
| synchronized(this){ |
| return handlers.toArray(new Handler[handlers.size()]); |
| } |
| } |
| |
| /** |
| * Removes a handler from this logger. If the specified handler does not |
| * exist then this method has no effect. |
| * |
| * @param handler |
| * the handler to be removed. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void removeHandler(Handler handler) { |
| // Anonymous loggers can always remove handlers |
| if (this.isNamed) { |
| LogManager.getLogManager().checkAccess(); |
| } |
| if (null == handler) { |
| return; |
| } |
| initHandler(); |
| synchronized(this){ |
| this.handlers.remove(handler); |
| } |
| } |
| |
| /** |
| * Gets the filter used by this logger. |
| * |
| * @return the filter used by this logger, may be {@code null}. |
| * @since Android 1.0 |
| */ |
| public Filter getFilter() { |
| return this.filter; |
| } |
| |
| /** |
| * Sets the filter used by this logger. |
| * |
| * @param newFilter |
| * the filter to set, may be {@code null}. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void setFilter(Filter newFilter) { |
| // Anonymous loggers can always set the filter |
| if (this.isNamed) { |
| LogManager.getLogManager().checkAccess(); |
| } |
| filter = newFilter; |
| } |
| |
| /** |
| * Gets the logging level of this logger. A {@code null} level indicates |
| * that this logger inherits its parent's level. |
| * |
| * @return the logging level of this logger. |
| * @since Android 1.0 |
| */ |
| public Level getLevel() { |
| return levelObjVal; |
| } |
| |
| /** |
| * Sets the logging level for this logger. A {@code null} level indicates |
| * that this logger will inherit its parent's level. |
| * |
| * @param newLevel |
| * the logging level to set. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void setLevel(Level newLevel) { |
| // Anonymous loggers can always set the level |
| if (this.isNamed) { |
| LogManager.getLogManager().checkAccess(); |
| } |
| synchronized (LogManager.getLogManager()) { |
| setLevelImpl(newLevel); |
| } |
| } |
| |
| /** |
| * Gets the flag which indicates whether to use the handlers of this |
| * logger's parent to publish incoming log records, potentially recursively |
| * up the namespace. |
| * |
| * @return {@code true} if set to use parent's handlers, {@code false} |
| * otherwise. |
| * @since Android 1.0 |
| */ |
| public boolean getUseParentHandlers() { |
| return this.notifyParentHandlers; |
| } |
| |
| /** |
| * Sets the flag which indicates whether to use the handlers of this |
| * logger's parent, potentially recursively up the namespace. |
| * |
| * @param notifyParentHandlers |
| * the new flag indicating whether to use the parent's handlers. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void setUseParentHandlers(boolean notifyParentHandlers) { |
| // Anonymous loggers can always set the useParentHandlers flag |
| if (this.isNamed) { |
| LogManager.getLogManager().checkAccess(); |
| } |
| this.notifyParentHandlers = notifyParentHandlers; |
| } |
| |
| /** |
| * Gets the nearest parent of this logger in the namespace, a {@code null} |
| * value will be returned if called on the root logger. |
| * |
| * @return the parent of this logger in the namespace. |
| * @since Android 1.0 |
| */ |
| public Logger getParent() { |
| return parent; |
| } |
| |
| /** |
| * Sets the parent of this logger in the namespace. This method should |
| * usually be used by the {@code LogManager} object only. This method does |
| * not check security. |
| * |
| * @param newParent |
| * the parent logger to set. |
| * @since Android 1.0 |
| */ |
| void internalSetParent(Logger newParent) { |
| //All hierarchy related modifications should get LogManager lock at first |
| synchronized(LogManager.getLogManager()){ |
| parent = newParent; |
| // -- update level after setting a parent. |
| // -- if level == null we should inherit the parent's level |
| if (null == levelObjVal) { |
| setLevelImpl(levelObjVal); |
| } |
| newParent.addChild(this); |
| } |
| } |
| |
| /** |
| * Sets the parent of this logger in the namespace. This method should be |
| * used by the {@code LogManager} object only. |
| * |
| * @param parent |
| * the parent logger to set. |
| * @throws SecurityException |
| * if a security manager determines that the caller does not |
| * have the required permission. |
| * @since Android 1.0 |
| */ |
| public void setParent(Logger parent) { |
| if (null == parent) { |
| // logging.B=The 'parent' parameter is null. |
| throw new NullPointerException(Messages.getString("logging.B")); //$NON-NLS-1$ |
| } |
| // even anonymous loggers are checked |
| LogManager.getLogManager().checkAccess(); |
| internalSetParent(parent); |
| } |
| |
| final void addChild(Logger logger) { |
| childs.add(logger); |
| } |
| |
| final void removeChild(Logger child) { |
| childs.remove(child); |
| } |
| |
| |
| /** |
| * Gets the name of this logger, {@code null} for anonymous loggers. |
| * |
| * @return the name of this logger. |
| * @since Android 1.0 |
| */ |
| public String getName() { |
| return this.name; |
| } |
| |
| /** |
| * Gets the loaded resource bundle used by this logger to localize logging |
| * messages. If the value is {@code null}, the parent's resource bundle will be |
| * inherited. |
| * |
| * @return the loaded resource bundle used by this logger. |
| * @since Android 1.0 |
| */ |
| public ResourceBundle getResourceBundle() { |
| return this.resBundle; |
| } |
| |
| /** |
| * Gets the name of the loaded resource bundle used by this logger to |
| * localize logging messages. If the value is {@code null}, the parent's resource |
| * bundle name will be inherited. |
| * |
| * @return the name of the loaded resource bundle used by this logger. |
| * @since Android 1.0 |
| */ |
| public String getResourceBundleName() { |
| return this.resBundleName; |
| } |
| |
| /** |
| * This method is for compatibility. Tests written to the reference |
| * implementation API imply that the isLoggable() method is not called |
| * directly. This behavior is important because subclass may override |
| * isLoggable() method, so that affect the result of log methods. |
| */ |
| private boolean internalIsLoggable(Level l) { |
| int effectiveLevel = levelIntVal; |
| if (effectiveLevel == Level.OFF.intValue()) { |
| // always return false if the effective level is off |
| return false; |
| } |
| return l.intValue() >= effectiveLevel; |
| } |
| |
| /** |
| * Determines whether this logger will actually log messages of the |
| * specified level. The effective level used to do the determination may be |
| * inherited from its parent. The default level is {@code Level.INFO}. |
| * |
| * @param l |
| * the level to check. |
| * @return {@code true} if this logger will actually log this level, |
| * otherwise {@code false}. |
| * @since Android 1.0 |
| */ |
| public boolean isLoggable(Level l) { |
| return internalIsLoggable(l); |
| } |
| |
| /* |
| * Sets the resource bundle and its name for a supplied LogRecord object. |
| * This method first tries to use this logger's resource bundle if any, |
| * otherwise try to inherit from this logger's parent, recursively up the |
| * namespace. Synchronize to ensure the consistency between resource bundle |
| * and its name. |
| */ |
| private void setResourceBundle(LogRecord record) { |
| if (null != this.resBundleName) { |
| record.setResourceBundle(this.resBundle); |
| record.setResourceBundleName(this.resBundleName); |
| } else { |
| Logger anyParent = this.parent; |
| // no need to synchronize here, because if resBundleName |
| // is not null, there is no chance to modify it |
| while (null != anyParent) { |
| if (null != anyParent.resBundleName) { |
| record.setResourceBundle(anyParent.resBundle); |
| record.setResourceBundleName(anyParent.resBundleName); |
| return; |
| } |
| anyParent = anyParent.parent; |
| } |
| } |
| } |
| |
| /** |
| * Logs a message indicating that a method has been entered. A log record |
| * with log level {@code Level.FINER}, log message "ENTRY", the specified |
| * source class name and source method name is submitted for logging. |
| * |
| * @param sourceClass |
| * the calling class name. |
| * @param sourceMethod |
| * the method name. |
| * @since Android 1.0 |
| */ |
| public void entering(String sourceClass, String sourceMethod) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, "ENTRY"); //$NON-NLS-1$ |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message indicating that a method has been entered. A log record |
| * with log level {@code Level.FINER}, log message "ENTRY", the specified |
| * source class name, source method name and one parameter is submitted for |
| * logging. |
| * |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param param |
| * the parameter for the method call. |
| * @since Android 1.0 |
| */ |
| public void entering(String sourceClass, String sourceMethod, Object param) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, "ENTRY" + " {0}"); //$NON-NLS-1$ //$NON-NLS-2$ |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(new Object[] { param }); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message indicating that a method has been entered. A log record |
| * with log level {@code Level.FINER}, log message "ENTRY", the specified |
| * source class name, source method name and array of parameters is |
| * submitted for logging. |
| * |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param params |
| * an array of parameters for the method call. |
| * @since Android 1.0 |
| */ |
| public void entering(String sourceClass, String sourceMethod, |
| Object[] params) { |
| if (internalIsLoggable(Level.FINER)) { |
| String msg = "ENTRY"; //$NON-NLS-1$ |
| if (null != params) { |
| StringBuilder msgBuffer = new StringBuilder("ENTRY"); //$NON-NLS-1$ |
| for (int i = 0; i < params.length; i++) { |
| msgBuffer.append(" {" + i + "}"); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| msg = msgBuffer.toString(); |
| } |
| LogRecord record = new LogRecord(Level.FINER, msg); |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(params); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message indicating that a method is exited. A log record with log |
| * level {@code Level.FINER}, log message "RETURN", the specified source |
| * class name and source method name is submitted for logging. |
| * |
| * @param sourceClass |
| * the calling class name. |
| * @param sourceMethod |
| * the method name. |
| * @since Android 1.0 |
| */ |
| public void exiting(String sourceClass, String sourceMethod) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, "RETURN"); //$NON-NLS-1$ |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message indicating that a method is exited. A log record with log |
| * level {@code Level.FINER}, log message "RETURN", the specified source |
| * class name, source method name and return value is submitted for logging. |
| * |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param result |
| * the return value of the method call. |
| * @since Android 1.0 |
| */ |
| public void exiting(String sourceClass, String sourceMethod, Object result) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, "RETURN" + " {0}"); //$NON-NLS-1$ //$NON-NLS-2$ |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(new Object[] { result }); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message indicating that an exception is thrown. A log record with |
| * log level {@code Level.FINER}, log message "THROW", the specified source |
| * class name, source method name and the {@code Throwable} object is |
| * submitted for logging. |
| * |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param thrown |
| * the {@code Throwable} object. |
| * @since Android 1.0 |
| */ |
| public void throwing(String sourceClass, String sourceMethod, |
| Throwable thrown) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, "THROW"); //$NON-NLS-1$ |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setThrown(thrown); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.SEVERE}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void severe(String msg) { |
| if (internalIsLoggable(Level.SEVERE)) { |
| LogRecord record = new LogRecord(Level.SEVERE, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.WARNING}; the message is |
| * transmitted to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void warning(String msg) { |
| if (internalIsLoggable(Level.WARNING)) { |
| LogRecord record = new LogRecord(Level.WARNING, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.INFO}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void info(String msg) { |
| if (internalIsLoggable(Level.INFO)) { |
| LogRecord record = new LogRecord(Level.INFO, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.CONFIG}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void config(String msg) { |
| if (internalIsLoggable(Level.CONFIG)) { |
| LogRecord record = new LogRecord(Level.CONFIG, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.FINE}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void fine(String msg) { |
| if (internalIsLoggable(Level.FINE)) { |
| LogRecord record = new LogRecord(Level.FINE, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.FINER}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void finer(String msg) { |
| if (internalIsLoggable(Level.FINER)) { |
| LogRecord record = new LogRecord(Level.FINER, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of level {@code Level.FINEST}; the message is transmitted |
| * to all subscribed handlers. |
| * |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void finest(String msg) { |
| if (internalIsLoggable(Level.FINEST)) { |
| LogRecord record = new LogRecord(Level.FINEST, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the specified level. The message is transmitted to all |
| * subscribed handlers. |
| * |
| * @param logLevel |
| * the level of the specified message. |
| * @param msg |
| * the message to log. |
| * @since Android 1.0 |
| */ |
| public void log(Level logLevel, String msg) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the specified level with the supplied parameter. The |
| * message is then transmitted to all subscribed handlers. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param msg |
| * the message to log. |
| * @param param |
| * the parameter associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void log(Level logLevel, String msg, Object param) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setParameters(new Object[] { param }); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the specified level with the supplied parameter array. |
| * The message is then transmitted to all subscribed handlers. |
| * |
| * @param logLevel |
| * the level of the given message |
| * @param msg |
| * the message to log. |
| * @param params |
| * the parameter array associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void log(Level logLevel, String msg, Object[] params) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setParameters(params); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the specified level with the supplied {@code Throwable} |
| * object. The message is then transmitted to all subscribed handlers. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param msg |
| * the message to log. |
| * @param thrown |
| * the {@code Throwable} object associated with the event that is |
| * logged. |
| * @since Android 1.0 |
| */ |
| public void log(Level logLevel, String msg, Throwable thrown) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setThrown(thrown); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a given log record. Only records with a logging level that is equal |
| * or greater than this logger's level will be submitted to this logger's |
| * handlers for logging. If {@code getUseParentHandlers()} returns {@code |
| * true}, the log record will also be submitted to the handlers of this |
| * logger's parent, potentially recursively up the namespace. |
| * <p> |
| * Since all other log methods call this method to actually perform the |
| * logging action, subclasses of this class can override this method to |
| * catch all logging activities. |
| * </p> |
| * |
| * @param record |
| * the log record to be logged. |
| * @since Android 1.0 |
| */ |
| public void log(LogRecord record) { |
| if (internalIsLoggable(record.getLevel())) { |
| // apply the filter if any |
| Filter f = filter; |
| if (null != f && !f.isLoggable(record)) { |
| return; |
| } |
| initHandler(); |
| /* |
| * call the handlers of this logger, throw any exception that |
| * occurs |
| */ |
| Handler[] allHandlers = getHandlers(); |
| for (Handler element : allHandlers) { |
| element.publish(record); |
| } |
| // call the parent's handlers if set useParentHandlers |
| Logger temp = this; |
| Logger theParent = temp.parent; |
| while (theParent != null && temp.getUseParentHandlers()) { |
| Handler[] ha = theParent.getHandlers(); |
| for (Handler element : ha) { |
| element.publish(record); |
| } |
| temp = theParent; |
| theParent = temp.parent; |
| } |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name |
| * and source method name. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param msg |
| * the message to be logged. |
| * @since Android 1.0 |
| */ |
| public void logp(Level logLevel, String sourceClass, String sourceMethod, |
| String msg) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and parameter. |
| * |
| * @param logLevel |
| * the level of the given message |
| * @param sourceClass |
| * the source class name |
| * @param sourceMethod |
| * the source method name |
| * @param msg |
| * the message to be logged |
| * @param param |
| * the parameter associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void logp(Level logLevel, String sourceClass, String sourceMethod, |
| String msg, Object param) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(new Object[] { param }); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and parameter array. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param msg |
| * the message to be logged. |
| * @param params |
| * the parameter array associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void logp(Level logLevel, String sourceClass, String sourceMethod, |
| String msg, Object[] params) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(params); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and {@code Throwable} object. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param msg |
| * the message to be logged. |
| * @param thrown |
| * the {@code Throwable} object. |
| * @since Android 1.0 |
| */ |
| public void logp(Level logLevel, String sourceClass, String sourceMethod, |
| String msg, Throwable thrown) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setThrown(thrown); |
| setResourceBundle(record); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name |
| * and source method name, using the given resource bundle to localize the |
| * message. If {@code bundleName} is null, the empty string or not valid then |
| * the message is not localized. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param bundleName |
| * the name of the resource bundle used to localize the message. |
| * @param msg |
| * the message to be logged. |
| * @since Android 1.0 |
| */ |
| public void logrb(Level logLevel, String sourceClass, String sourceMethod, |
| String bundleName, String msg) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| if (null != bundleName) { |
| try { |
| record.setResourceBundle(loadResourceBundle(bundleName)); |
| } catch (MissingResourceException e) { |
| // ignore |
| } |
| record.setResourceBundleName(bundleName); |
| } |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and parameter, using the given resource bundle to |
| * localize the message. If {@code bundleName} is null, the empty string |
| * or not valid then the message is not localized. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param bundleName |
| * the name of the resource bundle used to localize the message. |
| * @param msg |
| * the message to be logged. |
| * @param param |
| * the parameter associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void logrb(Level logLevel, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Object param) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| if (null != bundleName) { |
| try { |
| record.setResourceBundle(loadResourceBundle(bundleName)); |
| } catch (MissingResourceException e) { |
| // ignore |
| } |
| record.setResourceBundleName(bundleName); |
| } |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(new Object[] { param }); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and parameter array, using the given resource bundle |
| * to localize the message. If {@code bundleName} is null, the empty string |
| * or not valid then the message is not localized. |
| * |
| * @param logLevel |
| * the level of the given message. |
| * @param sourceClass |
| * the source class name. |
| * @param sourceMethod |
| * the source method name. |
| * @param bundleName |
| * the name of the resource bundle used to localize the message. |
| * @param msg |
| * the message to be logged. |
| * @param params |
| * the parameter array associated with the event that is logged. |
| * @since Android 1.0 |
| */ |
| public void logrb(Level logLevel, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Object[] params) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| if (null != bundleName) { |
| try { |
| record.setResourceBundle(loadResourceBundle(bundleName)); |
| } catch (MissingResourceException e) { |
| // ignore |
| } |
| record.setResourceBundleName(bundleName); |
| } |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setParameters(params); |
| log(record); |
| } |
| } |
| |
| /** |
| * Logs a message of the given level with the specified source class name, |
| * source method name and {@code Throwable} object, using the given resource |
| * bundle to localize the message. If {@code bundleName} is null, the empty |
| * string or not valid then the message is not localized. |
| * |
| * @param logLevel |
| * the level of the given message |
| * @param sourceClass |
| * the source class name |
| * @param sourceMethod |
| * the source method name |
| * @param bundleName |
| * the name of the resource bundle used to localize the message. |
| * @param msg |
| * the message to be logged. |
| * @param thrown |
| * the {@code Throwable} object. |
| * @since Android 1.0 |
| */ |
| public void logrb(Level logLevel, String sourceClass, String sourceMethod, |
| String bundleName, String msg, Throwable thrown) { |
| if (internalIsLoggable(logLevel)) { |
| LogRecord record = new LogRecord(logLevel, msg); |
| if (null != bundleName) { |
| try { |
| record.setResourceBundle(loadResourceBundle(bundleName)); |
| } catch (MissingResourceException e) { |
| // ignore |
| } |
| record.setResourceBundleName(bundleName); |
| } |
| record.setLoggerName(this.name); |
| record.setSourceClassName(sourceClass); |
| record.setSourceMethodName(sourceMethod); |
| record.setThrown(thrown); |
| log(record); |
| } |
| } |
| |
| /* |
| * This security manager is used to access the class context. |
| */ |
| static class PrivateSecurityManager extends SecurityManager { |
| public Class<?>[] privateGetClassContext() { |
| return super.getClassContext(); |
| } |
| } |
| |
| void setManager(LogManager manager) { |
| if(this.manager != manager){ |
| this.manager = manager; |
| handlerInited = false; |
| } |
| //init level here, but let handlers be for lazy loading |
| String configedLevel = manager.getProperty(name+ ".level"); //$NON-NLS-1$ |
| if (null != configedLevel) { |
| try { |
| setLevel(Level.parse(configedLevel)); |
| } catch (IllegalArgumentException e) { |
| //ignore |
| } |
| } |
| } |
| |
| synchronized void reset() { |
| levelObjVal = null; |
| levelIntVal = Level.INFO.intValue(); |
| if(handlers != null){ |
| for (Handler element : handlers) { |
| // close all handlers, when unknown exceptions happen, |
| // ignore them and go on |
| try { |
| element.close(); |
| } catch (Exception e) { |
| // Ignored. |
| } |
| } |
| handlers.clear(); |
| } |
| handlerInited = false; |
| } |
| } |
| |
