From cc2cfc7b0002ebba16a980a5627a7becdb066af2 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 18 Oct 2013 09:56:37 +0200 Subject: [PATCH 01/12] Add logs --- AndroidAnnotations/androidannotations/pom.xml | 203 +++++++++--------- .../AndroidAnnotationProcessor.java | 9 +- .../androidannotations/logger/Formatter.java | 77 +++++++ .../org/androidannotations/logger/Level.java | 22 ++ .../org/androidannotations/logger/Logger.java | 47 ++++ .../logger/LoggerContext.java | 56 +++++ .../logger/LoggerFactory.java | 52 +++++ .../logger/FormatterTest.java | 50 +++++ 8 files changed, 414 insertions(+), 102 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java create mode 100644 AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java diff --git a/AndroidAnnotations/androidannotations/pom.xml b/AndroidAnnotations/androidannotations/pom.xml index 36e030f5a1..dde735fe95 100644 --- a/AndroidAnnotations/androidannotations/pom.xml +++ b/AndroidAnnotations/androidannotations/pom.xml @@ -1,109 +1,110 @@ - - 4.0.0 + + 4.0.0 - - org.androidannotations - androidannotations-parent - 3.0-SNAPSHOT - + + org.androidannotations + androidannotations-parent + 3.0-SNAPSHOT + - androidannotations - AndroidAnnotations Annotation Processor - The Annotation Processor jar that generates code + androidannotations + AndroidAnnotations Annotation Processor + The Annotation Processor jar that generates code - - - org.androidannotations - androidannotations-api - - - com.sun.codemodel - codemodel - - - junit - junit - - - com.google.guava - guava - - - com.google.android - android - 1.6_r2 - provided - - - - org.springframework.android - spring-android-rest-template - 1.0.0.RELEASE - test - - + + + org.androidannotations + androidannotations-api + + + com.sun.codemodel + codemodel + + + junit + junit + + + com.google.guava + guava + + + com.google.android + android + 1.6_r2 + provided + + + + org.springframework.android + spring-android-rest-template + 1.0.0.RELEASE + test + + - - - - org.apache.maven.plugins - maven-compiler-plugin - - 1.6 - 1.6 - -proc:none - - - - maven-javadoc-plugin - - - attach-javadocs - - jar - - - - - - maven-source-plugin - - - attach-sources - - jar - - - - - - org.apache.maven.plugins - maven-resources-plugin - - + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.6 + 1.6 + -proc:none + + + + maven-javadoc-plugin + + + attach-javadocs + + jar + + + + + + maven-source-plugin + + + attach-sources + + jar + + + + + + org.apache.maven.plugins + maven-resources-plugin + + - - - src/main/resources - - rebel.xml - - - - src/main/java - - org/androidannotations/api/** - - - - src/main/resources - true - - **/*.properties - - - - + + + src/main/resources + + rebel.xml + + + + src/main/java + + org/androidannotations/api/** + + + + src/main/resources + true + + **/*.properties + + + + diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 1f9c9109cd..12536c8007 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -133,6 +133,8 @@ import org.androidannotations.helper.ErrorHelper; import org.androidannotations.helper.Option; import org.androidannotations.helper.TimeStats; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; import org.androidannotations.model.AnnotationElements; @@ -287,17 +289,20 @@ @SupportedOptions({ TRACE_OPTION, ANDROID_MANIFEST_FILE_OPTION, RESOURCE_PACKAGE_NAME_OPTION }) public class AndroidAnnotationProcessor extends AbstractProcessor { + private static final Logger LOGGER = LoggerFactory.getLogger(AndroidAnnotationProcessor.class); + private final Properties properties = new Properties(); private final Properties propertiesApi = new Properties(); private final TimeStats timeStats = new TimeStats(); private final ErrorHelper errorHelper = new ErrorHelper(); - private Set supportedAnnotationNames; @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); + LOGGER.warn("test: {}", processingEnv); + Messager messager = processingEnv.getMessager(); try { @@ -642,6 +647,8 @@ private void generateSources(ProcessResult processResult) throws IOException { private void handleException(Set annotations, RoundEnvironment roundEnv, ProcessingException e) { String errorMessage = errorHelper.getErrorMessage(processingEnv, e, getAAProcessorVersion()); + LOGGER.error("Something went wront : {}", errorMessage); + Messager messager = processingEnv.getMessager(); messager.printMessage(Diagnostic.Kind.ERROR, errorMessage); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java new file mode 100644 index 0000000000..1a2d4700d3 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java @@ -0,0 +1,77 @@ +package org.androidannotations.logger; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.Date; + +public class Formatter { + + private static final DateFormat DATE_FORMAT = new SimpleDateFormat("HH:mm:ss.S"); + private static final String ARGS_PATTERN = "{}"; + private static final int ARGS_PATTERN_LENGTH = ARGS_PATTERN.length(); + + public static String buildLog(Level level, String loggerName, String message, Throwable thr, Object... args) { + String fullMessage = buildFullMessage(message, args); + StringBuilder stringBuilder = new StringBuilder(fullMessage.length()); + + stringBuilder.append(DATE_FORMAT.format(new Date())) // + .append(" [").append(Thread.currentThread().getName()).append("] ") // + .append(" ").append(level.name) // + .append(" ").append(loggerName) // + .append(" - ").append(fullMessage); + + // Stacktrace + if (thr != null) { + stringBuilder.append('\n').append(stackTraceToString(thr)); + } + + stringBuilder.append('\n'); + + return stringBuilder.toString(); + } + + public static String buildFullMessage(String message, Object... args) { + StringBuilder stringBuilder = new StringBuilder(message.length()); + int lastIndex = 0; + int argIndex = 0; + + while (true) { + int argPos = message.indexOf(ARGS_PATTERN, lastIndex); + if (argPos == -1) { + break; + } + + stringBuilder.append(message.substring(lastIndex, argPos)); + + lastIndex = argPos + ARGS_PATTERN_LENGTH; + + // add the argument, if we still have any + if (argIndex < args.length) { + stringBuilder.append(formatArgument(args[argIndex])); + argIndex++; + } + } + + stringBuilder.append(message.substring(lastIndex)); + + return stringBuilder.toString(); + } + + private static String formatArgument(Object arg) { + if (arg != null && arg.getClass().isArray()) { + return Arrays.toString((Object[]) arg); + } + return arg.toString(); + } + + private static String stackTraceToString(Throwable e) { + StringWriter writer = new StringWriter(); + PrintWriter pw = new PrintWriter(writer); + e.printStackTrace(pw); + return writer.toString(); + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java new file mode 100644 index 0000000000..53c7d0a72b --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java @@ -0,0 +1,22 @@ +package org.androidannotations.logger; + +public enum Level { + TRACE(1, "TRACE"), // + DEBUG(2, "DEBUG"), // + INFO(3, "INFO "), // + WARN(4, "WARN "), // + ERROR(5, "ERROR"); + + public final int weight; + public final String name; + + private Level(int weight, String name) { + this.weight = weight; + this.name = name; + } + + public boolean isGreaterOrEqual(Level l) { + return weight >= l.weight; + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java new file mode 100644 index 0000000000..bf272de140 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java @@ -0,0 +1,47 @@ +package org.androidannotations.logger; + +public class Logger { + + private final String name; + + public Logger(String name) { + this.name = name; + } + + public void trace(String message, Object... args) { + log(Level.TRACE, message, null, args); + } + + public void debug(String message, Object... args) { + log(Level.DEBUG, message, null, args); + } + + public void info(String message, Object... args) { + log(Level.INFO, message, null, args); + } + + public void warn(String message, Object... args) { + log(Level.WARN, message, null, args); + } + + public void warn(String message, Throwable thr, Object... args) { + log(Level.WARN, message, thr, args); + } + + public void error(String message, Object... args) { + log(Level.ERROR, message, null, args); + } + + public void error(String message, Throwable thr, Object... args) { + log(Level.ERROR, message, thr, args); + } + + private void log(Level level, String message, Throwable thr, Object... args) { + if (LoggerContext.getInstance().getCurrentLevel().isGreaterOrEqual(level)) { + return; + } + + LoggerContext.getInstance().writeLog(level, name, message, thr, args); + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java new file mode 100644 index 0000000000..ef35e79257 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -0,0 +1,56 @@ +package org.androidannotations.logger; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +public class LoggerContext { + + private static LoggerContext INSTANCE = null; + private static final Level DEFAULT_LEVEL = Level.DEBUG; + + private Level currentLevel = DEFAULT_LEVEL; + private FileOutputStream outputStream; + private File fileLog; + + public static LoggerContext getInstance() { + if (INSTANCE == null) { + synchronized (LoggerContext.class) { + if (INSTANCE == null) { + INSTANCE = new LoggerContext(); + } + } + } + return INSTANCE; + } + + private LoggerContext() { + fileLog = new File("androidannotations.log"); + try { + outputStream = new FileOutputStream(fileLog, true); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + } + + public void writeLog(Level level, String loggerName, String message, Throwable thr, Object... args) { + String log = Formatter.buildLog(level, loggerName, message, thr, args); + + try { + outputStream.write(log.getBytes()); + outputStream.flush(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public Level getCurrentLevel() { + return currentLevel; + } + + public void setCurrentLevel(Level currentLevel) { + this.currentLevel = currentLevel; + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java new file mode 100644 index 0000000000..34b4119d65 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java @@ -0,0 +1,52 @@ +package org.androidannotations.logger; + +import java.util.HashMap; +import java.util.Map; + +public class LoggerFactory { + + private static final Map LOGGER_CACHE = new HashMap(); + + public static Logger getLogger(Class clazz) { + return getLogger(simpleLoggerName(clazz)); + } + + private static Logger getLogger(String name) { + if (name == null) { + throw new IllegalArgumentException("name argument cannot be null"); + } + + Logger logger = LOGGER_CACHE.get(name); + if (logger == null) { + logger = new Logger(name); + LOGGER_CACHE.put(name, logger); + } + + return logger; + } + + private static String simpleLoggerName(Class clazz) { + Package classPackage = clazz.getPackage(); + if (classPackage == null) { + return clazz.getName(); + } + + StringBuilder stringBuilder = new StringBuilder(); + + String packageName = classPackage.getName(); + int lastIndex = 0; + while (true) { + stringBuilder.append(packageName.charAt(lastIndex)).append("."); + + lastIndex = packageName.indexOf('.', lastIndex); + if (lastIndex == -1) { + break; + } + lastIndex++; + } + + stringBuilder.append(clazz.getSimpleName()); + + return stringBuilder.toString(); + } +} diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java new file mode 100644 index 0000000000..f035d49571 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java @@ -0,0 +1,50 @@ +package org.androidannotations.logger; + +import java.util.Arrays; +import java.util.List; + +import org.junit.Assert; +import org.junit.Test; + +public class FormatterTest { + + class SomeObject { + String name; + + public SomeObject(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } + } + + @Test + public void testBuildFullMessage_string() throws Exception { + Assert.assertEquals("This is a test", Formatter.buildFullMessage("{} is a test", "This")); + Assert.assertEquals("This is a test", Formatter.buildFullMessage("This is a {}", "test")); + Assert.assertEquals("This is a test", Formatter.buildFullMessage("This {} {} test", "is", "a")); + Assert.assertEquals("This is a test", Formatter.buildFullMessage("This {} a test", "is", "a")); + } + + @Test + public void testBuildFullMessage_int_array() throws Exception { + Integer[] values = new Integer[] { 1, 2 }; + Assert.assertEquals("Values = [1, 2]", Formatter.buildFullMessage("Values = {}", new Object[] { values })); + } + + @Test + public void testBuildFullMessage_object_array() throws Exception { + SomeObject[] values = new SomeObject[] { new SomeObject("a"), new SomeObject("b") }; + Assert.assertEquals("Objects = [a, b]", Formatter.buildFullMessage("Objects = {}", new Object[] { values })); + } + + @Test + public void testBuildFullMessage_list() throws Exception { + List values = Arrays.asList(new SomeObject("a"), new SomeObject("b")); + Assert.assertEquals("Objects = [a, b]", Formatter.buildFullMessage("Objects = {}", values)); + } + +} From 1c9d514424bdb5fc6fa77643515d8e7b05e90d63 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 22 Nov 2013 16:01:36 +0100 Subject: [PATCH 02/12] Refactoring --- .../AndroidAnnotationProcessor.java | 16 +++- .../androidannotations/logger/Appender.java | 87 +++++++++++++++++++ .../androidannotations/logger/Formatter.java | 10 +-- .../org/androidannotations/logger/Level.java | 5 +- .../org/androidannotations/logger/Logger.java | 12 ++- .../logger/LoggerContext.java | 42 ++++----- .../logger/LoggerFactory.java | 2 +- .../logger/FormatterTest.java | 16 ++-- .../androidannotations/logger/LoggerTest.java | 20 +++++ 9 files changed, 172 insertions(+), 38 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java create mode 100644 AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/LoggerTest.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 12536c8007..052c86212a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -133,7 +133,9 @@ import org.androidannotations.helper.ErrorHelper; import org.androidannotations.helper.Option; import org.androidannotations.helper.TimeStats; +import org.androidannotations.logger.Level; import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerContext; import org.androidannotations.logger.LoggerFactory; import org.androidannotations.model.AndroidRes; import org.androidannotations.model.AndroidSystemServices; @@ -300,8 +302,9 @@ public class AndroidAnnotationProcessor extends AbstractProcessor { @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); + LoggerContext.getInstance().setProcessingEnv(processingEnv); - LOGGER.warn("test: {}", processingEnv); + LOGGER.warn("Initialize AndroidAnnotationProcessor with options {}", processingEnv.getOptions()); Messager messager = processingEnv.getMessager(); @@ -332,6 +335,13 @@ public boolean process(Set annotations, RoundEnvironment timeStats.clear(); timeStats.start("Whole Processing"); + Set rootElements = roundEnv.getRootElements(); + if (LOGGER.isLoggable(Level.TRACE)) { + LOGGER.trace("Start processing for {} annotations {} on {} elements {}", annotations.size(), annotations, rootElements.size(), rootElements); + } else { + LOGGER.info("Start processing for {} annotations on {} elements", annotations.size(), rootElements.size()); + } + try { checkApiAndCoreVersions(); processThrowing(annotations, roundEnv); @@ -342,6 +352,10 @@ public boolean process(Set annotations, RoundEnvironment } timeStats.stop("Whole Processing"); timeStats.logStats(); + + LOGGER.info("Finish processing"); + + LoggerContext.getInstance().close(); return true; } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java new file mode 100644 index 0000000000..c0ec644ed0 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java @@ -0,0 +1,87 @@ +package org.androidannotations.logger; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; + +import javax.annotation.processing.Messager; +import javax.annotation.processing.ProcessingEnvironment; +import javax.tools.Diagnostic.Kind; + +public class Appender { + + private File file; + private FileOutputStream outputStream; + private ProcessingEnvironment processingEnv; + + public synchronized void openFile() { + try { + outputStream = new FileOutputStream(file, true); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + } + + public synchronized void closeFile() { + if (outputStream != null) { + try { + outputStream.close(); + } catch (IOException e) { + e.printStackTrace(); + } + outputStream = null; + } + } + + public synchronized void append(String log) { + if (!isFileOpened()) { + openFile(); + } + + try { + outputStream.write(log.getBytes()); + outputStream.flush(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public void resolveLogFile() { + if (file == null) { + if (processingEnv.getOptions().containsKey(LoggerContext.LOG_FILE_OPTION)) { + file = resolveLogFileInSpecifiedPath(); + } else { + file = resolveLogFileInParentsDirectories(); + } + } + } + + private File resolveLogFileInSpecifiedPath() { + String path = processingEnv.getOptions().get(LoggerContext.LOG_FILE_OPTION); + return new File(path); + } + + private File resolveLogFileInParentsDirectories() { + // TODO + + if (file == null) { + Messager messager = processingEnv.getMessager(); + messager.printMessage(Kind.ERROR, "Can't resolve log file path"); + } + return null; + } + + public boolean isFileOpened() { + return outputStream != null; + } + + public void setFile(File file) { + this.file = file; + } + + public void setProcessingEnv(ProcessingEnvironment processingEnv) { + this.processingEnv = processingEnv; + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java index 1a2d4700d3..c1559fbf80 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java @@ -13,12 +13,12 @@ public class Formatter { private static final String ARGS_PATTERN = "{}"; private static final int ARGS_PATTERN_LENGTH = ARGS_PATTERN.length(); - public static String buildLog(Level level, String loggerName, String message, Throwable thr, Object... args) { + public String buildLog(Level level, String loggerName, String message, Throwable thr, Object... args) { String fullMessage = buildFullMessage(message, args); StringBuilder stringBuilder = new StringBuilder(fullMessage.length()); stringBuilder.append(DATE_FORMAT.format(new Date())) // - .append(" [").append(Thread.currentThread().getName()).append("] ") // + .append(" [").append(Thread.currentThread().getName()).append("]") // .append(" ").append(level.name) // .append(" ").append(loggerName) // .append(" - ").append(fullMessage); @@ -33,7 +33,7 @@ public static String buildLog(Level level, String loggerName, String message, Th return stringBuilder.toString(); } - public static String buildFullMessage(String message, Object... args) { + public String buildFullMessage(String message, Object... args) { StringBuilder stringBuilder = new StringBuilder(message.length()); int lastIndex = 0; int argIndex = 0; @@ -60,14 +60,14 @@ public static String buildFullMessage(String message, Object... args) { return stringBuilder.toString(); } - private static String formatArgument(Object arg) { + private String formatArgument(Object arg) { if (arg != null && arg.getClass().isArray()) { return Arrays.toString((Object[]) arg); } return arg.toString(); } - private static String stackTraceToString(Throwable e) { + private String stackTraceToString(Throwable e) { StringWriter writer = new StringWriter(); PrintWriter pw = new PrintWriter(writer); e.printStackTrace(pw); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java index 53c7d0a72b..9f1eea4812 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java @@ -15,8 +15,11 @@ private Level(int weight, String name) { this.name = name; } - public boolean isGreaterOrEqual(Level l) { + public boolean isGreaterOrEquals(Level l) { return weight >= l.weight; } + public boolean isSmaller(Level l) { + return weight < l.weight; + } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java index bf272de140..5cbed69b2c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java @@ -2,9 +2,11 @@ public class Logger { + private final LoggerContext loggerContext; private final String name; - public Logger(String name) { + public Logger(LoggerContext loggerContext, String name) { + this.loggerContext = loggerContext; this.name = name; } @@ -36,12 +38,16 @@ public void error(String message, Throwable thr, Object... args) { log(Level.ERROR, message, thr, args); } + public boolean isLoggable(Level level) { + return level.isGreaterOrEquals(loggerContext.getCurrentLevel()); + } + private void log(Level level, String message, Throwable thr, Object... args) { - if (LoggerContext.getInstance().getCurrentLevel().isGreaterOrEqual(level)) { + if (!isLoggable(level)) { return; } - LoggerContext.getInstance().writeLog(level, name, message, thr, args); + loggerContext.writeLog(level, name, message, thr, args); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java index ef35e79257..63cb6ca920 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -1,18 +1,19 @@ package org.androidannotations.logger; import java.io.File; -import java.io.FileNotFoundException; -import java.io.FileOutputStream; -import java.io.IOException; + +import javax.annotation.processing.ProcessingEnvironment; public class LoggerContext { + public static final String LOG_FILE_OPTION = "logFile"; + public static final String LOG_LEVEL_OPTION = "logLevel"; private static LoggerContext INSTANCE = null; private static final Level DEFAULT_LEVEL = Level.DEBUG; private Level currentLevel = DEFAULT_LEVEL; - private FileOutputStream outputStream; - private File fileLog; + private Appender appender = new Appender(); + private Formatter formatter = new Formatter(); public static LoggerContext getInstance() { if (INSTANCE == null) { @@ -25,24 +26,12 @@ public static LoggerContext getInstance() { return INSTANCE; } - private LoggerContext() { - fileLog = new File("androidannotations.log"); - try { - outputStream = new FileOutputStream(fileLog, true); - } catch (FileNotFoundException e) { - e.printStackTrace(); - } + LoggerContext() { } public void writeLog(Level level, String loggerName, String message, Throwable thr, Object... args) { - String log = Formatter.buildLog(level, loggerName, message, thr, args); - - try { - outputStream.write(log.getBytes()); - outputStream.flush(); - } catch (IOException e) { - e.printStackTrace(); - } + String log = formatter.buildLog(level, loggerName, message, thr, args); + appender.append(log); } public Level getCurrentLevel() { @@ -53,4 +42,17 @@ public void setCurrentLevel(Level currentLevel) { this.currentLevel = currentLevel; } + public void setFileLog(String path) { + appender.setFile(new File(path)); + } + + public void setProcessingEnv(ProcessingEnvironment processingEnv) { + appender.setProcessingEnv(processingEnv); + appender.resolveLogFile(); + } + + public void close() { + appender.closeFile(); + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java index 34b4119d65..77156f16c0 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerFactory.java @@ -18,7 +18,7 @@ private static Logger getLogger(String name) { Logger logger = LOGGER_CACHE.get(name); if (logger == null) { - logger = new Logger(name); + logger = new Logger(LoggerContext.getInstance(), name); LOGGER_CACHE.put(name, logger); } diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java index f035d49571..b7c86d1593 100644 --- a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/FormatterTest.java @@ -8,6 +8,8 @@ public class FormatterTest { + private Formatter formatter = new Formatter(); + class SomeObject { String name; @@ -23,28 +25,28 @@ public String toString() { @Test public void testBuildFullMessage_string() throws Exception { - Assert.assertEquals("This is a test", Formatter.buildFullMessage("{} is a test", "This")); - Assert.assertEquals("This is a test", Formatter.buildFullMessage("This is a {}", "test")); - Assert.assertEquals("This is a test", Formatter.buildFullMessage("This {} {} test", "is", "a")); - Assert.assertEquals("This is a test", Formatter.buildFullMessage("This {} a test", "is", "a")); + Assert.assertEquals("This is a test", formatter.buildFullMessage("{} is a test", "This")); + Assert.assertEquals("This is a test", formatter.buildFullMessage("This is a {}", "test")); + Assert.assertEquals("This is a test", formatter.buildFullMessage("This {} {} test", "is", "a")); + Assert.assertEquals("This is a test", formatter.buildFullMessage("This {} a test", "is", "a")); } @Test public void testBuildFullMessage_int_array() throws Exception { Integer[] values = new Integer[] { 1, 2 }; - Assert.assertEquals("Values = [1, 2]", Formatter.buildFullMessage("Values = {}", new Object[] { values })); + Assert.assertEquals("Values = [1, 2]", formatter.buildFullMessage("Values = {}", new Object[] { values })); } @Test public void testBuildFullMessage_object_array() throws Exception { SomeObject[] values = new SomeObject[] { new SomeObject("a"), new SomeObject("b") }; - Assert.assertEquals("Objects = [a, b]", Formatter.buildFullMessage("Objects = {}", new Object[] { values })); + Assert.assertEquals("Objects = [a, b]", formatter.buildFullMessage("Objects = {}", new Object[] { values })); } @Test public void testBuildFullMessage_list() throws Exception { List values = Arrays.asList(new SomeObject("a"), new SomeObject("b")); - Assert.assertEquals("Objects = [a, b]", Formatter.buildFullMessage("Objects = {}", values)); + Assert.assertEquals("Objects = [a, b]", formatter.buildFullMessage("Objects = {}", values)); } } diff --git a/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/LoggerTest.java b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/LoggerTest.java new file mode 100644 index 0000000000..441c65c81f --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/test/java/org/androidannotations/logger/LoggerTest.java @@ -0,0 +1,20 @@ +package org.androidannotations.logger; + +import junit.framework.Assert; + +import org.junit.Test; + +public class LoggerTest { + + @Test + public void testIsLoggable() throws Exception { + LoggerContext loggerContext = LoggerContext.getInstance(); + loggerContext.setCurrentLevel(Level.INFO); + Logger logger = new Logger(loggerContext, getClass().getName()); + + Assert.assertFalse(logger.isLoggable(Level.DEBUG)); + Assert.assertTrue(logger.isLoggable(Level.INFO)); + Assert.assertTrue(logger.isLoggable(Level.WARN)); + } + +} From 03d35cb48d845c35dd5adea8ee34ce7613928a75 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 22 Nov 2013 16:28:06 +0100 Subject: [PATCH 03/12] Allow developer to change log level from processor options --- .../AndroidAnnotationProcessor.java | 7 +++++-- .../org/androidannotations/logger/Appender.java | 14 ++++---------- .../java/org/androidannotations/logger/Level.java | 10 ++++++++++ .../androidannotations/logger/LoggerContext.java | 15 +++++++++------ 4 files changed, 28 insertions(+), 18 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 052c86212a..117779bbf7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -302,9 +302,12 @@ public class AndroidAnnotationProcessor extends AbstractProcessor { @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); - LoggerContext.getInstance().setProcessingEnv(processingEnv); - LOGGER.warn("Initialize AndroidAnnotationProcessor with options {}", processingEnv.getOptions()); + // Configure Logger + LoggerContext loggerContext = LoggerContext.getInstance(); + loggerContext.setProcessingEnv(processingEnv); + + LOGGER.info("Initialize AndroidAnnotationProcessor with options {}", processingEnv.getOptions()); Messager messager = processingEnv.getMessager(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java index c0ec644ed0..9c169b9b41 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java @@ -48,12 +48,10 @@ public synchronized void append(String log) { } public void resolveLogFile() { - if (file == null) { - if (processingEnv.getOptions().containsKey(LoggerContext.LOG_FILE_OPTION)) { - file = resolveLogFileInSpecifiedPath(); - } else { - file = resolveLogFileInParentsDirectories(); - } + if (processingEnv.getOptions().containsKey(LoggerContext.LOG_FILE_OPTION)) { + file = resolveLogFileInSpecifiedPath(); + } else { + file = resolveLogFileInParentsDirectories(); } } @@ -76,10 +74,6 @@ public boolean isFileOpened() { return outputStream != null; } - public void setFile(File file) { - this.file = file; - } - public void setProcessingEnv(ProcessingEnvironment processingEnv) { this.processingEnv = processingEnv; } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java index 9f1eea4812..e9096ac3a7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Level.java @@ -22,4 +22,14 @@ public boolean isGreaterOrEquals(Level l) { public boolean isSmaller(Level l) { return weight < l.weight; } + + public static Level parse(String name) { + for (Level level : values()) { + if (level.name().equalsIgnoreCase(name)) { + return level; + } + } + throw new IllegalArgumentException("Can't find Level matching " + name); + } + } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java index 63cb6ca920..c6b8d1312c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -1,7 +1,5 @@ package org.androidannotations.logger; -import java.io.File; - import javax.annotation.processing.ProcessingEnvironment; public class LoggerContext { @@ -42,17 +40,22 @@ public void setCurrentLevel(Level currentLevel) { this.currentLevel = currentLevel; } - public void setFileLog(String path) { - appender.setFile(new File(path)); - } - public void setProcessingEnv(ProcessingEnvironment processingEnv) { appender.setProcessingEnv(processingEnv); appender.resolveLogFile(); + + resolveLogLevel(processingEnv); } public void close() { appender.closeFile(); } + private void resolveLogLevel(ProcessingEnvironment processingEnv) { + if (processingEnv.getOptions().containsKey(LoggerContext.LOG_LEVEL_OPTION)) { + Level logLevel = Level.parse(processingEnv.getOptions().get(LoggerContext.LOG_LEVEL_OPTION)); + setCurrentLevel(logLevel); + } + } + } From 85042a7b0ded3c6abac82d2789b7f11ec0535ed0 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 22 Nov 2013 17:13:51 +0100 Subject: [PATCH 04/12] Auto-detect output directory to write log --- .../helper/AndroidManifestFinder.java | 43 ++----- .../androidannotations/helper/FileHelper.java | 106 ++++++++++++++++++ .../androidannotations/logger/Appender.java | 24 ++-- 3 files changed, 130 insertions(+), 43 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FileHelper.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java index e85ef359b4..91f0728f12 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java @@ -18,21 +18,18 @@ import java.io.File; import java.io.FileInputStream; import java.io.IOException; -import java.net.URI; -import java.net.URISyntaxException; import java.util.ArrayList; import java.util.List; import java.util.Properties; -import javax.annotation.processing.Filer; import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.util.Elements; import javax.tools.Diagnostic.Kind; -import javax.tools.JavaFileObject; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; +import org.androidannotations.helper.FileHelper.FileHolder; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; @@ -112,40 +109,13 @@ private Option findManifestInSpecifiedPath() { * appreciated. */ private Option findManifestInParentsDirectories() { - Filer filer = processingEnv.getFiler(); - - Messager messager = processingEnv.getMessager(); - - JavaFileObject dummySourceFile; - try { - dummySourceFile = filer.createSourceFile("dummy" + System.currentTimeMillis()); - } catch (IOException ignored) { - messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file, unable to create a dummy source file to locate the source folder"); + Option projectRootHolderOption = FileHelper.findRootProjectHolder(processingEnv); + if (projectRootHolderOption.isAbsent()) { return Option.absent(); } - String dummySourceFilePath = dummySourceFile.toUri().toString(); - if (dummySourceFilePath.startsWith("file:")) { - if (!dummySourceFilePath.startsWith("file://")) { - dummySourceFilePath = "file://" + dummySourceFilePath.substring("file:".length()); - } - } else { - dummySourceFilePath = "file://" + dummySourceFilePath; - } - - URI cleanURI; - try { - cleanURI = new URI(dummySourceFilePath); - } catch (URISyntaxException e) { - messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file, path to dummy source file cannot be parsed: " + dummySourceFilePath); - return Option.absent(); - } - - File dummyFile = new File(cleanURI); - - File sourcesGenerationFolder = dummyFile.getParentFile(); - - File projectRoot = sourcesGenerationFolder.getParentFile(); + FileHolder projectRootHolder = projectRootHolderOption.get(); + File projectRoot = projectRootHolder.projectRoot; File androidManifestFile = new File(projectRoot, "AndroidManifest.xml"); for (int i = 0; i < MAX_PARENTS_FROM_SOURCE_FOLDER; i++) { @@ -161,8 +131,9 @@ private Option findManifestInParentsDirectories() { } } + Messager messager = processingEnv.getMessager(); if (!androidManifestFile.exists()) { - messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file, going up from path [" + sourcesGenerationFolder.getAbsolutePath() + "] found using dummy file [" + dummySourceFilePath + "] (max atempts: " + MAX_PARENTS_FROM_SOURCE_FOLDER + ")"); + messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file, going up from path [" + projectRootHolder.sourcesGenerationFolder.getAbsolutePath() + "] found using dummy file [" + projectRootHolder.dummySourceFilePath + "] (max atempts: " + MAX_PARENTS_FROM_SOURCE_FOLDER + ")"); return Option.absent(); } else { messager.printMessage(Kind.NOTE, "AndroidManifest.xml file found: " + androidManifestFile.toString()); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FileHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FileHelper.java new file mode 100644 index 0000000000..508be38db9 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/FileHelper.java @@ -0,0 +1,106 @@ +package org.androidannotations.helper; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; + +import javax.annotation.processing.Filer; +import javax.annotation.processing.ProcessingEnvironment; +import javax.tools.JavaFileObject; + +public class FileHelper { + + public static Option findRootProject(ProcessingEnvironment processingEnv) { + Option rootProjectHolder = findRootProjectHolder(processingEnv); + if (rootProjectHolder.isAbsent()) { + return Option.absent(); + } + + return Option.of(rootProjectHolder.get().projectRoot); + } + + /** + * We use a dirty trick to find the AndroidManifest.xml file, since it's not + * available in the classpath. The idea is quite simple : create a fake + * class file, retrieve its URI, and start going up in parent folders to + * find the AndroidManifest.xml file. Any better solution will be + * appreciated. + */ + public static Option findRootProjectHolder(ProcessingEnvironment processingEnv) { + Filer filer = processingEnv.getFiler(); + + JavaFileObject dummySourceFile; + try { + dummySourceFile = filer.createSourceFile("dummy" + System.currentTimeMillis()); + } catch (IOException ignored) { + return Option.absent(); + } + String dummySourceFilePath = dummySourceFile.toUri().toString(); + + if (dummySourceFilePath.startsWith("file:")) { + if (!dummySourceFilePath.startsWith("file://")) { + dummySourceFilePath = "file://" + dummySourceFilePath.substring("file:".length()); + } + } else { + dummySourceFilePath = "file://" + dummySourceFilePath; + } + + URI cleanURI; + try { + cleanURI = new URI(dummySourceFilePath); + } catch (URISyntaxException e) { + return Option.absent(); + } + + File dummyFile = new File(cleanURI); + File sourcesGenerationFolder = dummyFile.getParentFile(); + File projectRoot = sourcesGenerationFolder.getParentFile(); + + return Option.of(new FileHolder(dummySourceFilePath, sourcesGenerationFolder, projectRoot)); + } + + public static File resolveOutputDirectory(ProcessingEnvironment processingEnv) { + Option rootProjectOption = FileHelper.findRootProject(processingEnv); + if (rootProjectOption.isAbsent()) { + // Execution root folder + return null; + } + + File rootProject = rootProjectOption.get(); + + // Target folder - Maven + File targetFolder = new File(rootProject, "target"); + if (targetFolder.isDirectory() && targetFolder.canWrite()) { + return targetFolder; + } + + // Build folder - Gradle + File buildFolder = new File(rootProject, "build"); + if (buildFolder.isDirectory() && buildFolder.canWrite()) { + return buildFolder; + } + + // Bin folder - Eclipse + File binFolder = new File(rootProject, "bin"); + if (binFolder.isDirectory() && binFolder.canWrite()) { + return binFolder; + } + + // Fallback to projet root folder + return rootProject; + } + + static class FileHolder { + String dummySourceFilePath; + File sourcesGenerationFolder; + File projectRoot; + + public FileHolder(String dummySourceFilePath, File sourcesGenerationFolder, File projectRoot) { + this.dummySourceFilePath = dummySourceFilePath; + this.sourcesGenerationFolder = sourcesGenerationFolder; + this.projectRoot = projectRoot; + } + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java index 9c169b9b41..9545d13d3f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java @@ -9,8 +9,12 @@ import javax.annotation.processing.ProcessingEnvironment; import javax.tools.Diagnostic.Kind; +import org.androidannotations.helper.FileHelper; + public class Appender { + private static final String DEFAULT_FILENAME = "androidannotations.log"; + private File file; private FileOutputStream outputStream; private ProcessingEnvironment processingEnv; @@ -48,26 +52,32 @@ public synchronized void append(String log) { } public void resolveLogFile() { + Messager messager = processingEnv.getMessager(); if (processingEnv.getOptions().containsKey(LoggerContext.LOG_FILE_OPTION)) { file = resolveLogFileInSpecifiedPath(); } else { file = resolveLogFileInParentsDirectories(); } + + if (file == null) { + messager.printMessage(Kind.WARNING, "Can't resolve log file"); + } else { + messager.printMessage(Kind.NOTE, "Resolve log file to " + file.getAbsolutePath()); + } } private File resolveLogFileInSpecifiedPath() { + File outputDirectory = FileHelper.resolveOutputDirectory(processingEnv); + String path = processingEnv.getOptions().get(LoggerContext.LOG_FILE_OPTION); + path = path.replace("{outputFolder}", outputDirectory.getAbsolutePath()); + return new File(path); } private File resolveLogFileInParentsDirectories() { - // TODO - - if (file == null) { - Messager messager = processingEnv.getMessager(); - messager.printMessage(Kind.ERROR, "Can't resolve log file path"); - } - return null; + File outputDirectory = FileHelper.resolveOutputDirectory(processingEnv); + return new File(outputDirectory, DEFAULT_FILENAME); } public boolean isFileOpened() { From 1ad320dd8cf12670260049bb5c3960d1a2fb03f4 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 22 Nov 2013 17:23:05 +0100 Subject: [PATCH 05/12] Update processor options for functional-test-1-5 module to write logs --- .../.settings/org.eclipse.jdt.apt.core.prefs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/AndroidAnnotations/functional-test-1-5/.settings/org.eclipse.jdt.apt.core.prefs b/AndroidAnnotations/functional-test-1-5/.settings/org.eclipse.jdt.apt.core.prefs index ef6fa98563..30bc889a84 100644 --- a/AndroidAnnotations/functional-test-1-5/.settings/org.eclipse.jdt.apt.core.prefs +++ b/AndroidAnnotations/functional-test-1-5/.settings/org.eclipse.jdt.apt.core.prefs @@ -1,5 +1,7 @@ eclipse.preferences.version=1 org.eclipse.jdt.apt.aptEnabled=true org.eclipse.jdt.apt.genSrcDir=.apt_generated +org.eclipse.jdt.apt.processorOptions/logFile={outputFolder}/functional-test.log +org.eclipse.jdt.apt.processorOptions/logLevel=DEBUG org.eclipse.jdt.apt.processorOptions/trace=true org.eclipse.jdt.apt.reconcileEnabled=true From 9ad6e162fd5425974684d0e6de4d5dcab4dab01b Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 6 Dec 2013 12:19:37 +0100 Subject: [PATCH 06/12] Add a MessagerAppender to replace classic processingEvent.getMessager().printMessage(...) --- .../AndroidAnnotationProcessor.java | 20 ++----- .../androidannotations/logger/Formatter.java | 2 - .../org/androidannotations/logger/Logger.java | 44 ++++++++++---- .../logger/LoggerContext.java | 29 ++++++++-- .../logger/appender/Appender.java | 22 +++++++ .../logger/appender/ConsoleAppender.java | 26 +++++++++ .../FileAppender.java} | 58 +++++++++++-------- .../logger/appender/MessagerAppender.java | 48 +++++++++++++++ 8 files changed, 191 insertions(+), 58 deletions(-) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java rename AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/{Appender.java => appender/FileAppender.java} (63%) create mode 100644 AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 117779bbf7..0c2422df04 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -40,7 +40,6 @@ import javax.lang.model.SourceVersion; import javax.lang.model.element.Element; import javax.lang.model.element.TypeElement; -import javax.tools.Diagnostic; import org.androidannotations.annotations.AfterInject; import org.androidannotations.annotations.AfterTextChange; @@ -315,13 +314,10 @@ public synchronized void init(ProcessingEnvironment processingEnv) { loadPropertyFile(); loadApiPropertyFile(); } catch (Exception e) { - messager.printMessage(Diagnostic.Kind.ERROR, "AndroidAnnotations processing failed: " + e.getMessage()); + LOGGER.error("Can't load API or core properties files", e); } timeStats.setMessager(messager); - - messager.printMessage(Diagnostic.Kind.NOTE, "Starting AndroidAnnotations annotation processing"); - } private void checkApiAndCoreVersions() throws VersionMismatchException { @@ -654,9 +650,8 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices private void generateSources(ProcessResult processResult) throws IOException { timeStats.start("Generate Sources"); - Messager messager = processingEnv.getMessager(); - messager.printMessage(Diagnostic.Kind.NOTE, "Number of files generated by AndroidAnnotations: " + processResult.codeModel.countArtifacts()); - CodeModelGenerator modelGenerator = new CodeModelGenerator(processingEnv.getFiler(), messager, getAAProcessorVersion()); + LOGGER.info("Number of files generated by AndroidAnnotations: {}", processResult.codeModel.countArtifacts()); + CodeModelGenerator modelGenerator = new CodeModelGenerator(processingEnv.getFiler(), processingEnv.getMessager(), getAAProcessorVersion()); modelGenerator.generate(processResult); timeStats.stop("Generate Sources"); } @@ -664,11 +659,6 @@ private void generateSources(ProcessResult processResult) throws IOException { private void handleException(Set annotations, RoundEnvironment roundEnv, ProcessingException e) { String errorMessage = errorHelper.getErrorMessage(processingEnv, e, getAAProcessorVersion()); - LOGGER.error("Something went wront : {}", errorMessage); - - Messager messager = processingEnv.getMessager(); - messager.printMessage(Diagnostic.Kind.ERROR, errorMessage); - /* * Printing exception as an error on a random element. The exception is * not related to this element, but otherwise it wouldn't show up in @@ -678,7 +668,9 @@ private void handleException(Set annotations, RoundEnviro Iterator iterator = annotations.iterator(); if (iterator.hasNext()) { Element element = roundEnv.getElementsAnnotatedWith(iterator.next()).iterator().next(); - messager.printMessage(Diagnostic.Kind.ERROR, errorMessage, element); + LOGGER.error("Something went wront : {}", errorMessage, element); + } else { + LOGGER.error("Something went wront : {}", errorMessage); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java index c1559fbf80..c253ab77bc 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java @@ -28,8 +28,6 @@ public String buildLog(Level level, String loggerName, String message, Throwable stringBuilder.append('\n').append(stackTraceToString(thr)); } - stringBuilder.append('\n'); - return stringBuilder.toString(); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java index 5cbed69b2c..e690cd632f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java @@ -1,5 +1,7 @@ package org.androidannotations.logger; +import javax.lang.model.element.Element; + public class Logger { private final LoggerContext loggerContext; @@ -11,43 +13,63 @@ public Logger(LoggerContext loggerContext, String name) { } public void trace(String message, Object... args) { - log(Level.TRACE, message, null, args); + trace(message, null, args); + } + + public void trace(String message, Element element, Object... args) { + log(Level.TRACE, message, element, null, args); } public void debug(String message, Object... args) { - log(Level.DEBUG, message, null, args); + debug(message, null, args); + } + + public void debug(String message, Element element, Object... args) { + log(Level.DEBUG, message, element, null, args); } public void info(String message, Object... args) { - log(Level.INFO, message, null, args); + info(message, null, args); + } + + public void info(String message, Element element, Object... args) { + log(Level.INFO, message, element, null, args); } public void warn(String message, Object... args) { - log(Level.WARN, message, null, args); + warn(message, null, null, args); + } + + public void warn(String message, Element element, Object... args) { + warn(message, element, null, args); } - public void warn(String message, Throwable thr, Object... args) { - log(Level.WARN, message, thr, args); + public void warn(String message, Element element, Throwable thr, Object... args) { + log(Level.WARN, message, element, thr, args); } public void error(String message, Object... args) { - log(Level.ERROR, message, null, args); + error(message, null, null, args); + } + + public void error(String message, Element element, Object... args) { + error(message, element, null, args); } - public void error(String message, Throwable thr, Object... args) { - log(Level.ERROR, message, thr, args); + public void error(String message, Element element, Throwable thr, Object... args) { + log(Level.ERROR, message, element, thr, args); } public boolean isLoggable(Level level) { return level.isGreaterOrEquals(loggerContext.getCurrentLevel()); } - private void log(Level level, String message, Throwable thr, Object... args) { + private void log(Level level, String message, Element element, Throwable thr, Object... args) { if (!isLoggable(level)) { return; } - loggerContext.writeLog(level, name, message, thr, args); + loggerContext.writeLog(level, name, message, element, thr, args); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java index c6b8d1312c..04dfbaf713 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -1,6 +1,14 @@ package org.androidannotations.logger; +import java.util.ArrayList; +import java.util.List; + import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import org.androidannotations.logger.appender.Appender; +import org.androidannotations.logger.appender.FileAppender; +import org.androidannotations.logger.appender.MessagerAppender; public class LoggerContext { @@ -10,7 +18,7 @@ public class LoggerContext { private static final Level DEFAULT_LEVEL = Level.DEBUG; private Level currentLevel = DEFAULT_LEVEL; - private Appender appender = new Appender(); + private List appenders = new ArrayList(); private Formatter formatter = new Formatter(); public static LoggerContext getInstance() { @@ -25,11 +33,16 @@ public static LoggerContext getInstance() { } LoggerContext() { + // appenders.add(new ConsoleAppender()); + appenders.add(new FileAppender()); + appenders.add(new MessagerAppender()); } - public void writeLog(Level level, String loggerName, String message, Throwable thr, Object... args) { + public void writeLog(Level level, String loggerName, String message, Element element, Throwable thr, Object... args) { String log = formatter.buildLog(level, loggerName, message, thr, args); - appender.append(log); + for (Appender appender : appenders) { + appender.append(level, element, log); + } } public Level getCurrentLevel() { @@ -41,14 +54,18 @@ public void setCurrentLevel(Level currentLevel) { } public void setProcessingEnv(ProcessingEnvironment processingEnv) { - appender.setProcessingEnv(processingEnv); - appender.resolveLogFile(); + for (Appender appender : appenders) { + appender.setProcessingEnv(processingEnv); + appender.open(); + } resolveLogLevel(processingEnv); } public void close() { - appender.closeFile(); + for (Appender appender : appenders) { + appender.close(); + } } private void resolveLogLevel(ProcessingEnvironment processingEnv) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java new file mode 100644 index 0000000000..9e22154deb --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java @@ -0,0 +1,22 @@ +package org.androidannotations.logger.appender; + +import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; + +import org.androidannotations.logger.Level; + +public abstract class Appender { + + protected ProcessingEnvironment processingEnv; + + public void setProcessingEnv(ProcessingEnvironment processingEnv) { + this.processingEnv = processingEnv; + } + + public abstract void open(); + + public abstract void append(Level level, Element element, String message); + + public abstract void close(); + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java new file mode 100644 index 0000000000..9a67a71155 --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java @@ -0,0 +1,26 @@ +package org.androidannotations.logger.appender; + +import javax.lang.model.element.Element; + +import org.androidannotations.logger.Level; + +public class ConsoleAppender extends Appender { + + @Override + public void open() { + } + + @Override + public void append(Level level, Element element, String message) { + if (level.isSmaller(Level.ERROR)) { + System.out.println(message); + } else { + System.err.println(message); + } + } + + @Override + public void close() { + } + +} diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java similarity index 63% rename from AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java rename to AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java index 9545d13d3f..f481fb1e6c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Appender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java @@ -1,4 +1,4 @@ -package org.androidannotations.logger; +package org.androidannotations.logger.appender; import java.io.File; import java.io.FileNotFoundException; @@ -7,28 +7,34 @@ import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.Element; import javax.tools.Diagnostic.Kind; import org.androidannotations.helper.FileHelper; +import org.androidannotations.logger.Level; +import org.androidannotations.logger.LoggerContext; -public class Appender { +public class FileAppender extends Appender { private static final String DEFAULT_FILENAME = "androidannotations.log"; private File file; private FileOutputStream outputStream; - private ProcessingEnvironment processingEnv; - public synchronized void openFile() { - try { - outputStream = new FileOutputStream(file, true); - } catch (FileNotFoundException e) { - e.printStackTrace(); + @Override + public synchronized void open() { + if (!isStreamOpened()) { + try { + outputStream = new FileOutputStream(file, true); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } } } - public synchronized void closeFile() { - if (outputStream != null) { + @Override + public synchronized void close() { + if (isStreamOpened()) { try { outputStream.close(); } catch (IOException e) { @@ -38,20 +44,26 @@ public synchronized void closeFile() { } } - public synchronized void append(String log) { - if (!isFileOpened()) { - openFile(); + @Override + public synchronized void append(Level level, Element element, String message) { + if (isStreamOpened()) { + try { + message += "\n"; + outputStream.write(message.getBytes()); + outputStream.flush(); + } catch (IOException e) { + e.printStackTrace(); + } } + } - try { - outputStream.write(log.getBytes()); - outputStream.flush(); - } catch (IOException e) { - e.printStackTrace(); - } + @Override + public void setProcessingEnv(ProcessingEnvironment processingEnv) { + super.setProcessingEnv(processingEnv); + resolveLogFile(); } - public void resolveLogFile() { + private void resolveLogFile() { Messager messager = processingEnv.getMessager(); if (processingEnv.getOptions().containsKey(LoggerContext.LOG_FILE_OPTION)) { file = resolveLogFileInSpecifiedPath(); @@ -80,12 +92,8 @@ private File resolveLogFileInParentsDirectories() { return new File(outputDirectory, DEFAULT_FILENAME); } - public boolean isFileOpened() { + private boolean isStreamOpened() { return outputStream != null; } - public void setProcessingEnv(ProcessingEnvironment processingEnv) { - this.processingEnv = processingEnv; - } - } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java new file mode 100644 index 0000000000..917c219a3b --- /dev/null +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java @@ -0,0 +1,48 @@ +package org.androidannotations.logger.appender; + +import javax.annotation.processing.Messager; +import javax.lang.model.element.Element; +import javax.tools.Diagnostic.Kind; + +import org.androidannotations.logger.Level; + +public class MessagerAppender extends Appender { + + private Messager messager; + + @Override + public void open() { + messager = processingEnv.getMessager(); + } + + @Override + public void append(Level level, Element element, String message) { + if (messager == null) { + return; + } + + Kind kind = resolveKind(level); + messager.printMessage(kind, message, element); + } + + @Override + public void close() { + } + + private Kind resolveKind(Level level) { + switch (level) { + case TRACE: + return Kind.NOTE; + case DEBUG: + return Kind.NOTE; + case INFO: + return Kind.NOTE; + case WARN: + return Kind.WARNING; + case ERROR: + return Kind.ERROR; + } + return Kind.OTHER; + } + +} From 44a0206a61800cc4aed0c3156791237c725b1ce8 Mon Sep 17 00:00:00 2001 From: Damien Date: Fri, 6 Dec 2013 12:40:43 +0100 Subject: [PATCH 07/12] Replace getMessager() calls by logger call --- .../AndroidAnnotationProcessor.java | 7 +---- .../generation/CodeModelGenerator.java | 7 ++--- .../generation/SourceCodewriter.java | 18 +++++------- .../helper/AndroidManifestFinder.java | 29 ++++++++----------- .../helper/AnnotationHelper.java | 16 ++++++---- .../androidannotations/helper/TimeStats.java | 17 ++++------- .../org/androidannotations/logger/Logger.java | 15 +++++----- .../logger/LoggerContext.java | 5 ++-- .../logger/appender/Appender.java | 3 +- .../logger/appender/ConsoleAppender.java | 3 +- .../logger/appender/FileAppender.java | 3 +- .../logger/appender/MessagerAppender.java | 5 ++-- .../rclass/AndroidRClassFinder.java | 13 +++++---- .../rclass/ProjectRClassFinder.java | 8 ++--- 14 files changed, 70 insertions(+), 79 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 0c2422df04..6bbcb03a3f 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -32,7 +32,6 @@ import java.util.Set; import javax.annotation.processing.AbstractProcessor; -import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; import javax.annotation.processing.RoundEnvironment; import javax.annotation.processing.SupportedOptions; @@ -308,16 +307,12 @@ public synchronized void init(ProcessingEnvironment processingEnv) { LOGGER.info("Initialize AndroidAnnotationProcessor with options {}", processingEnv.getOptions()); - Messager messager = processingEnv.getMessager(); - try { loadPropertyFile(); loadApiPropertyFile(); } catch (Exception e) { LOGGER.error("Can't load API or core properties files", e); } - - timeStats.setMessager(messager); } private void checkApiAndCoreVersions() throws VersionMismatchException { @@ -651,7 +646,7 @@ private ModelProcessor buildModelProcessor(IRClass rClass, AndroidSystemServices private void generateSources(ProcessResult processResult) throws IOException { timeStats.start("Generate Sources"); LOGGER.info("Number of files generated by AndroidAnnotations: {}", processResult.codeModel.countArtifacts()); - CodeModelGenerator modelGenerator = new CodeModelGenerator(processingEnv.getFiler(), processingEnv.getMessager(), getAAProcessorVersion()); + CodeModelGenerator modelGenerator = new CodeModelGenerator(processingEnv.getFiler(), getAAProcessorVersion()); modelGenerator.generate(processResult); timeStats.stop("Generate Sources"); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java index 50495ef3fa..8b87004f99 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/CodeModelGenerator.java @@ -18,7 +18,6 @@ import java.io.IOException; import javax.annotation.processing.Filer; -import javax.annotation.processing.Messager; import org.androidannotations.processing.ModelProcessor.ProcessResult; @@ -27,12 +26,10 @@ public class CodeModelGenerator { private final Filer filer; - private final Messager messager; private final String aaVersion; - public CodeModelGenerator(Filer filer, Messager messager, String aaVersion) { + public CodeModelGenerator(Filer filer, String aaVersion) { this.filer = filer; - this.messager = messager; this.aaVersion = aaVersion; } @@ -41,7 +38,7 @@ public void generate(ProcessResult processResult) throws IOException { ApiCodeGenerator apiCodeGenerator = new ApiCodeGenerator(filer); apiCodeGenerator.writeApiClasses(processResult.apiClassesToGenerate, processResult.originatingElements); - SourceCodewriter sourceCodeWriter = new SourceCodewriter(filer, messager, processResult.originatingElements); + SourceCodewriter sourceCodeWriter = new SourceCodewriter(filer, processResult.originatingElements); PrologCodeWriter prologCodeWriter = new PrologCodeWriter(sourceCodeWriter, "DO NOT EDIT THIS FILE, IT HAS BEEN GENERATED USING AndroidAnnotations " + aaVersion + ".\n"); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java index ef6933e534..9dc292837d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java @@ -20,11 +20,11 @@ import javax.annotation.processing.Filer; import javax.annotation.processing.FilerException; -import javax.annotation.processing.Messager; import javax.lang.model.element.Element; -import javax.tools.Diagnostic.Kind; import javax.tools.JavaFileObject; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.processing.OriginatingElements; import com.sun.codemodel.CodeWriter; @@ -32,10 +32,9 @@ public class SourceCodewriter extends CodeWriter { - private final Filer filer; - private final Messager message; - private static final VoidOutputStream VOID_OUTPUT_STREAM = new VoidOutputStream(); + private static final Logger LOGGER = LoggerFactory.getLogger(SourceCodewriter.class); + private final Filer filer; private OriginatingElements originatingElements; private static class VoidOutputStream extends OutputStream { @@ -45,16 +44,15 @@ public void write(int arg0) throws IOException { } } - public SourceCodewriter(Filer filer, Messager message, OriginatingElements originatingElements) { + public SourceCodewriter(Filer filer, OriginatingElements originatingElements) { this.filer = filer; - this.message = message; this.originatingElements = originatingElements; } @Override public OutputStream openBinary(JPackage pkg, String fileName) throws IOException { String qualifiedClassName = toQualifiedClassName(pkg, fileName); - message.printMessage(Kind.NOTE, "Generating source file: " + qualifiedClassName); + LOGGER.info("Generating source file: {}", qualifiedClassName); Element[] classOriginatingElements = originatingElements.getClassOriginatingElements(qualifiedClassName); @@ -62,14 +60,14 @@ public OutputStream openBinary(JPackage pkg, String fileName) throws IOException JavaFileObject sourceFile; if (classOriginatingElements.length == 0) { - message.printMessage(Kind.NOTE, "Generating class with no originating element: " + qualifiedClassName); + LOGGER.info("Generating class with no originating element: {}", qualifiedClassName); } sourceFile = filer.createSourceFile(qualifiedClassName, classOriginatingElements); return sourceFile.openOutputStream(); } catch (FilerException e) { - message.printMessage(Kind.NOTE, "Could not generate source file for " + qualifiedClassName + ", message: " + e.getMessage()); + LOGGER.error("Could not generate source file for {}", qualifiedClassName, e.getMessage()); /* * This exception is expected, when some files are created twice. We * cannot delete existing files, unless using a dirty hack. Files a diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java index 91f0728f12..f3f237fc3c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java @@ -22,14 +22,14 @@ import java.util.List; import java.util.Properties; -import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.util.Elements; -import javax.tools.Diagnostic.Kind; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.androidannotations.helper.FileHelper.FileHolder; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; @@ -40,6 +40,7 @@ public class AndroidManifestFinder { public static final String ANDROID_MANIFEST_FILE_OPTION = "androidManifestFile"; + private static final Logger LOGGER = LoggerFactory.getLogger(AndroidManifestFinder.class); private static final int MAX_PARENTS_FROM_SOURCE_FOLDER = 10; private ProcessingEnvironment processingEnv; @@ -70,8 +71,7 @@ public Option extractAndroidManifest() { String androidLibraryProperty = properties.getProperty("android.library"); libraryProject = androidLibraryProperty.equals("true"); - Messager messager = processingEnv.getMessager(); - messager.printMessage(Kind.NOTE, "Found android.library property in project.properties, value: " + libraryProject); + LOGGER.info("Found android.library property in project.properties, value: {}", libraryProject); } } catch (IOException ignored) { } @@ -91,12 +91,11 @@ private Option findManifestFile() { private Option findManifestInSpecifiedPath() { String path = processingEnv.getOptions().get(ANDROID_MANIFEST_FILE_OPTION); File androidManifestFile = new File(path); - Messager messager = processingEnv.getMessager(); if (!androidManifestFile.exists()) { - messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file in specified path : " + path); + LOGGER.error("Could not find the AndroidManifest.xml file in specified path : {}", path); return Option.absent(); } else { - messager.printMessage(Kind.NOTE, "AndroidManifest.xml file found: " + androidManifestFile.toString()); + LOGGER.info("AndroidManifest.xml file found: {}", androidManifestFile.toString()); } return Option.of(androidManifestFile); } @@ -131,12 +130,11 @@ private Option findManifestInParentsDirectories() { } } - Messager messager = processingEnv.getMessager(); if (!androidManifestFile.exists()) { - messager.printMessage(Kind.ERROR, "Could not find the AndroidManifest.xml file, going up from path [" + projectRootHolder.sourcesGenerationFolder.getAbsolutePath() + "] found using dummy file [" + projectRootHolder.dummySourceFilePath + "] (max atempts: " + MAX_PARENTS_FROM_SOURCE_FOLDER + ")"); + LOGGER.error("Could not find the AndroidManifest.xml file, going up from path [{}] found using dummy file [] (max atempts: {})", projectRootHolder.sourcesGenerationFolder.getAbsolutePath(), projectRootHolder.dummySourceFilePath, MAX_PARENTS_FROM_SOURCE_FOLDER); return Option.absent(); } else { - messager.printMessage(Kind.NOTE, "AndroidManifest.xml file found: " + androidManifestFile.toString()); + LOGGER.info("AndroidManifest.xml file found: {}", androidManifestFile.toString()); } return Option.of(androidManifestFile); @@ -150,8 +148,7 @@ private Option parse(File androidManifestFile, boolean libraryP DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); doc = docBuilder.parse(androidManifestFile); } catch (Exception e) { - Messager messager = processingEnv.getMessager(); - messager.printMessage(Kind.ERROR, "Could not parse the AndroidManifest.xml file at path " + androidManifestFile); + LOGGER.error("Could not parse the AndroidManifest.xml file at path {}", androidManifestFile, e); return Option.absent(); } @@ -187,9 +184,8 @@ private Option parse(File androidManifestFile, boolean libraryP applicationClassQualifiedName = manifestNameToValidQualifiedName(applicationPackage, nameAttribute); if (applicationClassQualifiedName == null) { - Messager messager = processingEnv.getMessager(); if (nameAttribute != null) { - messager.printMessage(Kind.NOTE, String.format("The class application declared in the AndroidManifest.xml cannot be found in the compile path: [%s]", nameAttribute.getNodeValue())); + LOGGER.info("The class application declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); } } @@ -252,11 +248,10 @@ private List extractComponentNames(String applicationPackage, NodeList c if (qualifiedName != null) { componentQualifiedNames.add(qualifiedName); } else { - Messager messager = processingEnv.getMessager(); if (nameAttribute != null) { - messager.printMessage(Kind.NOTE, String.format("A class activity declared in the AndroidManifest.xml cannot be found in the compile path: [%s]", nameAttribute.getNodeValue())); + LOGGER.info("A class activity declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); } else { - messager.printMessage(Kind.NOTE, String.format("The %d activity node in the AndroidManifest.xml has no android:name attribute", i)); + LOGGER.info("The {} activity node in the AndroidManifest.xml has no android:name attribute", i); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java index 325f2bac2e..71333bf912 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AnnotationHelper.java @@ -38,11 +38,13 @@ import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; -import javax.tools.Diagnostic; import org.androidannotations.annotations.OnActivityResult; import org.androidannotations.annotations.OptionsItem; import org.androidannotations.annotations.ResId; +import org.androidannotations.logger.Level; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.processing.EBeanHolder; import org.androidannotations.rclass.IRInnerClass; import org.androidannotations.rclass.RInnerClass; @@ -51,6 +53,8 @@ public class AnnotationHelper { + private static final Logger LOGGER = LoggerFactory.getLogger(AnnotationHelper.class); + private final ProcessingEnvironment processingEnv; public AnnotationHelper(ProcessingEnvironment processingEnv) { @@ -94,24 +98,24 @@ public boolean isAnnotation(TypeElement annotation, String annotationName) { } public void printAnnotationError(Element annotatedElement, String annotationName, String message) { - printAnnotationMessage(Diagnostic.Kind.ERROR, annotatedElement, annotationName, message); + printAnnotationMessage(Level.ERROR, annotatedElement, annotationName, message); } public void printAnnotationWarning(Element annotatedElement, String annotationName, String message) { - printAnnotationMessage(Diagnostic.Kind.WARNING, annotatedElement, annotationName, message); + printAnnotationMessage(Level.WARN, annotatedElement, annotationName, message); } - public void printAnnotationMessage(Diagnostic.Kind diagnosticKind, Element annotatedElement, String annotationName, String message) { + public void printAnnotationMessage(Level level, Element annotatedElement, String annotationName, String message) { AnnotationMirror annotationMirror = findAnnotationMirror(annotatedElement, annotationName); if (annotationMirror != null) { - processingEnv.getMessager().printMessage(diagnosticKind, message, annotatedElement, annotationMirror); + LOGGER.log(level, message, annotatedElement, annotationMirror, null); } else { printError(annotatedElement, message); } } public void printError(Element element, String message) { - processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, message, element); + LOGGER.error(message, element); } public boolean isPrivate(Element element) { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java index e559c04837..51303e4740 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/TimeStats.java @@ -21,11 +21,13 @@ import java.util.List; import java.util.Map; -import javax.annotation.processing.Messager; -import javax.tools.Diagnostic; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; public class TimeStats { + private static final Logger LOGGER = LoggerFactory.getLogger(TimeStats.class); + private final Map measures = new HashMap(); private final List durations = new ArrayList(); @@ -44,8 +46,6 @@ public int compareTo(Duration o) { } } - private Messager messager; - public void start(String key) { long start = System.currentTimeMillis(); measures.put(key, start); @@ -62,7 +62,6 @@ public void stop(String key) { @Override public String toString() { - StringBuilder sb = new StringBuilder(); sb.append("Time measurements: "); @@ -79,13 +78,7 @@ public String toString() { } public void logStats() { - if (messager != null) { - messager.printMessage(Diagnostic.Kind.NOTE, toString()); - } - } - - public void setMessager(Messager messager) { - this.messager = messager; + LOGGER.info(toString()); } public void clear() { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java index e690cd632f..b3b3335005 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java @@ -1,5 +1,6 @@ package org.androidannotations.logger; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; public class Logger { @@ -17,7 +18,7 @@ public void trace(String message, Object... args) { } public void trace(String message, Element element, Object... args) { - log(Level.TRACE, message, element, null, args); + log(Level.TRACE, message, element, null, null, args); } public void debug(String message, Object... args) { @@ -25,7 +26,7 @@ public void debug(String message, Object... args) { } public void debug(String message, Element element, Object... args) { - log(Level.DEBUG, message, element, null, args); + log(Level.DEBUG, message, element, null, null, args); } public void info(String message, Object... args) { @@ -33,7 +34,7 @@ public void info(String message, Object... args) { } public void info(String message, Element element, Object... args) { - log(Level.INFO, message, element, null, args); + log(Level.INFO, message, element, null, null, args); } public void warn(String message, Object... args) { @@ -45,7 +46,7 @@ public void warn(String message, Element element, Object... args) { } public void warn(String message, Element element, Throwable thr, Object... args) { - log(Level.WARN, message, element, thr, args); + log(Level.WARN, message, element, null, thr, args); } public void error(String message, Object... args) { @@ -57,19 +58,19 @@ public void error(String message, Element element, Object... args) { } public void error(String message, Element element, Throwable thr, Object... args) { - log(Level.ERROR, message, element, thr, args); + log(Level.ERROR, message, element, null, thr, args); } public boolean isLoggable(Level level) { return level.isGreaterOrEquals(loggerContext.getCurrentLevel()); } - private void log(Level level, String message, Element element, Throwable thr, Object... args) { + public void log(Level level, String message, Element element, AnnotationMirror annotationMirror, Throwable thr, Object... args) { if (!isLoggable(level)) { return; } - loggerContext.writeLog(level, name, message, element, thr, args); + loggerContext.writeLog(level, name, message, element, annotationMirror, thr, args); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java index 04dfbaf713..8f4e9d8b6a 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -4,6 +4,7 @@ import java.util.List; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import org.androidannotations.logger.appender.Appender; @@ -38,10 +39,10 @@ public static LoggerContext getInstance() { appenders.add(new MessagerAppender()); } - public void writeLog(Level level, String loggerName, String message, Element element, Throwable thr, Object... args) { + public void writeLog(Level level, String loggerName, String message, Element element, AnnotationMirror annotationMirror, Throwable thr, Object... args) { String log = formatter.buildLog(level, loggerName, message, thr, args); for (Appender appender : appenders) { - appender.append(level, element, log); + appender.append(level, element, annotationMirror, log); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java index 9e22154deb..b9fdba1b37 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/Appender.java @@ -1,6 +1,7 @@ package org.androidannotations.logger.appender; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import org.androidannotations.logger.Level; @@ -15,7 +16,7 @@ public void setProcessingEnv(ProcessingEnvironment processingEnv) { public abstract void open(); - public abstract void append(Level level, Element element, String message); + public abstract void append(Level level, Element element, AnnotationMirror annotationMirror, String message); public abstract void close(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java index 9a67a71155..96343982e7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/ConsoleAppender.java @@ -1,5 +1,6 @@ package org.androidannotations.logger.appender; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import org.androidannotations.logger.Level; @@ -11,7 +12,7 @@ public void open() { } @Override - public void append(Level level, Element element, String message) { + public void append(Level level, Element element, AnnotationMirror annotationMirror, String message) { if (level.isSmaller(Level.ERROR)) { System.out.println(message); } else { diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java index f481fb1e6c..909a553c45 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/FileAppender.java @@ -7,6 +7,7 @@ import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import javax.tools.Diagnostic.Kind; @@ -45,7 +46,7 @@ public synchronized void close() { } @Override - public synchronized void append(Level level, Element element, String message) { + public synchronized void append(Level level, Element element, AnnotationMirror annotationMirror, String message) { if (isStreamOpened()) { try { message += "\n"; diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java index 917c219a3b..53afade0ff 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/appender/MessagerAppender.java @@ -1,6 +1,7 @@ package org.androidannotations.logger.appender; import javax.annotation.processing.Messager; +import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import javax.tools.Diagnostic.Kind; @@ -16,13 +17,13 @@ public void open() { } @Override - public void append(Level level, Element element, String message) { + public void append(Level level, Element element, AnnotationMirror annotationMirror, String message) { if (messager == null) { return; } Kind kind = resolveKind(level); - messager.printMessage(kind, message, element); + messager.printMessage(kind, message, element, annotationMirror); } @Override diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java index 21d1314e94..103f4c8b89 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java @@ -15,15 +15,18 @@ */ package org.androidannotations.rclass; -import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.TypeElement; -import javax.tools.Diagnostic.Kind; +import javax.lang.model.util.Elements; import org.androidannotations.helper.Option; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; public class AndroidRClassFinder { + private static final Logger LOGGER = LoggerFactory.getLogger(AndroidRClassFinder.class); + private final ProcessingEnvironment processingEnv; public AndroidRClassFinder(ProcessingEnvironment processingEnv) { @@ -31,10 +34,10 @@ public AndroidRClassFinder(ProcessingEnvironment processingEnv) { } public Option find() { - TypeElement androidRType = processingEnv.getElementUtils().getTypeElement("android.R"); + Elements elementUtils = processingEnv.getElementUtils(); + TypeElement androidRType = elementUtils.getTypeElement("android.R"); if (androidRType == null) { - Messager messager = processingEnv.getMessager(); - messager.printMessage(Kind.ERROR, "The android.R class cannot be found"); + LOGGER.error("The android.R class cannot be found"); return Option.absent(); } return Option. of(new RClass(androidRType)); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java index 32c22a8251..52b1b40f01 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java @@ -15,18 +15,19 @@ */ package org.androidannotations.rclass; -import javax.annotation.processing.Messager; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.TypeElement; import javax.lang.model.util.Elements; -import javax.tools.Diagnostic.Kind; import org.androidannotations.helper.AndroidManifest; import org.androidannotations.helper.Option; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; public class ProjectRClassFinder { public static final String RESOURCE_PACKAGE_NAME_OPTION = "resourcePackageName"; + private static final Logger LOGGER = LoggerFactory.getLogger(ProjectRClassFinder.class); private ProcessingEnvironment processingEnv; @@ -41,8 +42,7 @@ public Option find(AndroidManifest manifest) { TypeElement rType = elementUtils.getTypeElement(rClass); if (rType == null) { - Messager messager = processingEnv.getMessager(); - messager.printMessage(Kind.ERROR, "The generated " + rClass + " class cannot be found"); + LOGGER.error("The generated {} class cannot be found", rClass); return Option.absent(); } From ed00b2eb4bda092ca3a929ff12a28b462c4fd735 Mon Sep 17 00:00:00 2001 From: Damien Date: Sun, 8 Dec 2013 21:29:04 +0100 Subject: [PATCH 08/12] Adjust logs --- .../AndroidAnnotationProcessor.java | 15 ++++++------ .../generation/ApiCodeGenerator.java | 5 ++++ .../generation/SourceCodewriter.java | 2 +- .../helper/AndroidManifest.java | 5 ++++ .../helper/AndroidManifestFinder.java | 12 +++++----- .../processing/ModelProcessor.java | 24 +++++++++++++++++-- .../rclass/AndroidRClassFinder.java | 3 +++ .../rclass/ProjectRClassFinder.java | 3 ++- .../validation/ModelValidator.java | 15 ++++++++++++ 9 files changed, 66 insertions(+), 18 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index 6bbcb03a3f..ea79917dab 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -320,6 +320,7 @@ private void checkApiAndCoreVersions() throws VersionMismatchException { String coreVersion = getAAProcessorVersion(); if (!apiVersion.equals(coreVersion)) { + LOGGER.error("AndroidAnnotation version for API ({}) and core ({}) doesn't match. Please check your classpath", apiVersion, coreVersion); throw new VersionMismatchException("AndroidAnnotation version for API (" + apiVersion + ") and core (" + coreVersion + ") doesn't match. Please check your classpath"); } } @@ -359,7 +360,8 @@ private void loadPropertyFile() throws FileNotFoundException { URL url = getClass().getClassLoader().getResource(filename); properties.load(url.openStream()); } catch (Exception e) { - throw new FileNotFoundException(filename + " couldn't be parsed."); + LOGGER.error("Core property file {} couldn't be parse"); + throw new FileNotFoundException("Core property file " + filename + " couldn't be parsed."); } } @@ -369,7 +371,8 @@ private void loadApiPropertyFile() throws FileNotFoundException { URL url = EActivity.class.getClassLoader().getResource(filename); propertiesApi.load(url.openStream()); } catch (Exception e) { - throw new FileNotFoundException(filename + " couldn't be parsed. Please check your classpath and verify that AA-API's version is at least 3.0"); + LOGGER.error("API property file {} couldn't be parse"); + throw new FileNotFoundException("API property file " + filename + " couldn't be parsed. Please check your classpath and verify that AA-API's version is at least 3.0"); } } @@ -389,27 +392,23 @@ private void processThrowing(Set annotations, RoundEnviro AnnotationElementsHolder extractedModel = extractAnnotations(annotations, roundEnv); Option androidManifestOption = extractAndroidManifest(); - if (androidManifestOption.isAbsent()) { return; } - AndroidManifest androidManifest = androidManifestOption.get(); - Option rClassOption = findRClasses(androidManifest); + LOGGER.info("AndroidManifest.xml found: {}", androidManifest); + Option rClassOption = findRClasses(androidManifest); if (rClassOption.isAbsent()) { return; } - IRClass rClass = rClassOption.get(); AndroidSystemServices androidSystemServices = new AndroidSystemServices(); AnnotationElements validatedModel = validateAnnotations(extractedModel, rClass, androidSystemServices, androidManifest); - ProcessResult processResult = processAnnotations(validatedModel, rClass, androidSystemServices, androidManifest); - generateSources(processResult); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java index b93802f8d5..509bb7bdf6 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/ApiCodeGenerator.java @@ -25,10 +25,13 @@ import javax.lang.model.element.Element; import javax.tools.JavaFileObject; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.processing.OriginatingElements; public class ApiCodeGenerator { + private static final Logger LOGGER = LoggerFactory.getLogger(ApiCodeGenerator.class); private static final byte[] BUFFER = new byte[4096]; private static void copyStream(InputStream input, OutputStream output) throws IOException { @@ -46,6 +49,8 @@ public ApiCodeGenerator(Filer filer) { public void writeApiClasses(Set> apiClassesToGenerate, OriginatingElements originatingElements) { + LOGGER.info("Writting following API classes in project: {}", apiClassesToGenerate); + for (Class apiClassToGenerate : apiClassesToGenerate) { String canonicalApiClassName = apiClassToGenerate.getCanonicalName(); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java index 9dc292837d..a47b1dccca 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/generation/SourceCodewriter.java @@ -52,7 +52,7 @@ public SourceCodewriter(Filer filer, OriginatingElements originatingElements) { @Override public OutputStream openBinary(JPackage pkg, String fileName) throws IOException { String qualifiedClassName = toQualifiedClassName(pkg, fileName); - LOGGER.info("Generating source file: {}", qualifiedClassName); + LOGGER.debug("Generating class: {}", qualifiedClassName); Element[] classOriginatingElements = originatingElements.getClassOriginatingElements(qualifiedClassName); diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifest.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifest.java index e7bc87096a..c19d807791 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifest.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifest.java @@ -30,6 +30,11 @@ public class AndroidManifest { private final int maxSdkVersion; private final int targetSdkVersion; + @Override + public String toString() { + return "AndroidManifest [applicationPackage=" + applicationPackage + ", componentQualifiedNames=" + componentQualifiedNames + ", permissionQualifiedNames=" + permissionQualifiedNames + ", applicationClassName=" + applicationClassName + ", libraryProject=" + libraryProject + ", debugabble=" + debugabble + ", minSdkVersion=" + minSdkVersion + ", maxSdkVersion=" + maxSdkVersion + ", targetSdkVersion=" + targetSdkVersion + "]"; + } + public static AndroidManifest createManifest(String applicationPackage, String applicationClassName, List componentQualifiedNames, List permissionQualifiedNames, int minSdkVersion, int maxSdkVersion, int targetSdkVersion, boolean debugabble) { return new AndroidManifest(false, applicationPackage, applicationClassName, componentQualifiedNames, permissionQualifiedNames, minSdkVersion, maxSdkVersion, targetSdkVersion, debugabble); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java index f3f237fc3c..eeedc4518d 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/helper/AndroidManifestFinder.java @@ -71,7 +71,7 @@ public Option extractAndroidManifest() { String androidLibraryProperty = properties.getProperty("android.library"); libraryProject = androidLibraryProperty.equals("true"); - LOGGER.info("Found android.library property in project.properties, value: {}", libraryProject); + LOGGER.debug("Found android.library={} property in project.properties", libraryProject); } } catch (IOException ignored) { } @@ -95,7 +95,7 @@ private Option findManifestInSpecifiedPath() { LOGGER.error("Could not find the AndroidManifest.xml file in specified path : {}", path); return Option.absent(); } else { - LOGGER.info("AndroidManifest.xml file found: {}", androidManifestFile.toString()); + LOGGER.debug("AndroidManifest.xml file found with specified path: {}", androidManifestFile.toString()); } return Option.of(androidManifestFile); } @@ -134,7 +134,7 @@ private Option findManifestInParentsDirectories() { LOGGER.error("Could not find the AndroidManifest.xml file, going up from path [{}] found using dummy file [] (max atempts: {})", projectRootHolder.sourcesGenerationFolder.getAbsolutePath(), projectRootHolder.dummySourceFilePath, MAX_PARENTS_FROM_SOURCE_FOLDER); return Option.absent(); } else { - LOGGER.info("AndroidManifest.xml file found: {}", androidManifestFile.toString()); + LOGGER.debug("AndroidManifest.xml file found in parent folder {}: {}", projectRoot.getAbsolutePath(), androidManifestFile.toString()); } return Option.of(androidManifestFile); @@ -185,7 +185,7 @@ private Option parse(File androidManifestFile, boolean libraryP if (applicationClassQualifiedName == null) { if (nameAttribute != null) { - LOGGER.info("The class application declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); + LOGGER.warn("The class application declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); } } @@ -249,9 +249,9 @@ private List extractComponentNames(String applicationPackage, NodeList c componentQualifiedNames.add(qualifiedName); } else { if (nameAttribute != null) { - LOGGER.info("A class activity declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); + LOGGER.warn("A class activity declared in the AndroidManifest.xml cannot be found in the compile path: [{}]", nameAttribute.getNodeValue()); } else { - LOGGER.info("The {} activity node in the AndroidManifest.xml has no android:name attribute", i); + LOGGER.warn("The {} activity node in the AndroidManifest.xml has no android:name attribute", i); } } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java index 9aad843c6a..e174fdf34c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/processing/ModelProcessor.java @@ -25,6 +25,8 @@ import javax.lang.model.element.TypeElement; import org.androidannotations.exception.ProcessingException; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElements.AnnotatedAndRootElements; @@ -32,6 +34,8 @@ public class ModelProcessor { + private static final Logger LOGGER = LoggerFactory.getLogger(ModelProcessor.class); + public static class ProcessResult { public final JCodeModel codeModel; @@ -61,14 +65,19 @@ public void register(GeneratingElementProcessor processor) { } public ProcessResult process(AnnotationElements validatedModel) throws ProcessingException, Exception { - JCodeModel codeModel = new JCodeModel(); - EBeansHolder eBeansHolder = new EBeansHolder(codeModel); + LOGGER.info("Processing root elements"); + for (GeneratingElementProcessor processor : typeProcessors) { String annotationName = processor.getTarget(); Set annotatedElements = validatedModel.getRootAnnotatedElements(annotationName); + + if (!annotatedElements.isEmpty()) { + LOGGER.debug("Processing root elements with {}: {}", processor.getClass().getSimpleName(), annotatedElements); + } + for (Element annotatedElement : annotatedElements) { /* * We do not generate code for abstract classes, because the @@ -77,6 +86,8 @@ public ProcessResult process(AnnotationElements validatedModel) throws Processin */ if (!isAbstractClass(annotatedElement)) { processThrowing(processor, annotatedElement, codeModel, eBeansHolder); + } else { + LOGGER.trace("Skip element {} because it's abstract", annotatedElement); } } /* @@ -85,6 +96,8 @@ public ProcessResult process(AnnotationElements validatedModel) throws Processin */ } + LOGGER.info("Processing enclosed elements"); + for (DecoratingElementProcessor processor : enclosedProcessors) { String annotationName = processor.getTarget(); @@ -93,6 +106,11 @@ public ProcessResult process(AnnotationElements validatedModel) throws Processin * but uses the holder for the root element */ Set ancestorAnnotatedElements = validatedModel.getAncestorAnnotatedElements(annotationName); + + if (!ancestorAnnotatedElements.isEmpty()) { + LOGGER.debug("Processing enclosed elements with {}: {}", processor.getClass().getSimpleName(), ancestorAnnotatedElements); + } + for (AnnotatedAndRootElements elements : ancestorAnnotatedElements) { EBeanHolder holder = eBeansHolder.getEBeanHolder(elements.rootTypeElement); /* @@ -122,6 +140,8 @@ public ProcessResult process(AnnotationElements validatedModel) throws Processin if (!isAbstractClass(enclosingElement)) { EBeanHolder holder = eBeansHolder.getEBeanHolder(enclosingElement); processThrowing(processor, annotatedElement, codeModel, holder); + } else { + LOGGER.trace("Skip element {} because enclosing element {} is abstract", annotatedElement, enclosingElement); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java index 103f4c8b89..88c0ef155e 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/AndroidRClassFinder.java @@ -40,6 +40,9 @@ public Option find() { LOGGER.error("The android.R class cannot be found"); return Option.absent(); } + + LOGGER.info("Found Android class: {}", androidRType.toString()); + return Option. of(new RClass(androidRType)); } } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java index 52b1b40f01..e21496e8c4 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/rclass/ProjectRClassFinder.java @@ -36,7 +36,6 @@ public ProjectRClassFinder(ProcessingEnvironment processingEnv) { } public Option find(AndroidManifest manifest) { - Elements elementUtils = processingEnv.getElementUtils(); String rClass = getRClassPackageName(manifest) + ".R"; TypeElement rType = elementUtils.getTypeElement(rClass); @@ -46,6 +45,8 @@ public Option find(AndroidManifest manifest) { return Option.absent(); } + LOGGER.info("Found project R class: {}", rType.toString()); + return Option. of(new RClass(rType)); } diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java index 295aa08c82..ddca2df84b 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/validation/ModelValidator.java @@ -23,11 +23,15 @@ import javax.lang.model.element.Element; import org.androidannotations.exception.ProcessingException; +import org.androidannotations.logger.Logger; +import org.androidannotations.logger.LoggerFactory; import org.androidannotations.model.AnnotationElements; import org.androidannotations.model.AnnotationElementsHolder; public class ModelValidator { + private static final Logger LOGGER = LoggerFactory.getLogger(ModelValidator.class); + private List validators = new ArrayList(); public void register(ElementValidator validator) { @@ -36,6 +40,8 @@ public void register(ElementValidator validator) { public AnnotationElements validate(AnnotationElementsHolder extractedModel) throws ProcessingException, Exception { + LOGGER.info("Validating elements"); + /* * We currently do not validate the elements on the ancestors, assuming * they've already been validated. This also means some checks such as @@ -44,6 +50,8 @@ public AnnotationElements validate(AnnotationElementsHolder extractedModel) thro AnnotationElementsHolder validatedElements = extractedModel.validatingHolder(); for (ElementValidator validator : validators) { + String validatorSimpleName = validator.getClass().getSimpleName(); + String annotationName = validator.getTarget(); Set annotatedElements = extractedModel.getRootAnnotatedElements(annotationName); @@ -52,12 +60,19 @@ public AnnotationElements validate(AnnotationElementsHolder extractedModel) thro validatedElements.putRootAnnotatedElements(annotationName, validatedAnnotatedElements); + if (!annotatedElements.isEmpty()) { + LOGGER.debug("Validating with {}: {}", validatorSimpleName, annotatedElements); + } + for (Element annotatedElement : annotatedElements) { if (validateThrowing(validator, annotatedElement, validatedElements)) { validatedAnnotatedElements.add(annotatedElement); + } else { + LOGGER.warn("Element {} unvalidated by {}", annotatedElement, validatorSimpleName); } } } + return validatedElements; } From 4a90ad6a0cc426a963c6e80cfd65a1249970310d Mon Sep 17 00:00:00 2001 From: Damien Date: Sun, 8 Dec 2013 22:15:12 +0100 Subject: [PATCH 09/12] Add an annotation processing option to add ConsoleAppender --- .../logger/LoggerContext.java | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java index 8f4e9d8b6a..fbb8361c8c 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/LoggerContext.java @@ -2,12 +2,14 @@ import java.util.ArrayList; import java.util.List; +import java.util.Map; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.AnnotationMirror; import javax.lang.model.element.Element; import org.androidannotations.logger.appender.Appender; +import org.androidannotations.logger.appender.ConsoleAppender; import org.androidannotations.logger.appender.FileAppender; import org.androidannotations.logger.appender.MessagerAppender; @@ -15,6 +17,7 @@ public class LoggerContext { public static final String LOG_FILE_OPTION = "logFile"; public static final String LOG_LEVEL_OPTION = "logLevel"; + public static final String LOG_APPENDER_CONSOLE = "logAppenderConsole"; private static LoggerContext INSTANCE = null; private static final Level DEFAULT_LEVEL = Level.DEBUG; @@ -34,7 +37,6 @@ public static LoggerContext getInstance() { } LoggerContext() { - // appenders.add(new ConsoleAppender()); appenders.add(new FileAppender()); appenders.add(new MessagerAppender()); } @@ -61,6 +63,7 @@ public void setProcessingEnv(ProcessingEnvironment processingEnv) { } resolveLogLevel(processingEnv); + addConsoleAppender(processingEnv); } public void close() { @@ -70,10 +73,20 @@ public void close() { } private void resolveLogLevel(ProcessingEnvironment processingEnv) { - if (processingEnv.getOptions().containsKey(LoggerContext.LOG_LEVEL_OPTION)) { - Level logLevel = Level.parse(processingEnv.getOptions().get(LoggerContext.LOG_LEVEL_OPTION)); + Map options = processingEnv.getOptions(); + if (options.containsKey(LOG_LEVEL_OPTION)) { + Level logLevel = Level.parse(options.get(LOG_LEVEL_OPTION)); setCurrentLevel(logLevel); } } + private void addConsoleAppender(ProcessingEnvironment processingEnv) { + Map options = processingEnv.getOptions(); + if (options.containsKey(LOG_APPENDER_CONSOLE)) { + if (Boolean.parseBoolean(options.get(LOG_APPENDER_CONSOLE))) { + appenders.add(new ConsoleAppender()); + } + } + } + } From 4d0f446339a7f05a4cb97c711c025a39f97f0840 Mon Sep 17 00:00:00 2001 From: Damien Date: Sun, 8 Dec 2013 22:25:37 +0100 Subject: [PATCH 10/12] Add line number of logging caller --- .../org/androidannotations/logger/Formatter.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java index c253ab77bc..971213a359 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Formatter.java @@ -21,6 +21,7 @@ public String buildLog(Level level, String loggerName, String message, Throwable .append(" [").append(Thread.currentThread().getName()).append("]") // .append(" ").append(level.name) // .append(" ").append(loggerName) // + .append(":").append(getCallerLineNumber()) // .append(" - ").append(fullMessage); // Stacktrace @@ -72,4 +73,18 @@ private String stackTraceToString(Throwable e) { return writer.toString(); } + private int getCallerLineNumber() { + boolean previousWasLogger = false; + String loggerClassName = Logger.class.getCanonicalName(); + + StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); + for (StackTraceElement stackTraceElement : stackTrace) { + if (stackTraceElement.getClassName().equals(loggerClassName)) { + previousWasLogger = true; + } else if (previousWasLogger) { + return stackTraceElement.getLineNumber(); + } + } + return -1; + } } From aae4ea9d92314026fbc353d1c7b5638edf51a61b Mon Sep 17 00:00:00 2001 From: Damien Date: Sun, 8 Dec 2013 22:37:11 +0100 Subject: [PATCH 11/12] Add logging options keys in @SupportedOptions --- .../org/androidannotations/AndroidAnnotationProcessor.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java index ea79917dab..6377cf80ad 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/AndroidAnnotationProcessor.java @@ -19,6 +19,9 @@ import static org.androidannotations.helper.CanonicalNameConstants.PRODUCE; import static org.androidannotations.helper.CanonicalNameConstants.SUBSCRIBE; import static org.androidannotations.helper.ModelConstants.TRACE_OPTION; +import static org.androidannotations.logger.LoggerContext.LOG_APPENDER_CONSOLE; +import static org.androidannotations.logger.LoggerContext.LOG_FILE_OPTION; +import static org.androidannotations.logger.LoggerContext.LOG_LEVEL_OPTION; import static org.androidannotations.rclass.ProjectRClassFinder.RESOURCE_PACKAGE_NAME_OPTION; import java.io.FileNotFoundException; @@ -286,7 +289,7 @@ import org.androidannotations.validation.rest.RestValidator; @SupportedSourceVersion(SourceVersion.RELEASE_6) -@SupportedOptions({ TRACE_OPTION, ANDROID_MANIFEST_FILE_OPTION, RESOURCE_PACKAGE_NAME_OPTION }) +@SupportedOptions({ TRACE_OPTION, ANDROID_MANIFEST_FILE_OPTION, RESOURCE_PACKAGE_NAME_OPTION, LOG_FILE_OPTION, LOG_LEVEL_OPTION, LOG_APPENDER_CONSOLE }) public class AndroidAnnotationProcessor extends AbstractProcessor { private static final Logger LOGGER = LoggerFactory.getLogger(AndroidAnnotationProcessor.class); From ccdb2d507d4b7a1adb7d1445fbcb2ab8399d3722 Mon Sep 17 00:00:00 2001 From: Damien Date: Sun, 8 Dec 2013 22:52:54 +0100 Subject: [PATCH 12/12] Add missing methods in Logger which causes exception to be hidden --- .../main/java/org/androidannotations/logger/Logger.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java index b3b3335005..c88a0e21e7 100644 --- a/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java +++ b/AndroidAnnotations/androidannotations/src/main/java/org/androidannotations/logger/Logger.java @@ -41,6 +41,10 @@ public void warn(String message, Object... args) { warn(message, null, null, args); } + public void warn(String message, Throwable thr, Object... args) { + warn(message, null, thr, args); + } + public void warn(String message, Element element, Object... args) { warn(message, element, null, args); } @@ -57,6 +61,10 @@ public void error(String message, Element element, Object... args) { error(message, element, null, args); } + public void error(String message, Throwable thr, Object... args) { + error(message, null, thr, args); + } + public void error(String message, Element element, Throwable thr, Object... args) { log(Level.ERROR, message, element, null, thr, args); }