use __android_log_write or __android_log_buf_write based on template parameter

1 files changed, 30 insertions, 6 deletions

diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h
index dd811633..ba1f70b7 100644
--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -15,6 +15,7 @@
 #include <mutex>
 #include <string>
 #include <thread>
+#include <type_traits>
 
 #if !defined(SPDLOG_ANDROID_RETRIES)
 #define SPDLOG_ANDROID_RETRIES 2
@@ -24,13 +25,15 @@ namespace spdlog {
 namespace sinks {
 
 /*
- * Android sink (logging using __android_log_write)
- * __android_log_write is thread-safe. No lock is needed.
+ * Android sink
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified BufferID)
+ * They are thread-safe. No lock is needed.
  */
-class android_sink : public sink
+template<int BufferID>
+class android_sink_buf : public sink
 {
 public:
-    explicit android_sink(const std::string &tag = "spdlog", bool use_raw_msg = false)
+    explicit android_sink_buf(const std::string &tag = "spdlog", bool use_raw_msg = false)
         : _tag(tag)
         , _use_raw_msg(use_raw_msg)
     {
@@ -42,12 +45,12 @@ public:
         const char *msg_output = (_use_raw_msg ? msg.raw.c_str() : msg.formatted.c_str());
 
         // See system/core/liblog/logger_write.c for explanation of return value
-        int ret = __android_log_write(priority, _tag.c_str(), msg_output);
+        int ret = android_log(priority, _tag.c_str(), msg_output);
         int retry_count = 0;
         while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
         {
             details::os::sleep_for_millis(5);
-            ret = __android_log_write(priority, _tag.c_str(), msg_output);
+            ret = android_log(priority, _tag.c_str(), msg_output);
             retry_count++;
         }
 
@@ -60,6 +63,21 @@ public:
     void flush() override {}
 
 private:
+    // There might be liblog versions used, that do not support __android_log_buf_write. So we only compile and link against
+    // __android_log_buf_write, if user explicitely provides a non-default log buffer. Otherwise, when using the default log buffer, always
+    // log via __android_log_write.
+    template<int ID = BufferID, typename... Args>
+    typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(Args... args)
+    {
+        return __android_log_write(std::forward<Args>(args)...);
+    }
+
+    template<int ID = BufferID, typename... Args>
+    typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(Args... args)
+    {
+        return __android_log_buf_write(ID, std::forward<Args>(args)...);
+    }
+
     static android_LogPriority convert_to_android(spdlog::level::level_enum level)
     {
         switch (level)
@@ -85,6 +103,12 @@ private:
     bool _use_raw_msg;
 };
 
+/**
+ * Android sink (logging using __android_log_write)
+ * __android_log_write is thread-safe. No lock is needed.
+ */
+using android_sink = android_sink_buf<log_id::LOG_ID_MAIN>;
+
 } // namespace sinks
 } // namespace spdlog