21720211393

Committed 05 Feb 2026 04:44PM UTC coverage: 49.039% (+0.08%) from 48.959%

Build # 21720211393

Build Type

Pull #2762

github

Committed by

web-flow

Commit Message

Merge f47718c46 into b84eae3a5

Pull Request Pull Request #2762: core: fix MAVLink message sequence

Coverage Stats

51 of 56 new or added lines in 6 files covered. (91.07%)

3 existing lines in 2 files now uncovered.

18364 of 37448 relevant lines covered (49.04%)

668.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/mavsdk/plugins/events/event_handler.cpp


#include "event_handler.h"

#include <utility>

namespace mavsdk {

EventHandler::EventHandler(
    const std::string& profile,
    handle_event_f handle_event_cb,
    health_and_arming_checks_updated_f health_and_arming_checks_updated_cb,
    SystemImpl& system_impl,
    uint8_t system_id,
    uint8_t component_id) :
    _handle_event_cb(std::move(handle_event_cb)),
    _health_and_arming_checks_updated_cb(std::move(health_and_arming_checks_updated_cb)),
    _compid(component_id),
    _system_impl(system_impl)
{
    auto error_cb = [component_id, this](int num_events_lost) {
        _health_and_arming_checks.reset();
        LogWarn() << "Events got lost:" << num_events_lost << "comp_id:" << component_id;
    };

    const auto timeout_cb = [this](int timeout_ms) {
        if (_timer_cookie != 0) {
            _system_impl.unregister_timeout_handler(_timer_cookie);
            _timer_cookie = 0;
        }
        if (timeout_ms > 0) {
            _timer_cookie = _system_impl.register_timeout_handler(
                [this]() {
                    const std::lock_guard lg{_protocol_mutex};
                    _protocol->timerEvent();
                },
                timeout_ms / 1000.0);
        }
    };

    const auto send_request_cb = [this](const mavlink_request_event_t& msg) {
        _system_impl.queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {
            mavlink_message_t message;
            mavlink_msg_request_event_encode_chan(
                mavlink_address.system_id, mavlink_address.component_id, channel, &message, &msg);
            return message;
        });
    };

    _parser.setProfile(profile);

    _parser.formatters().url = [](const std::string& /*content*/, const std::string& link) {
        return link;
    };

    events::ReceiveProtocol::Callbacks callbacks{
        error_cb,
        send_request_cb,
        std::bind(&EventHandler::got_event, this, std::placeholders::_1),
        timeout_cb};
    _protocol = std::make_unique<events::ReceiveProtocol>(
        callbacks,
        _system_impl.get_own_system_id(),
        _system_impl.get_own_component_id(),
        system_id,
        component_id);

    _system_impl.register_mavlink_message_handler_with_compid(
        MAVLINK_MSG_ID_EVENT,
        _compid,
        std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),
        &_message_handler_cookies[0]);
    _system_impl.register_mavlink_message_handler_with_compid(
        MAVLINK_MSG_ID_CURRENT_EVENT_SEQUENCE,
        _compid,
        std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),
        &_message_handler_cookies[1]);
    _system_impl.register_mavlink_message_handler_with_compid(
        MAVLINK_MSG_ID_RESPONSE_EVENT_ERROR,
        _compid,
        std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),
        &_message_handler_cookies[2]);
}
EventHandler::~EventHandler()
{
    if (_timer_cookie != 0) {
        _system_impl.unregister_timeout_handler(_timer_cookie);
    }
    // Use blocking version to ensure any in-flight callbacks complete before destruction.
    for (size_t i = 0; i < _message_handler_cookies.size(); ++i) {
        _system_impl.unregister_all_mavlink_message_handlers_blocking(&_message_handler_cookies[i]);
    }
}
void EventHandler::set_metadata(const std::string& metadata_json)
{
    if (_parser.loadDefinitions(metadata_json)) {
        if (_parser.hasDefinitions()) {
            // do we have queued events?
            for (const auto& event : _pending_events) {
                got_event(event);
            }
            _pending_events.clear();
        }
    } else {
        LogErr() << "Failed to load events JSON metadata file";
    }
}

