ROS2 Navigation Framework and System导航节点生命周期管理机制

最新推荐文章于 2025-09-22 05:30:13 发布
原创 最新推荐文章于 2025-09-22 05:30:13 发布 · 835 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

ROS2 Navigation Framework and System导航节点生命周期管理机制

【免费下载链接】navigation2 ROS2 Navigation Framework and System 【免费下载链接】navigation2 项目地址: https://gitcode.com/gh_mirrors/na/navigation2

引言：解决ROS2导航系统的节点状态管理痛点

在ROS2 (Robot Operating System 2) 导航系统开发中，你是否曾面临以下挑战：节点启动顺序混乱导致系统初始化失败？关键节点崩溃后无法自动恢复？导航任务执行中无法安全暂停与恢复？ROS2 Navigation Framework (Nav2) 的生命周期管理机制为这些问题提供了优雅的解决方案。本文将深入剖析Nav2生命周期管理的核心架构、状态转换逻辑与实战应用，帮助你构建高可靠性的机器人导航系统。

读完本文后，你将能够：

  • 理解ROS2生命周期节点(Lifecycle Node)的核心概念与状态机模型
  • 掌握Nav2生命周期管理器(Lifecycle Manager)的工作原理与配置方法
  • 实现导航系统的有序启动、安全关闭、故障恢复等高级功能
  • 解决多节点协同工作时的状态一致性问题
  • 优化导航系统的资源利用与容错能力

1. ROS2生命周期节点基础

1.1 生命周期节点概念与优势

ROS2生命周期节点(Lifecycle Node)是一种特殊类型的节点，它引入了明确的状态管理机制，允许节点在不同的操作模式之间进行转换。相比传统的ROS节点，生命周期节点具有以下显著优势：

特性传统节点生命周期节点
状态管理无明确状态划分包含未配置、非活动、活动、已终止等状态
启动控制一次性初始化支持分阶段配置与激活
错误恢复通常需要重启节点支持状态回滚与清理
资源管理初始化后持续占用可根据状态动态分配/释放资源
系统协同依赖外部同步机制提供标准化的状态转换接口

1.2 核心状态与转换

ROS2生命周期节点定义了五种主要状态和七种标准转换，形成一个完整的状态机：

mermaid

主要状态说明：

  • Unconfigured（未配置）：节点已创建但未初始化，资源未分配
  • Inactive（非活动）：节点已配置但未激活，资源已分配但未执行主要功能
  • Active（活动）：节点正常运行，执行主要业务逻辑
  • Finalized（已终止）：节点已关闭，资源已释放
  • Error（错误）：节点遇到错误，需要处理或恢复

关键转换说明：

  • configure：从Unconfigured到Inactive，执行初始化操作
  • activate：从Inactive到Active，启动主要功能
  • deactivate：从Active到Inactive，暂停主要功能
  • cleanup：从Inactive到Unconfigured，清理资源
  • shutdown：从任意状态到Finalized，终止节点

2. Nav2生命周期管理器架构

2.1 整体架构设计

Nav2生命周期管理器(nav2_lifecycle_manager)是一个核心组件，它负责协调和控制导航系统中所有生命周期节点的状态转换。其架构设计如下：

mermaid

2.2 核心组件与功能

Nav2生命周期管理器的核心功能通过以下组件实现：

  1. 服务接口：提供管理节点状态的服务，包括启动、配置、清理、关闭、重置、暂停和恢复等操作。

  2. 状态机控制器：实现状态转换逻辑，按照预定顺序向各个生命周期节点发送状态转换请求。

  3. 节点状态跟踪：维护所有被管理节点的当前状态信息，确保状态一致性。

  4. Bond连接监控：通过Bond机制监控关键节点的心跳，实现故障检测与恢复。

  5. 诊断信息发布：将系统状态信息发布到ROS诊断系统，便于监控与调试。

  6. 配置参数：允许用户自定义被管理节点列表、超时时间、自动启动等参数。

3. 生命周期管理器实现细节

3.1 核心类与接口

Nav2生命周期管理器的核心实现位于nav2_lifecycle_manager包中，主要包含以下类：

class LifecycleManager : public rclcpp::Node {
public:
    // 构造函数与析构函数
    explicit LifecycleManager(const rclcpp::NodeOptions & options = rclcpp::NodeOptions());
    ~LifecycleManager();

