Initial project snapshot

workers/rdp-worker/include/rdp_worker/adapter/adapter_event_router.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+
+#include "rdp_worker/adapter/service_adapter_protocol.hpp"
+#include "rdp_worker/runtime/models.hpp"
+
+namespace rdp_worker::adapter {
+
+struct AdapterEventDescriptor {
+    AdapterChannel channel;
+    std::string_view normalized_type;
+    bool adapter_origin;
+    bool reliable;
+    bool droppable;
+};
+
+class AdapterEventRouter {
+public:
+    [[nodiscard]] AdapterEventDescriptor DescribeRenderNotification(const runtime::RenderNotification& notification) const;
+    [[nodiscard]] AdapterEventDescriptor DescribeClipboardNotification(const runtime::ClipboardNotification& notification) const;
+    [[nodiscard]] AdapterEventDescriptor DescribeClientEnvelope(std::string_view envelope_type,
+                                                                std::string_view payload_kind,
+                                                                std::string_view payload_action) const;
+};
+
+[[nodiscard]] std::string AdapterEventDescriptorLogLine(const AdapterEventDescriptor& descriptor);
+
+}  // namespace rdp_worker::adapter
+

workers/rdp-worker/include/rdp_worker/adapter/rdp_adapter_runtime.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "rdp_worker/adapter/adapter_event_router.hpp"
+#include "rdp_worker/common/logger.hpp"
+#include "rdp_worker/freerdp/rdp_runtime.hpp"
+#include "rdp_worker/runtime/models.hpp"
+
+namespace rdp_worker::adapter {
+
+class RdpAdapterRuntime {
+public:
+    explicit RdpAdapterRuntime(std::shared_ptr<common::Logger> logger);
+
+    bool Start(const runtime::ConnectionSpec& spec);
+    void Disconnect(bool terminate);
+    bool IsConnected() const;
+    bool PumpEvents(std::chrono::milliseconds timeout);
+    int DesktopWidth() const;
+    int DesktopHeight() const;
+    bool SendFocusEvent(bool focused);
+    bool SendKeyboardInput(uint16_t scan_code, bool key_down, bool extended);
+    bool SendMouseMove(double normalized_x, double normalized_y);
+    bool SendMouseButton(const std::string& button, bool pressed, double normalized_x, double normalized_y);
+    bool SendMouseWheel(int wheel_delta, bool horizontal, double normalized_x, double normalized_y);
+    bool SetClipboardText(const std::string& text);
+    void MarkInputAppliedForGraphicsTrace(const std::string& correlation_id);
+    std::optional<runtime::RenderNotification> CaptureFullFrameNotification(
+        const std::string& state,
+        const std::string& capture_source);
+    std::optional<runtime::RenderNotification> PopRenderNotification();
+    std::optional<runtime::ClipboardNotification> PopClipboardNotification();
+    const std::string& RenderQualityProfile() const;
+
+    [[nodiscard]] const AdapterEventRouter& EventRouter() const;
+
+private:
+    void TraceClientEnvelope(std::string_view envelope_type,
+                             std::string_view payload_kind,
+                             std::string_view payload_action);
+    void TraceAdapterEvent(const AdapterEventDescriptor& descriptor);
+
+    std::shared_ptr<common::Logger> logger_;
+    freerdp_runtime::RdpRuntime freerdp_;
+    AdapterEventRouter event_router_;
+    bool lifecycle_logged_{false};
+};
+
+}  // namespace rdp_worker::adapter

workers/rdp-worker/include/rdp_worker/adapter/service_adapter_protocol.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <array>
+#include <optional>
+#include <string_view>
+
+namespace rdp_worker::adapter {
+
+enum class AdapterChannel {
+    kInput,
+    kControl,
+    kDisplay,
+    kCursor,
+    kClipboard,
+    kFileTransfer,
+    kAudio,
+    kDevice,
+    kTelemetry,
+};
+
+enum class ChannelDirection {
+    kClientToAdapter,
+    kAdapterToClient,
+    kBidirectional,
+};
+
+enum class ChannelReliability {
+    kReliableOrdered,
+    kReliableChunked,
+    kDroppableLatest,
+    kAdaptiveDroppable,
+    kSampledDroppable,
+};
+
+enum class ChannelPriority {
+    kCritical = 0,
+    kHigh = 10,
+    kMedium = 50,
+    kLow = 90,
+};
+
+struct ChannelSpec {
+    AdapterChannel channel;
+    std::string_view name;
+    ChannelDirection direction;
+    ChannelReliability reliability;
+    ChannelPriority priority;
+    bool stale_updates_droppable;
+    bool may_block_input;
+};
+
+[[nodiscard]] constexpr std::array<ChannelSpec, 9> AllChannelSpecs() {
+    return {{
+        {AdapterChannel::kInput, "input", ChannelDirection::kClientToAdapter, ChannelReliability::kReliableOrdered, ChannelPriority::kCritical, true, false},
+        {AdapterChannel::kControl, "control", ChannelDirection::kBidirectional, ChannelReliability::kReliableOrdered, ChannelPriority::kHigh, false, false},
+        {AdapterChannel::kDisplay, "display", ChannelDirection::kAdapterToClient, ChannelReliability::kDroppableLatest, ChannelPriority::kHigh, true, false},
+        {AdapterChannel::kCursor, "cursor", ChannelDirection::kAdapterToClient, ChannelReliability::kDroppableLatest, ChannelPriority::kHigh, true, false},
+        {AdapterChannel::kClipboard, "clipboard", ChannelDirection::kBidirectional, ChannelReliability::kReliableOrdered, ChannelPriority::kMedium, false, false},
+        {AdapterChannel::kFileTransfer, "file_transfer", ChannelDirection::kBidirectional, ChannelReliability::kReliableChunked, ChannelPriority::kMedium, false, false},
+        {AdapterChannel::kAudio, "audio", ChannelDirection::kAdapterToClient, ChannelReliability::kAdaptiveDroppable, ChannelPriority::kMedium, true, false},
+        {AdapterChannel::kDevice, "device", ChannelDirection::kBidirectional, ChannelReliability::kReliableOrdered, ChannelPriority::kMedium, false, false},
+        {AdapterChannel::kTelemetry, "telemetry", ChannelDirection::kAdapterToClient, ChannelReliability::kSampledDroppable, ChannelPriority::kLow, true, false},
+    }};
+}
+
+[[nodiscard]] std::optional<ChannelSpec> FindChannelSpec(std::string_view name);
+[[nodiscard]] std::string_view ChannelName(AdapterChannel channel);
+[[nodiscard]] std::string_view DirectionName(ChannelDirection direction);
+[[nodiscard]] std::string_view ReliabilityName(ChannelReliability reliability);
+[[nodiscard]] int PriorityValue(ChannelPriority priority);
+[[nodiscard]] bool IsDroppable(AdapterChannel channel);
+[[nodiscard]] bool IsReliable(AdapterChannel channel);
+[[nodiscard]] bool ValidateAdapterChannelInvariants();
+
+}  // namespace rdp_worker::adapter
+