@mobrowser/native 2.0.0

package/README.md

@@ -0,0 +1 @@
+This package contains the configuration files for MōBrowser native integration.

package/cmake/MoBrowser.cmake

@@ -0,0 +1,80 @@
+message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+
+include(${PROJECT_ROOT_DIR}/node_modules/@mobrowser/native/cmake/Platform.cmake)
+
+# Configure project properties.
+set(TARGET_NAME "app")
+set(STATIC_LIB_NAME "mobrowser_lib")
+set(SHARED_LIB_NAME "mobrowser_client")
+set(DIST_DIR ${CMAKE_BINARY_DIR}/bin)
+
+# Configure SDK directory.
+if (OS_WIN)
+    set(MOBROWSER_SDK_DIR "${PROJECT_ROOT_DIR}/node_modules/@mobrowser/sdk-win-x64")
+elseif (OS_MAC)
+    set(MOBROWSER_SDK_DIR "${PROJECT_ROOT_DIR}/node_modules/@mobrowser/sdk-darwin-arm64")
+elseif (OS_LINUX)
+    set(MOBROWSER_SDK_DIR "${PROJECT_ROOT_DIR}/node_modules/@mobrowser/sdk-linux-x64")
+endif ()
+
+cmake_path(ABSOLUTE_PATH MOBROWSER_SDK_DIR NORMALIZE)
+message(STATUS "MOBROWSER_SDK_DIR: ${MOBROWSER_SDK_DIR}")
+set(MOBROWSER_SDK_NATIVE_DIR "${PROJECT_ROOT_DIR}/node_modules/@mobrowser/native")
+cmake_path(ABSOLUTE_PATH MOBROWSER_SDK_NATIVE_DIR NORMALIZE)
+
+if (MSVC)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    add_compile_options(/MP)
+    # Suppress Protobuf warnings
+    add_compile_options(
+        /wd4065 # switch statement contains 'default' but no 'case' labels
+        /wd4047 # 'operator' : 'identifier1' differs in levels of indirection from 'identifier2'
+        /wd4146 # unary minus operator applied to unsigned type
+        /wd4244 # 'conversion' conversion from 'type1' to 'type2', possible loss of data
+        /wd4251 # 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
+        /wd4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
+        /wd4305 # 'identifier' : truncation from 'type1' to 'type2'
+        /wd4307 # 'operator' : integral constant overflow
+        /wd4309 # 'conversion' : truncation of constant value
+        /wd4334 # 'operator' : result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
+        /wd4355 # 'this' : used in base member initializer list
+        /wd4506 # no definition for inline function 'function'
+        /wd4800 # 'type' : forcing value to bool 'true' or 'false' (performance warning)
+        /wd4996 # The compiler encountered a deprecated declaration.
+        /wd4715 # 'function' : not all control paths return a value
+        /wd5287 # operands are different enum types
+    )
+else ()
+    # Suppress Protobuf warnings for Clang/GCC
+    add_compile_options(
+        -Wno-deprecated-declarations
+    )
+endif ()
+
+# Suppress Protobuf linker warnings
+if (APPLE)
+    add_link_options("-Wl,-no_warn_duplicate_libraries")
+endif ()
+
+if (OS_LINUX)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif ()
+
+include(${PROJECT_ROOT_DIR}/node_modules/@mobrowser/native/cmake/Protobuf.cmake)
+
+# Create the shared library mobrowser_client with MoBrowser runtime
+add_library(${SHARED_LIB_NAME} SHARED
+        ${GENERATED_SOURCES}
+        ${MOBROWSER_SDK_NATIVE_DIR}/internal/rpc.cc
+        ${MOBROWSER_SDK_NATIVE_DIR}/internal/transport.cc)
+
+# Set up include paths for mobrowser_client
+target_include_directories(${SHARED_LIB_NAME} PRIVATE
+        ${protobuf_SOURCE_DIR}/src
+        ${absl_SOURCE_DIR}
+        ${PROJECT_SOURCE_DIR}/native/gen
+        ${MOBROWSER_SDK_NATIVE_DIR}/include
+        ${MOBROWSER_SDK_DIR}/include)
+
+# Link mobrowser_lib into mobrowser_client
+target_link_libraries(${SHARED_LIB_NAME} PRIVATE ${STATIC_LIB_NAME} libprotobuf)