    // 状态转换函数
    bool startup();
    bool configure();
    bool cleanup();
    bool shutdown();
    bool reset(bool hard_reset = false);
    bool pause();
    bool resume();

    // 服务回调函数
    void managerCallback(
        const std::shared_ptr<rmw_request_id_t> request_header,
        const std::shared_ptr<ManageLifecycleNodes::Request> request,
        std::shared_ptr<ManageLifecycleNodes::Response> response);
    
    // 其他辅助函数...
private:
    // 节点状态枚举
    enum NodeState {
        UNCONFIGURED,
        ACTIVE,
        INACTIVE,
        FINALIZED,
        UNKNOWN,
    };

    // 状态转换辅助函数
    bool changeStateForNode(const std::string & node_name, std::uint8_t transition);
    bool changeStateForAllNodes(std::uint8_t transition, bool hard_change = false);

    // 成员变量...
    std::map<std::string, std::shared_ptr<nav2_util::LifecycleServiceClient>> node_map_;
    std::vector<std::string> node_names_;
    NodeState managed_nodes_state_;
    // ...
};

3.2 节点管理流程

生命周期管理器按照以下流程管理导航系统中的节点：

  1. 初始化阶段：

    • 读取配置参数，获取被管理节点列表
    • 创建生命周期服务客户端，与每个被管理节点建立连接
    • 设置状态转换映射表，定义转换与目标状态的对应关系

  2. 状态转换阶段：

    • 接收外部服务请求（如启动、暂停、重置等）
    • 根据请求类型确定目标状态转换
    • 按照预定顺序向每个被管理节点发送状态转换请求
    • 检查转换结果，处理可能的错误情况

  3. 监控阶段：

    • 通过Bond机制监控被管理节点的心跳
    • 定期检查节点状态，确保系统一致性
    • 在检测到节点故障时执行恢复策略
    • 发布系统状态诊断信息

3.3 节点启动顺序

Nav2生命周期管理器按照特定顺序启动节点，以确保依赖关系正确：

mermaid

这种分阶段启动策略确保了：

  • 先启动提供基础数据的节点（地图、定位）
  • 再启动依赖这些数据的核心功能节点（规划、控制）
  • 最后启动执行高层任务的节点（导航器、路径跟随器）
  • 所有节点配置完成后才统一激活，确保系统一致性

4. 状态转换实现机制

4.1 状态转换核心算法

生命周期管理器的状态转换算法实现如下：

bool LifecycleManager::changeStateForAllNodes(std::uint8_t transition, bool hard_change) {
    // 根据转换类型确定处理顺序：配置和激活按正向顺序，其他按反向顺序
    if (transition == Transition::TRANSITION_CONFIGURE ||
        transition == Transition::TRANSITION_ACTIVATE) {
        // 正向顺序处理
        for (auto & node_name : node_names_) {
            try {
                if (!changeStateForNode(node_name, transition) && !hard_change) {
                    return false;
                }
            } catch (const std::runtime_error & e) {
                RCLCPP_ERROR(get_logger(), "Failed to change state for node: %s. Exception: %s.", 
                            node_name.c_str(), e.what());
                return false;
            }
        }
    } else {
        // 反向顺序处理
        std::vector<std::string>::reverse_iterator rit;
        for (rit = node_names_.rbegin(); rit != node_names_.rend(); ++rit) {
            try {
                if (!changeStateForNode(*rit, transition) && !hard_change) {
                    return false;
                }
            } catch (const std::runtime_error & e) {
                RCLCPP_ERROR(get_logger(), "Failed to change state for node: %s. Exception: %s.", 
                            (*rit).c_str(), e.what());
                return false;
            }
        }
    }
    return true;
}

这一算法的关键特性：

  • 根据转换类型自动选择处理顺序（正向或反向）
  • 支持"硬转换"模式，允许在部分节点失败时继续处理
  • 异常捕获机制确保单个节点故障不会导致整个系统崩溃
  • 严格的错误检查确保状态转换的可靠性

4.2 节点状态检查与验证

生命周期管理器在每次状态转换后都会验证节点状态：

