Initial implementation based on Loune's example

Author: neboskreb

library/src/main/java/net/loune/log4j2android/AndroidContextSelector.java

@@ -0,0 +1,75 @@
+package net.loune.log4j2android;
+
+import net.loune.log4j2android.AutoCloseConfigDescriptor.ConfigDescriptor;
+import org.apache.logging.log4j.core.LoggerContext;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.ConfigurationFactory;
+import org.apache.logging.log4j.core.config.ConfigurationSource;
+import org.apache.logging.log4j.core.impl.ContextAnchor;
+import org.apache.logging.log4j.core.selector.ContextSelector;
+
+import java.net.URI;
+import java.util.List;
+
+/**
+ * Created by loune on 16/05/2015.
+ */
+public class AndroidContextSelector implements ContextSelector {
+
+    private static LoggerContext CONTEXT = new LoggerContext("Default");
+
+    //private static boolean isStarted = false;
+
+    private void start(LoggerContext context) {
+        try (AutoCloseConfigDescriptor descriptor = AndroidLog4jHelper.getConfig()) {
+            if (descriptor.config.isPresent()) {
+                ConfigDescriptor config = descriptor.config.get();
+                ConfigurationSource source = new ConfigurationSource(config.inputStream, config.url);
+                Configuration configuration = ConfigurationFactory.getInstance().getConfiguration(context, source);
+                context.start(configuration);
+            } else {
+                context.start();
+            }
+        }
+    }
+
+    @Override
+    public LoggerContext getContext(final String fqcn, final ClassLoader loader, final boolean currentContext) {
+        if (!CONTEXT.isStarted()) {
+            start(CONTEXT);
+        }
+        final LoggerContext ctx = ContextAnchor.THREAD_CONTEXT.get();
+        return ctx != null ? ctx : CONTEXT;
+    }
+
+
+    @Override
+    public LoggerContext getContext(final String fqcn, final ClassLoader loader, final boolean currentContext,
+                                    final URI configLocation) {
+        if (!CONTEXT.isStarted()) {
+            start(CONTEXT);
+        }
+        final LoggerContext ctx = ContextAnchor.THREAD_CONTEXT.get();
+        return ctx != null ? ctx : CONTEXT;
+    }
+
+    public LoggerContext locateContext(final String name, final String configLocation) {
+        if (!CONTEXT.isStarted()) {
+            start(CONTEXT);
+        }
+        return CONTEXT;
+    }
+
+    @Override
+    public void removeContext(final LoggerContext context) {
+    }
+
+    @Override
+    public List<LoggerContext> getLoggerContexts() {
+        if (!CONTEXT.isStarted()) {
+            start(CONTEXT);
+        }
+
+        return List.of(CONTEXT);
+    }
+}

library/src/main/java/net/loune/log4j2android/AndroidLog4jHelper.java

@@ -0,0 +1,59 @@
+package net.loune.log4j2android;
+
+import android.app.Instrumentation;
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import java.io.File;
+
+import static net.loune.log4j2android.PluginProcessorHelper.injectPlugins;
+
+/**
+ * Created by loune on 9/04/2016.
+ */
+public class AndroidLog4jHelper {
+    public static final String FILENAME = "log4j2.properties";
+
+    private static ContextProxy savedContext;
+
+    static {
+        // Temporary init with a NO-OP configuration.
+        // If the user wants, they will call initialize later; otherwise we will log nothing
+        savedContext = new ContextProxy();
+
+        System.setProperty("Log4jContextSelector", "net.loune.log4j2android.AndroidContextSelector");
+        System.setProperty("log4j2.disable.jmx", "true");
+
+        injectPlugins("net.loune.log4j2android", AndroidLookup.class, LogcatAppender.class);
+    }
+
+    public static void initialize(Context context) {
+        initialize(new ContextProxy(context));
+    }
+
+    public static void initialize(Instrumentation instrumentation) {
+        Context appContext  = instrumentation.getTargetContext();
+        Context testContext = instrumentation.getContext();
+        // Test context goes first so it overrides the app context
+        initialize(new ContextProxy(testContext, appContext));
+    }
+
+    private static void initialize(ContextProxy proxy) {
+        savedContext = proxy;
+    }
+
+    public static File getFilesDir() {
+        return savedContext.getFilesDir();
+    }
+
+    public static File getExternalFilesDir(String type) {
+        return savedContext.getExternalFilesDir(type);
+    }
+
+    @NonNull
+    public static AutoCloseConfigDescriptor getConfig() {
+        return savedContext.getConfig(FILENAME);
+    }
+
+
+}

library/src/main/java/net/loune/log4j2android/AndroidLookup.java