package/cmake/Platform.cmake

@@ -0,0 +1,13 @@
+if (${CMAKE_SYSTEM_NAME} MATCHES Windows)
+    set(OS_WIN TRUE)
+    add_definitions(-DOS_WIN)
+elseif (${CMAKE_SYSTEM_NAME} MATCHES Linux)
+    set(OS_LINUX TRUE)
+    add_definitions(-DOS_LINUX)
+elseif (${CMAKE_SYSTEM_NAME} MATCHES Darwin)
+    set(OS_MAC TRUE)
+    add_definitions(-DOS_MAC)
+    # Set minimum macOS version to 12.0 for broader compatibility
+    # Use FORCE to ensure this overrides any cached value
+    set(CMAKE_OSX_DEPLOYMENT_TARGET "12.0" CACHE STRING "Minimum macOS deployment version" FORCE)
+endif ()

package/cmake/Protobuf.cmake

@@ -0,0 +1,121 @@
+include(FetchContent)
+
+set(FETCHCONTENT_QUIET OFF)
+set(BUILD_TESTING OFF)
+
+set(PROTOBUF_VERSION 33.2)
+
+if (NOT DEFINED PROTO_DIR)
+    file(REAL_PATH "${PROJECT_ROOT_DIR}/src/native/proto" PROTO_DIR)
+endif ()
+
+# Replace backslashes with forward slashes to fix path issue
+# when parsing the path with backslashes in CMake.
+string(REPLACE "\\" "/" PROTO_DIR "${PROTO_DIR}")
+
+message(STATUS "Proto dir: ${PROTO_DIR}")
+
+file(GLOB_RECURSE PROTO_FILES CONFIGURE_DEPENDS "${PROTO_DIR}/*.proto")
+
+# Ensure protobuf (and everything else) inherits the macOS deployment target
+if (APPLE)
+    if (NOT DEFINED CMAKE_OSX_DEPLOYMENT_TARGET)
+        set(CMAKE_OSX_DEPLOYMENT_TARGET "12.0" CACHE STRING "Minimum macOS deployment version")
+    endif ()
+endif ()
+
+# Verify C++17 or higher is set (required by Abseil).
+if (NOT DEFINED CMAKE_CXX_STANDARD OR CMAKE_CXX_STANDARD LESS 17)
+    message(FATAL_ERROR "CMAKE_CXX_STANDARD must be set to 17 or higher before including MoBrowser.cmake")
+endif ()
+
+# ##############################################################################
+# Protobuf (with automatic Abseil fetching)
+# ##############################################################################
+message(CHECK_START "Fetching Protobuf")
+list(APPEND CMAKE_MESSAGE_INDENT "  ")
+
+# Abseil options
+set(ABSL_USE_SYSTEM_INCLUDES      ON  CACHE BOOL "Use system includes for Abseil")
+set(ABSL_PROPAGATE_CXX_STD        ON  CACHE BOOL "Propagate C++ standard from consumers")
+set(ABSL_ENABLE_INSTALL           OFF CACHE BOOL "Enable install rules for Abseil")
+set(ABSL_BUILD_TESTING            OFF CACHE BOOL "Build Abseil tests")
+set(ABSL_BUILD_TEST_HELPERS       OFF CACHE BOOL "Build Abseil test helpers")
+set(ABSL_USE_EXTERNAL_GOOGLETEST  ON  CACHE BOOL "Use external GTest when needed")
+set(ABSL_FIND_GOOGLETEST          OFF CACHE BOOL "Let Abseil find GTest on its own")
+set(ABSL_MSVC_STATIC_RUNTIME      ON  CACHE BOOL "Use static runtime with MSVC")
+
+# Protobuf options
+set(protobuf_BUILD_TESTS              OFF CACHE BOOL "Do not build Protobuf tests")
+set(protobuf_BUILD_SHARED_LIBS        OFF CACHE BOOL "Build Protobuf as static libs")
+set(protobuf_BUILD_EXPORT             OFF CACHE BOOL "Do not export Protobuf CMake targets")
+set(protobuf_INSTALL                  OFF CACHE BOOL "Disable Protobuf install rules")
+set(protobuf_BUILD_LIBUPB             ON  CACHE BOOL "Build libupb for Protobuf")
+set(protobuf_MSVC_STATIC_RUNTIME      ON  CACHE BOOL "Use static runtime with MSVC")
+set(protobuf_FORCE_FETCH_DEPENDENCIES ON  CACHE BOOL "Let Protobuf fetch Abseil and utf8_range")
+set(utf8_range_ENABLE_INSTALL         OFF CACHE BOOL "Disable utf8_range install rules")
+
+FetchContent_Declare(
+        Protobuf
+        GIT_REPOSITORY "https://github.com/protocolbuffers/protobuf.git"
+        GIT_TAG        "v${PROTOBUF_VERSION}"
+        GIT_SHALLOW    TRUE
+)
+
+FetchContent_MakeAvailable(Protobuf)
+
+list(POP_BACK CMAKE_MESSAGE_INDENT)
+message(CHECK_PASS "fetched")
+
+# ##############################################################################
+# Protobuf code generation
+# ##############################################################################
+
+# Ensure output directory exists
+file(MAKE_DIRECTORY "${PROJECT_SOURCE_DIR}/src/native/gen")
+
+# Set proto paths for protoc command
+set(PROTOBUF_IMPORT_DIRS "${protobuf_SOURCE_DIR}/src" "${PROTO_DIR}")
+
+set(GENERATED_SOURCES)
+foreach (f IN LISTS PROTO_FILES)
+    # Get file name without extension: foo/bar/baz.proto -> baz
+    get_filename_component(proto_name "${f}" NAME_WE)
+
+    # Map proto path under .../proto/... to .../src/native/gen/...
+    # e.g.  <root>/proto/foo/bar/baz.proto -> <root>/src/native/gen/foo/bar/baz.pb.cc
+    string(REGEX REPLACE ".*/proto/" "${PROJECT_SOURCE_DIR}/src/native/gen/" base_path_with_ext "${f}")
+    # Remove the .proto extension from base_path
+    string(REGEX REPLACE "\\.proto$" "" base_path "${base_path_with_ext}")
+
+    set(msg_header "${base_path}.pb.h")
+    set(msg_source "${base_path}.pb.cc")
+    set(rpc_header "${base_path}.rpc.h")
+    set(rpc_source "${base_path}.rpc.cc")
+
+    list(APPEND GENERATED_SOURCES
+         "${msg_header}" "${msg_source}"
+         "${rpc_header}" "${rpc_source}")
+endforeach ()
+
+# Build protoc command arguments
+set(PROTOC_ARGS)
+foreach(dir ${PROTOBUF_IMPORT_DIRS})
+    list(APPEND PROTOC_ARGS --proto_path=${dir})
+endforeach()
+
+set(CC_NATIVEGEN_PLUGIN "${MOBROWSER_SDK_DIR}/bin/cc_nativegen${CMAKE_EXECUTABLE_SUFFIX}")
+
+add_custom_command(
+        OUTPUT ${GENERATED_SOURCES}
+        COMMAND $<TARGET_FILE:protoc>
+                ${PROTOC_ARGS}
+                --cpp_out=${PROJECT_SOURCE_DIR}/src/native/gen
+                --plugin=protoc-gen-rpc=${CC_NATIVEGEN_PLUGIN}
+                --rpc_out=${PROJECT_SOURCE_DIR}/src/native/gen
+                ${PROTO_FILES}
+        DEPENDS ${PROTO_FILES} protoc ${CC_NATIVEGEN_PLUGIN}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating C++ sources from .proto files"
+        VERBATIM
+)