bool LifecycleManager::changeStateForNode(const std::string & node_name, std::uint8_t transition) {
    message(transition_label_map_[transition] + node_name);

    // 发送状态转换请求并检查结果
    if (!node_map_[node_name]->change_state(transition, std::chrono::milliseconds(-1),
        service_timeout_) ||
        !(node_map_[node_name]->get_state(service_timeout_) == transition_state_map_[transition])) {
        RCLCPP_ERROR(get_logger(), "Failed to change state for node: %s", node_name.c_str());
        return false;
    }

    // 激活时建立Bond连接，停用时分断连接
    if (transition == Transition::TRANSITION_ACTIVATE) {
        return createBondConnection(node_name);
    } else if (transition == Transition::TRANSITION_DEACTIVATE) {
        bond_map_.erase(node_name);
    }

    return true;
}

状态验证流程：

  1. 发送状态转换请求到目标节点
  2. 等待转换完成（带超时机制）
  3. 查询节点当前状态，验证是否达到预期状态
  4. 根据转换类型更新Bond连接状态
  5. 返回转换结果（成功/失败）

4.3 错误处理与恢复策略

生命周期管理器实现了多层次的错误处理机制：

mermaid

核心错误恢复代码：

void LifecycleManager::checkBondConnections() {
    if (!isActive() || !rclcpp::ok() || bond_map_.empty()) {
        return;
    }

    for (auto & node_name : node_names_) {
        if (!rclcpp::ok()) {
            return;
        }

        if (bond_map_[node_name]->isBroken()) {
            message("Have not received a heartbeat from " + node_name + ".");

            // 一个节点故障，关闭所有相关节点
            RCLCPP_ERROR(
                get_logger(),
                "CRITICAL FAILURE: SERVER %s IS DOWN after not receiving a heartbeat for %i ms."
                " Shutting down related nodes.",
                node_name.c_str(), static_cast<int>(bond_timeout_.count()));
            reset(true);  // 硬重置，确保所有活动节点都能转换状态
            
            // 清除Bond映射（处理崩溃节点）
            bond_map_.clear();

            // 启动恢复计时器，检查节点是否重新上线
            if (attempt_respawn_reconnection_) {
                bond_respawn_timer_ = this->create_wall_timer(
                    1s,
                    std::bind(&LifecycleManager::checkBondRespawnConnection, this),
                    callback_group_);
            }
            return;
        }
    }
}

5. 配置与使用指南

5.1 参数配置详解

生命周期管理器提供了丰富的配置选项，可通过YAML文件或ROS参数服务器进行设置：

lifecycle_manager:
  ros__parameters:
    # 被管理节点列表，按启动顺序排列
    node_names: ["map_server", "amcl", "planner_server", "controller_server", "bt_navigator"]
    
    # 是否自动启动系统
    autostart: True
    
    # Bond心跳超时时间（秒）
    bond_timeout: 4.0
    
    # 服务调用超时时间（秒）
    service_timeout: 5.0
    
    # 节点重生最大等待时间（秒）
    bond_respawn_max_duration: 10.0
    
    # 是否尝试重新连接重生的节点
    attempt_respawn_reconnection: True

关键参数说明：

参数名类型默认值描述
node_names字符串数组[]被管理节点名称列表，按启动顺序排列
autostart布尔值False是否在管理器启动后自动启动所有节点
bond_timeout浮点型4.0节点心跳超时时间（秒）
service_timeout浮点型5.0状态转换服务调用超时时间（秒）
bond_respawn_max_duration浮点型10.0等待节点重生的最大时间（秒）
attempt_respawn_reconnection布尔值True是否尝试重新连接重生的节点

5.2 启动文件示例

以下是一个完整的Nav2启动文件示例，包含生命周期管理器配置：

