UiBusClient.hpp

Go to the documentation of this file.

#pragma once
 
#include <Bus.hpp>
#include <SubscribeOwned.hpp>
#include <algorithm>
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <utility>
 
#include "bus/Envelopes.hpp"
#include "bus/ModelBusClient.hpp"
 
namespace lacte::bus {
// ---------------------------------------------------------------------------
// UiRuntime: UI-состояние, которым `UiBusClient::SubscribeRuntime()`
// управляет на основе push-команд и снапшотов от бэкенда; методы-запросы
// `UiBusClient` отправляют блокирующие запросы UI к бэкенду.
// ---------------------------------------------------------------------------

class UiRuntime {
 public:
  // Верхняя граница валидного значения аэрации на проводе (0-100%) -
  // отдельная от ConsoleModel::K_MAX_AERATION_PERCENT константа (та живёт
  // выше по стеку, зависит от UiBusClient.hpp, а не наоборот), но то же
  // самое значение по той же причине: у платы поле аэрации - uint8_t
  // (0-255), значение вне 0-100 не может быть валидным процентом.
  static constexpr int K_MAX_AERATION_PERCENT = 100;
  using SetEnabledCallback = std::function<void(bool)>;
  using SetAerationCallback = std::function<void(int)>;
  using ApplySnapshotCallback = std::function<void(const BoardSnapshot&)>;
 
  UiRuntime(SetEnabledCallback set_enabled, SetAerationCallback set_aeration,
            ApplySnapshotCallback apply_snapshot = {})
      : m_set_enabled_(std::move(set_enabled)),
        m_set_aeration_(std::move(set_aeration)),
        m_apply_snapshot_(std::move(apply_snapshot)) {}
 
  // Защищено m_mutex_: эти сеттеры (вызываемые из того потока, что
  // публикует соответствующее событие - см.
  // UiBusClient::SubscribeRuntime()) и геттеры ниже (вызываемые из того
  // потока, что владеет UI, например его цикла рендера) по-настоящему
  // гоняются друг с другом (race).
  void set_enabled(const bool enabled) {
    {
      std::scoped_lock lock(m_mutex_);
      m_enabled_ = enabled;
    }
    if (m_set_enabled_) {
      m_set_enabled_(enabled);
    }
  }
 
  // Единственная точка входа значения аэрации в UiRuntime - и от
  // локального +/- пользователя (уже 0-100, см. ConsoleModel::
  // set_aeration()), и от самой платы (см. ConsoleModel::
  // refresh_snapshot_with_aeration(), напрямую снапшот -> сюда, без
  // собственного клэмпа по пути) - клэмп именно здесь гарантирует, что
  // некорректное сырое значение платы (>100, до 255 - uint8_t на проводе)
  // никогда не попадёт на экран как есть.
  void set_aeration(const int value) {
    const int clamped = std::clamp(value, 0, K_MAX_AERATION_PERCENT);
    {
      std::scoped_lock lock(m_mutex_);
      m_aeration_ = clamped;
    }
    if (m_set_aeration_) {
      m_set_aeration_(clamped);
    }
  }
 
  void apply_snapshot(const BoardSnapshot& snapshot) {
    {
      std::scoped_lock lock(m_mutex_);
      m_last_snapshot_ = snapshot;
    }
    if (m_apply_snapshot_) {
      m_apply_snapshot_(snapshot);
    }
  }

  [[nodiscard]] auto enabled() const -> bool {
    std::scoped_lock lock(m_mutex_);
    return m_enabled_;
  }

  [[nodiscard]] auto aeration() const -> int {
    std::scoped_lock lock(m_mutex_);
    return m_aeration_;
  }

  [[nodiscard]] auto last_snapshot() const -> std::optional<BoardSnapshot> {
    std::scoped_lock lock(m_mutex_);
    return m_last_snapshot_;
  }
 
