thread_manager.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "workers.hpp"
#include <atomic>
#include <future>
#include <memory>
#include <mutex>
#include <thread>

class ThreadManager
{
public:
  struct ThreadState
  {
    std::mutex play_mutex;        
    std::mutex queue_mutex;       
    std::mutex audioDevicesMutex; 
 
    std::atomic<bool> is_processing{false}; 
    std::atomic<bool> is_playing{false};    
 
    std::future<void>            play_future;       
    std::unique_ptr<std::thread> mpris_dbus_thread; 
    std::thread playNextSongThread; 
  };

  ThreadManager() : worker_pool(std::make_shared<WorkerThreadPool>()) {}

  /*~ThreadManager() { cleanupAllThreads(); }*/

  auto getThreadState() -> ThreadState& { return thread_state; }

  auto getWorkerThreadPool() -> WorkerThreadPool& { return *worker_pool; }

  void lockPlayMutex(ThreadState& thread_state)
  {
    std::lock_guard<std::mutex> lock(thread_state.play_mutex);
  }

  void lockQueueMutex(ThreadState& thread_state)
  {
    std::lock_guard<std::mutex> lock(thread_state.queue_mutex);
  }
 
private:
  void cleanupAllThreads()
  {
    try
    {
      // Clean up playNextSongThread if joinable.
      if (thread_state.playNextSongThread.joinable())
      {
        thread_state.playNextSongThread.join();
      }
    }
    catch (const std::exception& e)
    {
      // Log exceptions during cleanup (adjust logging mechanism as needed).
      std::cerr << "Exception during thread cleanup: " << e.what() << std::endl;
    }
    catch (...)
    {
      std::cerr << "Unknown exception during thread cleanup." << std::endl;
    }
  }

  ThreadState thread_state;

  std::shared_ptr<WorkerThreadPool> worker_pool;
};