# 基础信息配置（必填项）
base_info:
  # 项目名称，将作为代码的命名空间
  project_name: test_prj

  # 构建模式标签，可自定义编译选项
  # 格式为 {PROJECT_NAME}_{OPTION_NAME}，若无需要可置为空列表 []
  build_mode_tags: ["EXAMPLE", "SIMULATION", "TEST_CAMERA"]

  # AIMRT引入选项配置（必须使用单引号包裹值）
  aimrt_import_options:
    # 是否构建运行时
    AIMRT_BUILD_RUNTIME: 'ON'
    # 是否使用fmt库
    AIMRT_USE_FMT_LIB: 'ON'
    # 是否使用protobuf构建
    AIMRT_BUILD_WITH_PROTOBUF: 'ON'
    # 是否使用本地protoc编译器
    AIMRT_USE_LOCAL_PROTOC_COMPILER: 'OFF'
    # 是否使用protoc python插件
    AIMRT_USE_PROTOC_PYTHON_PLUGIN: 'OFF'
    # 是否与ROS2一起构建
    AIMRT_BUILD_WITH_ROS2: 'ON'

# 依赖的标准模块配置（可选）
depends_std_modules:
  - name: xxx  # 依赖库名称（应与实际库名一致）
    git_repository: https://github.com/xxx/xxx.git  # 库地址
    git_tag: v0.1.5  # 版本标签
    import_options:  # 导入选项（暂不支持）
      XXX: 'ON'
  - name: yyy
    git_repository: https://github.com/yyy/yyy.git
    git_tag: v0.1.11

# 协议配置（可选）
protocols:
  - name: my_proto  # 协议名称
    type: protobuf   # 协议类型（protobuf/ros2）
    options:         # 选项（暂不支持）
      xxx: xxx

  - name: my_ros2_proto
    type: ros2
    options:
      zzz: zzz
    # 构建模式标签，仅在指定模式下构建
    build_mode_tag: ["EXAMPLE"]

  - name: example_proto
    type: protobuf
    # 未设置build_mode_tag表示在所有模式下都构建
    build_mode_tag: ["EXAMPLE"]

# 模块配置（可选）
modules:
  - name: my_foo_module  # 模块名称

  - name: my_bar_module

  - name: exmaple_module
    # 仅在EXAMPLE模式下构建
    build_mode_tag: ["EXAMPLE"]
    options:  # 选项（暂不支持）
      aaa: aaa

# 模块包配置（可选）
pkgs:
  - name: pkg1  # 包名称
    modules:    # 包含的模块
      - name: my_foo_module  # 模块名
        namespace: local     # 命名空间（自定义模块用local）
      - name: my_bar_module
        namespace: local
    options:
      sss: sss

  - name: pkg2
    modules:
      - name: exmaple_module
        namespace: local
      - name: ep_example_bar_module
        namespace: ep_example_aimrt_module  # 外部模块使用其实际命名空间
    build_mode_tag: ["EXAMPLE"]  # 仅在EXAMPLE模式下构建
    options:
      sss: sss

# 部署配置（可选）
deploy_modes:
  - name: exmaple_mode  # 部署模式名称
    build_mode_tag: ["EXAMPLE"]  # 构建模式检查
    deploy_ins:  # 部署实例配置
      - name: local_ins_1  # 实例名称
        pkgs:    # 依赖的包
          - name: pkg1
            options:
              disable_modules: []  # 禁用的模块列表
      - name: local_ins_2  # 简单实例（无包配置）
      - name: remote_ins_123

  # 简单部署模式（默认在所有模式下构建）
  - name: deploy_mode_1
  - name: deploy_mode_2

class HelloworldModule : public aimrt::ModuleBase {
public:
  // 必须实现的三大生命周期方法
  bool Initialize(aimrt::CoreRef core) override;  // 初始化配置
  bool Start() override;                         // 业务逻辑入口
  void Shutdown() override;                      // 资源释放

private:
  aimrt::CoreRef core_;  // 框架核心句柄
};

bool HelloworldModule::Initialize(aimrt::CoreRef core) {
  core_ = core;  // 绑定框架核心

  // 读取 YAML 配置示例
  auto cfg_path = core_.GetConfigurator().GetConfigFilePath();
  YAML::Node cfg = YAML::LoadFile(cfg_path);
  AIMRT_INFO("Loaded config: {}", cfg["param"].as<std::string>());

  return true;  // 初始化成功标志
}

bool Start() {
  AIMRT_INFO("Module Started");  // 日志输出演示
  return true;
}

static std::tuple<std::string_view, FactoryFunc>
    aimrt_module_register_array[] = {
  {"HelloWorldModule",  // 模块标识名
   []() { return new HelloWorldModule(); }}  // 工厂函数
};

AIMRT_PKG_MAIN(aimrt_module_register_array)  // 框架入口宏

# Set link libraries of target
target_link_libraries(
  ${CUR_TARGET_NAME}
  PRIVATE gflags::gflags
          aimrt::runtime::core)

namespace aimrt::runtime::core {

class AimRTCore {
 public:
  struct Options {
    std::string cfg_file_path;
  };

 public:
  void Initialize(const Options& options);