@@ -0,0 +1,50 @@
+package net.loune.log4j2android;
+
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.lookup.StrLookup;
+
+import java.io.File;
+
+/**
+ * Created by loune on 16/05/2015.
+ */
+@Plugin(name = "android", category = "Lookup")
+public class AndroidLookup implements StrLookup {
+    /**
+     * Lookup the value for the key.
+     * @param key  the key to be looked up, may be null
+     * @return The value for the key.
+     */
+    public String lookup(String key) {
+        File filesDir = AndroidLog4jHelper.getFilesDir();
+        if ("filesdir".equals(key)) {
+            return filesDir.getAbsolutePath();
+        }
+
+        File externalFilesDir = AndroidLog4jHelper.getExternalFilesDir(null);
+        if ("externalfilesdir".equals(key)) {
+            if (externalFilesDir == null) {
+                return null;
+            }
+            return externalFilesDir.getAbsolutePath();
+        }
+
+        if ("logfilesdir".equals(key)) {
+            File baseDir = externalFilesDir == null ? filesDir : externalFilesDir;
+            return new File(baseDir, "logs").getAbsolutePath();
+        }
+
+        return null;
+    }
+
+    /**
+     * Lookup the value for the key using the data in the LogEvent.
+     * @param event The current LogEvent.
+     * @param key  the key to be looked up, may be null
+     * @return The value associated with the key.
+     */
+    public String lookup(LogEvent event, String key) {
+        return lookup(key);
+    }
+}

library/src/main/java/net/loune/log4j2android/AutoCloseConfigDescriptor.java

@@ -0,0 +1,48 @@
+package net.loune.log4j2android;
+
+import java.io.Closeable;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Optional;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+
+import static lombok.AccessLevel.PRIVATE;
+
+@RequiredArgsConstructor
+public class AutoCloseConfigDescriptor implements AutoCloseable {
+    private static final AutoCloseConfigDescriptor EMPTY = new AutoCloseConfigDescriptor(Optional.empty());
+
+    @Getter
+    @AllArgsConstructor(access = PRIVATE)
+    public static class ConfigDescriptor {
+        public final InputStream inputStream;
+        public final URL url;
+    }
+
+    /** @noinspection OptionalUsedAsFieldOrParameterType */
+    public final Optional<ConfigDescriptor> config;
+
+    public static AutoCloseConfigDescriptor empty() {
+        return EMPTY;
+    }
+
+    public static AutoCloseConfigDescriptor config(InputStream inputStream, URL url) {
+        return new AutoCloseConfigDescriptor(Optional.of(new ConfigDescriptor(inputStream, url)));
+    }
+
+    @Override
+    public void close() {
+        config.map(ConfigDescriptor::getInputStream)
+              .ifPresent(this::closeIt);
+    }
+
+    @SneakyThrows
+    private void closeIt(Closeable closeable) {
+        closeable.close();
+    }
+}

library/src/main/java/net/loune/log4j2android/ContextProxy.java

@@ -0,0 +1,51 @@
+package net.loune.log4j2android;
+
+import android.content.Context;
+import android.content.res.AssetManager;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+
+import static java.util.Arrays.asList;
+
+class ContextProxy {
+    private final Context[] contexts;
+
+    public ContextProxy(Context... contexts) {
+        this.contexts = contexts;
+    }
+
+    public AutoCloseConfigDescriptor getConfig(String filename) {
+        for (Context context : contexts) {
+            AutoCloseConfigDescriptor result = getConfig(context, filename);
+            if (result.config.isPresent()) {
+                return result;
+            }
+        }
+
+        return AutoCloseConfigDescriptor.empty();
+    }
+
+    public AutoCloseConfigDescriptor getConfig(Context context, String filename) {
+        try {
+            AssetManager assets = context.getAssets();
+            String[] list = assets.list("");
+            if (list == null || !asList(list).contains(filename)) {
+                return AutoCloseConfigDescriptor.empty();
+            } else {
+                return AutoCloseConfigDescriptor.config(assets.open(filename), new URL("file:///" + filename));
+            }
+
+        } catch (IOException e) {
+            throw new IllegalStateException("Error reading the configuration file");
+        }
+    }
+
+    public File getFilesDir() {
+        return contexts[0].getFilesDir();
+    }
+
+    public File getExternalFilesDir(String type) {
+        return contexts[0].getExternalFilesDir(type);
+    }
+}

library/src/main/java/net/loune/log4j2android/HideThrown.java

@@ -0,0 +1,22 @@
+package net.loune.log4j2android;
+
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.Delegate;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.impl.ThrowableProxy;
+
+@RequiredArgsConstructor
+public class HideThrown implements LogEvent {
+    @Delegate
+    private final LogEvent original;
+
+    @Override
+    public Throwable getThrown() {
+        return null;
+    }
+
+    @Override
+    public ThrowableProxy getThrownProxy() {
+        return null;
+    }
+}