Initial release

tools/pjarczak_bambu_linux_host/LinuxPluginHost.hpp

@@ -0,0 +1,127 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <map>
+#include <memory>
+#include <vector>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <functional>
+
+namespace Slic3r::PJarczakLinuxBridge {
+
+struct HostJobState {
+    std::int64_t job_id{0};
+    std::int64_t agent_handle{0};
+    std::string kind;
+    std::atomic<bool> cancel_requested{false};
+    std::mutex wait_mutex;
+    std::condition_variable wait_cv;
+    std::int64_t wait_request_id{0};
+    bool wait_reply_ready{false};
+    bool wait_reply_value{true};
+};
+
+struct HostCallbackReplyState {
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool ready{false};
+    std::string string_value;
+};
+
+
+struct HostFtJobState {
+    void* handle{nullptr};
+    std::mutex mutex;
+    std::condition_variable cv;
+    bool result_ready{false};
+    int result_ec{0};
+    int result_resp_ec{0};
+    std::string result_json;
+    std::vector<unsigned char> result_bin;
+    std::deque<std::pair<int, std::string>> messages;
+};
+
+class LinuxPluginHost {
+public:
+    LinuxPluginHost();
+    ~LinuxPluginHost();
+    nlohmann::json handle(const std::string& method, const nlohmann::json& payload);
+    static void set_thread_request_binary(std::vector<unsigned char> data);
+    static bool consume_thread_reply_binary(std::vector<unsigned char>& out);
+    void dispatch_logger_event(std::int64_t tunnel_handle, int level, const std::string& message);
+    std::string refresh_camera_url_for_ft(const std::string& device, const std::string& dev_ver, const std::string& channel);
+    std::string refresh_agora_url_ptr_string() const;
+
+private:
+    void load_modules();
+    void* resolve_network(const char* name);
+    void* resolve_source(const char* name);
+    bool has_network_symbol(const char* name);
+    nlohmann::json auth_capabilities() const;
+    nlohmann::json not_supported(const std::string& method) const;
+    void queue_event(std::int64_t agent_handle, const std::string& name, const nlohmann::json& payload);
+    void queue_tunnel_event(std::int64_t tunnel_handle, const std::string& name, const nlohmann::json& payload);
+    nlohmann::json drain_events(std::size_t limit);
+    std::shared_ptr<HostJobState> get_job(std::int64_t job_id);
+    void register_job(const std::shared_ptr<HostJobState>& job);
+    void unregister_job(std::int64_t job_id);
+    void set_job_cancel(std::int64_t job_id, bool value);
+    void set_job_wait_reply(std::int64_t job_id, std::int64_t request_id, bool value);
+    std::shared_ptr<HostCallbackReplyState> register_callback_request(std::int64_t request_id);
+    void unregister_callback_request(std::int64_t request_id);
+    void set_callback_reply(std::int64_t request_id, const std::string& value);
+    void queue_main_task(std::function<void()> fn);
+    void ensure_main_dispatcher();
+    void stop_main_dispatcher();
+    void main_dispatch_loop();
+
+    template <typename T>
+    T net(const char* name)
+    {
+        return reinterpret_cast<T>(resolve_network(name));
+    }
+
+    template <typename T>
+    T src(const char* name)
+    {
+        return reinterpret_cast<T>(resolve_source(name));
+    }
+
+    void* m_network{nullptr};
+    void* m_source{nullptr};
+    std::int64_t m_next_agent{1};
+    std::int64_t m_next_tunnel{1};
+    std::int64_t m_next_ft_tunnel{1};
+    std::int64_t m_next_ft_job{1};
+    std::map<std::int64_t, void*> m_agents;
+    std::map<std::int64_t, void*> m_tunnels;
+    std::map<std::int64_t, void*> m_ft_tunnels;
+    std::map<std::int64_t, void*> m_ft_jobs;
+    std::map<std::int64_t, std::shared_ptr<HostFtJobState>> m_ft_job_states;
+    std::map<std::int64_t, std::string> m_country_codes;
+    std::mutex m_state_mutex;
+    std::mutex m_events_mutex;
+    std::deque<nlohmann::json> m_events;
+    std::map<std::int64_t, std::shared_ptr<HostJobState>> m_jobs;
+    std::map<std::int64_t, std::shared_ptr<HostCallbackReplyState>> m_callback_replies;
+    std::atomic<std::int64_t> m_next_wait_request{1};
+    std::atomic<std::int64_t> m_next_callback_request{1};
+    std::map<std::int64_t, void*> m_logger_contexts;
+    std::mutex m_main_tasks_mutex;
+    std::condition_variable m_main_tasks_cv;
+    std::deque<std::function<void()>> m_main_tasks;
+    std::thread m_main_dispatcher;
+    std::atomic<bool> m_stop_main_dispatcher{false};
+    std::string m_network_status{"not_loaded"};
+    std::string m_network_actual_abi_version;
+    std::string m_source_status{"not_loaded"};
+};
+
+}