splog-杂谈与总结

1.概述
spdlog github地址，spdlog日志库自身带有包括控制台日志记录、基础文件日志记录、循环文件日志记录、每日文件日志记录等在内的日志记录方式，能满足日常不同的情景需求。
本文主要介绍spdlog日志库的基本使用，包括创建日志记录器(logger)、创建日志记录器槽(sink)、设置日志输出内容格式(pattern)、设置日志输出等级(level)等。如果想要获得这个库更加全面详细的使用资料，可以阅读spdlog学习笔记这篇文章。

2.基础概念
下面陈列的函数主要用于简单说明功能，其中的参数省略了一些命名空间以及类名

1.level_enum: 日志等级枚举，包括 trace、info、debug、warn、err、critical、off、n_levels。

2.sink: 日志记录器槽，进行底层操作（比如格式化内容、输出内容到控制台/文件）的类。spdlog自带的几种sinks已经能满足日常需求，也可以派生其基类设计新的sink以满足特殊的需求。sink类主要使用的函数包括：

set_pattern(const std::string&) ：设置日志输出的内容格式。
set_level(level_enum) ：设置日志输出的最低等级。
log(log_msg) ：由logger自动调用，外部不会主动调用。

3.logger: 日志记录器，被顶层调用来输出日志的类。一个logger对象中存储有多个sink，当调用logger的日志输出函数时，logger会调用自身存储的所有sink对象的log(log_msg) 函数进行输出。与自带的sink对应，spdlog也自带了几种logger。logger类主要使用的函数包括：

set_pattern(const std::string&) ：设置logger包含的所有sink的日志输出内容格式。
set_level(level_enum) ：设置logger日志输出最低等级，如果logger包含的sink没有设置日志等级的话，则会为其设置日志等级。
log(level_enum level,log_msg content) ：按照level等级进行输出content，logger其中日志输出最低等级小于或等于level的sink会进行执行输出操作。
trace(content,arg1,arg2…) ：按照trace等级进行输出，输出内容由content与后面的参数格式化而成。同类的函数还包括：debug/info/warn…

3.st/mt：对象版本，spdlog中的logger对象和sink对象都有两种版本，一种是以st结尾的单线程版本，以及以mt结尾的多线程版本。

st：单线程版本，不用加锁，效率更高。
mt：多线程版本，用于多线程程序是线程安全的。

3.使用示例

3.1创建logger

1.使用spdlog自带的logger

 //<1.创建名称为LoggerName1、内容输出到控制台的单线程版本日志记录器
auto logger1 = spdlog::stdout_color_st("LoggerName1");

//<2.创建名称为LoggerName2、内容输出到Logs/BasicFileLog.txt的多线程版本日志记录器
auto logger2 = spdlog::basic_logger_mt("LoggerName2", "Logs/BasicFileLog.txt");

//<3.创建名称为LoggerName3、内容输出到Logs/RotatingFileLog.txt的多线程版本日志记录器
//参数1024*1024*5设置了文件最大容量为5mb，参数3设置了文件最大数量为3
//当日志文件存储超过5mb时，将重命名日志文件并且新增另外一个日志文件
//当日志文件数量超过3时，将删除第一个日志文件

auto logger3 = spdlog::rotating_logger_mt("LoggerName3", "Logs/RotatingFileLog.txt", 1024 * 1024 * 5, 3);

//<4.创建名称为LoggerName4、内容输出到Logs/DailyFileLog.txt的多线程版本日志记录器
//参数2和30指定每天生成日志文件的时间为凌晨2点30分

auto logger4 = spdlog::daily_logger_mt("LoggerName4", "Logs/DailyFileLog.txt", 2, 30);

2.使用sink创建logger

//<1.创建名称为LoggerName1、内容输出到控制台的单线程版本日志记录器
auto logger1 = std::make_shared<spdlog::logger>("LoggerName1", 
std::make_shared<spdlog::sinks::stdout_color_sink_st>());

//<2.创建名称为LoggerName2、内容输出到Logs/BasicFileLog.txt的多线程版本日志记录器
auto logger2 = std::make_shared<spdlog::logger>("LoggerName2", std::make_shared<spdlog::sinks::basic_file_sink_mt>("Logs/BasicFileLog.txt"));