package/include/callback.h

@@ -0,0 +1,152 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#ifndef MO_RPC_CALLBACK_H_
+#define MO_RPC_CALLBACK_H_
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <utility>
+
+#include "google/protobuf/message.h"
+
+namespace mo::rpc {
+
+template<class T>
+concept ProtobufMessageType = std::is_base_of<google::protobuf::Message, T>::value;
+
+// Type-erased callback handlers for RPC operations.
+// These work with serialized protobuf data and are independent of message type.
+using OnCompleteHandler = std::function<void(uint64_t id, const char* data, size_t size)>;
+using OnRejectHandler = std::function<void(uint64_t id, const char* error)>;
+
+// A move-only, one-shot RPC callback for completing or rejecting an
+// asynchronous operation.
+//
+// Thread Safety:
+//   - All public methods are thread-safe and may be called from any thread.
+//   - Only one of Complete(), Reject(), or auto-cancel will fire; subsequent
+//     calls are no-ops.
+//
+// Usage:
+//   std::move(callback).Complete(response);  // Success path
+//   std::move(callback).Reject("error");     // Failure path
+//   // Or let it destruct to auto-cancel
+//
+template <ProtobufMessageType T>
+class Callback {
+ public:
+  // Constructs a callback with the given completion and rejection handlers.
+  Callback(uint64_t id, OnCompleteHandler on_complete, OnRejectHandler on_reject)
+      : id_(id),
+        on_complete_(std::move(on_complete)),
+        on_reject_(std::move(on_reject)),
+        is_pending_(true),
+        mutex_(std::make_unique<std::mutex>()) {}
+
+  // Non-copyable.
+  Callback(const Callback&) = delete;
+  Callback& operator=(const Callback&) = delete;
+
+  // Move constructor. The source callback becomes inert (already handled).
+  Callback(Callback&& other) noexcept : mutex_(std::make_unique<std::mutex>()) {
+    std::lock_guard<std::mutex> lock(*other.mutex_);
+    id_ = other.id_;
+    on_complete_ = std::move(other.on_complete_);
+    on_reject_ = std::move(other.on_reject_);
+    is_pending_ = other.is_pending_;
+    other.is_pending_ = false;
+  }
+
+  // Move assignment. Auto-cancels any pending operation on this callback
+  // before taking ownership from the source.
+  Callback& operator=(Callback&& other) noexcept {
+    if (this != &other) {
+      AutoCancelIfPending();
+      std::lock_guard<std::mutex> lock(*other.mutex_);
+      id_ = other.id_;
+      on_complete_ = std::move(other.on_complete_);
+      on_reject_ = std::move(other.on_reject_);
+      is_pending_ = other.is_pending_;
+      other.is_pending_ = false;
+    }
+    return *this;
+  }
+
+  // Destructor. Auto-cancels if still pending.
+  ~Callback() { AutoCancelIfPending(); }
+
+  // Completes the callback successfully with the given response.
+  //
+  // This is a one-shot operation; if already handled (completed, rejected, or
+  // moved-from), this call is a no-op.
+  //
+  // Note: The `&&` qualifier indicates this consumes the callback. Use with
+  // std::move: `std::move(callback).Complete(response);`
+  void Complete(T response) && {
+    std::unique_lock<std::mutex> lock(*mutex_);
+    if (!is_pending_) {
+      return;
+    }
+    is_pending_ = false;
+    OnCompleteHandler handler = std::move(on_complete_);
+    on_reject_ = nullptr;
+    lock.unlock();
+    auto buffer = response.SerializeAsString();
+    handler(id_, buffer.data(), buffer.size());
+  }
+
+  // Rejects the callback with an error message.
+  //
+  // This is a one-shot operation; if already handled (completed, rejected, or
+  // moved-from), this call is a no-op.
+  //
+  // Note: The `&&` qualifier indicates this consumes the callback. Use with
+  // std::move: `std::move(callback).Reject("error message");`
+  void Reject(std::string error) && {
+    std::unique_lock<std::mutex> lock(*mutex_);
+    if (!is_pending_) {
+      return;
+    }
+    is_pending_ = false;
+    OnRejectHandler handler = std::move(on_reject_);
+    on_complete_ = nullptr;
+    lock.unlock();
+    handler(id_, error.c_str());
+  }
+
+ private:
+  // Auto-cancels the callback if still pending by invoking the rejection
+  // handler with a cancellation message.
+  void AutoCancelIfPending() {
+    std::unique_lock<std::mutex> lock(*mutex_);
+    if (!is_pending_ || !on_reject_) {
+      return;
+    }
+    is_pending_ = false;
+    OnRejectHandler handler = std::move(on_reject_);
+    on_complete_ = nullptr;
+    lock.unlock();
+    handler(id_, "RPC canceled: callback destroyed without completion.");
+  }
+
+  uint64_t id_;
+  OnCompleteHandler on_complete_;
+  OnRejectHandler on_reject_;
+
+  // True if neither Complete() nor Reject() has been called yet.
+  // Protected by mutex_.
+  bool is_pending_;
+
+  // Mutex protecting internal state.
+  // Stored as unique_ptr to ensure stable address across moves
+  std::unique_ptr<std::mutex> mutex_;
+};
+
+}  // namespace mo::rpc
+
+#endif  // MO_RPC_CALLBACK_H_

