@lynx-js/lynx-library-headers 0.0.1-alpha.4

package/include/lynx/platform/embedder/public/lynx_env.h

@@ -0,0 +1,104 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_ENV_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_ENV_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "capi/lynx_env_capi.h"
+#include "lynx_native_module.h"
+
+namespace lynx {
+namespace pub {
+
+class LynxEnv {
+ public:
+  static LynxEnv& GetInstance();
+  const char* GetVersion();
+  void SetICUDataPath(const char* icu_data_path);
+  const char* GetICUDataPath() const;
+
+  void SetDevtoolAppInfo(const char* name, const char* value);
+  void SetDevtoolEnabled(bool enable);
+  bool IsDevtoolEnabled();
+  bool ConnectDevtool(const char* url);
+  void SetOpenCardCallback(lynx_env_open_card_callback callback,
+                           void* user_data);
+  void SetLogboxEnabled(bool enable);
+  bool IsLogboxEnabled();
+  void RegisterNativeModule(const std::string& module_name,
+                            napi_module_creator creator, void* opaque);
+  void RegisterExtensionModule(const std::string& module_name,
+                               extension_module_creator creator,
+                               bool is_lazy_create, void* opaque);
+
+  LynxEnv(const LynxEnv&) = delete;
+  LynxEnv& operator=(const LynxEnv&) = delete;
+
+ private:
+  LynxEnv() = default;
+  ~LynxEnv() = default;
+};
+
+inline LynxEnv& LynxEnv::GetInstance() {
+  static LynxEnv instance;
+  return instance;
+}
+
+inline const char* LynxEnv::GetVersion() { return lynx_env_get_sdk_version(); }
+
+inline void LynxEnv::SetICUDataPath(const char* icu_data_path) {
+  lynx_env_set_icu_data_path(icu_data_path);
+}
+
+inline const char* LynxEnv::GetICUDataPath() const {
+  return lynx_env_get_icu_data_path();
+}
+
+inline void LynxEnv::SetDevtoolAppInfo(const char* name, const char* value) {
+  lynx_env_set_devtool_app_info(name, value);
+}
+
+inline void LynxEnv::SetDevtoolEnabled(bool enable) {
+  lynx_env_enable_devtool(enable);
+}
+
+inline bool LynxEnv::IsDevtoolEnabled() {
+  return lynx_env_is_devtool_enabled();
+}
+
+inline bool LynxEnv::ConnectDevtool(const char* url) {
+  return lynx_env_connect_devtool(url);
+}
+
+inline void LynxEnv::SetOpenCardCallback(lynx_env_open_card_callback callback,
+                                         void* user_data) {
+  lynx_env_set_open_card_callback(callback, user_data);
+}
+
+inline void LynxEnv::SetLogboxEnabled(bool enable) {
+  lynx_env_enable_logbox(enable);
+}
+
+inline bool LynxEnv::IsLogboxEnabled() { return lynx_env_is_logbox_enabled(); }
+
+inline void LynxEnv::RegisterNativeModule(const std::string& module_name,
+                                          napi_module_creator creator,
+                                          void* opaque) {
+  lynx_env_register_native_module(module_name.c_str(), creator, opaque);
+}
+
+inline void LynxEnv::RegisterExtensionModule(const std::string& module_name,
+                                             extension_module_creator creator,
+                                             bool is_lazy_create,
+                                             void* opaque) {
+  lynx_env_register_extension_module(module_name.c_str(), creator,
+                                     is_lazy_create, opaque);
+}
+
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_ENV_H_

package/include/lynx/platform/embedder/public/lynx_event_reporter_service.h

@@ -0,0 +1,96 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_REPORTER_SERVICE_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_REPORTER_SERVICE_H_
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "capi/lynx_event_reporter_service_capi.h"
+#include "capi/lynx_service_center_capi.h"
+#include "lynx/base/include/value/lynx_api_types.h"
+#include "lynx_service_center.h"
+
+namespace lynx {
+namespace pub {
+
+class LynxEventReporterService
+    : public LynxServiceBase,
+      public std::enable_shared_from_this<LynxEventReporterService> {
+ public:
+  LynxEventReporterService() = default;
+  ~LynxEventReporterService() = default;
+
+  void InitIfNeeded() override {
+    if (event_reporter_service_) {
+      return;
+    }
+    event_reporter_service_ = lynx_event_reporter_service_create_with_finalizer(
+        new std::weak_ptr<LynxEventReporterService>(weak_from_this()),
+        [](lynx_event_reporter_service_t* event_reporter_service,
+           void* user_data) {
+          std::weak_ptr<LynxEventReporterService>* weak_ptr =
+              reinterpret_cast<std::weak_ptr<LynxEventReporterService>*>(
+                  user_data);
+          delete weak_ptr;
+        });
+    lynx_event_reporter_service_bind(
+        event_reporter_service_,
+        [](lynx_event_reporter_service_t* event_reporter_service,
+           const char* event_name, const lynx_value& params) {
+          std::weak_ptr<LynxEventReporterService>* weak_ptr =
+              reinterpret_cast<std::weak_ptr<LynxEventReporterService>*>(
+                  lynx_event_reporter_service_get_user_data(
+                      event_reporter_service));
+          auto shared_event_reporter_service = weak_ptr->lock();
+          if (shared_event_reporter_service) {
+            shared_event_reporter_service->OnEvent(event_name, params);
+          }
+        });
+
+    lynx_event_reporter_service_bind_performance_report_func(
+        event_reporter_service_,
+        [](lynx_event_reporter_service_t* event_reporter_service,
+           const lynx_value& params) {
+          std::weak_ptr<LynxEventReporterService>* weak_ptr =
+              reinterpret_cast<std::weak_ptr<LynxEventReporterService>*>(
+                  lynx_event_reporter_service_get_user_data(
+                      event_reporter_service));
+          auto shared_event_reporter_service = weak_ptr->lock();
+          if (shared_event_reporter_service) {
+            shared_event_reporter_service->OnPerformanceEvent(params);
+          }
+        });
+  }
+
+  lynx_service_type_e GetServiceType() override {
+    return kServiceTypeEventReporter;
+  }
+
+  void* Impl() override { return event_reporter_service_; }
+
+  /**
+   * @brief Interface to receive reported events
+   * @param event_name Name of reported event
+   * @param props Content of reported event in key-value format
+   */
+  virtual void OnEvent(const std::string& event_name,
+                       const lynx_value& params) = 0;
+
+  /**
+   * @brief Interface to receive reported performance events
+   * @param params Content of reported event in key-value format
+   */
+  virtual void OnPerformanceEvent(const lynx_value& params) {}
+
+ private:
+  lynx_event_reporter_service_t* event_reporter_service_ = nullptr;
+};
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_REPORTER_SERVICE_H_

package/include/lynx/platform/embedder/public/lynx_event_simulation_proxy.h

@@ -0,0 +1,31 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_SIMULATION_PROXY_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_SIMULATION_PROXY_H_
+
+#include <string>
+
+namespace lynx {
+namespace pub {
+
+class LynxEventSimulationProxy {
+ public:
+  static constexpr const char* kMousePressed = "mousePressed";
+  static constexpr const char* kMouseMoved = "mouseMoved";
+  static constexpr const char* kMouseReleased = "mouseReleased";
+  static constexpr const char* kMouseWheel = "mouseWheel";
+  static constexpr const char* kMouseLeftButton = "left";
+  static constexpr const char* kMouseRightButton = "right";
+
+  virtual ~LynxEventSimulationProxy() = default;
+  virtual void EmulateTouch(const std::string& event_type, int x, int y,
+                            const std::string& button, float delta_x,
+                            float delta_y, int modifiers, int click_count) = 0;
+};
+
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_EVENT_SIMULATION_PROXY_H_