  void Start();
  std::future<void> AsyncStart();

  void Shutdown();

  module::ModuleManager& GetModuleManager();

};

}  // namespace aimrt::runtime::core

#include <csignal>
#include <iostream>

#include "HelloWorld_module/HelloWorld_module.h"	// 这里引用的是我们之前创建的Module类
#include "core/aimrt_core.h"

using namespace aimrt::runtime::core;
using namespace helloworld::HelloWorld_module;

AimRTCore* global_core_ptr = nullptr;

void SignalHandler(int sig) {
  if (global_core_ptr && (sig == SIGINT || sig == SIGTERM)) {
    global_core_ptr->Shutdown();
    return;
  }

  raise(sig);
};

int32_t main(int32_t argc, char** argv) {
  signal(SIGINT, SignalHandler);
  signal(SIGTERM, SignalHandler);

  std::cout << "AimRT start." << std::endl;

  try {
    AimRTCore core;
    global_core_ptr = &core;

    // register module
    HelloworldModule helloworld_module;
    core.GetModuleManager().RegisterModule(helloworld_module.NativeHandle());

    AimRTCore::Options options;
    if (argc > 1) options.cfg_file_path = argv[1];

    core.Initialize(options);

    core.Start();

    core.Shutdown();

    global_core_ptr = nullptr;
  } catch (const std::exception& e) {
    std::cout << "AimRT run with exception and exit. " << e.what() << std::endl;
    return -1;
  }

  std::cout << "AimRT exit." << std::endl;

  return 0;
}

./helloworld_app_registration_mode ./cfg/examples_cpp_helloworld_app_mode_cfg.yaml

// Copyright (c) 2023, AgiBot Inc.
// All rights reserved.

#include <csignal>
#include <iostream>

#include "aimrt_module_cpp_interface/core.h"
#include "core/aimrt_core.h"

using namespace aimrt::runtime::core;

// 全局指针，指向 AimRTCore 实例，用于在信号处理函数中进行关闭操作
AimRTCore* global_core_ptr = nullptr;

/**
 * @brief 信号处理函数
 *
 * 处理 SIGINT (Ctrl+C) 和 SIGTERM 信号，如果 AimRTCore 实例存在，则调用其
 * Shutdown 方法进行关闭。
 */
void SignalHandler(int sig) {
  if (global_core_ptr && (sig == SIGINT || sig == SIGTERM)) {
    global_core_ptr->Shutdown();  // 调用 Shutdown 方法，优雅退出
    return;
  }

  raise(sig);  // 传递其他信号，按照默认行为处理
}

int32_t main(int32_t argc, char** argv) {
  // 注册信号处理函数，确保进程收到终止信号时能正确清理资源
  signal(SIGINT, SignalHandler);
  signal(SIGTERM, SignalHandler);

  std::cout << "AimRT 启动." << std::endl;  // 日志：AimRT 启动

  try {
    AimRTCore core;
    global_core_ptr = &core;  // 赋值全局指针，以便信号处理时可以访问

    // 配置 AimRTCore 选项
    AimRTCore::Options options;
    if (argc > 1)
      options.cfg_file_path =
          argv[1];  // 如果传入了参数，则使用该参数作为配置文件路径

    core.Initialize(options);  // 初始化 AimRTCore 实例

    // 创建 AimRT 模块，并获取模块句柄
    aimrt::CoreRef module_handle(
        core.GetModuleManager().CreateModule("HelloWorldModule"));

    // 记录日志，表示模块创建成功
    AIMRT_HL_INFO(module_handle.GetLogger(), "这是一个示例日志。");

    // 读取并解析 YAML 配置文件
    auto file_path = module_handle.GetConfigurator().GetConfigFilePath();
    if (!file_path.empty()) {
      YAML::Node cfg_node = YAML::LoadFile(std::string(file_path));
      for (const auto& itr : cfg_node) {
        std::string k = itr.first.as<std::string>();
        std::string v = itr.second.as<std::string>();
        AIMRT_HL_INFO(module_handle.GetLogger(), "cfg [{} : {}]", k, v);
      }
    }

    // 异步启动 AimRT 实例，返回一个 future 对象
    auto fu = core.AsyncStart();

    AIMRT_HL_INFO(module_handle.GetLogger(), "启动成功。");
    // 日志：启动成功。

    // 等待 AimRT 运行结束（即 shutdown 触发）
    fu.wait();

    // 关闭 AimRT 实例
    core.Shutdown();

    // 清空全局指针，避免悬空指针问题
    global_core_ptr = nullptr;
  } catch (const std::exception& e) {
    std::cout << "AimRT 运行时发生异常，退出: " << e.what() << std::endl;
    return -1;
  }

  std::cout << "AimRT 退出." << std::endl;  // 日志：AimRT 退出

  return 0;
}

./helloworld_app_registration_mode ./cfg/examples_cpp_helloworld_app_mode_cfg.yaml