package/include/rpc.h

@@ -0,0 +1,14 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#ifndef MO_RPC_H_
+#define MO_RPC_H_
+
+#include "service.h"
+
+namespace mo::rpc {
+void RegisterService(Service* service);
+}
+
+#endif  // MO_RPC_H_

package/include/service.h

@@ -0,0 +1,98 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#ifndef MO_RPC_SERVICE_H_
+#define MO_RPC_SERVICE_H_
+
+#include <string>
+
+#include "callback.h"
+
+namespace google::protobuf {
+class ServiceDescriptor;
+class MethodDescriptor;
+class Message;
+}  // namespace google::protobuf
+
+namespace mo::rpc {
+
+// Abstract base class for all generated RPC services.
+//
+// This class defines the interface that all generated services must implement.
+// It allows for dynamic invocation of service methods through a generic
+// interface.
+class Service {
+ public:
+  inline Service() {}
+
+  Service(const Service&) = delete;
+  Service& operator=(const Service&) = delete;
+  virtual ~Service() = default;
+
+  // Returns the descriptor for this service.
+  //
+  // The ServiceDescriptor contains metadata about the service, including its
+  // name, the methods it implements, and their signatures. This is used for
+  // reflection and dynamic invocation.
+  //
+  // Returns:
+  //   A pointer to the ServiceDescriptor for this service. The returned pointer
+  //   is owned by the service and remains valid for the lifetime of the
+  //   service.
+  virtual const ::google::protobuf::ServiceDescriptor* GetDescriptor() = 0;
+
+  // Invokes an RPC method on this service.
+  //
+  // This is the core method for executing RPC calls. The implementation should:
+  //   1. Validate that the method belongs to this service
+  //   2. Downcast the generic Message to the specific request type
+  //   3. Execute the method logic
+  //   4. Complete the callback with the response or reject it with an error
+  //
+  // Parameters:
+  //   method - Descriptor of the method to invoke. Must be a method of this
+  //            service (obtained via GetDescriptor()).
+  //   request - The request message. Must be of the type expected by the method
+  //             (as specified by GetRequestPrototype()).
+  //   on_complete - Handler to invoke on successful completion with the
+  //                 serialized response data.
+  //   on_reject - Handler to invoke on failure with an error message.
+  virtual void CallMethod(const ::google::protobuf::MethodDescriptor* method,
+                          const ::google::protobuf::Message& request,
+                          uint64_t request_id,
+                          OnCompleteHandler on_complete,
+                          OnRejectHandler on_reject) = 0;
+
+  // Returns the prototype (default instance) for request messages of a method.
+  //
+  // This is used for message deserialization and reflection. The returned
+  // prototype can be cloned to create new request messages of the correct type.
+  //
+  // Parameters:
+  //   method - The method descriptor. Must be a method of this service.
+  //
+  // Returns:
+  //   A const reference to the prototype request message for this method.
+  //   The returned reference remains valid for the lifetime of the service.
+  virtual const ::google::protobuf::Message& GetRequestPrototype(
+      const ::google::protobuf::MethodDescriptor* method) const = 0;
+
+  // Returns the prototype (default instance) for response messages of a method.
+  //
+  // This is used for message deserialization and reflection. The returned
+  // prototype can be cloned to create new response messages of the correct type.
+  //
+  // Parameters:
+  //   method - The method descriptor. Must be a method of this service.
+  //
+  // Returns:
+  //   A const reference to the prototype response message for this method.
+  //   The returned reference remains valid for the lifetime of the service.
+  virtual const ::google::protobuf::Message& GetResponsePrototype(
+      const ::google::protobuf::MethodDescriptor* method) const = 0;
+};
+
+}  // namespace mo::rpc
+
+#endif  // MO_RPC_SERVICE_H_

