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

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

@@ -0,0 +1,226 @@
+// 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_VIEW_CLIENT_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_VIEW_CLIENT_H_
+
+#include "capi/lynx_view_client_capi.h"
+
+namespace lynx {
+namespace pub {
+
+/**
+ * @apidoc
+ * @brief A client that provides callbacks for `LynxView`'s lifecycle and other
+ * events.
+ */
+class LynxViewClient {
+ public:
+  static LynxViewClient* Unwrap(lynx_view_client_t* client) {
+    return static_cast<LynxViewClient*>(lynx_view_client_get_user_data(client));
+  }
+
+  LynxViewClient() : client_(lynx_view_client_create(this)) {
+    // Bind callbacks to lynx_view_client_t.
+    lynx_view_client_bind_on_page_start(
+        client_, [](lynx_view_client_t* client, const char* url) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnPageStart(url);
+          }
+        });
+    lynx_view_client_bind_on_load_success(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnLoadSuccess();
+          }
+        });
+    lynx_view_client_bind_on_first_screen(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnFirstScreen();
+          }
+        });
+    lynx_view_client_bind_on_page_updated(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnPageUpdated();
+          }
+        });
+    lynx_view_client_bind_on_data_updated(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnDataUpdated();
+          }
+        });
+    lynx_view_client_bind_on_destroy(client_, [](lynx_view_client_t* client) {
+      auto* wrapper = LynxViewClient::Unwrap(client);
+      if (wrapper) {
+        wrapper->OnDestroy();
+      }
+    });
+    lynx_view_client_bind_on_runtime_ready(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnRuntimeReady();
+          }
+        });
+    lynx_view_client_bind_on_received_error(
+        client_,
+        [](lynx_view_client_t* client, int error_code, const char* message) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnReceivedError(error_code, message);
+          }
+        });
+    lynx_view_client_bind_on_timing_setup(
+        client_, [](lynx_view_client_t* client, const char* timing_info) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnTimingSetup(timing_info);
+          }
+        });
+    lynx_view_client_bind_on_timing_update(
+        client_, [](lynx_view_client_t* client, const char* timing_info,
+                    const char* update_timing, const char* update_flag) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnTimingUpdate(timing_info, update_timing, update_flag);
+          }
+        });
+    lynx_view_client_bind_on_enter_foreground(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnEnterForeground();
+          }
+        });
+    lynx_view_client_bind_on_enter_background(
+        client_, [](lynx_view_client_t* client) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnEnterBackground();
+          }
+        });
+    lynx_view_client_bind_on_frame_timing(
+        client_, [](lynx_view_client_t* client, int64_t frame_start_time_in_ns,
+                    int64_t frame_finish_time_in_ns) {
+          auto* wrapper = LynxViewClient::Unwrap(client);
+          if (wrapper) {
+            wrapper->OnFrameTiming(frame_start_time_in_ns,
+                                   frame_finish_time_in_ns);
+          }
+        });
+  }
+  virtual ~LynxViewClient() { lynx_view_client_release(client_); }
+
+  /**
+   * @apidoc
+   * @brief Called when page start loading.
+   * @param url The page URL
+   */
+  virtual void OnPageStart(const char* url) {}
+
+  /**
+   * @apidoc
+   * @brief Called when page load finish.
+   */
+  virtual void OnLoadSuccess() {}
+
+  /**
+   * @apidoc
+   * @brief Called when first screen layout completed.
+   */
+  virtual void OnFirstScreen() {}
+
+  /**
+   * @apidoc
+   * @brief Called when page update.
+   */
+  virtual void OnPageUpdated() {}
+
+  /**
+   * @apidoc
+   * @brief Called when data update, but the view may not be updated.
+   */
+  virtual void OnDataUpdated() {}
+
+  /**
+   * @apidoc
+   * @brief Called after the page is destroyed.
+   * @note The callback executed in the main thread.
+   */
+  virtual void OnDestroy() {}
+
+  /**
+   * @apidoc
+   * @brief Called when JS environment preparation completed.
+   * @note The callback is in an asynchronous thread.
+   */
+  virtual void OnRuntimeReady() {}
+
+  /**
+   * @apidoc
+   * @brief Called when error received.
+   * @param error_code The type of the error.
+   * @param message The error message.
+   */
+  virtual void OnReceivedError(int error_code, const char* message) {}
+
+  /**
+   * @apidoc
+   * @brief Called when timing setup.
+   * @param timing_info The timing info.
+   */
+  virtual void OnTimingSetup(const char* timing_info) {}
+
+  /**
+   * @apidoc
+   * @brief Called when timing update.
+   * @param timing_info The timing info.
+   * @param update_timing The update timing.
+   * @param update_flag The update flag.
+   */
+  virtual void OnTimingUpdate(const char* timing_info,
+                              const char* update_timing,
+                              const char* update_flag) {}
+
+  /**
+   * @apidoc
+   * @brief Called when the view enters the foreground.
+   */
+  virtual void OnEnterForeground() {}
+
+  /**
+   * @apidoc
+   * @brief Called when the view enters the background.
+   */
+  virtual void OnEnterBackground() {}
+
+  /**
+   * @apidoc
+   * @brief Called when frame timing is received.
+   * @param frame_start_time_in_ns The frame start time in ns.
+   * @param frame_finish_time_in_ns The frame finish time in ns.
+   */
+  virtual void OnFrameTiming(int64_t frame_start_time_in_ns,
+                             int64_t frame_finish_time_in_ns) {}
+
+  lynx_view_client_t* Impl() { return client_; }
+
+  LynxViewClient(const LynxViewClient&) = delete;
+  LynxViewClient& operator=(const LynxViewClient&) = delete;
+
+ private:
+  lynx_view_client_t* client_;
+};
+
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_VIEW_CLIENT_H_

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

