Source: lib/lifecycle_publisher.js

  1. // Copyright (c) 2020 Wayne Parrott. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. 'use strict';
  17. const rclnodejs = require('bindings')('rclnodejs');
  18. const Logging = require('./logging.js');
  19. const Publisher = require('./publisher.js');
  21. /**
  22.  * A publisher that sends messages only when activated.
  23.  * This implementation is based on the
  24.  * {@link https://github.com/ros2/rclcpp/blob/master/rclcpp_lifecycle/include/rclcpp_lifecycle/lifecycle_publisher.hpp|rclcpp LifecyclePublisher class}.
  25.  *
  26.  * @hideconstructor
  27.  */
  28. class LifecyclePublisher extends Publisher {
  29.   constructor(handle, typeClass, topic, options) {
  30.     super(handle, typeClass, options);
  32.     this._enabled = false;
  33.     this._loggger = Logging.getLogger('LifecyclePublisher');
  34.   }
  36.   /**
  37.    * Publish a message only when activated; otherwise do nothing (nop);
  38.    *
  39.    * @param {object|Buffer} message - The message to be sent, could be kind of JavaScript message generated from .msg
  40.    *                                                          or be a Buffer for a raw message.
  41.    * @returns {undefined}
  42.    */
  43.   publish(message) {
  44.     if (!this._enabled) {
  45.       this._loggger.warn(
  46.         `Trying to publish message on the topic ${this.topic}, but the publisher is not activated`
  47.       );
  49.       return;
  50.     }
  52.     return super.publish(message);
  53.   }
  55.   /**
  56.    * Enables communications; publish() will now send messages.
  57.    * @returns {unknown} Void return.
  58.    */
  59.   activate() {
  60.     this._enabled = true;
  61.   }
  63.   /**
  64.    * Disable communications; publish() will not send messages.
  65.    * @returns {unknown} Void return.
  66.    */
  67.   deactivate() {
  68.     this._enabled = false;
  69.   }
  71.   /**
  72.    * Determine if communications are enabled, i.e., activated, or
  73.    * disabled, i.e., deactivated.
  74.    * @returns {boolean} True if activated; otherwise false.
  75.    */
  76.   isActivated() {
  77.     return this._enabled;
  78.   }
  80.   /**
  81.    * A lifecycle-node activation notice.
  82.    * @returns {unknown} Void return.
  83.    */
  84.   onActivate() {
  85.     this.activate();
  86.   }
  88.   /**
  89.    * A lifecycle-node deactivation notice.
  90.    * @returns {unknown} Void return.
  91.    */
  92.   onDeactivate() {
  93.     this.deactivate();
  94.   }
  96.   static createPublisher(nodeHandle, typeClass, topic, options) {
  97.     let type = typeClass.type();
  98.     let handle = rclnodejs.createPublisher(
  99.       nodeHandle,
  100.       type.pkgName,
  101.       type.subFolder,
  102.       type.interfaceName,
  103.       topic,
  104.       options.qos
  105.     );
  107.     return new LifecyclePublisher(handle, typeClass, topic, options);
  108.   }
  109. }
  111. module.exports = LifecyclePublisher;