std::optional<int> EventHandler::get_mode_group(uint32_t custom_mode) const
{
    events::parser::Parser::NavigationModeGroups groups = _parser.navigationModeGroups(_compid);
    for (auto group_iter : groups.groups) {
        if (group_iter.second.find(custom_mode) != group_iter.second.end()) {
            return group_iter.first;
        }
    }
    return std::nullopt;
}
void EventHandler::handle_mavlink_message(const mavlink_message_t& message)
{
    const std::lock_guard lg{_protocol_mutex};
    _protocol->processMessage(message);
}
void EventHandler::got_event(const mavlink_event_t& event)
{
    if (!_parser.hasDefinitions()) {
        if (_pending_events.size() > 50) { // Limit size (not expected to hit that limit)
            _pending_events.clear();
        }
        if (_pending_events.empty()) { // Print only for the first to avoid spamming
            LogDebug() << "No metadata, queuing event, ID: " << event.id
                       << ", num pending: " << _pending_events.size();
        }
        _pending_events.push_back(event);
        return;
    }

    std::unique_ptr<events::parser::ParsedEvent> parsed_event =
        _parser.parse(events::EventType(event));
    if (parsed_event == nullptr) {
        LogWarn() << "Got Event without known metadata: ID:" << event.id << "comp id:" << _compid;
        return;
    }

    //    LogDebug() << "Got Event: ID: " << parsed_event->id() << " namespace: " <<
    //    parsed_event->eventNamespace().c_str() <<
    //        " name: " << parsed_event->name().c_str() << " msg: " <<
    //        parsed_event->message().c_str();

    if (_health_and_arming_checks.handleEvent(*parsed_event)) {
        _health_and_arming_checks_valid = true;
        _health_and_arming_checks_updated_cb();
    }
    _handle_event_cb(std::move(parsed_event));
}
} // namespace mavsdk