//<3.创建名称为LoggerName3、内容输出到Logs/RotatingFileLog.txt的多线程版本日志记录器
//参数1024*1024*5设置了文件最大容量为5mb，参数3设置了文件最大数量为3
//当日志文件存储超过5mb时，将重命名日志文件并且新增另外一个日志文件
//当日志文件数量超过3时，将删除第一个日志文件
auto logger3 = std::make_shared<spdlog::logger>("LoggerName3", std::make_shared<spdlog::sinks::rotating_file_sink_mt>("Logs/RotatingFileLog.txt",1024 * 1024 * 5, 3));

//<4.创建名称为LoggerName4、内容输出到Logs/DailyFileLog.txt的多线程版本日志记录器
//参数2和30指定每天生成日志文件的时间为凌晨2点30分
auto logger4 = std::make_shared<spdlog::logger>("LoggerName4", 
std::make_shared<spdlog::sinks::daily_file_sink_mt>("Logs/DailyFileLog.txt", 2,30));

3.创建使用同个sink的多个logger

//<1.创建sink
auto sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("Logs/RotatingFileLog.txt", 1024 * 1024 * 5, 3);

//<2.创建共同使用sink的多个logger，这些logger把内容一起输出到RotatingFileLog.txt中
auto logger1 = std::make_shared<spdlog::logger>("LoggerName1", sink);
auto logger2 = std::make_shared<spdlog::logger>("LoggerName2", sink);
auto logger3 = std::make_shared<spdlog::logger>("LoggerName3", sink);

4.创建使用多个sink的单个logger

 //<1.创建多个sink
auto sink1 = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
auto sink2 = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("Logs/RotatingFileLog.txt", 1024 * 1024 * 5, 3);
std::vector< spdlog::sink_ptr> sinks = { sink1,sink2 };

//<2.创建使用多个sink的单个logger，logger会把内容输出到不同位置，此处是控制台以及RotatingFileLog.txt
auto logger = std::make_shared<spdlog::logger>("LoggerName", sinks.begin(), sinks.end());

//<3.设置sink的pattern和level
sink1->set_pattern("[%Y-%m-%d %H:%M:%S.%e][%l]>>>%v");
sink1->set_level(spdlog::level::debug);
sink2->set_pattern("[%Y-%m-%d][%L]%v");
sink2->set_level(spdlog::level::info);

//<4.输出日志
logger->debug("The message will only be shown on stdout.");//因为日志等级为debug，所以只会调用sink1进行输出
logger->info("The message will only be shown on stdout.");//日志等级为info，sink1与sink2都会进行输出

2.常用的pattern标记

3.3使用logger

1.通过spdlog::get(std::string)获取指定名称的logger进行使用