# 基础信息
base_info:
  project_name: Logger # 项目名称
  build_mode_tags: ["EXAMPLE", "SIMULATION", "TEST_CAMERA"] # 构建模式标签
  aimrt_import_options: # AimRT框架的构建选项
    AIMRT_BUILD_TESTS: "OFF" # 是否构建测试代码
    AIMRT_BUILD_EXAMPLES: "ON" # 是否构建示例代码
    AIMRT_BUILD_DOCUMENT: "OFF" # 是否构建文档
    AIMRT_BUILD_RUNTIME: "ON" # 是否构建运行时核心
    AIMRT_BUILD_CLI_TOOLS: "OFF" # 是否构建命令行工具
    AIMRT_BUILD_WITH_PROTOBUF: "ON" # 是否启用Protobuf支持
    AIMRT_USE_LOCAL_PROTOC_COMPILER: "OFF" # 是否使用本地protoc编译器
    AIMRT_BUILD_WITH_ROS2: "OFF" # 是否集成ROS2支持
    AIMRT_BUILD_NET_PLUGIN: "OFF" # 是否构建网络插件
    AIMRT_BUILD_ROS2_PLUGIN: "OFF" # 是否构建ROS2插件

# 模块
modules:
  - name: executor_module # 最基本的 cpp executor 示例
  - name: executor_co_module # 基于协程接口使用 executor 功能的示例
  - name: executor_co_loop_module # 基于协程接口使用 executor 功能实现定时循环的示例
  - name: real_time_module #  executor 实时性相关功能的示例

# pkg
pkgs:
  - name: executor_pkg # 包名
    modules:
      - name: executor_module
      - name: executor_co_module
      - name: executor_co_loop_module
      - name: real_time_module

# 部署
deploy_modes:
  - name: local_deploy # 部署模式名称
    deploy_ins: # 部署实例
      - name: local_ins_executor # 实例名称
        pkgs:
          - name: executor_pkg # 实例加载的包

aimrt_cli gen -p configuration_executor.yaml -o executor

#pragma once

#include "aimrt_module_cpp_interface/module_base.h"

namespace Executor::executor_module {

// 执行器模块类，继承自模块基类
class ExecutorModule : public aimrt::ModuleBase {
 public:
  ExecutorModule() = default;
  ~ExecutorModule() override = default;

  // 获取模块信息
  aimrt::ModuleInfo Info() const override {
    return aimrt::ModuleInfo{.name = "ExecutorModule"};
  }  // 复制官方代码过来后需要添加命名空间  aimrt

  // 初始化模块
  bool Initialize(aimrt::CoreRef aimrt_ptr) override;

  // 启动模块
  bool Start() override;

  // 关闭模块
  void Shutdown() override;

 private:
  // 获取日志记录器
  auto GetLogger() { return core_.GetLogger(); }

  // 简单执行演示
  void SimpleExecuteDemo();
  // 线程安全演示
  void ThreadSafeDemo();
  // 时间调度演示
  void TimeScheduleDemo();

 private:
  aimrt::CoreRef core_;  // AIMRT框架核心引用

  aimrt::executor::ExecutorRef work_executor_;         // 普通执行器
  aimrt::executor::ExecutorRef thread_safe_executor_;  // 线程安全执行器

  std::atomic_bool run_flag_ = true;                     // 运行标志(原子变量)
  uint32_t loop_count_ = 0;                              // 循环计数器
  aimrt::executor::ExecutorRef time_schedule_executor_;  // 时间调度执行器
};

}  // namespace Executor::executor_module

// 初始化模块
bool ExecutorModule::Initialize(aimrt::CoreRef core) {
  // 保存AIMRT框架句柄
  core_ = core;

  // 获取工作执行器
  work_executor_ = core_.GetExecutorManager().GetExecutor("work_executor");
  AIMRT_CHECK_ERROR_THROW(work_executor_, "无法获取工作执行器(work_executor)");

  // 获取线程安全执行器
  thread_safe_executor_ =
      core_.GetExecutorManager().GetExecutor("thread_safe_executor");
  AIMRT_CHECK_ERROR_THROW(
      thread_safe_executor_ && thread_safe_executor_.ThreadSafe(),
      "无法获取线程安全执行器(thread_safe_executor)");

  // 获取时间调度执行器
  time_schedule_executor_ =
      core_.GetExecutorManager().GetExecutor("time_schedule_executor");
  AIMRT_CHECK_ERROR_THROW(
      time_schedule_executor_ && time_schedule_executor_.SupportTimerSchedule(),
      "无法获取时间调度执行器(time_schedule_executor)");

  AIMRT_INFO("初始化成功");

  return true;
}

executor:
  executors:
    - name: work_executor # 执行器名称
      type: asio_thread # 执行器类型：基于 ASIO 的线程池，
      options:
        thread_num: 2 # 分配的线程数量，用于并发处理任务

    - name: thread_safe_executor # 线程安全执行器：通过 ASIO Strand 实现串行执行，避免竞态条件
      type: asio_strand # 执行器类型：基于 ASIO 的 strand 包装，确保线程安全
      options:
        bind_asio_thread_executor_name: work_executor # 绑定的基础执行器，实际任务由其线程池调度执行

    - name: time_schedule_executor # 定时任务执行器：用于周期性/定时调度任务
      type: asio_thread # 执行器类型：使用独立的 ASIO 线程池执行定时任务
      options:
        thread_num: 2 # 分配的线程数量，可根据定时任务复杂度调整