import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    # 获取配置文件路径
    lifecycle_config = os.path.join(
        get_package_share_directory('nav2_bringup'),
        'params',
        'nav2_params.yaml'
    )

    # 生命周期管理器节点
    lifecycle_manager_node = Node(
        package='nav2_lifecycle_manager',
        executable='lifecycle_manager',
        name='lifecycle_manager',
        output='screen',
        parameters=[
            lifecycle_config,  # 从配置文件加载参数
            {'node_names': ["map_server", "amcl", "planner_server", 
                           "controller_server", "bt_navigator"]}
        ],
        remappings=[
            ('/lifecycle_manager/manage_nodes', '/nav2/manage_nodes'),
            ('/lifecycle_manager/is_active', '/nav2/is_active')
        ]
    )

    # 其他节点启动配置...
    map_server_node = Node(
        package='nav2_map_server',
        executable='map_server',
        name='map_server',
        output='screen',
        parameters=[lifecycle_config]
    )

    amcl_node = Node(
        package='nav2_amcl',
        executable='amcl',
        name='amcl',
        output='screen',
        parameters=[lifecycle_config]
    )

    # ...其他节点配置

    return LaunchDescription([
        map_server_node,
        amcl_node,
        # ...其他节点
        lifecycle_manager_node
    ])

5.3 服务接口使用

生命周期管理器提供了服务接口，允许外部节点控制导航系统状态：

  1. 管理服务：/lifecycle_manager/manage_nodes

    • 服务类型：nav2_msgs/srv/ManageLifecycleNodes
    • 支持命令：启动(STARTUP)、配置(CONFIGURE)、清理(CLEANUP)、关闭(SHUTDOWN)、重置(RESET)、暂停(PAUSE)、恢复(RESUME)

  2. 状态查询服务：/lifecycle_manager/is_active

    • 服务类型：std_srvs/srv/Trigger
    • 返回系统是否处于活动状态

服务调用示例（Python）：

import rclpy
from rclpy.node import Node
from nav2_msgs.srv import ManageLifecycleNodes
from std_srvs.srv import Trigger

def main(args=None):
    rclpy.init(args=args)
    node = Node('lifecycle_client')
    
    # 创建管理服务客户端
    manage_client = node.create_client(
        ManageLifecycleNodes, '/lifecycle_manager/manage_nodes')
    
    # 创建状态查询客户端
    is_active_client = node.create_client(
        Trigger, '/lifecycle_manager/is_active')
    
    # 等待服务可用
    while not manage_client.wait_for_service(timeout_sec=1.0):
        node.get_logger().info('管理服务不可用，等待中...')
    
    while not is_active_client.wait_for_service(timeout_sec=1.0):
        node.get_logger().info('状态查询服务不可用，等待中...')
    
    # 查询当前状态
    is_active_req = Trigger.Request()
    future = is_active_client.call_async(is_active_req)
    rclpy.spin_until_future_complete(node, future)
    if future.result().success:
        node.get_logger().info('系统当前处于活动状态')
    else:
        node.get_logger().info('系统当前不处于活动状态')
    
    # 发送暂停请求
    pause_req = ManageLifecycleNodes.Request()
    pause_req.command = ManageLifecycleNodes.Request.PAUSE
    
    future = manage_client.call_async(pause_req)
    rclpy.spin_until_future_complete(node, future)
    
    if future.result().success:
        node.get_logger().info('暂停成功')
    else:
        node.get_logger().error('暂停失败')
    
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

6. 高级应用与最佳实践

6.1 自定义节点集成

将自定义生命周期节点集成到Nav2系统的步骤：

  1. 实现生命周期节点：

    #include "nav2_core/lifecycle_node.hpp"

class MyCustomNode : public nav2_core::LifecycleNode {
public:
    MyCustomNode(const std::string & node_name, const rclcpp::NodeOptions & options)
        : nav2_core::LifecycleNode(node_name, options) {
        // 构造函数：声明参数，初始化成员变量
    }

    // 生命周期回调函数
    nav2_core::CallbackReturn on_configure(const rclcpp_lifecycle::State & state) override {
        // 配置阶段：获取参数，创建发布者/订阅者，初始化资源
        return nav2_core::CallbackReturn::SUCCESS;
    }

    nav2_core::CallbackReturn on_activate(const rclcpp_lifecycle::State & state) override {
        // 激活阶段：启动定时器，开始处理数据
        return nav2_core::CallbackReturn::SUCCESS;
    }

    nav2_core::CallbackReturn on_deactivate(const rclcpp_lifecycle::State & state) override {
        // 停用阶段：停止定时器，暂停数据处理
        return nav2_core::CallbackReturn::SUCCESS;
    }

    nav2_core::CallbackReturn on_cleanup(const rclcpp_lifecycle::State & state) override {
        // 清理阶段：释放资源，重置状态
        return nav2_core::CallbackReturn::SUCCESS;
    }

