@mobrowser/native 2.7.1 → 2.8.0

package/cmake/Protobuf.cmake

@@ -36,7 +36,7 @@ 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_USE_SYSTEM_INCLUDES      OFF CACHE BOOL "Treat Abseil headers as system includes (-isystem)")
 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")

package/include/rpc.h

@@ -2,13 +2,93 @@
 // TeamDev PROPRIETARY and CONFIDENTIAL.
 // Use is subject to license terms.
 
-#ifndef MO_RPC_H_
-#define MO_RPC_H_
+#ifndef NPM_TEMPLATES__MOBROWSER_NATIVE_INCLUDE_RPC_H_
+#define NPM_TEMPLATES__MOBROWSER_NATIVE_INCLUDE_RPC_H_
 
+#include <functional>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "google/protobuf/message.h"
 #include "service.h"
 
 namespace mo::rpc {
+
+template <class T>
+concept ResponseMessageType =
+    std::is_base_of<google::protobuf::Message, T>::value;
+
+struct SerializedResult {
+  bool ok;
+  std::string data;
+  std::string error;
+};
+
+template <ResponseMessageType T>
+class Result {
+ public:
+  static Result<T> Ok(T value) {
+    return Result<T>(std::move(value), std::string());
+  }
+
+  static Result<T> Error(std::string error) {
+    return Result<T>(std::nullopt, std::move(error));
+  }
+
+  bool ok() const { return value_.has_value(); }
+
+  const std::optional<T>& value() const { return value_; }
+
+  std::optional<T>& value() { return value_; }
+
+  const std::string& error() const { return error_; }
+
+ private:
+  Result(std::optional<T> value, std::string error)
+      : value_(std::move(value)), error_(std::move(error)) {}
+
+  std::optional<T> value_;
+  std::string error_;
+};
+
+template <ResponseMessageType T>
+using ResponseCallback = std::function<void(Result<T>)>;
+
 void RegisterService(Service* service);
+
+void RequestSerialized(const char* service_name,
+                       const char* method_name,
+                       const google::protobuf::Message& request,
+                       std::function<void(SerializedResult)> callback);
+
+template <ResponseMessageType RequestMessage,
+          ResponseMessageType ResponseMessage>
+void Request(const char* service_name,
+             const char* method_name,
+             const RequestMessage& request,
+             ResponseCallback<ResponseMessage> callback) {
+  RequestSerialized(
+      service_name,
+      method_name,
+      request,
+      [callback = std::move(callback)](SerializedResult result) mutable {
+        if (!result.ok) {
+          callback(Result<ResponseMessage>::Error(std::move(result.error)));
+          return;
+        }
+
+        ResponseMessage response;
+        if (!response.ParseFromString(result.data)) {
+          callback(
+              Result<ResponseMessage>::Error("Failed to parse RPC response."));
+          return;
+        }
+        callback(Result<ResponseMessage>::Ok(std::move(response)));
+      });
 }
 
-#endif  // MO_RPC_H_
+}  // namespace mo::rpc
+
+#endif  // NPM_TEMPLATES__MOBROWSER_NATIVE_INCLUDE_RPC_H_

package/internal/rpc.cc

@@ -17,4 +17,14 @@ namespace mo::rpc {
 void RegisterService(Service* service) {
   Transport::GetInstance()->RegisterService(service);
 }
+
+void RequestSerialized(const char* service_name,
+                       const char* method_name,
+                       const google::protobuf::Message& request,
+                       std::function<void(SerializedResult)> callback) {
+  Transport::GetInstance()->Request(service_name,
+                                    method_name,
+                                    request.SerializeAsString(),
+                                    std::move(callback));
+}
 }  // namespace mo::rpc

package/internal/transport.cc

@@ -5,6 +5,7 @@
 #include "transport.h"
 
 #include <shared_mutex>
+#include <utility>
 #include <vector>
 
 #include "../include/service.h"
@@ -20,7 +21,12 @@ void invoke(uint64_t id,
             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);
