control_host_ui_executor.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/inspect/capture_source.hpp>
#include <pulp/inspect/control_execution.hpp>
#include <pulp/inspect/control_identity.hpp>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
 
namespace pulp::inspect {
 
class InspectorMainThreadRpc;
class RuntimeEvaluator;
 
inline constexpr std::size_t kControlCaptureMaximumBytes = 16u * 1024u * 1024u;
inline constexpr std::size_t kControlRuntimeEvalMaximumResultBytes = 256u * 1024u;
inline constexpr std::size_t kControlUiMaximumTargetBytes = 256;
inline constexpr std::size_t kControlUiMaximumViewGenerationBytes = 128;
inline constexpr std::size_t kControlUiMaximumKeyBytes = 64;
inline constexpr std::size_t kControlUiMaximumTextBytes = 4096;
inline constexpr double kControlUiMaximumCoordinate = 1'000'000.0;

struct ControlUiExactTarget {
    std::string instance_id;
    std::string instance_generation;
    std::string view_generation;
    std::string node_id;
};

struct ControlUiAuthorityOwner {
    std::string authority_id;
 
    friend bool operator==(const ControlUiAuthorityOwner&,
                           const ControlUiAuthorityOwner&) = default;
};

struct ControlUiProjectedAuthority {
    ControlUiAuthorityOwner owner;
    std::function<bool()> authority_live;
    std::function<std::shared_ptr<void>(std::function<void()>)> subscribe_authority_end;
};
 
using ControlUiAuthorityResolver =
    std::function<std::optional<ControlUiProjectedAuthority>(const ControlAdmissionPlan&)>;
 
struct ControlUiPointerInput {
    enum class Phase : std::uint8_t { Down, Move, Up };
    Phase phase = Phase::Down;
    double x = 0.0;
    double y = 0.0;
    std::uint8_t button = 0;
};
 
struct ControlUiKeyboardInput {
    enum class Phase : std::uint8_t { Down, Up };
    Phase phase = Phase::Down;
    std::string key;
    bool repeat = false;
};
 
struct ControlUiFocusInput {
    bool focused = false;
};
 
struct ControlUiTextInput {
    std::string text;
};
 
using ControlUiInput = std::variant<ControlUiPointerInput, ControlUiKeyboardInput,
                                    ControlUiFocusInput, ControlUiTextInput>;
 
enum class ControlUiApplyStatus : std::uint8_t {
    Applied,
    TargetUnavailable,
    StaleGeneration,
    InvalidEvent,
};

class ControlHostUiTargetAdapter {
  public:
    virtual ~ControlHostUiTargetAdapter() = default;
    virtual InspectorCapture capture_node_png(const ControlUiExactTarget& target) = 0;
    virtual ControlUiApplyStatus dispatch_input(const ControlUiExactTarget& target,
                                                const ControlUiAuthorityOwner& owner,
                                                const ControlUiInput& input) = 0;
    virtual void release_controller(
        const std::optional<ControlUiAuthorityOwner>& owner) noexcept = 0;
};
 
struct ControlHostUiBinding {
    ControlRegistration registration;
    ControlManifest manifest;
};
 
using ControlRuntimeEvalRedactor =
    std::function<std::optional<std::string>(std::string_view result_json)>;
 
struct ControlHostUiExecutorConfig {
    ControlHostUiBinding binding;
    std::shared_ptr<InspectorMainThreadRpc> main_thread_rpc;
    std::shared_ptr<InspectorCaptureSource> capture_source;
    std::shared_ptr<ControlHostUiTargetAdapter> target_adapter;
    ControlUiAuthorityResolver resolve_authority;
    std::string view_generation;
    std::shared_ptr<RuntimeEvaluator> runtime_evaluator;
    ControlRuntimeEvalRedactor redact_runtime_eval_result;
    std::size_t maximum_capture_bytes = kControlCaptureMaximumBytes;
    std::size_t maximum_eval_result_bytes = kControlRuntimeEvalMaximumResultBytes;
    std::chrono::milliseconds capture_lifetime = std::chrono::minutes(15);
};

class ControlHostUiExecutor {
  public:
    static std::unique_ptr<ControlHostUiExecutor> create(ControlHostUiExecutorConfig config);
    ~ControlHostUiExecutor();
 
    ControlHostUiExecutor(const ControlHostUiExecutor&) = delete;
    ControlHostUiExecutor& operator=(const ControlHostUiExecutor&) = delete;
 
    ControlOperationExecutor executor() const;
    bool ready() const;
    bool release_controller_scope() noexcept;
    bool disconnect() noexcept;
 
  private:
    struct State;
    explicit ControlHostUiExecutor(std::shared_ptr<State> state);
    std::shared_ptr<State> state_;
};

std::string_view control_ui_input_disposition() noexcept;
 
} // namespace pulp::inspect