Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <Settings/NamespaceSettings.hpp>
       4             : 
       5             : #include <chrono>
       6             : #include <condition_variable>
       7             : #include <mutex>
       8             : #include <thread>
       9             : 
      10             : #include "BLEAPI.hpp"
      11             : #include <MIDI_Interfaces/BLEMIDI/BLEMIDIPacketBuilder.hpp>
      12             : 
      13             : BEGIN_CS_NAMESPACE
      14             : 
      15             : /// Class that manages a background thread that sends BLE packets asynchronously.
      16             : template <class Derived>
      17             : class ThreadedBLEMIDISender {
      18             :   public:
      19          58 :     ThreadedBLEMIDISender() = default;
      20             :     ThreadedBLEMIDISender(const ThreadedBLEMIDISender &) = delete;
      21             :     ThreadedBLEMIDISender &operator=(const ThreadedBLEMIDISender &) = delete;
      22             :     ~ThreadedBLEMIDISender();
      23             : 
      24             :     /// Start the background thread.
      25             :     void begin();
      26             : 
      27             :     struct ProtectedBuilder;
      28             : 
      29             :     /// Acquire exclusive access to the buffer to be sent by the timer.
      30             :     /// @return A RAII wrapper that automatically releases the buffer upon
      31             :     ///         destruction. Just make sure you don't keep any pointers to the
      32             :     ///         `packet` member.
      33             :     ProtectedBuilder acquirePacket();
      34             :     /// Release exclusive access to the buffer and notify the sender thread that
      35             :     /// data is available.
      36             :     void releasePacketAndNotify(ProtectedBuilder &lck);
      37             : 
      38             :     /// Sends the data immediately without waiting for the timeout.
      39             :     void sendNow(ProtectedBuilder &lck);
      40             : 
      41             :     /// Set the maximum transmission unit of the Bluetooth link. Used to compute
      42             :     /// the MIDI BLE packet size.
      43             :     void updateMTU(uint16_t mtu);
      44             :     /// Get the minimum MTU of all connected clients.
      45             :     uint16_t getMinMTU() const { return min_mtu; }
      46             :     /// Force the MTU to an artificially small value (used for testing).
      47             :     void forceMinMTU(uint16_t mtu);
      48             : 
      49             :     /// Set the timeout, the number of milliseconds to buffer the outgoing MIDI
      50             :     /// messages.
      51             :     void setTimeout(std::chrono::milliseconds timeout);
      52             : 
      53             :   private:
      54             :     /// Actually perform the BLE notification with the given data.
      55             :     void sendData(BLEDataView) = delete; // should be implemented by subclass
      56             : 
      57             :     /// Function that waits for BLE packets and sends them in the background.
      58             :     /// It either sends them after a timeout (a given number of milliseconds
      59             :     /// after the first data was added to the packet), or immediately when it
      60             :     /// receives a flush signal from the main thread.
      61             :     bool handleSendEvents();
      62             : 
      63             :   private:
      64             :     struct {
      65             :         /// View of the data to send
      66             :         BLEMIDIPacketBuilder packet;
      67             :         /// Flag to stop the background thread.
      68             :         bool stop = false;
      69             :         /// Flag to tell the sender thread to send the packet immediately.
      70             :         bool flush = false;
      71             :         /// Timeout before the sender thread sends a packet.
      72             :         /// @see @ref setTimeout()
      73          29 :         std::chrono::milliseconds timeout {10};
      74             :         /// Lock to protect all shared data in this struct.
      75             :         std::mutex mtx;
      76             :     } shared {};
      77             :     /// Condition variable used by the background sender thread to wait for
      78             :     /// data to send, and for the main thread to wait for the data to be flushed
      79             :     /// by the sender thread.
      80             :     std::condition_variable cv;
      81             :     /// Lock type used to lock the mutex
      82             :     using lock_t = std::unique_lock<std::mutex>;
      83             :     /// The background thread responsible for sending the data.
      84             :     std::thread send_thread;
      85             : 
      86             :   private:
      87             :     /// The minimum MTU of all connected clients.
      88             :     std::atomic_uint_fast16_t min_mtu {23};
      89             :     /// Override the minimum MTU (0 means don't override, nonzero overrides if
      90             :     /// it's smaller than the minimum MTU of the clients).
      91             :     /// @see    @ref forceMinMTU()
      92             :     std::atomic_uint_fast16_t force_min_mtu {515};
      93             : 
      94             :   public:
      95             :     struct ProtectedBuilder {
      96             :         BLEMIDIPacketBuilder *packet;
      97             :         lock_t lck;
      98             :     };
      99             : };
     100             : 
     101             : END_CS_NAMESPACE
     102             : 
     103             : #include "ThreadedBLEMIDISender.ipp"