package/internal/export.h

@@ -0,0 +1,14 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#ifndef MOBROWSER_EXPORT_H
+#define MOBROWSER_EXPORT_H
+
+#if defined(OS_WIN)
+#define MOBROWSER_EXPORT __declspec(dllexport)
+#else
+#define MOBROWSER_EXPORT __attribute__((visibility("default")))
+#endif
+
+#endif  // MOBROWSER_EXPORT_H

package/internal/rpc.cc

@@ -0,0 +1,20 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#include "../include/rpc.h"
+#include "transport.h"
+
+void launch();
+
+extern "C" {
+MOBROWSER_EXPORT void AppMain() {
+  launch();
+}
+}
+
+namespace mo::rpc {
+void RegisterService(Service* service) {
+  Transport::GetInstance()->RegisterService(service);
+}
+}  // namespace mo::rpc

package/internal/transport.cc

@@ -0,0 +1,66 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#include "transport.h"
+
+#include <shared_mutex>
+#include <vector>
+
+#include "../include/service.h"
+
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
+
+void invoke(uint64_t id,
+            const char* service_name,
+            const char* method_name,
+            const char* data,
+            size_t data_size,
+            reply_callback reply,
+            reject_callback reject) {
+  mo::rpc::Transport::GetInstance()->Invoke(id, service_name, method_name, data, data_size, reply, reject);
+}
+
+namespace mo::rpc {
+Transport::Transport() = default;
+Transport::~Transport() = default;
+
+Transport* Transport::GetInstance() {
+  static auto* instance = new Transport();
+  return instance;
+}
+
+void Transport::RegisterService(Service* service) {
+  std::unique_lock lock(mutex_);
+  services_.emplace(service->GetDescriptor()->full_name(), service);
+}
+
+void Transport::Invoke(uint64_t id,
+                       const char* service_name,
+                       const char* method_name,
+                       const char* data,
+                       size_t data_size,
+                       reply_callback reply,
+                       reject_callback reject) {
+  Service* service;
+  {
+    std::shared_lock lock(mutex_);
+    auto it = services_.find(service_name);
+    if (it == services_.end()) {
+      reject(id, "Service not found.");
+      return;
+    }
+    service = it->second;
+  }
+  auto method = service->GetDescriptor()->FindMethodByName(method_name);
+  if (!method) {
+    reject(id, "Method not found.");
+    return;
+  }
+  auto* request = service->GetRequestPrototype(method).New();
+  request->ParseFromArray(data, data_size);
+  service->CallMethod(method, *request, id, reply, reject);
+}
+}  // namespace mo::rpc

