feat(dom): modify call function use dom_argument as argument

Tencent · Dec 23, 2021 · 2ac3aff · 2ac3aff
1 parent 0730e4d
commit 2ac3aff
Show file tree

Hide file tree

Showing 19 changed files with 67 additions and 23 deletions.
diff --git a/dom/include/dom/dom_argument.h b/dom/include/dom/dom_argument.h
@@ -1,4 +1,7 @@
+#pragma once
+
 #include <any>
+#include <utility>
 #include <vector>
 
 #include "dom/dom_value.h"
@@ -20,18 +23,21 @@ class DomArgument {
       : data_(std::make_any<tdf::base::DomValue>(dom_value)), argument_type_(ArgumentType::OBJECT){};
   DomArgument(const std::vector<uint8_t>& bson_value)
       : data_(std::make_any<std::vector<uint8_t>>(bson_value)), argument_type_(ArgumentType::BSON){};
+  DomArgument(const std::pair<uint8_t*, size_t>& bson_value)
+      : data_(std::make_any<std::vector<uint8_t>>(bson_value.first, bson_value.first + bson_value.second)),
+        argument_type_(ArgumentType::BSON){};
 
   ~DomArgument();
 
   DomArgument& operator=(const DomArgument& rhs) noexcept;
 
-  bool ToBson(std::vector<uint8_t>& bson);
-  bool ToObject(tdf::base::DomValue& dom_value);
+  bool ToBson(std::vector<uint8_t>& bson) const;
+  bool ToObject(tdf::base::DomValue& dom_value) const;
 
  private:
-  bool ConvertObjectToBson(const tdf::base::DomValue& dom_value, std::vector<uint8_t>& bson);
+  bool ConvertObjectToBson(const tdf::base::DomValue& dom_value, std::vector<uint8_t>& bson) const;
 
-  bool ConvertBsonToObject(const std::vector<const uint8_t>& bson, tdf::base::DomValue& dom_value);
+  bool ConvertBsonToObject(const std::vector<const uint8_t>& bson, tdf::base::DomValue& dom_value) const;
 
   std::any data_;
   ArgumentType argument_type_;

diff --git a/dom/include/dom/dom_manager.h b/dom/include/dom/dom_manager.h
@@ -11,6 +11,7 @@
 #include "dom/dom_listener.h"
 #include "dom/dom_value.h"
 #include "dom/layout_node.h"
+#include "dom/dom_argument.h"
 
 namespace hippy {
 inline namespace dom {
@@ -45,7 +46,7 @@ class DomManager {
                             const EventCallback &cb);
   void RemoveEventListener(uint32_t id, const std::string &name, bool use_capture);
   void CallFunction(uint32_t id, const std::string &name,
-                    const DomValue &param, const CallFunctionCallback &cb);
+                    const DomArgument &param, const CallFunctionCallback &cb);
   void AddListenerOperation(std::shared_ptr<DomNode> node, const std::string& name);
   std::tuple<float, float> GetRootSize();
   void SetRootSize(float width, float height);

diff --git a/dom/include/dom/dom_node.h b/dom/include/dom/dom_node.h
@@ -95,7 +95,7 @@ class DomNode : public std::enable_shared_from_this<DomNode> {
                            std::shared_ptr<DomValue>> &GetStyleMap() const { return style_map_; }
   void SetStyleMap(std::unordered_map<std::string, std::shared_ptr<DomValue>> style) { style_map_ = style; }
   void CallFunction(const std::string &name,
-                    const DomValue &param,
+                    const DomArgument &param,
                     const CallFunctionCallback &cb);
   const std::unordered_map<std::string,
                            std::shared_ptr<DomValue>> &GetExtStyle() { return dom_ext_map_; }

diff --git a/dom/include/dom/layer_optimized_render_manager.h b/dom/include/dom/layer_optimized_render_manager.h
@@ -20,7 +20,7 @@ class LayerOptimizedRenderManager : public RenderManager {
   void RemoveEventListener(std::weak_ptr<DomNode> dom_node, const std::string& name) override;
 
   void CallFunction(std::weak_ptr<DomNode> dom_node, const std::string& name,
-                        const DomValue& param,
+                        const DomArgument& param,
                         CallFunctionCallback cb) override;
 
  protected:

diff --git a/dom/include/dom/render_manager.h b/dom/include/dom/render_manager.h
@@ -6,6 +6,7 @@
 
 #include "dom/dom_listener.h"
 #include "dom/dom_value.h"
+#include "dom/dom_argument.h"
 #include "dom/dom_node.h"
 
 namespace hippy {
@@ -24,11 +25,11 @@ class RenderManager {
   virtual void MoveRenderNode(std::vector<int32_t>&& moved_ids, int32_t from_pid, int32_t to_pid) = 0;
   virtual void Batch() = 0;
 
-  using DomValue = tdf::base::DomValue;
+  using DomArgument = hippy::dom::DomArgument;
   virtual void AddEventListener(std::weak_ptr<DomNode> dom_node, const std::string& name) = 0;
   virtual void RemoveEventListener(std::weak_ptr<DomNode> dom_node, const std::string& name) = 0;
   virtual void CallFunction(std::weak_ptr<DomNode> dom_node, const std::string& name,
-                                const DomValue& param,
+                                const DomArgument& param,
                                 CallFunctionCallback cb) = 0;
 };
 

diff --git a/dom/src/dom/dom_argument.cc b/dom/src/dom/dom_argument.cc
@@ -13,7 +13,7 @@ DomArgument::DomArgument(const DomArgument& source) : data_(source.data_), argum
 
 DomArgument::~DomArgument() {}
 
-bool DomArgument::ToBson(std::vector<uint8_t>& bson) {
+bool DomArgument::ToBson(std::vector<uint8_t>& bson) const {
   if (argument_type_ == ArgumentType::OBJECT) {
     auto dom_value = std::any_cast<tdf::base::DomValue>(data_);
     return ConvertObjectToBson(dom_value, bson);
@@ -24,7 +24,7 @@ bool DomArgument::ToBson(std::vector<uint8_t>& bson) {
   return false;
 }
 
-bool DomArgument::ToObject(tdf::base::DomValue& dom_value) {
+bool DomArgument::ToObject(tdf::base::DomValue& dom_value) const {
   if (argument_type_ == ArgumentType::OBJECT) {
     dom_value = std::any_cast<tdf::base::DomValue>(data_);
     return true;
@@ -35,7 +35,7 @@ bool DomArgument::ToObject(tdf::base::DomValue& dom_value) {
   return false;
 }
 
-bool DomArgument::ConvertObjectToBson(const tdf::base::DomValue& dom_value, std::vector<uint8_t>& bson) {
+bool DomArgument::ConvertObjectToBson(const tdf::base::DomValue& dom_value, std::vector<uint8_t>& bson) const {
   tdf::base::Serializer serializer;
   serializer.WriteHeader();
 
@@ -92,7 +92,7 @@ bool DomArgument::ConvertObjectToBson(const tdf::base::DomValue& dom_value, std:
   return true;
 };
 
-bool DomArgument::ConvertBsonToObject(const std::vector<const uint8_t>& bson, tdf::base::DomValue& dom_value) {
+bool DomArgument::ConvertBsonToObject(const std::vector<const uint8_t>& bson, tdf::base::DomValue& dom_value) const {
   tdf::base::Deserializer deserializer(bson);
   deserializer.ReadHeader();
 
@@ -170,4 +170,4 @@ bool DomArgument::ConvertBsonToObject(const std::vector<const uint8_t>& bson, td
 };
 
 }  // namespace dom
-}  // namespace hippy
+}  // namespace hippy
diff --git a/dom/src/dom/dom_manager.cc b/dom/src/dom/dom_manager.cc
@@ -147,7 +147,7 @@ void DomManager::RemoveEventListener(uint32_t id, const std::string &name, bool
 }
 
 void DomManager::CallFunction(uint32_t id, const std::string &name,
-                              const DomValue &param,
+                              const DomArgument &param,
                               const CallFunctionCallback &cb) {
   auto node = dom_node_registry_.GetNode(id);
   if (node == nullptr) {

diff --git a/dom/src/dom/dom_node.cc b/dom/src/dom/dom_node.cc
@@ -237,7 +237,7 @@ void DomNode::TransferLayoutOutputsRecursive() {
   }
 }
 
-void DomNode::CallFunction(const std::string &name, const DomValue &param,
+void DomNode::CallFunction(const std::string &name, const DomArgument &param,
                            const CallFunctionCallback &cb) {
   if (!func_cb_map_) {
     func_cb_map_ = std::make_shared<std::unordered_map<std::string, CallFunctionCallback>>();

diff --git a/dom/src/dom/layer_optimized_render_manager.cc b/dom/src/dom/layer_optimized_render_manager.cc
@@ -101,7 +101,7 @@ void LayerOptimizedRenderManager::RemoveEventListener(std::weak_ptr<DomNode> dom
 
 void LayerOptimizedRenderManager::CallFunction(
         std::weak_ptr<DomNode> dom_node, const std::string &name,
-        const DomValue &param,
+        const DomArgument &param,
         CallFunctionCallback cb) {
   render_manager_->CallFunction(dom_node, name, param, cb);
 }

diff --git a/framework/js/core/include/core/napi/js_native_api_types.h b/framework/js/core/include/core/napi/js_native_api_types.h
@@ -31,6 +31,7 @@
 #include "core/base/common.h"
 #include "core/base/js_value_wrapper.h"
 #include "dom/dom_value.h"
+#include "dom/dom_argument.h"
 
 class Scope;
 
@@ -177,6 +178,8 @@ class Ctx {
 
   virtual std::shared_ptr<DomValue> ToDomValue(
       const std::shared_ptr<CtxValue>& value) = 0;
+  virtual std::shared_ptr<DomArgument> ToDomArgument(
+      const std::shared_ptr<CtxValue>& value) = 0;
   virtual std::shared_ptr<CtxValue> CreateCtxValue(
       const std::shared_ptr<DomValue>& value) = 0;
 };

diff --git a/framework/js/core/include/core/napi/jsc/js_native_api_jsc.h b/framework/js/core/include/core/napi/jsc/js_native_api_jsc.h
@@ -192,6 +192,8 @@ class JSCCtx : public Ctx {
 
   virtual std::shared_ptr<DomValue> ToDomValue(
       const std::shared_ptr<CtxValue>& value) override;
+  virtual std::shared_ptr<DomArgument> ToDomArgument(
+    const std::shared_ptr<CtxValue>& value) override;
   virtual std::shared_ptr<CtxValue> CreateCtxValue(
       const std::shared_ptr<DomValue>& value) override;
 

diff --git a/framework/js/core/include/core/napi/v8/js_native_api_v8.h b/framework/js/core/include/core/napi/v8/js_native_api_v8.h
@@ -226,6 +226,8 @@ class V8Ctx : public Ctx {
 
   virtual std::shared_ptr<DomValue> ToDomValue(
       const std::shared_ptr<CtxValue>& value) override;
+  virtual std::shared_ptr<DomArgument> ToDomArgument(
+      const std::shared_ptr<CtxValue>& value) override;
   virtual std::shared_ptr<CtxValue> CreateCtxValue(
       const std::shared_ptr<DomValue>& value) override;
 
@@ -246,6 +248,8 @@ class V8Ctx : public Ctx {
       const unicode_string_view& file_name,
       bool is_use_code_cache,
       unicode_string_view* cache);
+
+  std::string v8_reused_buffer_;
 };
 
 struct V8CtxValue : public CtxValue {

diff --git a/framework/js/core/src/modules/ui_manager_module.cc b/framework/js/core/src/modules/ui_manager_module.cc
@@ -30,6 +30,7 @@
 #include "dom/node_props.h"
 #include "dom/dom_node.h"
 #include "dom/dom_event.h"
+#include "dom/dom_argument.h"
 
 REGISTER_MODULE(UIManagerModule, CreateNodes)
 REGISTER_MODULE(UIManagerModule, UpdateNodes)
@@ -63,6 +64,7 @@ constexpr char kEventCBKey[] = "cb";
 const int32_t kInvalidValue = -1;
 
 using DomValue = tdf::base::DomValue;
+using DomArgument = hippy::dom::DomArgument;
 using unicode_string_view = tdf::base::unicode_string_view;
 
 using Ctx = hippy::napi::Ctx;
@@ -429,7 +431,7 @@ void UIManagerModule::CallUIFunction(const hippy::napi::CallbackInfo &info) {
   }
 
   std::unordered_map<std::string, std::shared_ptr<DomValue>> param;
-  DomValue param_value = *(context->ToDomValue(info[2]));
+  DomArgument param_value = *(context->ToDomArgument(info[2]));
   hippy::CallFunctionCallback cb;
   bool flag = context->IsFunction(info[3]);
   if (flag) {

diff --git a/framework/js/core/src/napi/jsc/js_native_api_jsc.cc b/framework/js/core/src/napi/jsc/js_native_api_jsc.cc
@@ -645,6 +645,15 @@ TDF_BASE_NOTIMPLEMENTED();
 return nullptr;
 }
 
+std::shared_ptr<DomArgument> JSCCtx::ToDomArgument(const std::shared_ptr<CtxValue>& value) {
+  //TODO 等待ios实现ocdomvalue
+  std::shared_ptr<DomValue> dom_value = ToDomValue(value);
+  if(dom_value != nullptr) {
+    return std::make_shared<DomArgument>(*dom_value);
+  }
+  return nullptr;
+}
+
 std::shared_ptr<CtxValue> JSCCtx::CreateCtxValue(const std::shared_ptr<DomValue>& wrapper) {
   if (!wrapper) {
     return nullptr;

diff --git a/framework/js/core/src/napi/v8/js_native_api_v8.cc b/framework/js/core/src/napi/v8/js_native_api_v8.cc
@@ -1194,6 +1194,19 @@ std::shared_ptr<DomValue> V8Ctx::ToDomValue(
   return nullptr;
 }
 
+std::shared_ptr<DomArgument> V8Ctx::ToDomArgument(
+    const std::shared_ptr<CtxValue>& value) {
+  v8::Local<v8::Context> context = context_persistent_.Get(isolate_);
+  std::shared_ptr<V8CtxValue> ctx_value = std::static_pointer_cast<V8CtxValue>(value);
+  const v8::Global<v8::Value>& global_value = ctx_value->global_value_;
+  v8::Local<v8::Value> handle_value = v8::Local<v8::Value>::New(isolate_, global_value);
+  Serializer serializer(isolate_, context, v8_reused_buffer_);
+  serializer.WriteHeader();
+  serializer.WriteValue(handle_value);
+  std::pair<uint8_t *, size_t> pair = serializer.Release();
+  return std::make_shared<DomArgument>(pair);
+}
+
 std::shared_ptr<CtxValue> V8Ctx::CreateCtxValue(
     const std::shared_ptr<JSValueWrapper>& wrapper) {
   TDF_BASE_DCHECK(wrapper);

diff --git a/ios/sdk/module/uimanager/NativeRenderManager.h b/ios/sdk/module/uimanager/NativeRenderManager.h
@@ -55,7 +55,7 @@ class NativeRenderManager : public hippy::RenderManager {
     void RemoveEventListener(std::weak_ptr<DomNode> dom_node, const std::string &name) override;
 
     void CallFunction(std::weak_ptr<DomNode> dom_node, const std::string &name,
-                      const DomValue& param,
+                      const DomArgument& param,
                       CallFunctionCallback cb) override;
 
 private:

diff --git a/ios/sdk/module/uimanager/NativeRenderManager.mm b/ios/sdk/module/uimanager/NativeRenderManager.mm
@@ -77,10 +77,13 @@
 }
 
 void NativeRenderManager::CallFunction(std::weak_ptr<DomNode> dom_node, const std::string &name,
-                                    const DomValue& param,
+                                    const DomArgument& param,
                                     CallFunctionCallback cb) {
     std::shared_ptr<DomNode> node = dom_node.lock();
     if (node) {
-        [uiManager_ dispatchFunction:name forView:node->GetId() params:param callback:cb];
+        //TODO 等待ios实现ocdomvalue
+        DomValue dom_value;
+        param.ToObject(dom_value);
+        [uiManager_ dispatchFunction:name forView:node->GetId() params:dom_value callback:cb];
     }
 }
diff --git a/renderer/native/android/src/main/jni/include/render/hippy_render_manager.h b/renderer/native/android/src/main/jni/include/render/hippy_render_manager.h
@@ -33,7 +33,7 @@ class HippyRenderManager : public RenderManager {
 
   void RemoveEventListener(std::weak_ptr<DomNode> dom_node, const std::string& name) override;
 
-  void CallFunction(std::weak_ptr<DomNode> dom_node, const std::string& name, const DomValue& param,
+  void CallFunction(std::weak_ptr<DomNode> dom_node, const std::string& name, const DomArgument& param,
                     CallFunctionCallback cb) override;
 
   void SetDensity(float density) { density_ = density; };

diff --git a/renderer/native/android/src/main/jni/src/render/hippy_render_manager.cc b/renderer/native/android/src/main/jni/src/render/hippy_render_manager.cc
@@ -204,7 +204,7 @@ void HippyRenderManager::RemoveEventListener(std::weak_ptr<DomNode> dom_node, co
   TDF_BASE_NOTIMPLEMENTED();
 }
 
-void HippyRenderManager::CallFunction(std::weak_ptr<DomNode> domNode, const std::string& name, const DomValue& param,
+void HippyRenderManager::CallFunction(std::weak_ptr<DomNode> domNode, const std::string& name, const DomArgument& param,
                                       CallFunctionCallback cb) {
   TDF_BASE_NOTIMPLEMENTED();
 };