+  mo::rpc::Transport::GetInstance()
+      ->Invoke(id, service_name, method_name, data, data_size, reply, reject);
+}
+
+void set_host_invoke(host_invoke_callback invoke) {
+  mo::rpc::Transport::GetInstance()->SetHostInvoke(invoke);
 }
 
 namespace mo::rpc {
@@ -37,6 +43,11 @@ void Transport::RegisterService(Service* service) {
   services_.emplace(service->GetDescriptor()->full_name(), service);
 }
 
+void Transport::SetHostInvoke(host_invoke_callback invoke) {
+  std::lock_guard lock(host_mutex_);
+  host_invoke_ = invoke;
+}
+
 void Transport::Invoke(uint64_t id,
                        const char* service_name,
                        const char* method_name,
@@ -63,4 +74,76 @@ void Transport::Invoke(uint64_t id,
   request->ParseFromArray(data, data_size);
   service->CallMethod(method, *request, id, reply, reject);
 }
+
+void Transport::Request(std::string service_name,
+                        std::string method_name,
+                        std::string data,
+                        std::function<void(SerializedResult)> callback) {
+  host_invoke_callback host_invoke = nullptr;
+  uint64_t id = 0;
+  std::function<void(SerializedResult)> unavailable_callback;
+  {
+    std::lock_guard lock(host_mutex_);
+    host_invoke = host_invoke_;
+    if (!host_invoke) {
+      unavailable_callback = std::move(callback);
+    } else {
+      id = next_request_id_++;
+      pending_requests_.emplace(id, std::move(callback));
+    }
+  }
+
+  if (unavailable_callback) {
+    unavailable_callback(
+        {false, std::string(), "Native RPC host is not available."});
+    return;
+  }
+
+  host_invoke(
+      id,
+      service_name.c_str(),
+      method_name.c_str(),
+      data.data(),
+      data.size(),
+      [](uint64_t id, const char* data, size_t data_size) {
+        Transport::GetInstance()->OnHostReply(id, data, data_size);
+      },
+      [](uint64_t id, const char* error) {
+        Transport::GetInstance()->OnHostReject(id, error);
+      });
+}
+
+void Transport::OnHostReply(uint64_t id, const char* data, size_t data_size) {
+  std::function<void(SerializedResult)> callback;
+  {
+    std::lock_guard lock(host_mutex_);
+    auto it = pending_requests_.find(id);
+    if (it == pending_requests_.end()) {
+      return;
+    }
+    callback = std::move(it->second);
+    pending_requests_.erase(it);
+  }
+  callback({true,
+            data_size == 0 ? std::string() : std::string(data, data_size),
+            std::string()});
+}
+
+void Transport::OnHostReject(uint64_t id, const char* error) {
+  std::function<void(SerializedResult)> callback;
+  {
+    std::lock_guard lock(host_mutex_);
+    auto it = pending_requests_.find(id);
+    if (it == pending_requests_.end()) {
+      return;
+    }
+    callback = std::move(it->second);
+    pending_requests_.erase(it);
+  }
+  SerializedResult result;
+  result.ok = false;
+  result.data = std::string();
+  result.error = error ? std::string(error) : std::string();
+  callback(result);
+}
 }  // namespace mo::rpc

package/internal/transport.h

@@ -2,17 +2,27 @@
 // TeamDev PROPRIETARY and CONFIDENTIAL.
 // Use is subject to license terms.
 
-#ifndef MOBROWSER_TRANSPORT_H
-#define MOBROWSER_TRANSPORT_H
+#ifndef NPM_TEMPLATES__MOBROWSER_NATIVE_INTERNAL_TRANSPORT_H_
+#define NPM_TEMPLATES__MOBROWSER_NATIVE_INTERNAL_TRANSPORT_H_
 
+#include <functional>
+#include <mutex>
 #include <shared_mutex>
 #include <string>
 #include <unordered_map>
+#include "../include/rpc.h"
 #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);
+typedef void (*host_invoke_callback)(uint64_t id,
+                                     const char* service_name,
+                                     const char* method_name,
+                                     const char* data,
+                                     size_t data_size,
+                                     reply_callback reply,
+                                     reject_callback reject);
 
 MOBROWSER_EXPORT void invoke(uint64_t id,
                              const char* service_name,
@@ -21,6 +31,8 @@ MOBROWSER_EXPORT void invoke(uint64_t id,
                              size_t data_size,
                              reply_callback reply,
                              reject_callback reject);
+
+MOBROWSER_EXPORT void set_host_invoke(host_invoke_callback invoke);
 }
 
 namespace mo::rpc {
@@ -34,6 +46,7 @@ class Transport {
   static Transport* GetInstance();
 
   void RegisterService(Service* service);
+  void SetHostInvoke(host_invoke_callback invoke);
 
   void Invoke(uint64_t id,
               const char* service_name,
@@ -43,10 +56,23 @@ class Transport {
               reply_callback reply,
               reject_callback reject);
 
+  void Request(std::string service_name,
+               std::string method_name,
+               std::string data,
+               std::function<void(SerializedResult)> callback);
+
+  void OnHostReply(uint64_t id, const char* data, size_t data_size);
+  void OnHostReject(uint64_t id, const char* error);
+
  private:
   std::shared_mutex mutex_;
   std::unordered_map<std::string, Service*> services_;
+  std::mutex host_mutex_;
+  host_invoke_callback host_invoke_ = nullptr;
+  uint64_t next_request_id_ = 1;
+  std::unordered_map<uint64_t, std::function<void(SerializedResult)>>
+      pending_requests_;
 };
 }  // namespace mo::rpc
 
-#endif  // MOBROWSER_TRANSPORT_H
+#endif  // NPM_TEMPLATES__MOBROWSER_NATIVE_INTERNAL_TRANSPORT_H_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobrowser/native",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "Configuration files for MōBrowser native integration",
   "main": "cmake/MoBrowser.cmake",
   "files": [