diff options
author | Daniel Gultsch <daniel@gultsch.de> | 2014-11-01 13:51:05 +0100 |
---|---|---|
committer | Daniel Gultsch <daniel@gultsch.de> | 2014-11-01 13:51:05 +0100 |
commit | a0f694ea44b9d68390846b48d720f9a37fd679b8 (patch) | |
tree | 38ee04006e38197fd8009697b8975007ec0f45c8 /libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java | |
parent | 142384e5805d93887d185c9a5b74d4850e4ec719 (diff) | |
parent | 46f147a82c6b161e071f717c7686f8b78a20aaf1 (diff) |
Merge pull request #600 from SamWhited/gradle
Build system and library changes (Gradle / Subtree merging)
Diffstat (limited to 'libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java')
m--------- | libs/MemorizingTrustManager | 0 | ||||
-rw-r--r-- | libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java | 169 |
2 files changed, 169 insertions, 0 deletions
diff --git a/libs/MemorizingTrustManager b/libs/MemorizingTrustManager deleted file mode 160000 -Subproject fad835037adc1bd313bb56b694426fca4eb6734 diff --git a/libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java b/libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java new file mode 100644 index 00000000..40f71f58 --- /dev/null +++ b/libs/MemorizingTrustManager/example/src/de/duenndns/mtmexample/JULHandler.java @@ -0,0 +1,169 @@ +package de.duenndns.mtmexample; + +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintWriter; +import java.io.StringBufferInputStream; +import java.io.StringWriter; +import java.util.logging.Formatter; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.LogManager; +import java.util.logging.LogRecord; +import java.util.logging.Logger; + +import android.util.Log; + +/** + * A <code>java.util.logging</code> (JUL) Handler for Android. + * <p> + * If you want fine-grained control over MTM's logging, you can copy this + * class to your code base and call the static {@link #initialize()} method. + * </p> + * <p> + * This JUL Handler passes log messages sent to JUL to the Android log, while + * keeping the format and stack traces of optionally supplied Exceptions. It + * further allows to install a {@link DebugLogSettings} class via + * {@link #setDebugLogSettings(DebugLogSettings)} that determines whether JUL log messages of + * level {@link java.util.logging.Level#FINE} or lower are logged. This gives + * the application developer more control over the logged messages, while + * allowing a library developer to place debug log messages without risking to + * spam the Android log. + * </p> + * <p> + * If there are no {@code DebugLogSettings} configured, then all messages sent + * to JUL will be logged. + * </p> + * + * @author Florian Schmaus + * + */ +@SuppressWarnings("deprecation") +public class JULHandler extends Handler { + + /** Implement this interface to toggle debug logging. + */ + public interface DebugLogSettings { + public boolean isDebugLogEnabled(); + } + + private static final String CLASS_NAME = JULHandler.class.getName(); + + /** + * The global LogManager configuration. + * <p> + * This configures: + * <ul> + * <li> JULHandler as the default handler for all log messages + * <li> A default log level FINEST (300). Meaning that log messages of a level 300 or higher a + * logged + * </ul> + * </p> + */ + private static final InputStream LOG_MANAGER_CONFIG = new StringBufferInputStream( +// @formatter:off +"handlers = " + CLASS_NAME + '\n' + +".level = FINEST" +); +// @formatter:on + + // Constants for Android vs. JUL debug level comparisons + private static final int FINE_INT = Level.FINE.intValue(); + private static final int INFO_INT = Level.INFO.intValue(); + private static final int WARN_INT = Level.WARNING.intValue(); + private static final int SEVE_INT = Level.SEVERE.intValue(); + + private static final Logger LOGGER = Logger.getLogger(CLASS_NAME); + + /** A formatter that creates output similar to Android's Log.x. */ + private static final Formatter FORMATTER = new Formatter() { + @Override + public String format(LogRecord logRecord) { + Throwable thrown = logRecord.getThrown(); + if (thrown != null) { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw, false); + pw.write(logRecord.getMessage() + ' '); + thrown.printStackTrace(pw); + pw.flush(); + return sw.toString(); + } else { + return logRecord.getMessage(); + } + } + }; + + private static DebugLogSettings sDebugLogSettings; + private static boolean initialized = false; + + public static void initialize() { + try { + LogManager.getLogManager().readConfiguration(LOG_MANAGER_CONFIG); + initialized = true; + } catch (IOException e) { + Log.e("JULHandler", "Can not initialize configuration", e); + } + if (initialized) LOGGER.info("Initialzied java.util.logging logger"); + } + + public static void setDebugLogSettings(DebugLogSettings debugLogSettings) { + if (!isInitialized()) initialize(); + sDebugLogSettings = debugLogSettings; + } + + public static boolean isInitialized() { + return initialized; + } + + public JULHandler() { + setFormatter(FORMATTER); + } + + @Override + public void close() {} + + @Override + public void flush() {} + + @Override + public boolean isLoggable(LogRecord record) { + final boolean debugLog = sDebugLogSettings == null ? true : sDebugLogSettings + .isDebugLogEnabled(); + + if (record.getLevel().intValue() <= FINE_INT) { + return debugLog; + } + return true; + } + + /** JUL method that forwards log records to Android's LogCat. */ + @Override + public void publish(LogRecord record) { + if (!isLoggable(record)) return; + + final int priority = getAndroidPriority(record.getLevel()); + final String tag = substringAfterLastDot(record.getSourceClassName()); + final String msg = getFormatter().format(record); + + Log.println(priority, tag, msg); + } + + /** Helper to convert JUL verbosity levels to Android's Log. */ + private static int getAndroidPriority(Level level) { + int value = level.intValue(); + if (value >= SEVE_INT) { + return Log.ERROR; + } else if (value >= WARN_INT) { + return Log.WARN; + } else if (value >= INFO_INT) { + return Log.INFO; + } else { + return Log.DEBUG; + } + } + + /** Helper to extract short class names. */ + private static String substringAfterLastDot(String s) { + return s.substring(s.lastIndexOf('.') + 1).trim(); + } +} |