android_log_sink.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Jarosław Pelczar <jarek@jpelczar.com>
//
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "../log/detail/tagged_log_sink_base.hpp"
#include "../log/sink.hpp"
#include <cstddef>
#include <cstring>
#include <string_view>
 
#if MICROFMT_HAS_ANDROID_LOG
#include <android/log.h>
#else
#include <cstdarg>
#include <cstdio>
 
// Fallback stubs for host-side unit testing / compilation outside the NDK.
// Rather than being a silent no-op, this prints to stdout so demos and
// manual testing still produce visible output on non-Android hosts.
enum android_LogPriority {
  ANDROID_LOG_UNKNOWN = 0,
  ANDROID_LOG_DEFAULT,
  ANDROID_LOG_VERBOSE,
  ANDROID_LOG_DEBUG,
  ANDROID_LOG_INFO,
  ANDROID_LOG_WARN,
  ANDROID_LOG_ERROR,
  ANDROID_LOG_FATAL,
  ANDROID_LOG_SILENT
};
 
RELOCO_BEGIN_UNSAFE_BUFFER_USAGE
// NOLINTNEXTLINE(reloco-noexcept): declaration mirrors the platform C varargs API
// bridges to a C/platform API (FILE*, syslog, android log, raw chunk storage) that takes raw pointers.
RELOCO_BEGIN_UNSAFE_CODE
inline int __android_log_print(int prio, const char *tag, const char *fmt, ...) {
  va_list args = {};
  va_start(args, fmt);
  std::fprintf(stdout, "[%d] %s: ", prio, tag);
  std::vfprintf(stdout, fmt, args);
  std::fprintf(stdout, "\n");
  va_end(args);
  return 0;
}
RELOCO_END_UNSAFE_CODE
RELOCO_END_UNSAFE_BUFFER_USAGE
#endif
 
namespace microfmt::log {
 
template <std::size_t MessageCapacity, std::size_t TagCapacity> class android_log_sink;
 
template <std::size_t MessageCapacity, std::size_t TagCapacity> struct android_log_sink_tag {};
 
template <std::size_t MessageCapacity = 512, std::size_t TagCapacity = 64>
class android_log_sink : public detail::tagged_log_sink_base<TagCapacity> {
  static_assert(MessageCapacity > 0, "Message capacity must be at least 1 byte");
 
  using tag_base = detail::tagged_log_sink_base<TagCapacity>;
 
public:
  using write_fn_t = void (*)(int priority, microfmt::string_view tag, microfmt::string_view message) noexcept;
 
  explicit android_log_sink(microfmt::string_view tag = "microfmt", write_fn_t write_fn = write_to_logcat) noexcept
      : tag_base(tag), write_fn_(write_fn) {}
 
  [[nodiscard]] log_sink as_sink() & noexcept RELOCO_LIFETIMEBOUND {
    return log_sink(android_log_sink_tag<MessageCapacity, TagCapacity>{}, *this);
  }
 
  void log_impl(const log_msg &msg) noexcept {
    if (msg.lvl == level::off) {
      return;
    }
 
    buffer_sink<MessageCapacity> buffer;
    const auto out = buffer.as_sink();
    microfmt::format_to(out, "{}", msg.payload);
 
    char scratch[TagCapacity];
    const auto tag = this->resolve_tag(msg.logger_name, scratch);
    write_fn_(priority_for(msg.lvl), tag, buffer.view());
  }
 
private:
  // bridges to a C/platform API (FILE*, syslog, android log, raw chunk storage) that takes raw pointers.
  RELOCO_BEGIN_UNSAFE_CODE
  static void write_to_logcat(int priority, microfmt::string_view tag, microfmt::string_view message) noexcept {
    RELOCO_BEGIN_UNSAFE_BUFFER_USAGE;
    char tag_buf[64] = {};
    size_t tag_len = std::min(tag.size(), sizeof(tag_buf) - 1);
    std::memcpy(tag_buf, tag.data(), tag_len);
    tag_buf[tag_len] = '\0';
 
    ::__android_log_print(priority, tag_buf, "%.*s", static_cast<int>(message.size()), message.data());
    RELOCO_END_UNSAFE_BUFFER_USAGE;
  }
  RELOCO_END_UNSAFE_CODE
 
  static int priority_for(level lvl) noexcept {
    switch (lvl) {
    case level::trace:
      return ANDROID_LOG_VERBOSE;
    case level::debug:
      return ANDROID_LOG_DEBUG;
    case level::info:
      return ANDROID_LOG_INFO;
    case level::warn:
      return ANDROID_LOG_WARN;
    case level::err:
      return ANDROID_LOG_ERROR;
    case level::critical:
      return ANDROID_LOG_FATAL;
    case level::off:
      return ANDROID_LOG_SILENT;
    }
    return ANDROID_LOG_SILENT;
  }
 
  write_fn_t write_fn_;
};
 
// Explicit guides: GCC 11 cannot synthesize the implicit CTAD guide because the
// constructor's default argument (write_to_logcat) names a member of the
// still-incomplete class template, so `android_log_sink s("tag");` failed there.
android_log_sink() -> android_log_sink<>;
android_log_sink(microfmt::string_view) -> android_log_sink<>;
android_log_sink(microfmt::string_view, void (*)(int, microfmt::string_view, microfmt::string_view) noexcept)
    -> android_log_sink<>;
 
template <std::size_t MessageCapacity, std::size_t TagCapacity>
struct log_sink_traits<android_log_sink_tag<MessageCapacity, TagCapacity>> {
  using context_type = android_log_sink<MessageCapacity, TagCapacity>;
 
  static void log(value_ref<context_type> ctx, const log_msg &msg) noexcept { ctx->log_impl(msg); }
};
 
} // namespace microfmt::log