Working GET call

Author: ospfranco

OpServer.podspec

@@ -13,7 +13,7 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/OP-Engineering/op-server.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.source_files = Dir.glob("ios/**/*.{h,hpp,m,mm}") + Dir.glob("cpp/**/*.{hpp,h,cpp,c}")
   s.private_header_files = "ios/**/*.h"
 
   install_modules_dependencies(s)

cpp/Server.cpp

@@ -0,0 +1,123 @@
+#pragma once
+
+#include "Server.hpp"
+#include "macros.hpp"
+#include <future>
+#include <iostream>
+
+namespace opserver {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+Server::Server(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker) {
+
+  function_map["callback"] = HFN2(this, invoker) {
+    const std::string method = args[0].asString(rt).utf8(rt);
+    const std::string path = args[1].asString(rt).utf8(rt);
+    auto callback = std::make_shared<jsi::Value>(rt, args[2]);
+
+    if (method == "GET") {
+      server.Get(
+          path, [this, &rt, invoker, callback](const httplib::Request &req,
+                                               httplib::Response &res) {
+            auto responseDone = std::make_shared<std::promise<std::string>>();
+            auto responseFuture = responseDone->get_future();
+
+            invoker->invokeAsync([callback, responseDone](jsi::Runtime &rt) {
+              try {
+                auto promise = callback->asObject(rt).asFunction(rt).call(rt);
+
+                if (promise.isObject()) {
+                  auto promiseObj = promise.asObject(rt);
+                  auto then = promiseObj.getPropertyAsFunction(rt, "then");
+
+                  // Create success handler
+                  auto successHandler = HFN(responseDone) {
+                    if (count > 0 && args[0].isString()) {
+                      responseDone->set_value(args[0].asString(rt).utf8(rt));
+                    } else {
+                      responseDone->set_value("Success!");
+                    }
+                    return jsi::Value::undefined();
+                  });
+
+                  then.callWithThis(rt, promiseObj, successHandler);
+                }
+              } catch (const std::exception &e) {
+                responseDone->set_value(std::string("Error: ") + e.what());
+              }
+            });
+                                                 
+            if (responseFuture.wait_for(std::chrono::seconds(5)) ==
+                std::future_status::ready) {
+              res.set_content(responseFuture.get(), "text/plain");
+            } else {
+              res.set_content("Timeout", "text/plain");
+            }
+          });
+
+    } else if (method == "POST") {
+      server.Post(path,
+                  [callback](const httplib::Request &, httplib::Response &res) {
+                    res.set_content("Hello World!", "text/plain");
+                  });
+    }
+
+    return {};
+  });
+
+  //  function_map["getIp"] = HFN(this) {
+  //    std::string ip;
+  //    int port;
+  //    // Get the local IP and port from the server socket
+  //    auto sock = server.socket();
+  //    if (sock != -1) {
+  //      detail::get_local_ip_and_port(sock, ip, port);
+  //      return jsi::String::createFromUtf8(rt, ip);
+  //    }
+  //
+  //    return jsi::Value::undefined();
+  //  });
+
+  function_map["listen"] = HFN(this) {
+    std::thread([this]() { server.listen("0.0.0.0", 3000); }).detach();
+    return {};
+  });
+}
+
+std::vector<jsi::PropNameID> Server::getPropertyNames(jsi::Runtime &_rt) {
+  std::vector<jsi::PropNameID> keys;
+  keys.reserve(function_map.size());
+  for (const auto &pair : function_map) {
+    keys.emplace_back(jsi::PropNameID::forUtf8(_rt, pair.first));
+  }
+  return keys;
+}
+
+jsi::Value Server::get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) {
+  const auto name = propNameID.utf8(rt);
+  if (function_map.count(name) != 1) {
+    return HFN(name) {
+      throw std::runtime_error("[op-server] Function " + name +
+                               " not implemented");
+    });
+  }
+
+  return {rt, function_map[name]};
+}
+
+void Server::set(jsi::Runtime &_rt, const jsi::PropNameID &name,
+                 const jsi::Value &value) {
+  throw std::runtime_error("You cannot write to this object!");
+}
+
+void Server::stop() {
+  //  http_server_
+}
+
+Server::~Server() {
+
+};
+
+} // namespace opserver

cpp/Server.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include <httplib.h>
+
+namespace opserver {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+
+class JSI_EXPORT Server : public jsi::HostObject {
+public:
+  Server(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker);
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
+  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+           const jsi::Value &value) override;
+  void stop();
+  ~Server() override;
+
+private:
+  httplib::Server server;
+  std::unordered_map<std::string, jsi::Value> function_map;
+};
+
+} // namespace opserver

cpp/bindings.cpp

@@ -0,0 +1,41 @@
+#include "bindings.hpp"
+#include "Server.hpp"
+#include "macros.hpp"
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace opserver {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+std::vector<std::shared_ptr<Server>> servers;
+
+// React native will try to clean the module on JS context invalidation
+// (CodePush/Hot Reload) The clearState function is called
+void invalidate() {
+  for (auto &server : servers) {
+    if (server) {
+      server->stop();
+    }
+  }
+  servers.clear();
+}
+
+void install(jsi::Runtime &rt,
+             const std::shared_ptr<react::CallInvoker> &invoker) {
+
+  const auto create = HFN(invoker) {
+    std::shared_ptr<Server> server = std::make_shared<Server>(rt, invoker);
+    servers.emplace_back(server);
+    return jsi::Object::createFromHostObject(rt, server);
+  });
+
+  jsi::Object module = jsi::Object(rt);
+  module.setProperty(rt, "create", create);
+
+  rt.global().setProperty(rt, "__OPServerProxy", std::move(module));
+}
+
+} // namespace opserver

cpp/bindings.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <jsi/jsilib.h>
+
+namespace opserver {
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+void install(jsi::Runtime &rt,
+             const std::shared_ptr<react::CallInvoker> &invoker);
+void invalidate();
+
+} // namespace opserver