// 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. #include "rcl_time_point_bindings.h" #include #include #include #include "macros.h" #include "rcl_handle.h" #include "rcl_utilities.h" namespace rclnodejs { Napi::Value CreateTimePoint(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); if (!info[0].IsBigInt()) { Napi::TypeError::New(env, "Timer period must be a BigInt") .ThrowAsJavaScriptException(); return env.Undefined(); } bool lossless; int64_t nanoseconds = info[0].As().Int64Value(&lossless); uint32_t clock_type = info[1].As().Uint32Value(); rcl_time_point_t* time_point = reinterpret_cast(malloc(sizeof(rcl_time_point_t))); time_point->nanoseconds = nanoseconds; time_point->clock_type = static_cast(clock_type); auto js_obj = RclHandle::NewInstance(env, time_point, nullptr, [](void* ptr) { free(ptr); }); return js_obj; } Napi::Value GetNanoseconds(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* time_point_handle = RclHandle::Unwrap(info[0].As()); rcl_time_point_t* time_point = reinterpret_cast(time_point_handle->ptr()); return Napi::BigInt::New(env, time_point->nanoseconds); } Napi::Value CreateDuration(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); if (!info[0].IsBigInt()) { Napi::TypeError::New(env, "Timer period must be a BigInt") .ThrowAsJavaScriptException(); return env.Undefined(); } bool lossless; int64_t nanoseconds = info[0].As().Int64Value(&lossless); rcl_duration_t* duration = reinterpret_cast(malloc(sizeof(rcl_duration_t))); duration->nanoseconds = nanoseconds; auto js_obj = RclHandle::NewInstance(env, duration, nullptr, [](void* ptr) { free(ptr); }); return js_obj; } Napi::Value GetDurationNanoseconds(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* duration_handle = RclHandle::Unwrap(info[0].As()); rcl_duration_t* duration = reinterpret_cast(duration_handle->ptr()); return Napi::BigInt::New(env, duration->nanoseconds); } Napi::Value SetRosTimeOverrideIsEnabled(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* clock_handle = RclHandle::Unwrap(info[0].As()); rcl_clock_t* clock = reinterpret_cast(clock_handle->ptr()); bool enabled = info[1].As(); if (enabled) { THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_enable_ros_time_override(clock), rcl_get_error_string().str); } else { THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_disable_ros_time_override(clock), rcl_get_error_string().str); } return env.Undefined(); } Napi::Value SetRosTimeOverride(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* clock_handle = RclHandle::Unwrap(info[0].As()); rcl_clock_t* clock = reinterpret_cast(clock_handle->ptr()); RclHandle* time_point_handle = RclHandle::Unwrap(info[1].As()); rcl_time_point_t* time_point = reinterpret_cast(time_point_handle->ptr()); THROW_ERROR_IF_NOT_EQUAL( RCL_RET_OK, rcl_set_ros_time_override(clock, time_point->nanoseconds), rcl_get_error_string().str); return env.Undefined(); } Napi::Value GetRosTimeOverrideIsEnabled(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* clock_handle = RclHandle::Unwrap(info[0].As()); rcl_clock_t* clock = reinterpret_cast(clock_handle->ptr()); bool is_enabled; THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_is_enabled_ros_time_override(clock, &is_enabled), rcl_get_error_string().str); return Napi::Boolean::New(env, is_enabled); } Napi::Value CreateClock(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); auto clock_type = static_cast(info[0].As().Int32Value()); rcl_clock_t* clock = reinterpret_cast(malloc(sizeof(rcl_clock_t))); rcl_allocator_t allocator = rcl_get_default_allocator(); THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_clock_init(clock_type, clock, &allocator), rcl_get_error_string().str); return RclHandle::NewInstance(env, clock, nullptr, [env](void* ptr) { rcl_clock_t* clock = reinterpret_cast(ptr); rcl_ret_t ret = rcl_clock_fini(clock); free(ptr); THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret, rcl_get_error_string().str); }); } Napi::Value ClockGetNow(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); rcl_clock_t* clock = reinterpret_cast( RclHandle::Unwrap(info[0].As())->ptr()); rcl_time_point_t time_point; time_point.clock_type = clock->type; THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_clock_get_now(clock, &time_point.nanoseconds), rcl_get_error_string().str); return Napi::BigInt::New(env, time_point.nanoseconds); } struct JumpCallbackData { Napi::ThreadSafeFunction tsfn_pre; Napi::ThreadSafeFunction tsfn_post; }; struct JumpCallbackContext { rcl_time_jump_t time_jump; bool before_jump; }; void _rclnodejs_on_time_jump(const rcl_time_jump_t* time_jump, bool before_jump, void* user_data) { JumpCallbackData* data = static_cast(user_data); auto context = new JumpCallbackContext{*time_jump, before_jump}; if (before_jump) { auto callback = [](Napi::Env env, Napi::Function js_callback, JumpCallbackContext* context) { js_callback.Call({}); delete context; }; data->tsfn_pre.NonBlockingCall(context, callback); } else { auto callback = [](Napi::Env env, Napi::Function js_callback, JumpCallbackContext* context) { Napi::Object jump_info = Napi::Object::New(env); jump_info.Set("clock_change", static_cast(context->time_jump.clock_change)); jump_info.Set("delta", Napi::BigInt::New( env, context->time_jump.delta.nanoseconds)); js_callback.Call({jump_info}); delete context; }; data->tsfn_post.NonBlockingCall(context, callback); } } Napi::Value ClockAddJumpCallback(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* clock_handle = RclHandle::Unwrap(info[0].As()); rcl_clock_t* clock = reinterpret_cast(clock_handle->ptr()); Napi::Object callback_obj = info[1].As(); Napi::Function pre_callback = callback_obj.Get("_pre_callback").As(); Napi::Function post_callback = callback_obj.Get("_post_callback").As(); bool on_clock_change = info[2].As(); bool lossless; int64_t min_forward = info[3].As().Int64Value(&lossless); if (!lossless) { Napi::TypeError::New( env, "min_forward BigInt value cannot be represented as int64_t") .ThrowAsJavaScriptException(); return env.Undefined(); } int64_t min_backward = info[4].As().Int64Value(&lossless); if (!lossless) { Napi::TypeError::New( env, "min_backward BigInt value cannot be represented as int64_t") .ThrowAsJavaScriptException(); return env.Undefined(); } rcl_jump_threshold_t threshold; threshold.on_clock_change = on_clock_change; threshold.min_forward.nanoseconds = min_forward; threshold.min_backward.nanoseconds = min_backward; JumpCallbackData* data = new JumpCallbackData(); data->tsfn_pre = Napi::ThreadSafeFunction::New( env, pre_callback, "ClockJumpPreCallback", 10, 1, [](Napi::Env) {}); data->tsfn_post = Napi::ThreadSafeFunction::New(env, post_callback, "ClockJumpPostCallback", 10, 1, [data](Napi::Env) { delete data; }); Napi::Object handle_obj = Napi::Object::New(env); handle_obj.Set("_cpp_handle", Napi::External::New(env, data)); rcl_ret_t ret = rcl_clock_add_jump_callback(clock, threshold, _rclnodejs_on_time_jump, data); if (ret != RCL_RET_OK) { data->tsfn_pre.Release(); data->tsfn_post.Release(); THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str); } callback_obj.Set("_cpp_handle", handle_obj.Get("_cpp_handle")); return env.Undefined(); } Napi::Value ClockRemoveJumpCallback(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); RclHandle* clock_handle = RclHandle::Unwrap(info[0].As()); rcl_clock_t* clock = reinterpret_cast(clock_handle->ptr()); Napi::Object handle_obj = info[1].As(); Napi::Value cpp_handle = handle_obj.Get("_cpp_handle"); if (cpp_handle.IsUndefined() || !cpp_handle.IsExternal()) { Napi::Error::New(env, "Callback object was not registered or already removed") .ThrowAsJavaScriptException(); return env.Undefined(); } JumpCallbackData* data = cpp_handle.As>().Data(); rcl_ret_t ret = rcl_clock_remove_jump_callback(clock, _rclnodejs_on_time_jump, data); if (ret == RCL_RET_OK) { data->tsfn_pre.Release(); data->tsfn_post.Release(); handle_obj.Set("_cpp_handle", env.Undefined()); } else { THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str); } return env.Undefined(); } Napi::Object InitTimePointBindings(Napi::Env env, Napi::Object exports) { exports.Set("createClock", Napi::Function::New(env, CreateClock)); exports.Set("clockGetNow", Napi::Function::New(env, ClockGetNow)); exports.Set("clockAddJumpCallback", Napi::Function::New(env, ClockAddJumpCallback)); exports.Set("clockRemoveJumpCallback", Napi::Function::New(env, ClockRemoveJumpCallback)); exports.Set("createTimePoint", Napi::Function::New(env, CreateTimePoint)); exports.Set("getNanoseconds", Napi::Function::New(env, GetNanoseconds)); exports.Set("createDuration", Napi::Function::New(env, CreateDuration)); exports.Set("getDurationNanoseconds", Napi::Function::New(env, GetDurationNanoseconds)); exports.Set("setRosTimeOverrideIsEnabled", Napi::Function::New(env, SetRosTimeOverrideIsEnabled)); exports.Set("setRosTimeOverride", Napi::Function::New(env, SetRosTimeOverride)); exports.Set("getRosTimeOverrideIsEnabled", Napi::Function::New(env, GetRosTimeOverrideIsEnabled)); return exports; } } // namespace rclnodejs