    nav2_core::CallbackReturn on_shutdown(const rclcpp_lifecycle::State & state) override {
        // 关闭阶段：保存数据，释放所有资源
        return nav2_core::CallbackReturn::SUCCESS;
    }
};

// 注册为组件
#include "rclcpp_components/register_node_macro.hpp"
RCLCPP_COMPONENTS_REGISTER_NODE(MyCustomNode)

  2. 更新生命周期管理器配置：

    lifecycle_manager:
  ros__parameters:
    node_names: ["map_server", "amcl", "my_custom_node", "planner_server", "controller_server", "bt_navigator"]

  3. 实现依赖管理：

    • 确保自定义节点在其依赖的节点之后启动
    • 在package.xml中声明正确的依赖关系
    • 实现适当的错误处理与状态反馈

6.2 系统监控与诊断

Nav2生命周期管理器集成了ROS诊断系统，提供系统状态监控：

mermaid

诊断信息使用方法：

  1. 启动诊断聚合器：

    ros2 launch nav2_bringup diagnostics_launch.py

  2. 查看诊断信息：

    ros2 run rqt_runtime_monitor rqt_runtime_monitor

  3. 自定义诊断分析：

    void LifecycleManager::CreateDiagnostic(diagnostic_updater::DiagnosticStatusWrapper & stat) {
    unsigned char error_level;
    std::string message;
    switch (managed_nodes_state_) {
        case NodeState::ACTIVE:
            error_level = diagnostic_msgs::msg::DiagnosticStatus::OK;
            message = "Managed nodes are active";
            break;
        case NodeState::INACTIVE:
            error_level = diagnostic_msgs::msg::DiagnosticStatus::OK;
            message = "Managed nodes are inactive";
            break;
        case NodeState::UNCONFIGURED:
            error_level = diagnostic_msgs::msg::DiagnosticStatus::OK;
            message = "Managed nodes are unconfigured";
            break;
        case NodeState::FINALIZED:
            error_level = diagnostic_msgs::msg::DiagnosticStatus::WARN;
            message = "Managed nodes have been shut down";
            break;
        default:  // NodeState::UNKNOWN
            error_level = diagnostic_msgs::msg::DiagnosticStatus::ERROR;
            message = "An error has occurred during a node state transition";
            break;
    }
    stat.summary(error_level, message);

    // 添加每个节点的详细状态
    for (auto & node_name : node_names_) {
        std::string state_str;
        try {
            auto state = node_map_[node_name]->get_state(service_timeout_);
            state_str = lifecycle_msgs::msg::State::PRIMARY_STATE_NAMES[state];
        } catch (...) {
            state_str = "UNKNOWN";
        }
        stat.addf(node_name, "%s", state_str.c_str());
    }
}

6.3 性能优化策略

优化生命周期管理器性能的关键策略：

  1. 调整超时参数：

    • 根据系统性能和网络状况调整服务超时时间
    • 对资源密集型节点设置较长的超时时间

  2. 优化节点启动顺序：

    • 分析节点间依赖关系，优化启动顺序
    • 将独立节点并行启动（通过分组）

  3. 减少不必要的状态转换：

    • 设计幂等的配置与清理函数，允许安全重试
    • 避免频繁的暂停/恢复操作，改用参数动态调整

  4. 资源管理优化：

    • 在非活动状态下释放GPU、传感器等稀缺资源
    • 使用条件变量而非轮询检查节点状态

  5. 故障恢复策略定制：

    • 为关键节点配置更积极的恢复策略
    • 为非关键节点配置降级运行模式

7. 常见问题与解决方案

7.1 节点启动失败

问题：生命周期管理器报告节点启动失败，日志中显示"Failed to change state for node"。

解决方案：

  1. 检查节点依赖：

    # 检查节点是否正确安装
ros2 pkg list | grep <package_name>

# 检查节点可执行文件是否存在
which <node_executable>

  2. 验证参数配置：

    # 检查节点参数
ros2 param dump /<node_name>

# 比较参数与预期值

  3. 查看节点详细日志：

    # 启动时增加日志级别
