port_change_watcher.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/midi/device.hpp>
 
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <utility>
#include <vector>
 
namespace pulp::midi {

struct PortListDiff {
    std::vector<MidiPortInfo> added;
    std::vector<MidiPortInfo> removed;
    bool empty() const {
        return added.empty() && removed.empty();
    }
};
 
namespace detail {
inline bool same_port(const MidiPortInfo& a, const MidiPortInfo& b) {
    return a.id == b.id && a.name == b.name && a.is_input == b.is_input &&
           a.is_output == b.is_output;
}
inline bool contains_port(const std::vector<MidiPortInfo>& list, const MidiPortInfo& p) {
    for (const auto& q : list) {
        if (same_port(p, q))
            return true;
    }
    return false;
}
} // namespace detail

inline PortListDiff diff_port_lists(const std::vector<MidiPortInfo>& before,
                                    const std::vector<MidiPortInfo>& after) {
    PortListDiff d;
    std::vector<bool> matched(after.size(), false);
    for (const auto& b : before) {
        bool found = false;
        for (std::size_t i = 0; i < after.size(); ++i) {
            if (!matched[i] && detail::same_port(b, after[i])) {
                matched[i] = true;
                found = true;
                break;
            }
        }
        if (!found)
            d.removed.push_back(b);
    }
    for (std::size_t i = 0; i < after.size(); ++i) {
        if (!matched[i])
            d.added.push_back(after[i]);
    }
    return d;
}

class PortListTracker {
  public:
    PortListDiff update(std::vector<MidiPortInfo> current) {
        PortListDiff d;
        if (have_baseline_)
            d = diff_port_lists(last_, current);
        last_ = std::move(current);
        have_baseline_ = true;
        return d;
    }
 
  private:
    std::vector<MidiPortInfo> last_;
    bool have_baseline_ = false;
};

class PortChangePoller {
  public:
    using Enumerate = std::function<std::vector<MidiPortInfo>()>;
    using OnChange = std::function<void(const PortListDiff&)>;
 
    PortChangePoller() = default;
    PortChangePoller(const PortChangePoller&) = delete;
    PortChangePoller& operator=(const PortChangePoller&) = delete;
    ~PortChangePoller() {
        stop();
    }

    void start(Enumerate enumerate, OnChange on_change,
               std::chrono::milliseconds interval = std::chrono::milliseconds(1000)) {
        // A change handler that re-registers from the worker thread cannot
        // restart its own thread; ignore the request.
        if (worker_.joinable() && worker_.get_id() == std::this_thread::get_id())
            return;
        stop();
        // The worker owns this state through a shared pointer and never
        // touches the poller itself, so it cannot outlive what it uses.
        auto state = std::make_shared<State>();
        state->tracker.update(enumerate());
        state_ = state;
        worker_ = std::thread(
            [state, enumerate = std::move(enumerate), on_change = std::move(on_change), interval] {
                std::unique_lock<std::mutex> lk(state->mu);
                while (!state->stopping) {
                    state->cv.wait_for(lk, interval, [&state] { return state->stopping; });
                    if (state->stopping)
                        break;
                    lk.unlock();
                    const auto diff = state->tracker.update(enumerate());
                    if (!diff.empty() && on_change)
                        on_change(diff);
                    lk.lock();
                }
            });
    }
 
    void stop() {
        if (auto state = state_) {
            {
                std::lock_guard<std::mutex> lk(state->mu);
                state->stopping = true;
            }
            state->cv.notify_all();
        }
        // Called from inside `on_change`: the loop sees the flag and exits on
        // its own; the next stop() or the destructor joins it.
        if (worker_.joinable() && worker_.get_id() != std::this_thread::get_id())
            worker_.join();
    }
 
    bool running() const {
        return worker_.joinable();
    }
 
  private:
    struct State {
        std::mutex mu;
        std::condition_variable cv;
        bool stopping = false;
        PortListTracker tracker;
    };
 
    std::shared_ptr<State> state_;
    std::thread worker_;
};
 
} // namespace pulp::midi