Add android sink and improve android build

Author: odygrd

CHANGELOG.md

@@ -113,6 +113,18 @@
         return config;
       }());
     ```  
+- Added the `AndroidSink`, which integrates with Android's logging system.
+
+    ```c++
+    auto sink = quill::Frontend::create_or_get_sink<quill::AndroidSink>(
+      "s1", []()
+      {
+        quill::AndroidSinkConfig config;
+        config.set_tag("app");
+        config.set_format_message(true);
+        return config;
+      }());
+    ```  
 - Added `Frontend::remove_logger_blocking(...)`, this function blocks the caller thread until the specified logger has
   been fully removed.
 - Added a runtime check to detect duplicate backend worker threads caused by inconsistent linkage  

CMakeLists.txt

@@ -215,6 +215,7 @@ set(HEADER_FILES
 
         include/quill/filters/Filter.h
 
+        include/quill/sinks/AndroidSink.h
         include/quill/sinks/ConsoleSink.h
         include/quill/sinks/FileSink.h
         include/quill/sinks/JsonSink.h

README.md

@@ -543,12 +543,33 @@ target_link_libraries(my_project PUBLIC quill::quill)
 
 ### Android NDK
 
-Building Quill for Android? Add this flag during configuration:
+When building Quill for Android, you might need to add this flag during configuration, but in most cases, it works without it:
 
 ```bash
 -DQUILL_NO_THREAD_NAME_SUPPORT:BOOL=ON
 ```
 
+For timestamps, use `quill::ClockSourceType::System`. Quill also includes an `AndroidSink`, which integrates with Android's logging system.
+
+#### Minimal Example to Start Logging on Android
+
+```c++
+quill::Backend::start();
+
+auto sink = quill::Frontend::create_or_get_sink<quill::AndroidSink>("app", [](){
+    quill::AndroidSinkConfig asc;
+    asc.set_tag("app");
+    asc.set_format_message(true);
+    return asc;
+}());
+
+auto logger = quill::Frontend::create_or_get_logger("root", std::move(sink),
+                                                    quill::PatternFormatterOptions {}, 
+                                                    quill::ClockSourceType::System);
+
+LOG_INFO(logger, "Test {}", 123);
+```
+
 ### Meson
 
 #### Using WrapDB

include/quill/backend/BackendWorkerLock.h

@@ -69,6 +69,8 @@ class BackendWorkerLock
         "Please build and link the logging library uniformly as a shared library with exported "
         "symbols to ensure a single backend instance."});
     }
+#elif defined(__ANDROID__)
+    // disabled
 #else
     std::string name = "/QuillLock" + pid;
 

include/quill/backend/ThreadUtilities.h

@@ -141,7 +141,8 @@ ReturnT callRunTimeDynamicLinkedFunction(std::string const& dll_name,
  */
 QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED inline std::string get_thread_name()
 {
-#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(QUILL_NO_THREAD_NAME_SUPPORT)
+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(__ANDROID__) || \
+  defined(QUILL_NO_THREAD_NAME_SUPPORT)
   // Disabled on MINGW / Cygwin.
   return std::string{"ThreadNameDisabled"};
 #elif defined(_WIN32)
@@ -160,7 +161,7 @@ QUILL_NODISCARD QUILL_EXPORT QUILL_ATTRIBUTE_USED inline std::string get_thread_
   {
     QUILL_THROW(QuillError{"Failed to get thread name. Invalid data."});
   }
-  
+
   std::wstring const wide_name{data, wcsnlen_s(data, 256)};
   LocalFree(data);
   return ws2s(wide_name);

include/quill/sinks/AndroidSink.h

@@ -0,0 +1,127 @@
+/**
+ * @page copyright
+ * Copyright(c) 2020-present, Odysseas Georgoudis & quill contributors.
+ * Distributed under the MIT License (http://opensource.org/licenses/MIT)
+ */
+
+#pragma once
+
+#include "quill/core/Attributes.h"
+#include "quill/core/LogLevel.h"
+#include "quill/sinks/Sink.h"
+
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <android/log.h>
+
+QUILL_BEGIN_NAMESPACE
+
+/**
+ * @brief Holds the configuration options for the AndroidSink.
+ *
+ * This configuration class allows you to set various parameters that determine how log messages are
+ * mapped and sent to the Android log system.
+ */
+class AndroidSinkConfig
+{
+public:
+  /**
+   * @brief Sets the tag that is prepended to every syslog message.
+   * Typically, this is set to the program name.
+   * @param tag The tag string.
+   */
+  QUILL_ATTRIBUTE_COLD void set_tag(std::string const& tag) { _tag = tag; }
+
+  /**
+   * @brief Enables or disables message formatting.
+   * If enabled, the log message will be formatted using the specified
+   * PatternFormatter before being sent to syslog.
+   * @param format_message Set to true to format the message; false otherwise.
+   */
+  QUILL_ATTRIBUTE_COLD void set_format_message(bool format_message)
+  {
+    _format_message = format_message;
+  }
+
+  /**
+   * @brief Sets the mapping from quill log levels to syslog levels.
+   * This mapping determines which syslog level is used for each quill log level.
+   * @param mapping An array of 12 integers representing syslog levels.
+   */
+  QUILL_ATTRIBUTE_COLD void set_log_level_mapping(std::array<int, 12> mapping)
+  {
+    _log_level_mapping = mapping;
+  }
+
+  /** Getters **/
+  QUILL_NODISCARD std::string const& tag() const noexcept { return _tag; }
+  QUILL_NODISCARD bool should_format_message() const noexcept { return _format_message; }
+  QUILL_NODISCARD int get_android_level(quill::LogLevel level) const
+  {
+    return _log_level_mapping[static_cast<size_t>(level)];
+  }
+
+private:
+  std::string _tag{"quill"};
+  std::array<int, 12> _log_level_mapping = {
+    // Mapping from quill log levels to syslog levels:
+    /* "TRACE_L3" */ ANDROID_LOG_VERBOSE, /* "TRACE_L2" */ ANDROID_LOG_VERBOSE,
+    /* "TRACE_L1" */ ANDROID_LOG_VERBOSE, /* "DEBUG"    */ ANDROID_LOG_DEBUG,
+    /* "INFO"     */ ANDROID_LOG_INFO,    /* "NOTICE"   */ ANDROID_LOG_INFO,
+    /* "WARNING"  */ ANDROID_LOG_WARN,    /* "ERROR"    */ ANDROID_LOG_ERROR,
+    /* "CRITICAL" */ ANDROID_LOG_FATAL,   /* "BACKTRACE"*/ ANDROID_LOG_INFO,
+    /* "NONE"     */ ANDROID_LOG_INFO,    /* "DYNAMIC"  */ ANDROID_LOG_INFO};
+  bool _format_message{false};
+};
+
+/**
+ * @brief A sink that writes log messages to the Android logging system (logcat).
+ *
+ * This sink leverages the Android log API to send log messages. It uses the configuration
+ * provided via AndroidSinkConfig to determine how the messages are formatted and mapped.
+ */
+class AndroidSink : public quill::Sink
+{
+public:
+  /**
+   * @brief Constructs an AndroidSink with the given configuration.
+   * @param config The configuration options for the AndroidSink. Defaults to a default-configured AndroidSinkConfig.
+   */
+  explicit AndroidSink(AndroidSinkConfig config = AndroidSinkConfig{}) : _config(std::move(config))
+  {
+  }
+
+  /***/
+  ~AndroidSink() override = default;
+
+  /**
+   * @brief Writes a formatted log message to the stream
+   */
+  void write_log(MacroMetadata const* /* log_metadata */, uint64_t /* log_timestamp */,
+                 std::string_view /* thread_id */, std::string_view /* thread_name */,
+                 std::string const& /* process_id */, std::string_view /* logger_name */, LogLevel log_level,
+                 std::string_view /* log_level_description */, std::string_view /* log_level_short_code */,
+                 std::vector<std::pair<std::string, std::string>> const* /* named_args */,
+                 std::string_view log_message, std::string_view log_statement) override
+  {
+    // Choose between formatted log statement or raw log message
+    std::string_view const message = _config.should_format_message() ? log_statement : log_message;
+    size_t const message_length = message.size();
+
+    __android_log_print(_config.get_android_level(log_level), _config.tag().data(), "%.*s",
+                        message_length, message.data());
+  }
+
+  /***/
+  void flush_sink() noexcept override {}
+
+private:
+  AndroidSinkConfig _config;
+};
+
+QUILL_END_NAMESPACE