client.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace antenna_switcher {
 
enum class Channel { One = 1, Two = 2 };
 
enum class TimeUnit { Ms, Us };
 
enum class Mode { Manual, Auto, Plan, Unknown };
 
struct PlanStep {
    enum class Kind { Input, Delay } kind = Kind::Input;
    int input = 0;
    int delay = 0;
    TimeUnit unit = TimeUnit::Ms;
 
    static PlanStep input_step(const int n) {
        return PlanStep{Kind::Input, n, 0, TimeUnit::Ms};
    }
    static PlanStep delay_step(const int value, const TimeUnit unit = TimeUnit::Ms) {
        return PlanStep{Kind::Delay, 0, value, unit};
    }
};
 
struct ChannelState {
    int bearing = 0;                
    int activeInput = 0;            
    int angleOffset = 0;            
    long intervalUs = 0;            
    Mode mode = Mode::Unknown;      
    std::vector<int> activeInputs;  
};
 
struct Options {
    std::string host;           
    std::uint16_t port = 6053;  
    std::string noise_psk;      
    std::string client_info = "antenna-switcher-client";  
};
 
class AntennaSwitcher {
public:
    using StateCallback = std::function<void(Channel, const ChannelState&)>;
 
    explicit AntennaSwitcher(Options opts);
    ~AntennaSwitcher();
 
    AntennaSwitcher(const AntennaSwitcher&) = delete;
    AntennaSwitcher& operator=(const AntennaSwitcher&) = delete;
 
    void connect() const;
    void disconnect() const;
    [[nodiscard]] bool isConnected() const;
 
    void setInput(Channel channel, int input) const;
    void startAuto(Channel channel,
                   int interval,
                   TimeUnit unit,
                   const std::vector<int>& inputs = {}) const;
    void runPlan(Channel channel, const std::vector<PlanStep>& steps, bool repeat = false) const;
    void stop(Channel channel) const;
    void setAngleOffset(Channel channel, int degrees) const;
 
    [[nodiscard]] ChannelState state(Channel channel) const;
    void onStateChanged(StateCallback cb) const;
 
private:
    void shutdown_worker() const;
 
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
namespace detail {
 
std::string build_set_input(int input);
std::string build_start_auto(int interval, TimeUnit unit, const std::vector<int>& inputs);
std::string build_run_plan(const std::vector<PlanStep>& steps, bool repeat);
std::string build_stop();
 
}  // namespace detail
 
}  // namespace antenna_switcher