[messageport] Refactor the C++ code (#526)

Signed-off-by: Boram Bae <[email protected]>

Author: bbrto21

packages/messageport/CHANGELOG.md

@@ -1,3 +1,7 @@
+## Next
+
+* Refactor the C++ code.
+
 ## 0.2.0
 
 * Deprecate `TizenMessagePort.createLocalPort` and `TizenMessagePort.connectToRemotePort`

packages/messageport/tizen/src/messageport.cc

@@ -5,234 +5,168 @@
 #include "messageport.h"
 
 #include <bundle.h>
-#include <flutter/standard_message_codec.h>
 
 #include <cstdint>
 #include <vector>
 
 #include "log.h"
 
-MessagePortManager::MessagePortManager() {}
-
-MessagePortManager::~MessagePortManager() {
-  for (const auto& [port, sink] : sinks_) {
-    int ret;
-    bool is_trusted = trusted_ports_.find(port) != trusted_ports_.end();
-    if (is_trusted) {
-      ret = message_port_unregister_trusted_local_port(port);
-    } else {
-      ret = message_port_unregister_local_port(port);
-    }
-    if (MESSAGE_PORT_ERROR_NONE != ret) {
-      LOG_ERROR("Failed to unregister port: %s", get_error_message(ret));
-    }
+void LocalPort::OnMessageReceived(int local_port_id, const char* remote_app_id,
+                                  const char* remote_port,
+                                  bool trusted_remote_port, bundle* bundle,
+                                  void* user_data) {
+  LocalPort* self = static_cast<LocalPort*>(user_data);
+  uint8_t* byte_array = nullptr;
+  size_t size = 0;
+  int ret = bundle_get_byte(bundle, "bytes",
+                            reinterpret_cast<void**>(&byte_array), &size);
+  if (ret != BUNDLE_ERROR_NONE) {
+    Message message{
+      error : "Failed to get data from bundle",
+    };
+    self->message_callback_(message);
+  } else if (remote_port) {
+    Message message{
+      remote_port :
+          RemotePort{remote_app_id ? remote_app_id : "",
+                     remote_port ? remote_port : "", trusted_remote_port},
+      encoded_message : std::vector<uint8_t>(byte_array, byte_array + size)
+    };
+    self->message_callback_(message);
+  } else {
+    Message message{
+      encoded_message : std::vector<uint8_t>(byte_array, byte_array + size)
+    };
+    self->message_callback_(message);
   }
 }
 
-static bool ConvertEncodableValueToBundle(flutter::EncodableValue& value,
-                                          bundle* bundle) {
-  if (!bundle) {
-    LOG_ERROR("Invalid bundle handle");
-    return false;
+LocalPort::~LocalPort() {
+  if (port_ != -1) {
+    Unregister();
   }
-  std::unique_ptr<std::vector<uint8_t>> encoded =
-      flutter::StandardMessageCodec::GetInstance().EncodeMessage(value);
-
-  int ret = bundle_add_byte(bundle, "bytes", encoded->data(), encoded->size());
-  if (BUNDLE_ERROR_NONE != ret) {
-    return false;
-  }
-  return true;
 }
 
-void MessagePortManager::OnMessageReceived(int local_port_id,
-                                           const char* remote_app_id,
-                                           const char* remote_port,
-                                           bool trusted_remote_port,
-                                           bundle* message, void* user_data) {
-  LOG_DEBUG(
-      "OnMessageReceived, local_port_id: %d, remote_app_id: %s, "
-      "remote_port: %s, trusted: %s",
-      local_port_id, remote_app_id, remote_port,
-      trusted_remote_port ? "yes" : "no");
-
-  MessagePortManager* manager = static_cast<MessagePortManager*>(user_data);
-
-  if (manager->sinks_.find(local_port_id) != manager->sinks_.end()) {
-    uint8_t* byte_array = NULL;
-    size_t size = 0;
-
-    int ret = bundle_get_byte(message, "bytes", (void**)&byte_array, &size);
-    if (ret != BUNDLE_ERROR_NONE) {
-      manager->sinks_[local_port_id]->Error("Failed to parse a response");
-    }
-
-    std::vector<uint8_t> encoded(byte_array, byte_array + size);
-
-    auto value =
-        flutter::StandardMessageCodec::GetInstance().DecodeMessage(encoded);
-
-    flutter::EncodableMap map;
-    map[flutter::EncodableValue("message")] = *(value.get());
-    if (remote_port) {
-      map[flutter::EncodableValue("remotePort")] =
-          flutter::EncodableValue(std::string(remote_port));
-    }
-    map[flutter::EncodableValue("remoteAppId")] =
-        flutter::EncodableValue(remote_app_id);
-
-    map[flutter::EncodableValue("trusted")] =
-        flutter::EncodableValue(trusted_remote_port);
-
-    manager->sinks_[local_port_id]->Success(flutter::EncodableValue(map));
-  }
-}
-
-MessagePortResult MessagePortManager::RegisterLocalPort(
-    const std::string& port_name, EventSink sink, bool is_trusted,
-    int* local_port) {
-  LOG_DEBUG("RegisterLocalPort: %s, is_trusted: %s", port_name.c_str(),
-            is_trusted ? "yes" : "no");
+std::optional<MessagePortError> LocalPort::Register(
+    OnMessage message_callback) {
   int ret = -1;
-  if (is_trusted) {
-    ret = message_port_register_trusted_local_port(port_name.c_str(),
+  if (is_trusted_) {
+    ret = message_port_register_trusted_local_port(name_.c_str(),
                                                    OnMessageReceived, this);
+    if (ret < MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
+    }
+    port_ = ret;
   } else {
-    ret = message_port_register_local_port(port_name.c_str(), OnMessageReceived,
+    ret = message_port_register_local_port(name_.c_str(), OnMessageReceived,
                                            this);
+    if (ret < MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
+    }
+    port_ = ret;
   }
 
-  if (ret < 0) {
-    return CreateResult(ret);
-  }
-
-  *local_port = ret;
-  LOG_DEBUG("Successfully opened local %s port, native id: %d",
-            port_name.c_str(), *local_port);
-
-  sinks_[*local_port] = std::move(sink);
-
-  if (is_trusted) {
-    trusted_ports_.insert(*local_port);
-  }
-
-  return CreateResult(MESSAGE_PORT_ERROR_NONE);
+  message_callback_ = std::move(message_callback);
+  return std::nullopt;
 }
 
-MessagePortResult MessagePortManager::UnregisterLocalPort(int local_port_id) {
-  LOG_DEBUG("UnregisterLocalPort: %d", local_port_id);
-  bool is_trusted = trusted_ports_.find(local_port_id) != trusted_ports_.end();
-  int ret = -1;
-
-  if (is_trusted) {
-    ret = message_port_unregister_trusted_local_port(local_port_id);
+std::optional<MessagePortError> LocalPort::Unregister() {
+  if (is_trusted_) {
+    int ret = message_port_unregister_trusted_local_port(port_);
+    if (ret != MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
+    }
   } else {
-    ret = message_port_unregister_local_port(local_port_id);
-  }
-
-  if (MESSAGE_PORT_ERROR_NONE == ret) {
-    sinks_.erase(local_port_id);
-    if (is_trusted) {
-      trusted_ports_.erase(local_port_id);
+    int ret = message_port_unregister_local_port(port_);
+    if (ret != MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
     }
   }
-
-  return CreateResult(ret);
+  port_ = -1;
+  return std::nullopt;
 }
 
-MessagePortResult MessagePortManager::CheckRemotePort(
-    std::string& remote_app_id, std::string& port_name, bool is_trusted,
-    bool* port_check) {
-  LOG_DEBUG("CheckRemotePort remote_app_id: %s, port_name: %s, trusted: %s",
-            remote_app_id.c_str(), port_name.c_str(),
-            is_trusted ? "yes" : "no");
-
-  int ret;
-  if (is_trusted) {
-    ret = message_port_check_trusted_remote_port(remote_app_id.c_str(),
-                                                 port_name.c_str(), port_check);
+ErrorOr<bool> RemotePort::CheckRemotePort() {
+  bool exist = false;
+  if (is_trusted_) {
+    int ret = message_port_check_trusted_remote_port(app_id_.c_str(),
+                                                     name_.c_str(), &exist);
+    if (ret != MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
+    }
   } else {
-    ret = message_port_check_remote_port(remote_app_id.c_str(),
-                                         port_name.c_str(), port_check);
+    int ret =
+        message_port_check_remote_port(app_id_.c_str(), name_.c_str(), &exist);
+    if (ret != MESSAGE_PORT_ERROR_NONE) {
+      return MessagePortError(ret);
+    }
   }
 
-  LOG_DEBUG("message_port_check_%s_remote_port (%s): %s",
-            is_trusted ? "trusted" : "", port_name.c_str(),
-            *port_check ? "true" : "false");
-
-  return CreateResult(ret);
+  return exist;
 }
 
-MessagePortResult MessagePortManager::Send(std::string& remote_app_id,
-                                           std::string& port_name,
-                                           flutter::EncodableValue& message,
-                                           bool is_trusted) {
-  LOG_DEBUG("Send (%s, %s), trusted: %s", remote_app_id.c_str(),
-            port_name.c_str(), is_trusted ? "yes" : "no");
-  bundle* bundle = nullptr;
-  MessagePortResult result = PrepareBundle(message, bundle);
-  if (!result) {
-    return result;
+std::optional<MessagePortError> RemotePort::Send(
+    const std::vector<uint8_t>& encoded_message) {
+  ErrorOr<bundle*> maybe_bundle = PrepareBundle(encoded_message);
+  if (maybe_bundle.has_error()) {
+    return maybe_bundle.error();
   }
+  bundle* bundle = maybe_bundle.value();
 
-  int ret;
-  if (is_trusted) {
-    ret = message_port_send_trusted_message(remote_app_id.c_str(),
-                                            port_name.c_str(), bundle);
+  int ret = MESSAGE_PORT_ERROR_NONE;
+  if (is_trusted_) {
+    ret = message_port_send_trusted_message(app_id_.c_str(), name_.c_str(),
+                                            bundle);
   } else {
-    ret = message_port_send_message(remote_app_id.c_str(), port_name.c_str(),
-                                    bundle);
+    ret = message_port_send_message(app_id_.c_str(), name_.c_str(), bundle);
   }
   bundle_free(bundle);
 
-  return CreateResult(ret);
+  if (ret != MESSAGE_PORT_ERROR_NONE) {
+    return MessagePortError(ret);
+  }
+
+  return std::nullopt;
 }
 
-MessagePortResult MessagePortManager::Send(std::string& remote_app_id,
-                                           std::string& port_name,
-                                           flutter::EncodableValue& message,
-                                           bool is_trusted, int local_port) {
-  LOG_DEBUG("Send (%s, %s), port: %d, trusted: %s", remote_app_id.c_str(),
-            port_name.c_str(), local_port, is_trusted ? "yes" : "no");
-  bundle* bundle = nullptr;
-  MessagePortResult result = PrepareBundle(message, bundle);
-  if (!result) {
-    return result;
+std::optional<MessagePortError> RemotePort::SendWithLocalPort(
+    const std::vector<uint8_t>& encoded_message, LocalPort* local_port) {
+  ErrorOr<bundle*> maybe_bundle = PrepareBundle(encoded_message);
+  if (maybe_bundle.has_error()) {
+    return maybe_bundle.error();
   }
-  int ret;
-  if (is_trusted) {
+  bundle* bundle = maybe_bundle.value();
+
+  int ret = MESSAGE_PORT_ERROR_NONE;
+  if (is_trusted_) {
     ret = message_port_send_trusted_message_with_local_port(
-        remote_app_id.c_str(), port_name.c_str(), bundle, local_port);
+        app_id_.c_str(), name_.c_str(), bundle, local_port->port());
   } else {
     ret = message_port_send_message_with_local_port(
-        remote_app_id.c_str(), port_name.c_str(), bundle, local_port);
+        app_id_.c_str(), name_.c_str(), bundle, local_port->port());
   }
   bundle_free(bundle);
 
-  return CreateResult(ret);
+  if (ret != MESSAGE_PORT_ERROR_NONE) {
+    return MessagePortError(ret);
+  }
+
+  return std::nullopt;
 }
 
-MessagePortResult MessagePortManager::PrepareBundle(
-    flutter::EncodableValue& message, bundle*& bundle) {
-  bundle = bundle_create();
+ErrorOr<bundle*> RemotePort::PrepareBundle(
+    const std::vector<uint8_t>& encoded_message) {
+  bundle* bundle = bundle_create();
   if (!bundle) {
-    return CreateResult(MESSAGE_PORT_ERROR_OUT_OF_MEMORY);
+    return MessagePortError(MESSAGE_PORT_ERROR_OUT_OF_MEMORY);
   }
 
-  bool result = ConvertEncodableValueToBundle(message, bundle);
-  if (!result) {
-    LOG_ERROR("Failed to parse EncodableValue");
+  int ret = bundle_add_byte(bundle, "bytes", encoded_message.data(),
+                            encoded_message.size());
+  if (ret != BUNDLE_ERROR_NONE) {
     bundle_free(bundle);
-    return CreateResult(MESSAGE_PORT_ERROR_INVALID_PARAMETER);
+    return MessagePortError(ret);
   }
-  return CreateResult(MESSAGE_PORT_ERROR_NONE);
-}
 
-MessagePortResult MessagePortManager::CreateResult(int return_code) {
-  MessagePortResult result(return_code);
-
-  if (!result) {
-    LOG_ERROR("Failed: %s", result.message().c_str());
-  }
-  return result;
+  return bundle;
 }