//<1.创建logger
//A.cpp
auto logger1 = std::make_shared<spdlog::logger>("LoggerName1", 
std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
auto logger2 = std::make_shared<spdlog::logger>("LoggerName2", 
std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
spdlog::register(logger2);
auto logger3 = spdlog::stdout_color_st("LoggerName3");

//<2.使用spdlog::get(std::string)获取logger
//B.cpp
auto logger1 = spdlog::get("LoggerName1");//logger1为空，因为logger1在A.cpp中没被注册
if (logger1)
{
    logger1->info("Hello world!");
}
auto logger2 = spdlog::get("LoggerName2");//logger2不为空，因为logger2在A.cpp中已被注册
if (logger2)
{
    logger2->info("Good night.");//输出
}
auto logger3 = spdlog::get("LoggerName3");//logger2不为空，因为spdlog自带的logger对象在构造时会自动注册
if (logger3)
{
    logger3->info("Good night.");//输出
}

2.通过spdlog::default_logger()调用默认的logger进行使用

 //<1.创建logger，并且将logger设置为默认的日志记录器
//A.cpp
auto logger = spdlog::stdout_color_mt("LoggerName");
spdlog::set_default_logger(logger);

//<2.使用spdlog::default_logger()获取默认的日志记录器
//B.cpp
auto logger = spdlog::default_logger();
if (logger)
{
    logger->info("Gigigigigi");//输出
}
spdlog::info("Taco Tuesday");//同样使用default_logger进行输出，更加方便的调用方式；未作default_logger是否为空的判断，会有程序中断的可能。

3.使用宏调用默认的logger的方法进行日志输出

#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
#include <spdlog/spdlog.h>
SPDLOG_INFO("This message will be shown.");//输出
SPDLOG_DEBUG("This message will not be shown.");//不输出

4.使用fmt库格式化字符串

spdlog::info("Support for string.For example,hello,{}.", "Leborn Jame");//[2021-04-13 22:06:21.219] [info] Support for string.For example,hello,Leborn Jame.

spdlog::warn("Supprot for integer.For example,{:08d}.", 23);//[2021-04-13 22:07:48.865] [warning] Supprot for integer.For example,00000023.

spdlog::error("Support for float.For example,{:3.2}.", 1.23456);//[2021-04-13 22:07:48.865] [error] Support for float.For example,1.2.

spdlog::critical("Support for position parameter.For example,{1} and {0}.", "dog", "cat");//[2021-04-13 22:07:48.866] [critical] Support for position parameter.For example,cat and dog.

详细请见：https://blog.csdn.net/haojie_superstar/article/details/89383433

通过我们项目中对可能会对日志改写

如下：

log.cpp

#include "log.h"
#include <dirent.h>
#include <stdio.h>
#include <algorithm>
#include <ctime>
#include <string>
#include <mutex>
#include <chrono>
#include <iomanip>

#include "spdlog/cfg/env.h"
#include "spdlog/sinks/rotating_file_sink.h"
#include "spdlog/spdlog.h"
#include "time_utils.h"

static uint32_t cur_year;
static std::mutex logger_mutex;
static std::string logger_name;
static std::string log_file_dir;

static void init_loggers_impl(const char* moudle_name, const char* log_dir_path) {
  logger_name = moudle_name;
  log_file_dir = log_dir_path;

  std::tm now_tm = {0};
  get_time(&now_tm);

  cur_year = now_tm.tm_year+1900;
  // time_t now = std::time(0);
  // std::tm* now_tm = std::localtime(&now);

  const size_t MAX_PATH = 200;
  char file_name_buffer[MAX_PATH] = {0};
  snprintf(file_name_buffer, sizeof(file_name_buffer), "%s/%s.%d%02d%02d.log", log_dir_path,
           moudle_name, now_tm.tm_year+1900, now_tm.tm_mon+1, now_tm.tm_mday);
  
  auto max_size = 10 * 1024 * 1024;
  auto max_files = 300;
  auto logger =
      spdlog::rotating_logger_mt(moudle_name, file_name_buffer, max_size, max_files, true);

  logger->set_pattern("%Y-%m-%d %H:%M:%S, %l, %n, %P, %v");

  // Load log levels from env variable: export SPDLOG_LEVEL=trace
  spdlog::cfg::load_env_levels();
  spdlog::flush_every(std::chrono::seconds(2));
}

static bool has_sync_time() {
  const uint32_t default_year_on_board = 1970;
  return (cur_year != default_year_on_board);
}

static bool time_is_synced() {
  std::tm now_tm = {0};
  get_time(&now_tm);
  
  return (cur_year != (now_tm.tm_year+1900));
}

static void reinit_logger() {
  std::lock_guard<std::mutex> lock(logger_mutex);
  uninit_logger();
  init_loggers_impl(logger_name.c_str(), log_file_dir.c_str());
}


static tm *get_time() {
  thread_local static tm cur_time = {0};
  get_time(&cur_time);

  return &cur_time;
}

static void monitor_log_time() {
  if (has_sync_time()) {
    return;
  }
  
  while (true) {
    if (time_is_synced()) {
      reinit_logger();
      return;
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  
}

void init_logger(const char* moudle_name, const char* log_dir_path) {
  init_loggers_impl(moudle_name, log_dir_path);
  std::thread(monitor_log_time).detach();
}

void uninit_logger() {
  spdlog::shutdown();
}

static const uint32_t MAX_LOG_MSG_SIZE = 1024;

#define LOG(LOG_METHOD, MSG) \
  auto logger = spdlog::get(logger_name); \
  if (logger) { \
    logger->LOG_METHOD(MSG); \
  }

static bool format_msg(const char* fmt, va_list& args, std::string& msg) {
  char msg_buf[MAX_LOG_MSG_SIZE];
  int n = vsnprintf(msg_buf, MAX_LOG_MSG_SIZE, fmt, args);
  if (n < 0) {
    std::string err_msg = "encoding error: ";
    err_msg += fmt;

    LOG(error, err_msg);
  } else if (n > MAX_LOG_MSG_SIZE - 1) {
    std::string err_msg = "msg size too long: ";
    err_msg += fmt;
    
    LOG(error, err_msg);
  } else {
    msg = msg_buf;
    return true;
  }

  return false;
}

void zdebug(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

  std::string msg;
  if (format_msg(fmt, args, msg)) {
    std::lock_guard<std::mutex> lock(logger_mutex);
    LOG(debug, msg);
  }

  va_end(args);
}

void zinfo(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

  std::string msg;
  if (format_msg(fmt, args, msg)) {
    std::lock_guard<std::mutex> lock(logger_mutex);
    LOG(info, msg);
  }

  va_end(args);
}

void zwarn(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

  std::string msg;
  if (format_msg(fmt, args, msg)) {
    std::lock_guard<std::mutex> lock(logger_mutex);
    LOG(warn, msg);
  }

  va_end(args);
}

void zerror(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

  std::string msg;
  if (format_msg(fmt, args, msg)) {
    std::lock_guard<std::mutex> lock(logger_mutex);
    LOG(error, msg);
  }

  va_end(args);
}

void zfatal(const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

  std::string msg;
  if (format_msg(fmt, args, msg)) {
    std::lock_guard<std::mutex> lock(logger_mutex);
    LOG(critical, msg);
  }

  va_end(args);
}


void dbg_zinfo(const char* fmt, ...) {
  static bool enable_log = (access("/data/zlog/debug_enable", 0) == 0);
  if (!enable_log) {
    return;
  }

  va_list args;
  va_start(args, fmt);

  zinfo(fmt, args);

  va_end(args);
}

同步时间：

void get_time(tm* tm) {
  try {
    const auto now = 获取ros,bsp，mcu系统的时间

    tm->tm_year = now.Year() - 1900;
    tm->tm_mon = now.Month() - 1;
    tm->tm_mday = now.Day();
    tm->tm_hour = now.Hour();
    tm->tm_min = now.Minute();
    tm->tm_sec = now.Second();
  }
  catch(...) {
    time_t now = {0};
    time(&now);

    auto local_time = localtime(&now);
    *tm = *local_time;
  }
}

偶尔，我们也会对spdlog进行改写：https://github.com/lipeilei/spdlog.git

以便符合项目要求

附上项目：常见的宁外一种使用方式：

定义log.hpp

#ifndef INCLUDE_LOG_HPP_
#define INCLUDE_LOG_HPP_

/// sdk默认采用在android上采用android log, 在其他平台上采用stdout/stderr log.， 并且loglevel设置为warning.
/// 如果用户使用静态库, 可以自行进行定义：
/// 若要自定义loglevel，可以在代码中加入：
///    SDK_LOG_TRACE("dummy"); //确保internal sdk先初始化
///    spdlog::set_level(spdlog::level::trace);  //自行设置level为trace
/// 若要使用另外的输出，可以在代码中加入：
///    SDK_LOG_TRACE("dummy"); //确保internal sdk先初始化
///    spdlog::drop_all();    //释放internal sdk所申请的资源
///    spdlog::basic_stsdk-logger_mt("stsdk-logger", "my.txt"); //自行设置输出到my.txt
///    spdlog::set_level(spdlog::level::trace);

/// EXTERN_ENABLE_LOG is added for internal-sdk's users
/// if they want to use spdlog in their's own codes

typedef enum
{
    SDK_TRACE = 0,
    SDK_DEBUG = 1,
    SDK_INFO = 2,
    SDK_WARN = 3,
    SDK_ERR = 4,
} log_level_enum;


#if defined(CONFIG_SDK_LICENSE_ENABLE_LOG) || defined(EXTERN_ENABLE_LOG)

#include <spdlog/spdlog.h>

#define SPDLOG_STR_H(x) #x
#define SPDLOG_STR_HELPER(x) SPDLOG_STR_H(x)

class SpdlogDummyClass {
public:
    SpdlogDummyClass(){

        /// 支持文本log， 标准输出log， syslog， android的logcat， 还有多源sensetime-stsdk-logger（比如同时标准输出和文本输出）
        /// 在初始化stsdk-logger的时候，还可以设置stsdk-logger的过滤条件和输出格式
        /// 具体可以参考https://github.com/gabime/spdlog
        #if defined(__ANDROID__)
            spdlog::android_logger("stsdk-logger", "sensetime-sdk"); //android logcat
        #elif defined(_MSC_VER)
            spdlog::stdout_logger_mt("stsdk-logger"); //colored log not work on some console of windows
        #else
            spdlog::stdout_color_mt("stsdk-logger"); //default stsdk-logger is stdout_color_mt
        #endif
        //spdlog::basic_stsdk-logger_mt("stsdk-logger", "sensetime_sdk_log.txt"); // basic file stsdk-logger

        spdlog::set_level(spdlog::level::warn);
    }
    ~SpdlogDummyClass(){
    }
};
inline std::shared_ptr<spdlog::logger> sdk_get_logger() {
    static SpdlogDummyClass logger_init;
    return spdlog::get("stsdk-logger");
}
/* some notes:
 * "A static local variable in an extern inline function always refers to the same object."
 * https://stackoverflow.com/questions/185624/static-variables-in-an-inlined-function
 * Every cpp file which includes this header, won't call SDK_STDOUT_LOG_INIT multiple times,
 * As there is only one global SpdlogDummyClass object.
 */

#define SDK_LOG_TRACE(...) if (sdk_get_logger()){ sdk_get_logger()->trace("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_DEBUG(...) if (sdk_get_logger()){ sdk_get_logger()->debug("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_INFO(...) if (sdk_get_logger()){ sdk_get_logger()->info("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_WARN(...) if (sdk_get_logger()){ sdk_get_logger()->warn("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_ERROR(...) if (sdk_get_logger()){ sdk_get_logger()->error("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }


// SDK_CUT_BEGIN and SDK_CUT_END, based on info-level log, is used to mark a code range as cuttable.
// They are embeded in the source, usually near a pair of braces {}, e.g. a function or if-else block.
// If an application requires a reduced-size library, a log-enabled library with full functionality is used to generate logs.
// In the next build, all cuttable ranges not shown in the logs are commented out.
//
// A cross-projects-level unique tag is required to indicate the correspondence between SDK_CUT_BEGIN and SDK_CUT_END.
// The tag needs to be a string literal, prefixed by the project name. For example
// CV_SDK_API
// cv_result_t
// cv_feature_serialize(
//     const cv_feature_t *feature,
//     char *feature_str
// ) {
//     SDK_CUT_BEGIN("sdk_common_CvFeatureSerialize");
//     ...
//     SDK_CUT_END("sdk_common_CvFeatureSerialize");
//     return CV_OK;
// }
// The tag shown above is sdk_common_CvFeatureSerialize, which could also be sdk_common_WorldCup, as long as it is unique.
// If the actual log shows no sign of sdk_common_CvFeatureSerialize, the lines between and including
// SDK_CUT_BEGIN("sdk_common_CvFeatureSerialize"); and SDK_CUT_END("sdk_common_CvFeatureSerialize"); will be commented out.
//
// Usually the developer needs a basic understanding of the code before marking it cuttable.
// For any commit, GerritCI will actually cut all cuttable code and check for build success.
#define SDK_CUT_BEGIN(...) if (sdk_get_logger()){ sdk_get_logger()->info("[internal_sdk_cut_begin] [" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_CUT_END(...) if (sdk_get_logger()){ sdk_get_logger()->info("[internal_sdk_cut_end] [" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }

#else

#define SDK_LOG_TRACE(...)
#define SDK_LOG_DEBUG(...)
#define SDK_LOG_INFO(...)
#define SDK_LOG_WARN(...)
#define SDK_LOG_ERROR(...)

#define SDK_CUT_BEGIN(...)
#define SDK_CUT_END(...)

#endif

#endif  // INCLUDE_LOG_HPP_

这个 log.hpp 头文件提供了一个日志记录机制，用于在不同的平台（如 Android、Windows 等）上输出日志。该文件使用了 spdlog 库来实现日志记录功能。以下是对代码的详细分析：

1. Log Level Enum

typedef enum
{
    SDK_TRACE = 0,
    SDK_DEBUG = 1,
    SDK_INFO = 2,
    SDK_WARN = 3,
    SDK_ERR = 4,
} log_level_enum;

定义了一个枚举 log_level_enum，用于表示不同的日志级别：
- SDK_TRACE：跟踪级别日志，通常用于详细调试信息。
- SDK_DEBUG：调试级别日志，用于开发过程中调试代码。
- SDK_INFO：信息级别日志，用于输出普通的信息。
- SDK_WARN：警告级别日志，用于显示警告信息。
- SDK_ERR：错误级别日志，用于显示错误信息。

2. 日志初始化和输出机制

根据平台的不同，日志会有不同的输出方式：

Android平台：使用 spdlog::android_logger 输出到 Android 的 logcat。
Windows平台：使用 spdlog::stdout_logger_mt 输出到标准输出（控制台），但由于 Windows 控制台有时不支持彩色输出，所以没有启用彩色日志。
其他平台：使用 spdlog::stdout_color_mt 输出到标准输出，并启用彩色日志。

3. SpdlogDummyClass

class SpdlogDummyClass {
public:
	SpdlogDummyClass(){
		#if defined(__ANDROID__)
			spdlog::android_logger("stsdk-logger", "sensetime-sdk"); //android logcat
		#elif defined(_MSC_VER)
			spdlog::stdout_logger_mt("stsdk-logger"); //colored log not work on some console of windows
		#else
			spdlog::stdout_color_mt("stsdk-logger"); //default stsdk-logger is stdout_color_mt
		#endif
		spdlog::set_level(spdlog::level::warn);
	}
	~SpdlogDummyClass(){}
};

SpdlogDummyClass 类负责初始化日志输出机制，并设置默认日志级别为 warn（警告）。它会根据不同的平台选择不同的输出方式（logcat、标准输出等）。
构造函数中初始化了一个日志对象，并设置日志级别。
日志级别设置为 warn 表示默认情况下，只输出警告级别及更严重的日志。

4. SDK Get Logger

cppCopy Code

inline std::shared_ptr<spdlog::logger> sdk_get_logger() {
	static SpdlogDummyClass logger_init;
	return spdlog::get("stsdk-logger");
}

sdk_get_logger 返回一个静态的 spdlog::logger 实例，保证在整个程序中使用的是同一个日志对象。
SpdlogDummyClass 是静态对象，它只会初始化一次，确保日志系统的初始化只发生一次。

5. 宏定义

这部分定义了一些日志宏，这些宏会根据日志级别输出不同的日志信息。

cppCopy Code

#define SDK_LOG_TRACE(...) if (sdk_get_logger()){ sdk_get_logger()->trace("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_DEBUG(...) if (sdk_get_logger()){ sdk_get_logger()->debug("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_INFO(...) if (sdk_get_logger()){ sdk_get_logger()->info("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_WARN(...) if (sdk_get_logger()){ sdk_get_logger()->warn("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_LOG_ERROR(...) if (sdk_get_logger()){ sdk_get_logger()->error("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }

这些宏为每个日志级别（trace、debug、info、warn、error）定义了输出格式，其中包括：
- 当前文件名（__FILE__）。
- 当前行号（__LINE__）。
- 传入的日志信息（__VA_ARGS__）。

6. SDK_CUT_BEGIN 和 SDK_CUT_END

#define SDK_CUT_BEGIN(...) if (sdk_get_logger()){ sdk_get_logger()->info("[internal_sdk_cut_begin] [" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }
#define SDK_CUT_END(...) if (sdk_get_logger()){ sdk_get_logger()->info("[internal_sdk_cut_end] [" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__ ); }

这两个宏用于标记一个代码段，通常用于减少库大小。在实际的编译过程中，相关代码可以被注释掉，从而减小二进制文件的大小。
这些宏会在日志中输出相应的标记信息，帮助开发者知道哪些代码块在编译时被切除了。

7. 条件编译

#if defined(CONFIG_SDK_LICENSE_ENABLE_LOG) || defined(EXTERN_ENABLE_LOG)

如果定义了 CONFIG_SDK_LICENSE_ENABLE_LOG 或 EXTERN_ENABLE_LOG，则启用日志功能，否则日志宏会被禁用。这可以帮助开发者在需要时启用或禁用日志功能，而不需要修改代码。

8. 禁用日志的宏

#define SDK_LOG_TRACE(...)
#define SDK_LOG_DEBUG(...)
#define SDK_LOG_INFO(...)
#define SDK_LOG_WARN(...)
#define SDK_LOG_ERROR(...)
#define SDK_CUT_BEGIN(...)
#define SDK_CUT_END(...)

当日志功能被禁用时，这些宏不会产生任何输出，避免了不必要的日志记录。

总结

该头文件提供了一个灵活的日志系统，可以根据不同的开发平台（如 Android、Windows）配置不同的日志输出方式，支持多种日志级别，并允许在需要时启用或禁用日志功能。开发者还可以通过 SDK_CUT_BEGIN 和 SDK_CUT_END 宏标记代码段，以减少库的大小。

posted @ 2023-09-11 14:40 白伟碧一些小心得阅读(681) 评论(0) 收藏举报

刷新页面返回顶部

sucfrperperseverance