1
2	#include "event_handler.h"
3
4	#include <utility>
5
6	namespace mavsdk {
7
8	EventHandler::EventHandler(	×
9	const std::string& profile,
10	handle_event_f handle_event_cb,
11	health_and_arming_checks_updated_f health_and_arming_checks_updated_cb,
12	SystemImpl& system_impl,
13	uint8_t system_id,
14	uint8_t component_id) :	×
15	_handle_event_cb(std::move(handle_event_cb)),	×
16	_health_and_arming_checks_updated_cb(std::move(health_and_arming_checks_updated_cb)),	×
17	_compid(component_id),	×
18	_system_impl(system_impl)	×
19	{
20	auto error_cb = [component_id, this](int num_events_lost) {	×
21	_health_and_arming_checks.reset();	×
22	LogWarn() << "Events got lost:" << num_events_lost << "comp_id:" << component_id;	×
23	};	×
24
25	const auto timeout_cb = [this](int timeout_ms) {	×
26	if (_timer_cookie != 0) {	×
27	_system_impl.unregister_timeout_handler(_timer_cookie);	×
28	_timer_cookie = 0;	×
29	}
30	if (timeout_ms > 0) {	×
31	_timer_cookie = _system_impl.register_timeout_handler(	×
32	[this]() {	×
33	const std::lock_guard lg{_protocol_mutex};	×
34	_protocol->timerEvent();	×
35	},	×
36	timeout_ms / 1000.0);
37	}
38	};	×
39
40	const auto send_request_cb = [this](const mavlink_request_event_t& msg) {	×
NEW 41	_system_impl.queue_message([&](MavlinkAddress mavlink_address, uint8_t channel) {	×
42	mavlink_message_t message;
NEW 43	mavlink_msg_request_event_encode_chan(	×
NEW 44	mavlink_address.system_id, mavlink_address.component_id, channel, &message, &msg);	×
NEW 45	return message;	×
46	});
UNCOV 47	};	×
48
49	_parser.setProfile(profile);	×
50
51	_parser.formatters().url = [](const std::string& /content/, const std::string& link) {	×
52	return link;	×
53	};	×
54
55	events::ReceiveProtocol::Callbacks callbacks{
56	error_cb,
57	send_request_cb,
58	std::bind(&EventHandler::got_event, this, std::placeholders::_1),	×
59	timeout_cb};	×
60	_protocol = std::make_unique<events::ReceiveProtocol>(	×
61	callbacks,
62	_system_impl.get_own_system_id(),	×
63	_system_impl.get_own_component_id(),	×
64	system_id,
65	component_id);	×
66
67	_system_impl.register_mavlink_message_handler_with_compid(	×
68	MAVLINK_MSG_ID_EVENT,
69	_compid,	×
70	std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),	×
71	&_message_handler_cookies[0]);	×
72	_system_impl.register_mavlink_message_handler_with_compid(	×
73	MAVLINK_MSG_ID_CURRENT_EVENT_SEQUENCE,
74	_compid,	×
75	std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),	×
76	&_message_handler_cookies[1]);	×
77	_system_impl.register_mavlink_message_handler_with_compid(	×
78	MAVLINK_MSG_ID_RESPONSE_EVENT_ERROR,
79	_compid,	×
80	std::bind(&EventHandler::handle_mavlink_message, this, std::placeholders::_1),	×
81	&_message_handler_cookies[2]);	×
82	}	×
83	EventHandler::~EventHandler()	×
84	{
85	if (_timer_cookie != 0) {	×
86	_system_impl.unregister_timeout_handler(_timer_cookie);	×
87	}
88	// Use blocking version to ensure any in-flight callbacks complete before destruction.
89	for (size_t i = 0; i < _message_handler_cookies.size(); ++i) {	×
90	_system_impl.unregister_all_mavlink_message_handlers_blocking(&_message_handler_cookies[i]);	×
91	}
92	}	×
93	void EventHandler::set_metadata(const std::string& metadata_json)	×
94	{
95	if (_parser.loadDefinitions(metadata_json)) {	×
96	if (_parser.hasDefinitions()) {	×
97	// do we have queued events?
98	for (const auto& event : _pending_events) {	×
99	got_event(event);	×
100	}
101	_pending_events.clear();	×
102	}
103	} else {
104	LogErr() << "Failed to load events JSON metadata file";	×
105	}
106	}	×
107
108	std::optional<int> EventHandler::get_mode_group(uint32_t custom_mode) const	×
109	{
110	events::parser::Parser::NavigationModeGroups groups = _parser.navigationModeGroups(_compid);	×
111	for (auto group_iter : groups.groups) {	×
112	if (group_iter.second.find(custom_mode) != group_iter.second.end()) {	×
113	return group_iter.first;	×
114	}
115	}	×
116	return std::nullopt;	×
117	}	×
118	void EventHandler::handle_mavlink_message(const mavlink_message_t& message)	×
119	{
120	const std::lock_guard lg{_protocol_mutex};	×
121	_protocol->processMessage(message);	×
122	}	×
123	void EventHandler::got_event(const mavlink_event_t& event)	×
124	{
125	if (!_parser.hasDefinitions()) {	×
126	if (_pending_events.size() > 50) { // Limit size (not expected to hit that limit)	×
127	_pending_events.clear();	×
128	}
129	if (_pending_events.empty()) { // Print only for the first to avoid spamming	×
130	LogDebug() << "No metadata, queuing event, ID: " << event.id	×
131	<< ", num pending: " << _pending_events.size();	×
132	}
133	_pending_events.push_back(event);	×
134	return;	×
135	}
136
137	std::unique_ptr<events::parser::ParsedEvent> parsed_event =
138	_parser.parse(events::EventType(event));	×
139	if (parsed_event == nullptr) {	×
140	LogWarn() << "Got Event without known metadata: ID:" << event.id << "comp id:" << _compid;	×
141	return;	×
142	}
143
144	// LogDebug() << "Got Event: ID: " << parsed_event->id() << " namespace: " <<
145	// parsed_event->eventNamespace().c_str() <<
146	// " name: " << parsed_event->name().c_str() << " msg: " <<
147	// parsed_event->message().c_str();
148
149	if (_health_and_arming_checks.handleEvent(*parsed_event)) {	×
150	_health_and_arming_checks_valid = true;	×
151	_health_and_arming_checks_updated_cb();	×
152	}
153	_handle_event_cb(std::move(parsed_event));	×
154	}	×
155	} // namespace mavsdk

mavlink / MAVSDK / 21720211393

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous