runtime.hpp

Go to the documentation of this file.

 
#pragma once
 
// standard includes
#include <cstddef>
#include <memory>
#include <vector>
 
// local includes
#include <libvirtualhid/types.hpp>
 
namespace lvh {
 
  class Runtime;
 
  namespace detail {
    struct RuntimeConstructionToken {
    private:
      friend class ::lvh::Runtime;
 
      RuntimeConstructionToken() = default;
    };
 
    struct GamepadDevice;
    struct KeyboardDevice;
    struct MouseDevice;
    struct TouchscreenDevice;
    struct TrackpadDevice;
    struct PenTabletDevice;
    class RuntimeState;
  }  // namespace detail
 
  class VirtualDevice {
  public:
    virtual ~VirtualDevice() = default;
 
    virtual DeviceId device_id() const = 0;
 
    virtual const DeviceProfile &profile() const = 0;
 
    virtual bool is_open() const = 0;
 
    virtual std::vector<DeviceNode> device_nodes() const = 0;
 
    virtual OperationStatus close() = 0;
  };
 
  class Gamepad final: public VirtualDevice {
  public:
    Gamepad(const Gamepad &) = delete;
 
    Gamepad &operator=(const Gamepad &) = delete;
 
    Gamepad(Gamepad &&other) noexcept;
 
    Gamepad &operator=(Gamepad &&other) noexcept;
 
    Gamepad(detail::RuntimeConstructionToken token, std::shared_ptr<detail::GamepadDevice> device);
 
    ~Gamepad() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    const GamepadMetadata &metadata() const;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus submit(const GamepadState &state);
 
    void set_output_callback(const OutputCallback &callback);
 
    OperationStatus dispatch_output(const GamepadOutput &output);
 
    GamepadState last_submitted_state() const;
 
    std::vector<std::uint8_t> last_input_report() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::GamepadDevice> device_;
  };
 
  class Keyboard final: public VirtualDevice {
  public:
    Keyboard(const Keyboard &) = delete;
 
    Keyboard &operator=(const Keyboard &) = delete;
 
    Keyboard(Keyboard &&other) noexcept;
 
    Keyboard &operator=(Keyboard &&other) noexcept;
 
    Keyboard(detail::RuntimeConstructionToken token, std::shared_ptr<detail::KeyboardDevice> device);
 
    ~Keyboard() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus submit(const KeyboardEvent &event);
 
    OperationStatus press(KeyboardKeyCode key_code);
 
    OperationStatus release(KeyboardKeyCode key_code);
 
    OperationStatus type_text(const KeyboardTextEvent &event);
 
    KeyboardEvent last_submitted_event() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::KeyboardDevice> device_;
  };
 
  class Mouse final: public VirtualDevice {
  public:
    Mouse(const Mouse &) = delete;
 
    Mouse &operator=(const Mouse &) = delete;
 
    Mouse(Mouse &&other) noexcept;
 
    Mouse &operator=(Mouse &&other) noexcept;
 
    Mouse(detail::RuntimeConstructionToken token, std::shared_ptr<detail::MouseDevice> device);
 
    ~Mouse() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus submit(const MouseEvent &event);
 
    OperationStatus move_relative(std::int32_t delta_x, std::int32_t delta_y);
 
    OperationStatus move_absolute(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height);
 
    OperationStatus button(MouseButton button, bool pressed);
 
    OperationStatus vertical_scroll(std::int32_t distance);
 
    OperationStatus horizontal_scroll(std::int32_t distance);
 
    MouseEvent last_submitted_event() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::MouseDevice> device_;
  };
 
  class Touchscreen final: public VirtualDevice {
  public:
    Touchscreen(const Touchscreen &) = delete;
 
    Touchscreen &operator=(const Touchscreen &) = delete;
 
    Touchscreen(Touchscreen &&other) noexcept;
 
    Touchscreen &operator=(Touchscreen &&other) noexcept;
 
    Touchscreen(detail::RuntimeConstructionToken token, std::shared_ptr<detail::TouchscreenDevice> device);
 
    ~Touchscreen() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus place_contact(const TouchContact &contact);
 
    OperationStatus release_contact(std::int32_t contact_id);
 
    TouchContact last_submitted_contact() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::TouchscreenDevice> device_;
  };
 
  class Trackpad final: public VirtualDevice {
  public:
    Trackpad(const Trackpad &) = delete;
 
    Trackpad &operator=(const Trackpad &) = delete;
 
    Trackpad(Trackpad &&other) noexcept;
 
    Trackpad &operator=(Trackpad &&other) noexcept;
 
    Trackpad(detail::RuntimeConstructionToken token, std::shared_ptr<detail::TrackpadDevice> device);
 
    ~Trackpad() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus place_contact(const TouchContact &contact);
 
    OperationStatus release_contact(std::int32_t contact_id);
 
    OperationStatus button(bool pressed);
 
    TouchContact last_submitted_contact() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::TrackpadDevice> device_;
  };
 
  class PenTablet final: public VirtualDevice {
  public:
    PenTablet(const PenTablet &) = delete;
 
    PenTablet &operator=(const PenTablet &) = delete;
 
    PenTablet(PenTablet &&other) noexcept;
 
    PenTablet &operator=(PenTablet &&other) noexcept;
 
    PenTablet(detail::RuntimeConstructionToken token, std::shared_ptr<detail::PenTabletDevice> device);
 
    ~PenTablet() override;
 
    DeviceId device_id() const override;
 
    const DeviceProfile &profile() const override;
 
    bool is_open() const override;
 
    std::vector<DeviceNode> device_nodes() const override;
 
    OperationStatus close() override;
 
    OperationStatus place_tool(const PenToolState &state);
 
    OperationStatus button(PenButton button, bool pressed);
 
    PenToolState last_submitted_tool() const;
 
    std::size_t submit_count() const;
 
  private:
    std::shared_ptr<detail::PenTabletDevice> device_;
  };
 
  struct GamepadCreationResult {
    OperationStatus status;
 
    std::unique_ptr<Gamepad> gamepad;
 
    explicit operator bool() const {
      return status.ok() && gamepad != nullptr;
    }
  };
 
  struct KeyboardCreationResult {
    OperationStatus status;
 
    std::unique_ptr<Keyboard> keyboard;
 
    explicit operator bool() const {
      return status.ok() && keyboard != nullptr;
    }
  };
 
  struct MouseCreationResult {
    OperationStatus status;
 
    std::unique_ptr<Mouse> mouse;
 
    explicit operator bool() const {
      return status.ok() && mouse != nullptr;
    }
  };
 
  struct TouchscreenCreationResult {
    OperationStatus status;
 
    std::unique_ptr<Touchscreen> touchscreen;
 
    explicit operator bool() const {
      return status.ok() && touchscreen != nullptr;
    }
  };
 
  struct TrackpadCreationResult {
    OperationStatus status;
 
    std::unique_ptr<Trackpad> trackpad;
 
    explicit operator bool() const {
      return status.ok() && trackpad != nullptr;
    }
  };
 
  struct PenTabletCreationResult {
    OperationStatus status;
 
    std::unique_ptr<PenTablet> pen_tablet;
 
    explicit operator bool() const {
      return status.ok() && pen_tablet != nullptr;
    }
  };
 
  class Runtime final {
  public:
    Runtime(const Runtime &) = delete;
 
    Runtime &operator=(const Runtime &) = delete;
 
    Runtime(Runtime &&other) noexcept;
 
    Runtime &operator=(Runtime &&other) noexcept;
 
    Runtime(detail::RuntimeConstructionToken token, RuntimeOptions options);
 
    ~Runtime();
 
    static std::unique_ptr<Runtime> create(RuntimeOptions options = {});
 
    const BackendCapabilities &capabilities() const;
 
    BackendKind backend_kind() const;
 
    GamepadCreationResult create_gamepad(const DeviceProfile &profile);
 
    GamepadCreationResult create_gamepad(const CreateGamepadOptions &options);
 
    KeyboardCreationResult create_keyboard();
 
    KeyboardCreationResult create_keyboard(const CreateKeyboardOptions &options);
 
    MouseCreationResult create_mouse();
 
    MouseCreationResult create_mouse(const CreateMouseOptions &options);
 
    TouchscreenCreationResult create_touchscreen();
 
    TouchscreenCreationResult create_touchscreen(const CreateTouchscreenOptions &options);
 
    TrackpadCreationResult create_trackpad();
 
    TrackpadCreationResult create_trackpad(const CreateTrackpadOptions &options);
 
    PenTabletCreationResult create_pen_tablet();
 
    PenTabletCreationResult create_pen_tablet(const CreatePenTabletOptions &options);
 
    std::size_t active_device_count() const;
 
    void close_all();
 
  private:
    std::shared_ptr<detail::RuntimeState> state_;
  };
 
}  // namespace lvh