BluetoothMIDI_Interface.hpp

Go to the documentation of this file.

#pragma once
 
#include <AH/Error/Error.hpp>
 
#include "BLEMIDI/BLEMIDIPacketBuilder.hpp"
#include "BLEMIDI/MIDIMessageQueue.hpp"
#include "MIDI_Interface.hpp"
#include "Util/ESP32Threads.hpp"
#include <MIDI_Parsers/BLEMIDIParser.hpp>
#include <MIDI_Parsers/SerialMIDI_Parser.hpp>
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <thread>
 
#ifndef ARDUINO
#include <gmock/gmock.h>
#endif
 
BEGIN_CS_NAMESPACE
 
class BluetoothMIDI_Interface : public MIDI_Interface {
 
  public:
    BluetoothMIDI_Interface() {
        if (instance)
            FATAL_ERROR(F("Only one instance is supported"), 0x1345);
        instance = this;
    };
    ~BluetoothMIDI_Interface() {
        instance = nullptr;
        stopSendingThread();
        end();
    }
 
  public:
    void flush() {
        lock_t lock(mtx);
        flushImpl(lock);
    }
 
    void setTimeout(std::chrono::milliseconds timeout) {
        lock_t lock(mtx);
        this->timeout = timeout;
    }
 
  public:
    void setName(const char *name);
 
    void begin() override;
    void end();
 
    MIDIReadEvent read();
 
    void update() override { MIDI_Interface::updateIncoming(this); }
 
  private:
#if !DISABLE_PIPES
    void handleStall() override { MIDI_Interface::handleStall(this); }
#endif
 
  public:
    ChannelMessage getChannelMessage() const;
    SysCommonMessage getSysCommonMessage() const;
    RealTimeMessage getRealTimeMessage() const;
    SysExMessage getSysExMessage() const;
    uint16_t getTimestamp() const;
 
  protected:
    // MIDI send implementations
    void sendChannelMessageImpl(ChannelMessage) override;
    void sendSysCommonImpl(SysCommonMessage) override;
    void sendSysExImpl(SysExMessage) override;
    void sendRealTimeImpl(RealTimeMessage) override;
    void sendNowImpl() override { flush(); }
 
    void sendChannelMessageImpl3Bytes(ChannelMessage);
    void sendChannelMessageImpl2Bytes(ChannelMessage);
 
  public:
    void parse(const uint8_t *const data, const size_t len);
 
  private:
    std::atomic_uint_fast16_t min_mtu{23};
    std::atomic_uint_fast16_t force_min_mtu{0};
 
    void updateMTU(uint16_t mtu);
 
  public:
    uint16_t getMinMTU() const { return min_mtu; }
 
    void forceMinMTU(uint16_t mtu);
 
  private:
    static BluetoothMIDI_Interface *instance;
    SerialMIDI_Parser parser{false};
    BLEMIDIPacketBuilder packetbuilder;
    MIDIMessageQueue queue{64};
    MIDIMessageQueue::MIDIMessageQueueElement incomingMessage;
 
  private:
    // Synchronization for asynchronous BLE sending
 
    using lock_t = std::unique_lock<std::mutex>;
    std::mutex mtx;
    std::condition_variable cv;
    std::thread send_thread;
    std::atomic_bool stop_sending{false};
    bool flushnow = false;
    std::chrono::milliseconds timeout{10};
 
  private:
    void startSendingThread();
 
    bool handleSendEvents();
 
    void flushImpl(lock_t &lock);
 
#if !defined(ARDUINO) && !defined(DOXYGEN)
    public:
#endif
    void stopSendingThread();
 
  public:
    static void midi_write_callback(const uint8_t *data, size_t length) {
        if (instance)
            instance->parse(data, length);
    }
 
    static void midi_mtu_callback(uint16_t mtu) {
        if (instance)
            instance->updateMTU(mtu);
    }
 
#ifdef ARDUINO
  private:
    void notifyMIDIBLE(const std::vector<uint8_t> &packet);
#else
  public:
    MOCK_METHOD(void, notifyMIDIBLE, (const std::vector<uint8_t> &), ());
#endif
};
 
END_CS_NAMESPACE