rclnodejs 1.0.0 → 1.2.0

package/lib/node.js

@@ -39,7 +39,10 @@ const Service = require('./service.js');
 const Subscription = require('./subscription.js');
 const TimeSource = require('./time_source.js');
 const Timer = require('./timer.js');
+const TypeDescriptionService = require('./type_description_service.js');
 const Entity = require('./entity.js');
+const { SubscriptionEventCallbacks } = require('../lib/event_handler.js');
+const { PublisherEventCallbacks } = require('../lib/event_handler.js');
 
 // Parameter event publisher constants
 const PARAMETER_EVENT_MSG_TYPE = 'rcl_interfaces/msg/ParameterEvent';
@@ -95,12 +98,14 @@ class Node extends rclnodejs.ShadowNode {
     this._services = [];
     this._timers = [];
     this._guards = [];
+    this._events = [];
     this._actionClients = [];
     this._actionServers = [];
     this._rateTimerServer = null;
     this._parameterDescriptors = new Map();
     this._parameters = new Map();
     this._parameterService = null;
+    this._typeDescriptionService = null;
     this._parameterEventPublisher = null;
     this._setParametersCallbacks = [];
     this._logger = new Logging(rclnodejs.getNodeLoggerName(this.handle));
@@ -147,6 +152,14 @@ class Node extends rclnodejs.ShadowNode {
       this._parameterService = new ParameterService(this);
       this._parameterService.start();
     }
+
+    if (
+      DistroUtils.getDistroId() >= DistroUtils.getDistroId('jazzy') &&
+      options.startTypeDescriptionService
+    ) {
+      this._typeDescriptionService = new TypeDescriptionService(this);
+      this._typeDescriptionService.start();
+    }
   }
 
   execute(handles) {
@@ -171,6 +184,9 @@ class Node extends rclnodejs.ShadowNode {
     let actionServersReady = this._actionServers.filter((actionServer) =>
       handles.includes(actionServer.handle)
     );
+    let eventsReady = this._events.filter((event) =>
+      handles.includes(event.handle)
+    );
 
     timersReady.forEach((timer) => {
       if (timer.isReady()) {
@@ -179,6 +195,10 @@ class Node extends rclnodejs.ShadowNode {
       }
     });
 
+    eventsReady.forEach((event) => {
+      event.takeData();
+    });
+
     for (const subscription of subscriptionsReady) {
       if (subscription.isDestroyed()) continue;
       if (subscription.isRaw) {
@@ -578,27 +598,39 @@ class Node extends rclnodejs.ShadowNode {
    * @param {object} options - The options argument used to parameterize the publisher.
    * @param {boolean} options.enableTypedArray - The topic will use TypedArray if necessary, default: true.
    * @param {QoS} options.qos - ROS Middleware "quality of service" settings for the publisher, default: QoS.profileDefault.
+   * @param {PublisherEventCallbacks} eventCallbacks - The event callbacks for the publisher.
    * @return {Publisher} - An instance of Publisher.
    */
-  createPublisher(typeClass, topic, options) {
-    return this._createPublisher(typeClass, topic, options, Publisher);
+  createPublisher(typeClass, topic, options, eventCallbacks) {
+    return this._createPublisher(
+      typeClass,
+      topic,
+      options,
+      Publisher,
+      eventCallbacks
+    );
   }
 
-  _createPublisher(typeClass, topic, options, publisherClass) {
+  _createPublisher(typeClass, topic, options, publisherClass, eventCallbacks) {
     if (typeof typeClass === 'string' || typeof typeClass === 'object') {
       typeClass = loader.loadInterface(typeClass);
     }
     options = this._validateOptions(options);
 
-    if (typeof typeClass !== 'function' || typeof topic !== 'string') {
+    if (
+      typeof typeClass !== 'function' ||
+      typeof topic !== 'string' ||
+      (eventCallbacks && !(eventCallbacks instanceof PublisherEventCallbacks))
+    ) {
       throw new TypeError('Invalid argument');
     }
 
     let publisher = publisherClass.createPublisher(
-      this.handle,
+      this,
       typeClass,
       topic,
-      options
+      options,
+      eventCallbacks
     );
     debug('Finish creating publisher, topic = %s.', topic);
     this._publishers.push(publisher);
@@ -633,12 +665,13 @@ class Node extends rclnodejs.ShadowNode {
    *  the ‘parameters’ (i.e., "%n" tokens) in the filter_expression. The number of supplied parameters must
    *  fit with the requested values in the filter_expression (i.e., the number of %n tokens). default: undefined.
    * @param {SubscriptionCallback} callback - The callback to be call when receiving the topic subscribed. The topic will be an instance of null-terminated Buffer when options.isRaw is true.
+   * @param {SubscriptionEventCallbacks} eventCallbacks - The event callbacks for the subscription.
    * @return {Subscription} - An instance of Subscription.
    * @throws {ERROR} - May throw an RMW error if content-filter is malformed. 
    * @see {@link SubscriptionCallback}
    * @see {@link https://www.omg.org/spec/DDS/1.4/PDF|Content-filter details at DDS 1.4 specification, Annex B}
    */
-  createSubscription(typeClass, topic, options, callback) {
+  createSubscription(typeClass, topic, options, callback, eventCallbacks) {
     if (typeof typeClass === 'string' || typeof typeClass === 'object') {
       typeClass = loader.loadInterface(typeClass);
     }
@@ -652,17 +685,20 @@ class Node extends rclnodejs.ShadowNode {
     if (
       typeof typeClass !== 'function' ||
       typeof topic !== 'string' ||
-      typeof callback !== 'function'
+      typeof callback !== 'function' ||
+      (eventCallbacks &&
+        !(eventCallbacks instanceof SubscriptionEventCallbacks))
     ) {
       throw new TypeError('Invalid argument');
     }
 
     let subscription = Subscription.createSubscription(
-      this.handle,
+      this,
       typeClass,
       topic,
       options,
-      callback
+      callback,
+      eventCallbacks
     );
     debug('Finish creating subscription, topic = %s.', topic);
     this._subscriptions.push(subscription);
@@ -826,6 +862,12 @@ class Node extends rclnodejs.ShadowNode {
     if (!(publisher instanceof Publisher)) {
       throw new TypeError('Invalid argument');
     }
+    if (publisher.events) {
+      publisher.events.forEach((event) => {
+        this._destroyEntity(event, this._events);
+      });
+      publisher.events = [];
+    }
     this._destroyEntity(publisher, this._publishers, false);
   }
 
@@ -838,6 +880,13 @@ class Node extends rclnodejs.ShadowNode {
     if (!(subscription instanceof Subscription)) {
       throw new TypeError('Invalid argument');
     }
+    if (subscription.events) {
+      subscription.events.forEach((event) => {
+        this._destroyEntity(event, this._events);
+      });
+      subscription.events = [];
+    }
+
     this._destroyEntity(subscription, this._subscriptions);
   }
 
@@ -1053,7 +1102,15 @@ class Node extends rclnodejs.ShadowNode {
    * @return {Array<{name: string, namespace: string}>} An array of the names and namespaces.
    */
   getNodeNamesAndNamespaces() {
-    return rclnodejs.getNodeNames(this.handle);
+    return rclnodejs.getNodeNames(this.handle, /*getEnclaves=*/ false);
+  }
+
+  /**
+   * Get the list of nodes and their namespaces with enclaves discovered by the provided node.
+   * @return {Array<{name: string, namespace: string, enclave: string}>} An array of the names, namespaces and enclaves.
+   */
+  getNodeNamesAndNamespacesWithEnclaves() {
+    return rclnodejs.getNodeNames(this.handle, /*getEnclaves=*/ true);
   }
 
   /**
@@ -1610,6 +1667,23 @@ class Node extends rclnodejs.ShadowNode {
     }
   }
 
+  /**
+   * Get the fully qualified name of the node.
+   *
+   * @returns {string} - String containing the fully qualified name of the node.
+   */
+  getFullyQualifiedName() {
+    return rclnodejs.getFullyQualifiedName(this.handle);
+  }
+
+  /**
+   * Get the RMW implementation identifier
+   * @returns {string} - The RMW implementation identifier.
+   */
+  getRMWImplementationIdentifier() {
+    return rclnodejs.getRMWImplementationIdentifier();
+  }
+
   // returns on 1st error or result {successful, reason}
   _validateParameters(parameters = [], declareParameterMode = false) {
     for (const parameter of parameters) {

package/lib/node_options.js

@@ -26,16 +26,19 @@ class NodeOptions {
    * @param {boolean} [startParameterServices=true]
    * @param {array} [parameterOverrides=[]]
    * @param {boolean} [automaticallyDeclareParametersFromOverrides=false]
+   * @param {boolean} [startTypeDescriptionService=true]
    */
   constructor(
     startParameterServices = true,
     parameterOverrides = [],
-    automaticallyDeclareParametersFromOverrides = false
+    automaticallyDeclareParametersFromOverrides = false,
+    startTypeDescriptionService = true
   ) {
     this._startParameterServices = startParameterServices;
     this._parameterOverrides = parameterOverrides;
     this._automaticallyDeclareParametersFromOverrides =
       automaticallyDeclareParametersFromOverrides;
+    this._startTypeDescriptionService = startTypeDescriptionService;
   }
 
   /**
@@ -105,6 +108,23 @@ class NodeOptions {
     this._automaticallyDeclareParametersFromOverrides = declareParamsFlag;
   }
 
+  /**
+   * Get the startTypeDescriptionService option, only available for ROS2 > Humble.
+   * Default value = true;
+   * @returns {boolean} - true if the type description service is enabled.
+   */
+  get startTypeDescriptionService() {
+    return this._startTypeDescriptionService;
+  }
+
+  /**
+   * Set startTypeDescriptionService, only available for ROS2 > Humble
+   * @param {boolean} willStartTypeDescriptionService
+   */
+  set startTypeDescriptionService(willStartTypeDescriptionService) {
+    this._startTypeDescriptionService = willStartTypeDescriptionService;
+  }
+
   /**
    * Return an instance configured with default options.
    * @returns {NodeOptions} - An instance with default values.

package/lib/publisher.js

@@ -24,8 +24,12 @@ const Entity = require('./entity.js');
  */
 
 class Publisher extends Entity {
-  constructor(handle, typeClass, topic, options) {
+  constructor(handle, typeClass, topic, options, node, eventCallbacks) {
     super(handle, typeClass, options);
+    if (node && eventCallbacks) {
+      this._events = eventCallbacks.createEventHandlers(this.handle);
+      node._events.push(...this._events);
+    }
   }
 
   /**
@@ -60,17 +64,24 @@ class Publisher extends Entity {
     debug(`Message of topic ${this.topic} has been published.`);
   }
 
-  static createPublisher(nodeHandle, typeClass, topic, options) {
+  static createPublisher(node, typeClass, topic, options, eventCallbacks) {
     let type = typeClass.type();
     let handle = rclnodejs.createPublisher(
-      nodeHandle,
+      node.handle,
       type.pkgName,
       type.subFolder,
       type.interfaceName,
       topic,
       options.qos
     );
-    return new Publisher(handle, typeClass, topic, options);
+    return new Publisher(
+      handle,
+      typeClass,
+      topic,
+      options,
+      node,
+      eventCallbacks
+    );
   }
 
   /**
@@ -80,6 +91,41 @@ class Publisher extends Entity {
   get subscriptionCount() {
     return rclnodejs.getSubscriptionCount(this._handle);
   }
+
+  /**
+   * Wait until all published message data is acknowledged or until the specified timeout elapses
+   *
+   * If the timeout is negative then this function will block indefinitely until all published
+   * message data is acknowledged.
+   * If the timeout is 0 then it will check if all published message has been acknowledged without
+   * waiting.
+   * If the timeout is greater than 0 then it will return after that period of time has elapsed or
+   * all published message data is acknowledged.
+   *
+   * Raises an error if failed, such as the middleware not supporting this feature.
+   *
+   * @param {timeout} timeout - The duration to wait for all published message data to be acknowledged in nanoseconds.
+   * @return {boolean} `true` if all published message data is acknowledged before the timeout, otherwise `false`.
+   */
+  waitForAllAcked(timeout) {
+    return rclnodejs.waitForAllAcked(this._handle, timeout);
+  }
+
+  /**
+   * Get the event handlers for this publisher.
+   * @returns {Array} The array of event handlers for this publisher.
+   */
+  get events() {
+    return this._events;
+  }
+
+  /**
+   * Set the event handlers for this publisher.
+   * @param {Array} events - The array of event handlers to be set for this publisher.
+   */
+  set events(events) {
+    this._events = events;
+  }
 }
 
 module.exports = Publisher;

package/lib/service.js

@@ -125,7 +125,7 @@ class Service extends Entity {
   configureIntrospection(clock, qos, introspectionState) {
     if (DistroUtils.getDistroId() <= DistroUtils.getDistroId('humble')) {
       console.warn(
-        'Service introspection is not supported by this versionof ROS 2'
+        'Service introspection is not supported by this version of ROS 2'
       );
       return;
     }

package/lib/subscription.js

@@ -29,11 +29,24 @@ const debug = require('debug')('rclnodejs:subscription');
  */
 
 class Subscription extends Entity {
-  constructor(handle, typeClass, topic, options, callback) {
+  constructor(
+    handle,
+    typeClass,
+    topic,
+    options,
+    callback,
+    node,
+    eventCallbacks
+  ) {
     super(handle, typeClass, options);
     this._topic = topic;
     this._callback = callback;
     this._isRaw = options.isRaw || false;
+
+    if (node && eventCallbacks) {
+      this._events = eventCallbacks.createEventHandlers(this.handle);
+      node._events.push(...this._events);
+    }
   }
 
   processResponse(msg) {
@@ -45,7 +58,14 @@ class Subscription extends Entity {
     }
   }
 
-  static createSubscription(nodeHandle, typeClass, topic, options, callback) {
+  static createSubscription(
+    node,
+    typeClass,
+    topic,
+    options,
+    callback,
+    eventCallbacks
+  ) {
     let type = typeClass.type();
 
     // convert contentFilter.parameters to a string[]
@@ -56,14 +76,22 @@ class Subscription extends Entity {
     }
 
     let handle = rclnodejs.createSubscription(
-      nodeHandle,
+      node.handle,
       type.pkgName,
       type.subFolder,
       type.interfaceName,
       topic,
       options
     );
-    return new Subscription(handle, typeClass, topic, options, callback);
+    return new Subscription(
+      handle,
+      typeClass,
+      topic,
+      options,
+      callback,
+      node,
+      eventCallbacks
+    );
   }
 
   /**
@@ -124,6 +152,22 @@ class Subscription extends Entity {
   get publisherCount() {
     return rclnodejs.getPublisherCount(this._handle);
   }
+
+  /**
+   * Get the event handlers for this subscription.
+   * @returns {Array} The array of event handlers for this subscription.
+   */
+  get events() {
+    return this._events;
+  }
+
+  /**
+   * Set the event handlers for this subscription.
+   * @param {Array} events - The array of event handlers for this subscription.
+   */
+  set events(events) {
+    this._events = events;
+  }
 }
 
 module.exports = Subscription;

package/lib/type_description_service.js

@@ -0,0 +1,82 @@
+// Copyright (c) 2025, The Robot Web Tools Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+const loader = require('./interface_loader.js');
+const rclnodejs = require('bindings')('rclnodejs');
+const Service = require('./service.js');
+
+// This class is used to create a TypeDescriptionService which can be used to
+// retrieve information about types used by the node’s publishers, subscribers,
+// services or actions.
+class TypeDescriptionService {
+  constructor(node) {
+    this._node = node;
+    this._serviceName = this._node.name() + '/get_type_description';
+    this._typeDescriptionServiceHandle = rclnodejs.initTypeDescriptionService(
+      this._node.handle
+    );
+    this._typeClass = loader.loadInterface(
+      'type_description_interfaces/srv/GetTypeDescription'
+    );
+    this._typeDescriptionService = null;
+  }
+
+  start() {
+    if (this._typeDescriptionService) {
+      return;
+    }
+
+    this._typeDescriptionService = new Service(
+      this._node.handle,
+      this._typeDescriptionServiceHandle,
+      this._serviceName,
+      this._typeClass,
+      this._node._validateOptions(undefined),
+      (request, response) => {
+        const responseToBeSent = new this._typeClass.Response();
+        const requestReceived = new this._typeClass.Request(request);
+        rclnodejs.handleRequest(
+          this._node.handle,
+          requestReceived.serialize(),
+          responseToBeSent.serialize()
+        );
+        responseToBeSent.deserialize(responseToBeSent.refObject);
+        rclnodejs.sendResponse(
+          this._typeDescriptionServiceHandle,
+          responseToBeSent.serialize(),
+          response._header
+        );
+        return null;
+      }
+    );
+    this._node._services.push(this._typeDescriptionService);
+    this._node.syncHandles();
+  }
+
+  /**
+   * Get the node this
+   * @return {Node} - The supported node.
+   */
+  get node() {
+    return this._node;
+  }
+
+  static toTypeHash(topicTypeHash) {
+    return `RIHS0${topicTypeHash.version}_${topicTypeHash.value.toString('hex')}`;
+  }
+}
+
+module.exports = TypeDescriptionService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",

package/scripts/npmjs-readme.md

@@ -1,4 +1,4 @@
-# rclnodejs ![GitHub Workflow Status](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-build-and-test.yml/badge.svg?branch=jazzy)
+# rclnodejs [![Linux](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-x64-build-and-test.yml/badge.svg?branch=develop)](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-x64-build-and-test.yml?query=branch%3Adevelop)[![Linux](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-arm64-build-and-test.yml/badge.svg?branch=develop)](https://github.com/RobotWebTools/rclnodejs/actions/workflows/linux-arm64-build-and-test.yml?query=branch%3Adevelop)
 
 `rclnodejs` is a Node.js client for the Robot Operating System (ROS 2). It provides a simple and easy JavaScript API for ROS 2 programming. TypeScript declarations are included to support use of rclnodejs in TypeScript projects.
 
@@ -22,8 +22,8 @@ rclnodejs.init().then(() => {
 
 **ROS 2 SDK**
 
-- See the ROS 2 SDK [Installation Guide](https://docs.ros.org/en/jazzy/Installation.html) for details.
-- **DON'T FORGET TO [SOURCE THE ROS 2 STARTUP FILES](https://docs.ros.org/en/jazzy/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.html#source-the-setup-files)**
+- See the ROS 2 SDK [Installation Guide](https://docs.ros.org/en/kilted/Installation.html) for details.
+- **DON'T FORGET TO [SOURCE THE ROS 2 STARTUP FILES](https://docs.ros.org/en/kilted/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.htmls)**
 
 ## Install rclnodejs
 
@@ -43,9 +43,9 @@ npm i rclnodejs@x.y.z
 
 #### RCLNODEJS - ROS 2 Version Compatibility
 
-|                                     RCLNODEJS Version                                      |                                                             Compatible ROS 2 LTS                                                             |
-| :----------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v1.0.0](https://github.com/RobotWebTools/rclnodejs/tree/1.0.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+|                                     RCLNODEJS Version                                      |                                                                                               Compatible ROS 2 LTS                                                                                               |
+| :----------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| latest version (currently [v1.2.0](https://github.com/RobotWebTools/rclnodejs/tree/1.2.0)) | [Kilted](https://github.com/RobotWebTools/rclnodejs/tree/kilted)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy)<br>[Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill) |
 
 ## Documentation
 

package/src/addon.cpp

@@ -34,6 +34,10 @@
 #include "rcl_subscription_bindings.h"
 #include "rcl_time_point_bindings.h"
 #include "rcl_timer_bindings.h"
+#if ROS_VERSION > 2205  // ROS2 > Humble
+#include "rcl_event_handle_bindings.h"
+#include "rcl_type_description_service_bindings.h"
+#endif
 #include "rcl_utilities.h"
 #include "shadow_node.h"
 
@@ -79,6 +83,10 @@ Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
   rclnodejs::InitSubscriptionBindings(env, exports);
   rclnodejs::InitTimePointBindings(env, exports);
   rclnodejs::InitTimerBindings(env, exports);
+#if ROS_VERSION > 2205  // ROS2 > Humble
+  rclnodejs::InitTypeDescriptionServiceBindings(env, exports);
+  rclnodejs::InitEventHandleBindings(env, exports);
+#endif
   rclnodejs::InitLifecycleBindings(env, exports);
   rclnodejs::ShadowNode::Init(env, exports);
   rclnodejs::RclHandle::Init(env, exports);

package/src/executor.cpp

@@ -190,10 +190,11 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
     size_t num_timers = 0u;
     size_t num_clients = 0u;
     size_t num_services = 0u;
+    size_t num_events = 0u;
 
     rcl_ret_t get_entity_ret = handle_manager_->GetEntityCounts(
         &num_subscriptions, &num_guard_conditions, &num_timers, &num_clients,
-        &num_services);
+        &num_services, &num_events);
     if (get_entity_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to get entity counts: ") +
                                   std::string(rcl_get_error_string().str);
@@ -202,9 +203,7 @@ RclResult Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
 
     rcl_ret_t resize_ret =
         rcl_wait_set_resize(wait_set, num_subscriptions, num_guard_conditions,
-                            num_timers, num_clients, num_services,
-                            // TODO(minggang): support events.
-                            0u);
+                            num_timers, num_clients, num_services, num_events);
     if (resize_ret != RCL_RET_OK) {
       std::string error_message = std::string("Failed to resize: ") +
                                   std::string(rcl_get_error_string().str);

package/src/handle_manager.cpp

@@ -40,7 +40,6 @@ HandleManager::~HandleManager() {
 
 void HandleManager::SynchronizeHandles(const Napi::Object& node) {
   Napi::HandleScope scope(node.Env());
-
   Napi::Value timers = node.Get("_timers");
   Napi::Value subscriptions = node.Get("_subscriptions");
   Napi::Value clients = node.Get("_clients");
@@ -48,6 +47,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
   Napi::Value guard_conditions = node.Get("_guards");
   Napi::Value action_clients = node.Get("_actionClients");
   Napi::Value action_servers = node.Get("_actionServers");
+  Napi::Value events = node.Get("_events");
 
   uint32_t sum = 0;
   is_synchronizing_.store(true);
@@ -66,6 +66,7 @@ void HandleManager::SynchronizeHandles(const Napi::Object& node) {
                                     &action_clients_);
     sum += SynchronizeHandlesByType(action_servers.As<Napi::Object>(),
                                     &action_servers_);
+    sum += SynchronizeHandlesByType(events.As<Napi::Object>(), &events_);
   }
   is_synchronizing_.store(false);
 
@@ -98,6 +99,7 @@ void HandleManager::ClearHandles() {
   guard_conditions_.clear();
   action_clients_.clear();
   action_servers_.clear();
+  events_.clear();
 }
 
 rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
@@ -152,6 +154,11 @@ rcl_ret_t HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
     if (ret != RCL_RET_OK) return ret;
   }
 
+  for (auto& event : events_) {
+    rcl_event_t* rcl_event = reinterpret_cast<rcl_event_t*>(event->ptr());
+    rcl_ret_t ret = rcl_wait_set_add_event(wait_set, rcl_event, nullptr);
+    if (ret != RCL_RET_OK) return ret;
+  }
   return RCL_RET_OK;
 }
 
@@ -169,6 +176,8 @@ rcl_ret_t HandleManager::CollectReadyHandles(rcl_wait_set_t* wait_set) {
   CollectReadyHandlesByType(wait_set->guard_conditions,
                             wait_set->size_of_guard_conditions,
                             guard_conditions_, &ready_handles);
+  CollectReadyHandlesByType(wait_set->events, wait_set->size_of_events, events_,
+                            &ready_handles);
 
   rcl_ret_t ret = CollectReadyActionHandles(wait_set, &ready_handles);
   if (!ready_handles.empty()) {
@@ -184,7 +193,8 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
                                          size_t* guard_conditions_size,
                                          size_t* timers_size,
                                          size_t* clients_size,
-                                         size_t* services_size) {
+                                         size_t* services_size,
+                                         size_t* events_size) {
   size_t num_subscriptions = 0u;
   size_t num_guard_conditions = 0u;
   size_t num_timers = 0u;
@@ -230,6 +240,7 @@ rcl_ret_t HandleManager::GetEntityCounts(size_t* subscriptions_size,
   *timers_size += timer_count();
   *clients_size += client_count();
   *services_size += service_count();
+  *events_size += event_count();
 
   return RCL_RET_OK;
 }