// 启动模块
bool ExecutorModule::Start() {
  // 测试简单执行
  SimpleExecuteDemo();

  // 测试线程安全执行
  ThreadSafeDemo();

  // 测试时间调度执行
  TimeScheduleDemo();

  AIMRT_INFO("启动成功");

  return true;
}

// 任务函数实现

// 简单执行演示
void ExecutorModule::SimpleExecuteDemo() {
  work_executor_.Execute([this]() { AIMRT_INFO("这是一个简单任务"); });
}

// 线程安全演示
void ExecutorModule::ThreadSafeDemo() {
  uint32_t n = 0;
  for (uint32_t ii = 0; ii < 10000; ++ii) {
    thread_safe_executor_.Execute([&n]() { n++; });  // 线程安全执行器
    // work_executor_.Execute([&n]() { n++; }); // 普通执行器
  }

  std::this_thread::sleep_for(std::chrono::seconds(1));  // 等待1秒

  AIMRT_INFO("n的值为: {}", n);
}

// 时间调度演示
void ExecutorModule::TimeScheduleDemo() {
  if (!run_flag_) return;  // 检查运行标志

  AIMRT_INFO("循环计数: {}", loop_count_++);

  // 1秒后再次执行本函数
  time_schedule_executor_.ExecuteAfter(
      std::chrono::seconds(1),
      std::bind(&ExecutorModule::TimeScheduleDemo, this));
}

// 关闭模块
void ExecutorModule::Shutdown() {
  run_flag_ = false;  // 设置运行标志为false

  std::this_thread::sleep_for(std::chrono::seconds(1));  // 等待1秒

  AIMRT_INFO("关闭成功");
}

# Copyright (c) 2023, AgiBot Inc.
# All rights reserved.

aimrt:
  log:
    core_lvl: INFO # Trace/Debug/Info/Warn/Error/Fatal/Off
    backends:
      - type: console
  executor:
    executors:
      - name: work_executor
        type: asio_thread
        options:
          thread_num: 2
      - name: thread_safe_executor
        type: asio_strand
        options:
          bind_asio_thread_executor_name: work_executor
      - name: time_schedule_executor
        type: asio_thread
        options:
          thread_num: 2
  module:
    pkgs:
      - path: ./libexecutor_pkg.so
        enable_modules: [ExecutorModule]
    modules:
      - name: ExecutorModule
        log_lvl: INFO

#pragma once

#include "aimrt_module_cpp_interface/co/aimrt_context.h"
#include "aimrt_module_cpp_interface/co/async_scope.h"
#include "aimrt_module_cpp_interface/co/task.h"
#include "aimrt_module_cpp_interface/module_base.h"

namespace Executor::executor_co_module {

using namespace aimrt;

// 定义一个协程模块，继承自 AimRT 的 ModuleBase 接口
class ExecutorCoModule : public aimrt::ModuleBase {
 public:
  ExecutorCoModule() = default;
  ~ExecutorCoModule() override = default;

  // 返回模块信息
  aimrt::ModuleInfo Info() const override {
    return ModuleInfo{.name = "ExecutorCoModule"};
  }

  // 初始化模块
  bool Initialize(aimrt::CoreRef aimrt_ptr) override;

  // 启动模块，执行实际的协程逻辑
  bool Start() override;

  // 模块关闭逻辑，清理资源
  void Shutdown() override;

 private:
  // 获取日志器
  auto GetLogger() { return core_.GetLogger(); }

  // 简单执行器示例：演示普通线程池调度
  co::Task<void> SimpleExecuteDemo();

  // 线程安全执行器示例：演示多个任务安全执行
  co::Task<void> ThreadSafeDemo();

  // 定时执行器示例：定时打印计数
  co::Task<void> TimeScheduleDemo();

 private:
  aimrt::CoreRef core_;  // 框架核心引用

  co::AimRTContext
      ctx_;  // 协程上下文对象，可以用来获取某个执行器的"协程封装接口"

  co::AsyncScope
      scope_;  // 协程作用域，用于启动协程(spawn)和等待协程完成(complete),可以跟踪和管理多个异步协程的生命周期

  std::atomic_bool run_flag_ = true;  // 控制定时任务运行的标志位
};

}  // namespace Executor::executor_co_module