package/internal/transport.h

@@ -0,0 +1,52 @@
+// Copyright (c) 2000-2026 TeamDev. All rights reserved.
+// TeamDev PROPRIETARY and CONFIDENTIAL.
+// Use is subject to license terms.
+
+#ifndef MOBROWSER_TRANSPORT_H
+#define MOBROWSER_TRANSPORT_H
+
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include "export.h"
+
+extern "C" {
+typedef void (*reply_callback)(uint64_t id, const char* data, size_t data_size);
+typedef void (*reject_callback)(uint64_t id, const char* error);
+
+MOBROWSER_EXPORT void invoke(uint64_t id,
+                             const char* service_name,
+                             const char* method_name,
+                             const char* data,
+                             size_t data_size,
+                             reply_callback reply,
+                             reject_callback reject);
+}
+
+namespace mo::rpc {
+class Service;
+
+class Transport {
+ public:
+  Transport();
+  ~Transport();
+
+  static Transport* GetInstance();
+
+  void RegisterService(Service* service);
+
+  void Invoke(uint64_t id,
+              const char* service_name,
+              const char* method_name,
+              const char* data,
+              size_t data_size,
+              reply_callback reply,
+              reject_callback reject);
+
+ private:
+  std::shared_mutex mutex_;
+  std::unordered_map<std::string, Service*> services_;
+};
+}  // namespace mo::rpc
+
+#endif  // MOBROWSER_TRANSPORT_H

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@mobrowser/native",
+  "version": "2.0.0",
+  "description": "Configuration files for MōBrowser native integration",
+  "main": "cmake/MoBrowser.cmake",
+  "files": [
+    "cmake/MoBrowser.cmake",
+    "cmake/Platform.cmake",
+    "cmake/Protobuf.cmake",
+    "include",
+    "internal"
+  ],
+  "keywords": [
+    "mobrowser",
+    "native"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TeamDev-IP/MoBrowser.git"
+  },
+  "author": "TeamDev",
+  "license": "MŌBROWSER",
+  "bugs": {
+    "url": "https://github.com/TeamDev-IP/MoBrowser/issues"
+  },
+  "homepage": "https://teamdev.com/mobrowser"
+}