@@ -0,0 +1,70 @@
+// 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_VSYNC_MONITOR_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_VSYNC_MONITOR_H_
+
+#include <functional>
+#include <memory>
+
+#include "capi/lynx_vsync_monitor_capi.h"
+
+namespace lynx {
+namespace pub {
+class LynxVSyncMonitor : public std::enable_shared_from_this<LynxVSyncMonitor> {
+ public:
+  explicit LynxVSyncMonitor(lynx_vsync_monitor_t* c_monitor)
+      : c_monitor_(c_monitor) {}
+  virtual ~LynxVSyncMonitor() = default;
+  /**
+   * @apidoc
+   * @brief Synchronize a Vsync signal
+   * @param callback OnVsync signal callback.
+   */
+  virtual void RequestVSync(std::function<void(int64_t, int64_t)> callback) = 0;
+
+  lynx_vsync_monitor_t* GetCMonitor() { return c_monitor_; }
+
+  void InitIfNeed() {
+    if (c_monitor_) {
+      return;
+    }
+    c_monitor_ = lynx_vsync_monitor_create_with_finalizer(
+        new std::weak_ptr<LynxVSyncMonitor>(weak_from_this()),
+        [](lynx_vsync_monitor_t* monitor, void* user_data) {
+          std::weak_ptr<LynxVSyncMonitor>* weak_ptr =
+              reinterpret_cast<std::weak_ptr<LynxVSyncMonitor>*>(user_data);
+          delete weak_ptr;
+        });
+    BindFunction();
+  }
+
+ private:
+  void BindFunction() {
+    lynx_vsync_monitor_bind_request_vsync_func(
+        c_monitor_,
+        [](lynx_vsync_monitor_t* c_monitor,
+           lynx_vsync_monitor_on_vsync_callback callback, void* user_data) {
+          auto* weak_monitor =
+              reinterpret_cast<std::weak_ptr<LynxVSyncMonitor>*>(
+                  lynx_vsync_monitor_get_user_data(c_monitor));
+          std::shared_ptr<LynxVSyncMonitor> shared_monitor =
+              weak_monitor ? weak_monitor->lock() : nullptr;
+          if (!shared_monitor) {
+            return;
+          }
+          shared_monitor->RequestVSync(
+              [callback, user_data](int64_t frame_start_time,
+                                    int64_t frame_target_time) {
+                callback(user_data, frame_start_time, frame_target_time);
+              });
+        });
+  }
+
+  lynx_vsync_monitor_t* c_monitor_ = nullptr;
+};
+
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_VSYNC_MONITOR_H_

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

@@ -0,0 +1,302 @@
+// 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_WINDOWLESS_RENDERER_H_
+#define PLATFORM_EMBEDDER_PUBLIC_LYNX_WINDOWLESS_RENDERER_H_
+
+#include <cstdbool>
+#include <memory>
+
+#include "capi/lynx_types.h"
+#include "capi/lynx_windowless_renderer_capi.h"
+
+namespace lynx {
+namespace pub {
+
+class LynxWindowlessRenderer
+    : public std::enable_shared_from_this<LynxWindowlessRenderer> {
+ public:
+  explicit LynxWindowlessRenderer(lynx_windowless_renderer_type_e type)
+      : type_(type) {}
+
+  void InitIfNeeded() {
+    if (windowless_renderer_) {
+      return;
+    }
+    windowless_renderer_ = lynx_windowless_renderer_create_with_finalizer(
+        type_, new std::weak_ptr<LynxWindowlessRenderer>(weak_from_this()),
+        [](lynx_windowless_renderer_t* renderer, void* user_data) {
+          std::weak_ptr<LynxWindowlessRenderer>* weak_ptr =
+              reinterpret_cast<std::weak_ptr<LynxWindowlessRenderer>*>(
+                  user_data);
+          delete weak_ptr;
+        });
+    if (type_ == kRendererTypeSoftware) {
+      lynx_windowless_renderer_bind_on_software_present(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer, const void* allocation,
+             size_t row_bytes, size_t height) -> bool {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnSoftwarePresent(allocation, row_bytes,
+                                                         height);
+            }
+            return false;
+          });
+    } else if (type_ == kRendererTypeGL || type_ == kRendererTypeGLDirect) {
+      lynx_windowless_renderer_bind_on_gl_make_current(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer) -> bool {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnGLMakeCurrent();
+            }
+            return false;
+          });
+      lynx_windowless_renderer_bind_on_gl_clear_current(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer) -> bool {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnGLClearCurrent();
+            }
+            return false;
+          });
+
+      lynx_windowless_renderer_bind_on_gl_present(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer) -> bool {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnGLPresent();
+            }
+            return false;
+          });
+      lynx_windowless_renderer_bind_on_gl_create_fbo(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer, int width,
+             int height) -> uint32_t {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnGLCreateFBO(width, height);
+            }
+            return 0;
+          });
+      lynx_windowless_renderer_bind_on_gl_proc_resolver(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer, const char* name) -> void* {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnGLProcResolver(name);
+            }
+            return nullptr;
+          });
+    } else if (type_ == kRendererTypeAccelerated) {
+      lynx_windowless_renderer_bind_on_accelerated_present(
+          windowless_renderer_,
+          [](lynx_windowless_renderer_t* renderer) -> bool {
+            std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+                LynxWindowlessRenderer::Unwrap(
+                    lynx_windowless_renderer_get_user_data(renderer));
+            if (renderer_wrapper) {
+              return renderer_wrapper->OnAcceleratedPresent();
+            }
+            return false;
+          });
+    }
+
+    lynx_windowless_renderer_bind_on_post_task(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, lynx_task_t task,
+           uint64_t interval_nanoseconds) {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->OnPostTask(task, interval_nanoseconds);
+          }
+        });
+    lynx_windowless_renderer_bind_get_clipboard_data(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer) -> const char* {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            return renderer_wrapper->GetClipboardData();
+          }
+          return "";
+        });
+    lynx_windowless_renderer_bind_set_clipboard_data(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, const char* data) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->SetClipboardData(data);
+          }
+        });
+    lynx_windowless_renderer_bind_activate_system_cursor(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, lynx_cursor_type_e cursor_type,
+           const char* path) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->ActivateSystemCursor(cursor_type, path);
+          }
+        });
+    lynx_windowless_renderer_bind_show_text_input(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, bool show) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->ShowTextInput(show);
+          }
+        });
+    lynx_windowless_renderer_bind_update_caret_position(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, float x, float y, float w,
+           float h) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->UpdateCaretPosition(x, y, w, h);
+          }
+        });
+    lynx_windowless_renderer_bind_set_cursor_position(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, int position) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->SetCursorPosition(position);
+          }
+        });
+    lynx_windowless_renderer_bind_set_marked_text_rect(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer, float x, float y, float w,
+           float h) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->SetMarkedTextRect(x, y, w, h);
+          }
+        });
+    lynx_windowless_renderer_bind_set_editable_transform(
+        windowless_renderer_,
+        [](lynx_windowless_renderer_t* renderer,
+           const float transform[16]) -> void {
+          std::shared_ptr<LynxWindowlessRenderer> renderer_wrapper =
+              LynxWindowlessRenderer::Unwrap(
+                  lynx_windowless_renderer_get_user_data(renderer));
+          if (renderer_wrapper) {
+            renderer_wrapper->SetEditableTransform(transform);
+          }
+        });
+  }
+
+  virtual ~LynxWindowlessRenderer() {
+    if (windowless_renderer_) {
+      lynx_windowless_renderer_release(windowless_renderer_);
+    }
+  }
+
+  /* ----- Callbacks for Software renderer type ----- */
+  virtual bool OnSoftwarePresent(const void* allocation, size_t row_bytes,
+                                 size_t height) {
+    return false;
+  }
+  /* ----- Callbacks for Software renderer type ----- */
+
+  /* ----- Callbacks for GL renderer type ----- */
+  virtual bool OnGLMakeCurrent() { return false; }
+  virtual bool OnGLClearCurrent() { return false; }
+  virtual bool OnGLPresent() { return false; }
+  virtual uint32_t OnGLCreateFBO(int width, int height) { return 0; }
+  virtual void* OnGLProcResolver(const char* name) { return nullptr; }
+  /* ----- Callbacks for GL renderer type ----- */
+
+  /* ----- Callbacks for shared texture renderer type ----- */
+  virtual bool OnAcceleratedPresent() { return false; }
+  /* ----- Callbacks for shared texture renderer type ----- */
+
+  virtual void OnPostTask(lynx_task_t task, uint64_t interval_nanoseconds) {}
+
+  void RunTask(lynx_task_t task) {
+    if (windowless_renderer_) {
+      lynx_windowless_renderer_run_task(windowless_renderer_, task);
+    }
+  }
+
+  bool GetAcceleratedPaintInfo(lynx_accelerated_paint_info_t* paint_info) {
+    if (windowless_renderer_) {
+      return lynx_windowless_renderer_get_accelerated_paint_info(
+          windowless_renderer_, paint_info);
+    }
+    return false;
+  }
+
+  void SendPointerEvent(lynx_pointer_event_t* event) {
+    if (windowless_renderer_) {
+      lynx_windowless_renderer_send_pointer_event(windowless_renderer_, event);
+    }
+  }
+
+  void SendKeyEvent(lynx_key_event_t* event) {
+    if (windowless_renderer_) {
+      lynx_windowless_renderer_send_key_event(windowless_renderer_, event);
+    }
+  }
+
+  /* ----- Callbacks for platform function ----- */
+  virtual const char* GetClipboardData() { return ""; }
+  virtual void SetClipboardData(const char* data) {}
+  virtual void ActivateSystemCursor(lynx_cursor_type_e cursor_type,
+                                    const char* path) {}
+  virtual void ShowTextInput(bool show) {}
+  virtual void UpdateCaretPosition(float x, float y, float width,
+                                   float height) {}
+  virtual void SetCursorPosition(int position) {}
+  virtual void SetMarkedTextRect(float x, float y, float width, float height) {}
+  virtual void SetEditableTransform(const float transform[16]) {}
+  /* ----- Callbacks for platform function ----- */
+
+  lynx_windowless_renderer_t* Impl() { return windowless_renderer_; }
+
+  static std::shared_ptr<LynxWindowlessRenderer> Unwrap(void* user_data) {
+    std::weak_ptr<LynxWindowlessRenderer>* weak_ptr =
+        reinterpret_cast<std::weak_ptr<LynxWindowlessRenderer>*>(user_data);
+    std::shared_ptr<LynxWindowlessRenderer> shared_renderer =
+        weak_ptr ? weak_ptr->lock() : nullptr;
+    return shared_renderer;
+  }
+
+ protected:
+  lynx_windowless_renderer_type_e type_;
+  lynx_windowless_renderer_t* windowless_renderer_ = nullptr;
+};
+
+}  // namespace pub
+}  // namespace lynx
+
+#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_WINDOWLESS_RENDERER_H_