ros2 run <package_name> <node_executable> --ros-args --log-level DEBUG

  4. 常见原因与修复：

    • 参数缺失：确保所有必要参数都已设置
    • 依赖服务不可用：检查节点依赖的其他服务是否正常运行
    • 资源冲突：检查是否有其他进程占用了节点需要的资源
    • 权限问题：确保节点有足够权限访问所需文件或设备

7.2 系统状态不一致

问题：部分节点处于活动状态，而其他节点处于非活动状态，系统无法正常工作。

解决方案：

  1. 手动重置系统：

    # 使用ROS2服务调用工具发送重置命令
ros2 service call /lifecycle_manager/manage_nodes nav2_msgs/srv/ManageLifecycleNodes "{command: 4}"

  2. 检查节点间通信：

    # 检查节点间连接
ros2 topic list
ros2 node info /<node_name>

  3. 分析状态转换历史：

    # 查看生命周期管理器日志
grep "changeStateForNode" ~/.ros/log/latest/nav2_lifecycle_manager-*.log

  4. 修复措施：

    • 调整节点启动顺序，解决依赖问题
    • 增加服务超时时间，适应慢速节点
    • 实现更健壮的错误处理逻辑
    • 检查网络配置，确保节点间通信正常

7.3 系统无法自动恢复

问题：节点崩溃后，生命周期管理器未能成功恢复系统。

解决方案：

  1. 检查重生配置：

    # 检查重生参数配置
ros2 param get /lifecycle_manager attempt_respawn_reconnection
ros2 param get /lifecycle_manager bond_respawn_max_duration

  2. 分析故障恢复日志：

    # 查找重生相关日志
grep "respawn" ~/.ros/log/latest/nav2_lifecycle_manager-*.log

  3. 验证节点重生能力：

    # 手动杀死节点并观察是否重生
kill -9 <node_pid>
ros2 node list  # 检查节点是否重生

  4. 修复措施：

    • 确保节点设计为可重启的（无残留状态）
    • 增加重生超时时间，适应慢速系统
    • 实现节点状态持久化，支持恢复后继续执行
    • 配置进程管理工具（如systemd）自动重启崩溃的节点

8. 总结与展望

Nav2的生命周期管理机制为构建可靠的机器人导航系统提供了强大的基础。通过明确的状态管理、有序的节点协调和健壮的故障恢复策略，生命周期管理器解决了传统ROS系统中节点协同工作的诸多挑战。

8.1 核心优势回顾

  • 提高系统可靠性：明确的状态转换与错误处理机制
  • 增强资源管理：根据节点状态动态分配/释放资源
  • 简化系统集成：标准化的节点接口与启动流程
  • 提升容错能力：自动化的故障检测与恢复
  • 优化开发效率：清晰的状态划分与生命周期回调

8.2 未来发展方向

  1. 智能化状态管理：引入AI技术预测节点故障，实现主动预防
  2. 分布式生命周期管理：支持多机器人系统的协同状态管理
  3. 更精细的状态划分：支持中间状态与部分激活模式
  4. 增强的诊断与可视化：提供更直观的状态监控与调试工具
  5. 与ROS 2扩展功能集成：结合实时性扩展、安全性功能等

8.3 学习资源与社区支持

  • 官方文档：https://docs.nav2.org/
  • 源代码仓库：https://gitcode.com/gh_mirrors/na/navigation2
  • ROS2生命周期设计文档：https://design.ros2.org/articles/node_lifecycle.html
  • Nav2社区论坛：https://discourse.ros.org/c/navigation/nav2/
  • ROS2生命周期教程：https://index.ros.org/doc/ros2/Tutorials/Lifecycle-Nodes/

通过掌握Nav2生命周期管理机制，你将能够构建更可靠、更健壮的机器人导航系统，为实际应用场景中的复杂挑战提供有效的解决方案。无论是自主移动机器人、工业自动化系统还是服务机器人，良好的生命周期管理都是实现高性能和高可用性的关键。

如果觉得本文对你有帮助，请点赞、收藏并关注作者，获取更多ROS2与机器人导航技术深度解析。下期预告：《基于行为树的ROS2导航任务规划》

【免费下载链接】navigation2 ROS2 Navigation Framework and System 【免费下载链接】navigation2 项目地址: https://gitcode.com/gh_mirrors/na/navigation2

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值