My question seems to be easily answerable, but there are several good solutions. I like to choose the 'best' one.

Available frameworks (feel free to suggest more):

• Androlog
• SLF4J Android
• Log4J - Android

Pros/Cons:

Androlog:

• Pro: Similar to Android logging framework, so there are only small changes in the existing code; Able to send crash reports with more detail in the error report (the logs around the exception); Nice logs
• Con: No standard java "getLogger" approach; Production configuration achievable by uploading property file to sdcard; I need to call init logging manually; Need to create LOG_TAG like constants, or hack it to create log tag constants by Aspect to achieve the standard behavior: tags are the class names; When logging is a business requirement, we need to test it. Testing static calls on Android nearly impossible; Logger can not be injected by framework

Log4J-Android:

• Pro: Standard way to log in Java; Compatible with SLF4J; Able to parse property files;
• Con: No built-in crash report system; Seems to me: its not commonly used, so it might me dangerous to use it;

SLF4J-Android:

• Pro: Seems to be developed by more people like Log4J-Android; The logger.debug("Some log message. Details: {}", someObject.toString()); is a good, and effective way to skip string concatenations if the logger is turned off; lightweight logger binding that delegates to android.util.Log.
• Con: Auto generated log tags that are <= 23 characters long due to a length restriction of log tags on the Android platform (e.g., com.example.myapp.MyClass tag translated to c*.e*.m*.MyClass), which can result in the same log tag for different classes (e.g., com.example.app.MyClass and com.example.anotherapp.MyClass both translate to c*.e*.a*.MyClass); No built in crash reporting system.

Besides of these, I like Androlog behavior, but I'm a Java dev, familiar with log4j/slf4j. We will definitely need crash report system, but there are several frameworks for crash reporting (beside of android default crash report).

I can combine some of them, for example use Log4J android, but create an appender to use the androlog framework, but sooner or later it will be a mess, which should be avoided.

Thanks for your suggestions, I hope the results will help decide others in the future.

Edit: As mentioned below, I can combine for ex: log4j-android with slf4j (whitch I prefer to do if I'll use log4j, because the log formatting support ("{}",...) ), but it does not answers the question. I have to choose a framework, then I can decorate it with the SLF4J facade.

Solution 1:

The better way. I think, is to use SLF4J API + some of its implementation.

For Android applications you can use the following:

1. Android Logger is the lightweight but easy-to-configure SLF4J implementation (< 50 Kb).
2. LOGBack is the most powerful and optimized implementation but its size is about 1 Mb.
3. Any other by your taste: slf4jandroid, slf4j-android.

Solution 2:

Please check this first answer

It says:

SLF4J is basically an abstraction layer. It is not a logging implementation. It means that if you're writing a library and you use SLF4J, you can give that library to someone else to use and they can choose which logging implementation to use with SLF4J e.g. log4j or the Java logging API. It helps prevent projects from being dependent on lots of logging APIs just because they use libraries that are dependent on them.

So, to summarise: SLF4J does not replace log4j, they work together. It removes the dependency on log4j from your library/app.

Solution 3:

I have tried original slf4j.org-android but unfortunately this jar was not able to get debug/verbose messages to be logged because it internally uses LOG.isDebugEnabled() for debug output wich seems always to be false.

currently i use the alternative lp0-slf4j-android implementation that uses a properties-file with the logging settings where i can also get debug/verbose messages if enabled.