bool ExecutorCoModule::Initialize(aimrt::CoreRef core) {
  // 保存框架核心引用
  core_ = core;

  // 创建协程上下文对象
  ctx_ = co::AimRTContext(core_.GetExecutorManager());

  // 检查普通执行器是否可用
  auto work_executor = core_.GetExecutorManager().GetExecutor("work_executor");
  AIMRT_CHECK_ERROR_THROW(work_executor, "无法获取 work_executor 执行器");

  // 检查线程安全执行器是否可用
  auto thread_safe_executor =
      core_.GetExecutorManager().GetExecutor("thread_safe_executor");
  AIMRT_CHECK_ERROR_THROW(
      thread_safe_executor && thread_safe_executor.ThreadSafe(),
      "无法获取 thread_safe_executor 执行器或不支持线程安全");

  // 检查定时执行器是否可用
  auto time_schedule_executor =
      core_.GetExecutorManager().GetExecutor("time_schedule_executor");
    AIMRT_CHECK_ERROR_THROW(
        time_schedule_executor &&
        time_schedule_executor.SupportTimerSchedule(), "无法获取
        time_schedule_executor 执行器或不支持定时调度");

  // 初始化成功
  AIMRT_INFO("模块初始化成功。");

  return true;
}

bool ExecutorCoModule::Start() {
  // 启动普通协程任务
  scope_.spawn(co::On(co::InlineScheduler(), SimpleExecuteDemo()));

  // 启动线程安全的协程任务
  scope_.spawn(co::On(co::InlineScheduler(), ThreadSafeDemo()));

  // 启动定时执行的协程任务
  scope_.spawn(co::On(co::InlineScheduler(), TimeScheduleDemo()));

  AIMRT_INFO("模块启动成功。");

  return true;
}

co::Task<void> ExecutorCoModule::SimpleExecuteDemo() {
  // 获取 work_executor 的调度器
  auto work_scheduler = ctx_.GetScheduler("work_executor");

  // 打印当前协程的线程 ID
  std::ostringstream oss1;
  oss1 << std::this_thread::get_id();
  std::cout << "[SimpleExecuteDemo] 当前协程的线程 ID: " << oss1.str()
            << std::endl;

  // 将当前协程调度到 work_executor 上执行
  co_await co::Schedule(work_scheduler);

  // 打印切换后的线程 ID
  std::ostringstream oss2;
  oss2 << std::this_thread::get_id();
  std::cout << "[SimpleExecuteDemo] 切换执行器后的线程 ID: " << oss2.str()
            << std::endl;

  // 执行任务内容
  AIMRT_INFO("执行普通任务：SimpleExecuteDemo");

  co_return;
}

co::Task<void> ExecutorCoModule::ThreadSafeDemo() {
  // 获取 thread_safe_executor 的调度器
  auto thread_safe_scheduler = ctx_.GetScheduler("thread_safe_executor");

  co::AsyncScope scope;

  uint32_t n = 0;  // 计数器
  auto task = [&n]() -> co::Task<void> {
    n++;
    co_return;
  };

  // 启动 10000 个线程安全任务
  for (size_t ii = 0; ii < 10000; ++ii) {
    scope.spawn(co::On(thread_safe_scheduler, task()));
  }

  // 等待所有任务执行完毕
  co_await co::On(co::InlineScheduler(), scope.complete());

  // 输出最终计数值
  AIMRT_INFO("线程安全任务已完成，n 的值为 {}", n);

  co_return;
}

co::Task<void> ExecutorCoModule::TimeScheduleDemo() {
  AIMRT_INFO("开始定时任务循环。");

  // 获取 time_schedule_executor 的调度器
  auto time_scheduler = ctx_.GetScheduler("time_schedule_executor");

  // 切换协程到定时调度线程池
  co_await co::Schedule(time_scheduler);

  uint32_t count = 0;
  while (run_flag_) {
    count++;
    AIMRT_INFO("定时循环第 {} 次 -------------------------", count);

    // 延迟 1 秒后再次调度（实现定时循环）
    co_await co::ScheduleAfter(time_scheduler, std::chrono::seconds(1));
  }

  AIMRT_INFO("退出定时任务循环。");

  co_return;
}

void ExecutorCoModule::Shutdown() {
  // 停止定时任务循环
  run_flag_ = false;

  // 等待所有协程任务完成
  co::SyncWait(scope_.complete());

  AIMRT_INFO("模块已关闭。");
}

#pragma once

// 引入原子操作支持，用于线程安全的布尔变量
#include <atomic>

// 引入 AimRT 协程相关的接口
#include "aimrt_module_cpp_interface/co/aimrt_context.h"
#include "aimrt_module_cpp_interface/co/async_scope.h"
#include "aimrt_module_cpp_interface/co/task.h"

#include "aimrt_module_cpp_interface/module_base.h"

// 所有代码都放在对应命名空间下，防止命名冲突
namespace Executor::executor_co_loop_module {

using namespace aimrt;

// 自定义模块类，继承自 AimRT 框架的 ModuleBase 基类
class ExecutorCoLoopModule : public aimrt::ModuleBase {
 public:
  // 构造函数：默认构造
  ExecutorCoLoopModule() = default;

  // 析构函数：使用默认析构
  ~ExecutorCoLoopModule() override = default;

  // 模块信息，用于注册模块时描述其名称
  ModuleInfo Info() const override {
    return ModuleInfo{.name = "ExecutorCoLoopModule"};
  }

  // 初始化函数，框架会在模块加载时调用
  bool Initialize(aimrt::CoreRef aimrt_ptr) override;

  // 启动函数，框架会在模块 Start 时调用
  bool Start() override;

  // 关闭函数，框架会在模块卸载或退出时调用
  void Shutdown() override;

 private:
  // 获取模块的日志对象，用于打印日志
  auto GetLogger() { return core_.GetLogger(); }

  // 主逻辑循环，使用协程定义
  co::Task<void> MainLoop();

 private:
  // 框架核心对象引用，用于访问其他模块/调度器等
  aimrt::CoreRef core_;

  // 指向时间调度执行器的引用，用于控制调度策略
  aimrt::executor::ExecutorRef time_schedule_executor_;

  // 异步任务作用域，用于批量管理协程任务
  co::AsyncScope scope_;

  // 控制循环运行状态的原子布尔标志，线程安全
  std::atomic_bool run_flag_ = true;
};

}  // namespace aimrt::examples::cpp::executor::executor_co_loop_module

bool ExecutorCoLoopModule::Initialize(aimrt::CoreRef core) {
  // 保存框架核心对象引用
  core_ = core;

  // 从框架中获取名为 "time_schedule_executor" 的调度器执行器
  time_schedule_executor_ =
      core_.GetExecutorManager().GetExecutor("time_schedule_executor");

  // 校验是否成功获取，并且该执行器支持定时调度功能
  AIMRT_CHECK_ERROR_THROW(
      time_schedule_executor_ && time_schedule_executor_.SupportTimerSchedule(),
      "无法获取支持定时调度的执行器：time_schedule_executor");

  // 打印初始化成功日志（中文）
  AIMRT_INFO("模块初始化成功。");

  return true;
}

bool ExecutorCoLoopModule::Start() {
  // 在内联调度器上启动主协程循环任务
  scope_.spawn(co::On(co::InlineScheduler(), MainLoop()));

  // 打印启动成功日志（中文）
  AIMRT_INFO("模块启动成功。");

  return true;
}

// 模块的主协程逻辑
co::Task<void> ExecutorCoLoopModule::MainLoop() {
  // 打印循环开始日志（中文）
  AIMRT_INFO("协程主循环开始。");

  // 使用 time_schedule_executor 创建调度器对象
  auto scheduler = aimrt::co::AimRTScheduler(time_schedule_executor_);

  // 切换协程到定时调度线程池
  co_await co::Schedule(scheduler);

  uint32_t count = 0;

  // 开始循环，直到 run_flag_ 被设置为 false
  while (run_flag_) {
    count++;
    // 打印当前循环次数（中文）
    AIMRT_INFO("协程主循环第 {} 次 -------------------------", count);

    // 延迟 1 秒后再次调度，实现定时循环逻辑
    co_await co::ScheduleAfter(scheduler, std::chrono::seconds(1));
  }

  // 循环结束后打印退出日志（中文）
  AIMRT_INFO("协程主循环已退出。");

  co_return;
}

void ExecutorCoLoopModule::Shutdown() {
  // 设置运行标志为 false，用于结束循环
  run_flag_ = false;

  // 阻塞等待所有协程任务完成
  co::SyncWait(scope_.complete());

  // 打印关闭成功日志（中文）
  AIMRT_INFO("模块已关闭。");
}

#pragma once  // 防止头文件被多次包含

#include <atomic>  // 提供原子类型 std::atomic，用于线程安全标志控制

// 引入协程相关接口
#include "aimrt_module_cpp_interface/co/async_scope.h"  // 异步作用域，管理协程生命周期
#include "aimrt_module_cpp_interface/co/task.h"         // 协程任务 Task 定义
#include "aimrt_module_cpp_interface/module_base.h"  // AIMRT 模块基类定义

namespace Executor::real_time_module {

// RealTimeModule 是一个继承自 AIMRT 框架的 ModuleBase 的模块实现
class RealTimeModule : public aimrt::ModuleBase {
 public:
  RealTimeModule() = default;            // 默认构造函数
  ~RealTimeModule() override = default;  // 析构函数，确保虚析构行为

  // 实现模块信息接口，返回模块的名称
  ModuleInfo Info() const override {
    return ModuleInfo{.name = "RealTimeModule"};
  }

  // 模块初始化函数，在模块被加载时调用
  bool Initialize(aimrt::CoreRef aimrt_ptr) override;

  // 模块启动函数，在模块开始运行时调用
  bool Start() override;

  // 模块关闭函数，在模块卸载或退出时调用
  void Shutdown() override;

 private:
  // 获取模块的日志接口，用于打印日志信息
  auto GetLogger() { return core_.GetLogger(); }

  // 通过指定执行器名称启动一个协程工作循环
  void StartWorkLoopByExecutor(std::string_view executor_name);

  // 工作循环协程函数，接收一个执行器引用作为参数
  co::Task<void> WorkLoop(aimrt::executor::ExecutorRef executor_ptr);

 private:
  aimrt::CoreRef core_;               // AIMRT 框架核心引用，用于访问系统资源
  co::AsyncScope scope_;              // 管理模块中所有异步协程任务的作用域
  std::atomic_bool run_flag_ = true;  // 控制定时循环协程是否继续运行的标志位
};

}  // namespace Executor::real_time_module

// 初始化模块，保存 AIMRT 核心引用
bool RealTimeModule::Initialize(aimrt::CoreRef core) {
  // 保存 AIMRT 框架句柄
  core_ = core;

  // 日志：初始化成功
  AIMRT_INFO("初始化成功（Init succeeded）.");

  return true;
}

// 启动模块，分别在三个不同类型的执行器上启动工作协程
bool RealTimeModule::Start() {
  StartWorkLoopByExecutor("sched_fifo_thread");   // 启动 FIFO 调度线程的协程
  StartWorkLoopByExecutor("sched_other_thread");  // 启动 OTHER 调度线程的协程
  StartWorkLoopByExecutor("sched_rr_thread");  // 启动 RR（轮询）调度线程的协程

  // 日志：启动成功
  AIMRT_INFO("启动成功（Start succeeded）.");
  return true;
}


// 启动指定执行器名的协程工作循环
void RealTimeModule::StartWorkLoopByExecutor(std::string_view executor_name) {
  auto executor = core_.GetExecutorManager().GetExecutor(executor_name);
  // 校验执行器存在并支持定时调度
  AIMRT_CHECK_ERROR_THROW(executor && executor.SupportTimerSchedule(),
                          "获取执行器 '{}' 失败（Get executor '{}' failed）.",
                          executor_name);
  // 使用指定执行器调度 WorkLoop 协程，并托管给 scope_
  scope_.spawn(co::On(co::AimRTScheduler(executor), WorkLoop(executor)));
}

// 工作协程逻辑：定时执行并打印线程和 CPU 信息
co::Task<void> RealTimeModule::WorkLoop(aimrt::executor::ExecutorRef executor) {
  try {
    // 日志：启动工作循环
    AIMRT_INFO("在执行器 {} 中启动工作循环（Start WorkLoop in {}）.",
               executor.Name());

#ifdef __linux__
    // 获取当前线程名称
    char thread_name[16];
    pthread_getname_np(pthread_self(), thread_name, sizeof(thread_name));

    // 获取线程调度策略和优先级
    int policy = 0;
    struct sched_param param;
    pthread_getschedparam(pthread_self(), &policy, &param);

    // 日志：打印线程信息
    AIMRT_INFO(
        "执行器名: {}, 线程名: {}, 调度策略: {}, 优先级: {}（Executor name: "
        "{}, thread_name: {}, policy: {}, priority: {}）",
        executor.Name(), thread_name, policy, param.sched_priority);
#endif

    uint32_t count = 0;
    while (run_flag_) {
      count++;

      // 记录当前时间戳（用于计算 sleep 时间）
      auto start_tp = std::chrono::steady_clock::now();

      // 协程挂起 1000 毫秒（使用指定调度器）
      co_await co::ScheduleAfter(co::AimRTScheduler(executor),
                                 std::chrono::milliseconds(1000));
      auto end_tp = std::chrono::steady_clock::now();

#ifdef __linux__
      // 获取当前线程使用的 CPU 集合
      cpu_set_t cur_cpuset;
      CPU_ZERO(&cur_cpuset);
      auto pthread_getaffinity_np_ret = pthread_getaffinity_np(
          pthread_self(), sizeof(cpu_set_t), &cur_cpuset);
      AIMRT_CHECK_ERROR_THROW(
          pthread_getaffinity_np_ret == 0,
          "调用 pthread_getaffinity_np 失败，错误码：{}（Call "
          "'pthread_getaffinity_np' get error: {}）",
          pthread_getaffinity_np_ret);

      // 构造当前线程使用的 CPU ID 字符串
      uint32_t cpu_size = std::thread::hardware_concurrency();
      std::string cur_cpuset_str;
      for (int ii = 0; ii < cpu_size; ii++) {
        if (CPU_ISSET(ii, &cur_cpuset)) {
          cur_cpuset_str += (std::to_string(ii) + ", ");
        }
      }
      cur_cpuset_str = cur_cpuset_str.substr(0, cur_cpuset_str.size() - 2);

      // 获取当前运行在哪个 CPU 上（逻辑核）
      unsigned int current_cpu = 0, current_node = 0;
      int getcpu_ret = getcpu(&current_cpu, &current_node);
      AIMRT_CHECK_ERROR_THROW(
          getcpu_ret == 0,
          "调用 getcpu 失败，错误码：{}（Call 'getcpu' get error: {}）",
          getcpu_ret);

      // 日志：打印循环次数、耗时、CPU 信息等
      AIMRT_INFO(
          "循环次数: {}, 执行器名: {}, 睡眠时间: {}, 当前 CPU: {}, NUMA 节点: "
          "{}, 使用 CPU 集合: '{}'（"
          "Loop count: {}, executor name: {}, sleep for {}, cpu: {}, node: {}, "
          "use cpu: '{}'）",
          count, executor.Name(), end_tp - start_tp, current_cpu, current_node,
          cur_cpuset_str);
#else
      // 非 Linux 下仅打印次数与耗时
      AIMRT_INFO(
          "循环次数: {}, 执行器名: {}, 睡眠时间: {}（Loop count: {}, executor "
          "name: {}, sleep for {}）",
          count, executor.Name(), end_tp - start_tp);
#endif
    }

    // 日志：协程正常退出
    AIMRT_INFO("退出工作循环（Exit WorkLoop）.");
  } catch (const std::exception& e) {
    // 日志：协程因异常退出
    AIMRT_ERROR(
        "工作循环异常退出，原因：{}（Exit WorkLoop with exception, {}）",
        e.what());
  }

  co_return;
}

// 关闭模块，停止协程并等待其完成
void RealTimeModule::Shutdown() {
  try {
    // 设置退出标志，等待所有协程完成
    run_flag_ = false;
    co::SyncWait(scope_.complete());
  } catch (const std::exception& e) {
    // 日志：关闭失败，打印异常信息
    AIMRT_ERROR("关闭失败（Shutdown failed），异常信息：{}", e.what());
    return;
  }

  // 日志：关闭成功
  AIMRT_INFO("关闭成功（Shutdown succeeded）.");
}

# 基础信息
base_info:
  project_name: Logger # 项目名称
  build_mode_tags: ["EXAMPLE", "SIMULATION", "TEST_CAMERA"] # 构建模式标签
  aimrt_import_options: # AimRT框架的构建选项
    AIMRT_BUILD_TESTS: "OFF" # 是否构建测试代码
    AIMRT_BUILD_EXAMPLES: "ON" # 是否构建示例代码
    AIMRT_BUILD_DOCUMENT: "OFF" # 是否构建文档
    AIMRT_BUILD_RUNTIME: "ON" # 是否构建运行时核心
    AIMRT_BUILD_CLI_TOOLS: "OFF" # 是否构建命令行工具
    AIMRT_BUILD_WITH_PROTOBUF: "ON" # 是否启用Protobuf支持
    AIMRT_USE_LOCAL_PROTOC_COMPILER: "OFF" # 是否使用本地protoc编译器
    AIMRT_BUILD_WITH_ROS2: "OFF" # 是否集成ROS2支持
    AIMRT_BUILD_NET_PLUGIN: "OFF" # 是否构建网络插件
    AIMRT_BUILD_ROS2_PLUGIN: "OFF" # 是否构建ROS2插件

# 模块
modules:
  - name: logger_module
  - name: logger_bench_module

# pkg
pkgs:
  - name: logger_pkg # 包名
    modules:
      - name: logger_module
      - name: logger_bench_module

# 部署
deploy_modes:
  - name: local_deploy # 部署模式名称
    deploy_ins: # 部署实例
      - name: local_ins_logger # 实例名称
        pkgs:
          - name: logger_pkg # 实例加载的包

#pragma once
#include <atomic>
#include <future>

#include "aimrt_module_cpp_interface/module_base.h"

namespace Logger::logger_module {
using namespace aimrt;

// 日志模块类，继承自AIMRT模块基类
class LoggerModule : public aimrt::ModuleBase {
 public:
  LoggerModule() = default;
  ~LoggerModule() override = default;

  // 获取模块信息
  ModuleInfo Info() const override {
    return ModuleInfo{.name = "LoggerModule"};
  }

  // 初始化模块
  bool Initialize(aimrt::CoreRef aimrt_ptr) override;

  // 启动模块
  bool Start() override;

  // 关闭模块
  void Shutdown() override;

 private:
  aimrt::CoreRef core_;                    // AIMRT核心引用
  aimrt::executor::ExecutorRef executor_;  // 执行器引用

  std::atomic_bool run_flag_ = false;  // 运行标志位
  std::promise<void> stop_sig_;        // 停止信号
};

}  // namespace Logger::logger_module

#include "logger_module/logger_module.h"

#include "yaml-cpp/yaml.h"

namespace Logger::logger_module {

using namespace aimrt::logger;

bool LoggerModule::Initialize(aimrt::CoreRef core) {
  // 保存AIMRT框架句柄
  core_ = core;

  // 获取执行器句柄
  executor_ = core_.GetExecutorManager().GetExecutor("work_executor");
  AIMRT_HL_CHECK_ERROR_THROW(core_.GetLogger(), executor_,
                             "获取执行器'work_thread_pool'失败");

  AIMRT_HL_INFO(core_.GetLogger(), "初始化成功");

  return true;
}

bool LoggerModule::Start() {
  run_flag_ = true;
  executor_.Execute([this]() {
    // 为当前作用域创建日志句柄
    auto GetLogger = [this]() { return core_.GetLogger(); };

    std::string s = "abc";
    int n = 0;

    while (run_flag_.load()) {
      ++n;

      // 输出各级别日志
      AIMRT_TRACE("测试跟踪日志, 字符串 = {}, 计数器 = {}", s, n);
      AIMRT_DEBUG("测试调试日志, 字符串 = {}, 计数器 = {}", s, n);
      AIMRT_INFO("测试信息日志, 字符串 = {}, 计数器 = {}", s, n);
      AIMRT_WARN("测试警告日志, 字符串 = {}, 计数器 = {}", s, n);
      AIMRT_ERROR("测试错误日志, 字符串 = {}, 计数器 = {}", s, n);
      AIMRT_FATAL("测试致命日志, 字符串 = {}, 计数器 = {}", s, n);

      std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    stop_sig_.set_value();
  });

  AIMRT_HL_INFO(core_.GetLogger(), "启动成功");

  return true;
}

void LoggerModule::Shutdown() {
  if (run_flag_) {
    run_flag_ = false;
    stop_sig_.get_future().wait();
  }
  AIMRT_HL_INFO(core_.GetLogger(), "关闭成功");
}

}  // namespace Logger::logger_module