 private:
  SetEnabledCallback m_set_enabled_;
  SetAerationCallback m_set_aeration_;
  ApplySnapshotCallback m_apply_snapshot_;
  mutable std::mutex m_mutex_;
  bool m_enabled_{false};
  int m_aeration_{0};
  std::optional<BoardSnapshot> m_last_snapshot_;
};

inline constexpr uint32_t K_UI_BUS_ADDRESS = 2;
 
// ---------------------------------------------------------------------------
// UiBusClient: см. doc-комментарий файла выше.
// ---------------------------------------------------------------------------
 
class UiBusClient : public insitech::bus::LocalClient {
 public:
  static auto create(insitech::bus::IHub& bus, const uint32_t address,
                     const std::string& name,
                     const std::string& binary = "lacteApp")
      -> std::shared_ptr<UiBusClient> {
    auto self = std::shared_ptr<UiBusClient>(new UiBusClient(
        address, proto::bus::make_identity(name, binary, 1, "lacte"),
        bus.make_client_bindings(address)));
    bus.register_local_client(address, self);
    // Объявлено один раз здесь (не при каждом вызове Publish() -
    // Publish<Msg>() сам сознательно не принимает описание, см. его
    // собственный doc-комментарий в Bus.hpp), чтобы эти топики появлялись
    // с реальным описанием в Hub::build_report(), а не с пустым, к которому
    // иначе откатился бы advertise_if_new().
    self->advertise(UiCommand::K_TOPIC,
                    "Model-pushed command enabling/disabling the UI");
    self->advertise(BoardSnapshotEvent::K_TOPIC,
                    "Model-pushed full board snapshot");
    return self;
  }
 
  UiBusClient(const UiBusClient&) = delete;
  auto operator=(const UiBusClient&) -> UiBusClient& = delete;

  void set_ui_enabled(const bool enabled) { publish(UiCommand{enabled}); }

  void enable_ui(ModelBusHandler& handler) { set_ui_enabled(handler.health()); }

  void disable_ui() { set_ui_enabled(false); }

  void publish_snapshot(ModelBusHandler& handler) {
    publish(BoardSnapshotEvent{handler.get_snapshot()});
  }

  void subscribe_runtime(const std::shared_ptr<UiRuntime>& runtime) {
    insitech::bus_utils::subscribe_owned_typed<UiCommand>(
        *this, runtime,
        [](UiRuntime& ui_runtime, const UiCommand& command) -> void {
          ui_runtime.set_enabled(command.enable);
        },
        "Model-pushed command enabling/disabling this UI");
    insitech::bus_utils::subscribe_owned_typed<BoardSnapshotEvent>(
        *this, runtime,
        [](UiRuntime& ui_runtime, const BoardSnapshotEvent& event) -> void {
          ui_runtime.apply_snapshot(event.snapshot);
          ui_runtime.set_aeration(event.snapshot.aeration);
        },
        "Model-pushed full board snapshot");
  }

  auto check_health(UiRuntime& runtime, const std::chrono::milliseconds timeout)
      -> bool {
    if (const auto reply = request<HealthRequest, StatusReply>({}, timeout);
        !reply || !reply->ok) {
      runtime.set_enabled(false);
      return false;
    }
    return true;
  }

  auto set_param(std::string param, const int value,
                 const std::chrono::milliseconds timeout) -> bool {
    const auto reply = request<ParamSetRequest, StatusReply>(
        {std::move(param), value}, timeout);
    return reply && reply->ok;
  }

  auto get_param(std::string param, const std::chrono::milliseconds timeout)
      -> std::optional<int> {
    auto reply =
        request<ParamGetRequest, ParamGetReply>({std::move(param)}, timeout);
    if (!reply || !reply->ok) {
      return std::nullopt;
    }
    return reply->value;
  }

  auto get_snapshot(const std::chrono::milliseconds timeout)
      -> std::optional<BoardSnapshot> {
    auto reply = request<SnapshotRequest, SnapshotReply>({}, timeout);
    if (!reply || !reply->ok) {
      return std::nullopt;
    }
    return reply->snapshot;
  }

  auto get_rfid_data(const std::chrono::milliseconds timeout)
      -> std::optional<RfidData> {
    auto reply = request<RfidDataRequest, RfidDataReply>({}, timeout);
    if (!reply || !reply->ok) {
      return std::nullopt;
    }
    return reply->data;
  }

  auto set_test_board_online(const bool online,
                             const std::chrono::milliseconds timeout) -> bool {
    const auto reply =
        request<TestBoardOnlineRequest, StatusReply>({online}, timeout);
    return reply && reply->ok;
  }
 
 private:
  // Приватный: только Create() может сконструировать экземпляр, так что
  // нигде не может оказаться UiBusClient, который никогда не был
  // зарегистрирован на своей шине (см. doc-комментарий Create()) - обычный
  // публичный конструктор не смог бы это гарантировать.
  UiBusClient(const uint32_t address, const proto::bus::NodeIdentity& identity,
              Bindings bindings)
      : LocalClient(address, identity, std::move(bindings)) {}
};
}  // namespace lacte::bus