Cleanup

Author: minggangw

lib/action/server.js

@@ -130,6 +130,7 @@ class ActionServer extends Entity {
       this.qos.statusSubQosProfile,
       this.options.resultTimeout
     );
+
     node._addActionServer(this);
   }
 

lib/logging.js

@@ -47,17 +47,17 @@ class Caller {
 
     const stackLines = new Error().stack.split('\n');
 
-    // Adjust the index (usually 3 or 4) to correctly point to the caller frame
+    // Adjust the index (usually 3 or 4) to correctly point to the caller frame.
     const callerFrame = stackLines[4] || stackLines[3];
-    // Match both named and anonymous function stack frames
+    // Match both named and anonymous function stack frames.
     const frameRegex = /^\s*at\s+(?:(.+)\s+\()?(.+):(\d+):(\d+)\)?$/;
     const match = callerFrame.match(frameRegex);
     if (match && match.length === 5) {
       this._info.functionName = match[1] || '(anonymous)';
       this._info.fileName = path.basename(match[2]);
       this._info.lineNumber = match[3];
     } else {
-      // Handle anonymous functions or different stack formats
+      // Handle anonymous functions or different stack formats.
       const altMatch = callerFrame.match(/at\s+(.*):(\d+):(\d+)/i);
       if (altMatch && altMatch.length >= 4) {
         this._info.functionName = '(anonymous)';

package.json

@@ -81,7 +81,7 @@
     "json-bigint": "^1.0.0",
     "terser": "^5.39.0",
     "walk": "^2.3.15",
-    "node-addon-api": "^5.0.0"
+    "node-addon-api": "^8.3.1"
   },
   "husky": {
     "hooks": {

src/addon.cpp

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <napi.h>
 #include <node_api.h>
 
 #include "macros.hpp"
@@ -31,10 +30,6 @@ bool IsRunningInElectronRenderer(const Napi::Env& env) {
   return processType.StrictEquals(Napi::String::New(env, "renderer"));
 }
 
-void Cleanup(Napi::Env env, void* data) {
-  rclnodejs::RclHandle::CleanupThreadSafeFunction();
-}
-
 Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
 // workaround process name mangling by chromium
 //
@@ -52,36 +47,18 @@ Napi::Object InitModule(Napi::Env env, Napi::Object exports) {
   }
 #endif
   rclnodejs::StoreEnv(env);
-  // for (uint32_t i = 0; i < rclnodejs::binding_methods.size(); i++) {
-  //   exports.Set(rclnodejs::binding_methods[i].name,
-  //               Napi::Function::New(env,
-  //               rclnodejs::binding_methods[i].function));
-  // }
   rclnodejs::InitBindings(env, exports);
-  // for (uint32_t i = 0; i < rclnodejs::action_binding_methods.size(); i++) {
-  //   exports.Set(rclnodejs::action_binding_methods[i].name,
-  //               Napi::Function::New(env,
-  //               rclnodejs::action_binding_methods[i].function));
-  // }
   rclnodejs::InitAction(env, exports);
-
-  for (uint32_t i = 0; i < rclnodejs::lifecycle_binding_methods.size(); i++) {
-    exports.Set(rclnodejs::lifecycle_binding_methods[i].name,
-                Napi::Function::New(
-                    env, rclnodejs::lifecycle_binding_methods[i].function));
-  }
-
+  rclnodejs::InitLifecycle(env, exports);
   rclnodejs::ShadowNode::Init(env, exports);
   rclnodejs::RclHandle::Init(env, exports);
-  // Initialize thread-safe function
-  // rclnodejs::RclHandle::InitThreadSafeFunction(env);
+
 #ifdef DEBUG_ON
   int result = rcutils_logging_set_logger_level(PACKAGE_NAME,
                                                 RCUTILS_LOG_SEVERITY_DEBUG);
   RCUTILS_UNUSED(result);
 #endif
-  // Register cleanup handler
-  // env.SetInstanceData<void>(nullptr, Cleanup);
+
   return exports;
 }
 

src/handle_manager.cpp

@@ -300,24 +300,15 @@ rcl_ret_t HandleManager::CollectReadyActionHandles(
     if (ret != RCL_RET_OK) {
       return ret;
     }
-    if (is_feedback_ready) {
-      action_client->SetBoolProperty("isFeedbackReady", is_feedback_ready);
-    }
-    if (is_status_ready) {
-      action_client->SetBoolProperty("isStatusReady", is_status_ready);
-    }
-    if (is_goal_response_ready) {
-      action_client->SetBoolProperty("isGoalResponseReady",
-                                     is_goal_response_ready);
-    }
-    if (is_cancel_response_ready) {
-      action_client->SetBoolProperty("isCancelResponseReady",
-                                     is_cancel_response_ready);
-    }
-    if (is_result_response_ready) {
-      action_client->SetBoolProperty("isResultResponseReady",
-                                     is_result_response_ready);
-    }
+
+    action_client->SetBoolProperty("isFeedbackReady", is_feedback_ready);
+    action_client->SetBoolProperty("isStatusReady", is_status_ready);
+    action_client->SetBoolProperty("isGoalResponseReady",
+                                   is_goal_response_ready);
+    action_client->SetBoolProperty("isCancelResponseReady",
+                                   is_cancel_response_ready);
+    action_client->SetBoolProperty("isResultResponseReady",
+                                   is_result_response_ready);
 
     if (is_feedback_ready || is_status_ready || is_goal_response_ready ||
         is_cancel_response_ready || is_result_response_ready) {
@@ -339,21 +330,13 @@ rcl_ret_t HandleManager::CollectReadyActionHandles(
     if (ret != RCL_RET_OK) {
       return ret;
     }
-    if (is_goal_request_ready) {
-      action_server->SetBoolProperty("isGoalRequestReady",
-                                     is_goal_request_ready);
-    }
-    if (is_cancel_request_ready) {
-      action_server->SetBoolProperty("isCancelRequestReady",
-                                     is_cancel_request_ready);
-    }
-    if (is_result_request_ready) {
-      action_server->SetBoolProperty("isResultRequestReady",
-                                     is_result_request_ready);
-    }
-    if (is_goal_expired) {
-      action_server->SetBoolProperty("isGoalExpired", is_goal_expired);
-    }
+
+    action_server->SetBoolProperty("isGoalRequestReady", is_goal_request_ready);
+    action_server->SetBoolProperty("isCancelRequestReady",
+                                   is_cancel_request_ready);
+    action_server->SetBoolProperty("isResultRequestReady",
+                                   is_result_request_ready);
+    action_server->SetBoolProperty("isGoalExpired", is_goal_expired);
 
     if (is_goal_request_ready || is_cancel_request_ready ||
         is_result_request_ready || is_goal_expired) {

src/rcl_action_bindings.hpp

@@ -18,7 +18,6 @@
 #include <napi.h>
 #include <rcl/rcl.h>
 
-#include <utility>
 #include <vector>
 
 #include "rcl_bindings.hpp"

src/rcl_bindings.cpp

@@ -14,8 +14,8 @@
 
 #include "rcl_bindings.hpp"
 
+#include <napi.h>
 #include <node.h>
-#include <node_buffer.h>
 #include <rcl/arguments.h>
 #include <rcl/error_handling.h>
 #include <rcl/expand_topic_name.h>
@@ -33,7 +33,6 @@
 #include <rmw/validate_namespace.h>
 #include <rmw/validate_node_name.h>
 
-#include "v8.h"
 #if ROS_VERSION >= 2006
 #include <rosidl_runtime_c/string_functions.h>
 #else
@@ -53,8 +52,6 @@
 #include <utility>
 #endif
 
-#include <napi.h>
-
 #include "handle_manager.hpp"
 #include "macros.hpp"
 #include "rcl_handle.hpp"

src/rcl_bindings.hpp

@@ -39,16 +39,8 @@ void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
 
 std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(Napi::Value qos);
 
-extern std::vector<BindingMethod> binding_methods;
-
 Napi::Object InitBindings(Napi::Env env, Napi::Object exports);
 
-// Initialize the environment
-void InitEnvironment(Napi::Env env);
-
-// Get the current environment
-Napi::Env GetEnvironment();
-
 }  // namespace rclnodejs
 
 #endif  // SRC_RCL_BINDINGS_HPP_

src/rcl_handle.cpp

@@ -25,16 +25,11 @@ namespace rclnodejs {
 
 Napi::FunctionReference RclHandle::constructor;
 
-// Define the static ThreadSafeFunction
-Napi::ThreadSafeFunction RclHandle::tsfn_;
-
 RclHandle::RclHandle(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<RclHandle>(info), pointer_(nullptr), parent_(nullptr) {}
 
 RclHandle::~RclHandle() {
   if (pointer_) Reset();
-
-  // tsfn_.Release();
 }
 
 Napi::Object RclHandle::Init(Napi::Env env, Napi::Object exports) {
@@ -54,39 +49,15 @@ Napi::Object RclHandle::Init(Napi::Env env, Napi::Object exports) {
 }
 
 void RclHandle::SyncProperties() {
-  // Napi::Env env = Env();
   Napi::Env env = rclnodejs::GetEnv();
-  // if (env.IsNull()) return;
-  // std::cout << "===before SyncProperties" << std::endl;
-
   Napi::HandleScope scope(env);
-  // std::cout << "====after SyncProperties" << std::endl;
   Napi::Object obj = Napi::Object::New(env);
-  // std::cout << "after====after SyncProperties" << std::endl;
-
   for (auto& pair : properties_) {
     obj.Set(pair.first, Napi::Boolean::New(env, pair.second));
   }
-
   properties_obj_ = Napi::Persistent(obj);
 }
 
-// void RclHandle::SetBoolProperty(const std::string& name, bool value) {
-//   // properties_[name] = value;
-//   // SyncProperties();
-//   std::lock_guard<std::mutex> lock(property_mutex_);
-
-//   // Allocate a new update object
-//   PropertyUpdate* update = new PropertyUpdate{name, value};
-
-//   // Queue the update to be executed on the main thread
-//   napi_status status = tsfn_.BlockingCall(update);
-//   if (status != napi_ok) {
-//     delete update;  // Clean up if failed
-//     // Handle error appropriately (log or handle internally)
-//   }
-// }
-
 Napi::Value RclHandle::PropertiesGetter(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 

src/rcl_handle.hpp

@@ -14,15 +14,14 @@
 
 #ifndef SRC_RCL_HANDLE_HPP_
 #define SRC_RCL_HANDLE_HPP_
+
 #include <napi.h>
 
 #include <functional>
-#include <iostream>
 #include <map>
-#include <mutex>
 #include <set>
 #include <string>
-#include <vector>
+
 namespace rclnodejs {
 
 class RclHandle : public Napi::ObjectWrap<RclHandle> {
@@ -43,7 +42,6 @@ class RclHandle : public Napi::ObjectWrap<RclHandle> {
   void Reset();
   void AddChild(RclHandle* child) { children_.insert(child); }
   void RemoveChild(RclHandle* child) { children_.erase(child); }
-  // void SetBoolProperty(const std::string& name, bool value);
   void SyncProperties();
 
   explicit RclHandle(const Napi::CallbackInfo& info);
@@ -57,88 +55,9 @@ class RclHandle : public Napi::ObjectWrap<RclHandle> {
   // Property getter
   Napi::Value PropertiesGetter(const Napi::CallbackInfo& info);
 
-  // Store property updates to be applied later
-  struct PropertyUpdate {
-    std::string name;
-    bool value;
-  };
-
-  std::mutex property_mutex_;
-  std::vector<PropertyUpdate> pending_property_updates_;
-
-  // ThreadSafeFunction to process updates on main thread
-  static Napi::ThreadSafeFunction tsfn_;
-
-  // Thread-safe version to queue property updates
-  //   void SetBoolProperty(const std::string& name, bool value) {
-
-  //     std::lock_guard<std::mutex> lock(property_mutex_);
-  //     pending_property_updates_.push_back({name, value});
-  //     if (tsfn_) {
-  //         // Queue work to be processed on main thread
-  //         tsfn_.BlockingCall(this, []( Napi::Env env, Napi::Function
-  //         jsCallback, RclHandle* handle) {
-  //           std::cout << "====ProcessPropertyUpdates" << std::endl;
-  //           handle->ProcessPropertyUpdates();
-  //         });
-  //         // napi_status status = tsfn_.BlockingCall(this, [](Napi::Env env,
-  //         Napi::Function jsCallback, RclHandle* handle) {
-  //         //   std::cout << "====SetBoolProperty" << std::endl;
-  //         // });
-  //         // if ( status != napi_ok )
-  //         // {
-  //         //   std::cout << "===ERRRRRRRRRRRRRrr" << std::endl;
-  //         // }
-  //     }
-  // }
   void SetBoolProperty(const std::string& name, bool value) {
     properties_[name] = value;
   }
-  // Process pending property updates on main thread
-  void ProcessPropertyUpdates() {
-    std::vector<PropertyUpdate> updates;
-    {
-      std::lock_guard<std::mutex> lock(property_mutex_);
-      updates.swap(pending_property_updates_);
-    }
-
-    Napi::Env env = Env();  // Get env from ObjectWrap
-    for (const auto& update : updates) {
-      if (!properties_obj_.IsEmpty()) {
-        Napi::Object props = properties_obj_.Value().As<Napi::Object>();
-        props.Set(update.name, Napi::Boolean::New(env, update.value));
-      }
-    }
-  }
-
-  // Initialize thread-safe function
-  static void InitThreadSafeFunction(Napi::Env env) {
-    if (!tsfn_) {
-      // std::cout << "====InitThreadSafeFunction" << std::endl;
-      tsfn_ = Napi::ThreadSafeFunction::New(
-          env,
-          Napi::Function::New(env,
-                              [](const Napi::CallbackInfo& info) {
-                                // This runs on the main thread
-                                // Napi::Env env = info.Env();
-                                // RclHandle* handle =
-                                // RclHandle::Unwrap(info[0].As<Napi::Object>());
-                                // handle->ProcessPropertyUpdates();
-                                // std::cout << "====ProcessPropertyUpdates" <<
-                                // std::endl;
-                              }),
-          "SetBoolProperty",
-          0,   // Max queue size (0 = unlimited)
-          1);  // Number of threads to use);
-    }
-  }
-
-  // Finalize the thread-safe function
-  static void CleanupThreadSafeFunction() {
-    if (tsfn_) {
-      tsfn_.Release();
-    }
-  }
 
  private:
   void* pointer_;