TimerManager.h

Go to the documentation of this file.

 
 #pragma once
 
 #include "Timer.h"
 #include <sys/timerfd.h>
 #include <sys/epoll.h>
 #include <unistd.h>
 #include <signal.h>
 #include <time.h>
 #include <functional>
 #include <unordered_map>
 #include <thread>
 #include <atomic>
 #include <memory>
 #include <mutex>
 #include <stdexcept>
 
 // ========== Timer Backend Selection ==========
 // Uncomment ONE of the following lines to select timer backend:
 
 //#define TIMER_USE_SIGEV_THREAD    ///< Use timer_create + sigev_thread
 #define TIMER_USE_TIMERFD_EPOLL     
 
 // Validate macro selection
 #if defined(TIMER_USE_SIGEV_THREAD) && defined(TIMER_USE_TIMERFD_EPOLL)
     #error "Cannot define both TIMER_USE_SIGEV_THREAD and TIMER_USE_TIMERFD_EPOLL"
 #endif
 
 #if !defined(TIMER_USE_SIGEV_THREAD) && !defined(TIMER_USE_TIMERFD_EPOLL)
     #define TIMER_USE_TIMERFD_EPOLL  
 #endif
 
 
 namespace swt {
 
 // Forward declaration
 class SLLooper;
 
 using TimerId = uint64_t;
 
 class TimerManager {
 public:
     struct TimerInfo {
 #ifdef TIMER_USE_TIMERFD_EPOLL
         int fd;                           
 #else
         timer_t timer;                    
         TimerId timerId;                  
 #endif
         std::function<void()> callback;   
         bool periodic;                    
         uint64_t interval_ms;             
         TimerId id;                       
         std::atomic<bool>* cancelled;     
     };
 
 private:
 #ifdef TIMER_USE_TIMERFD_EPOLL
     int mEpollFd;                         
     std::thread mTimerThread;             
 #else
     static std::unordered_map<TimerId, TimerManager*> sTimerManagerMap;
     
     static std::mutex sManagerMapMutex;
     
 #endif
 
     std::atomic<bool> mRunning{true};                    
     std::unordered_map<TimerId, TimerInfo> mTimers;      
     std::mutex mTimersMutex;                             
     std::weak_ptr<SLLooper> mLooper;                     
     std::atomic<TimerId> mNextId{1};                     
 public:
     explicit TimerManager(std::weak_ptr<SLLooper> looper);
     
     ~TimerManager();
 
     TimerId createTimer(std::function<void()> callback, uint64_t delay_ms, 
                        bool periodic, std::atomic<bool>* cancelled);
 
     bool cancelTimer(TimerId id);
 
     bool hasTimer(TimerId id);
 
     bool restartTimer(TimerId id, uint64_t delay_ms);
 
     void updateCancelledPtr(TimerId id, std::atomic<bool>* newPtr);
 
     size_t getActiveTimerCount();
 
     static const char* getBackendName() {
 #ifdef TIMER_USE_TIMERFD_EPOLL
         return "TIMERFD_EPOLL";
 #else
         return "SIGEV_THREAD";
 #endif
     }
 
 private:
 #ifdef TIMER_USE_TIMERFD_EPOLL
     void timerThreadFunc();
     
     int createTimerFd(uint64_t delay_ms, bool periodic);
     
     void updateTimerFd(int fd, uint64_t delay_ms, bool periodic);
     
 #else
     timer_t createSigevTimer(TimerId id);
     
     void updateSigevTimer(timer_t timer, uint64_t delay_ms, bool periodic);
     
     static void sigevTimerCallback(sigval_t sv);
     
 #endif
 
     void handleTimerExpired(const TimerInfo& timerInfo);
     
     void cleanupTimer(TimerId id);
     
 };
 
 } // namespace swt