Handler.cpp

Go to the documentation of this file.

 
 #include <assert.h>
 #include <chrono>
 #include "Handler.h"
 #include <iostream>
 #include <string>
 
 #define ms2us(x) (x*1000LL)
 
namespace swt {
 Handler::Handler(std::shared_ptr<SLLooper>& looper)
 {
     mEventQueue = looper->getEventQueue();  // ✅ Updated method name
     mLooper = looper;
 }
 
 Handler::~Handler()
 {
     // Future: Remove pending messages from queue
     // mEventQueue->removeMessagesForHandler(shared_from_this());
 }
 
 // ========== MESSAGE CREATION API ==========
 
 std::shared_ptr<Message> Handler::obtainMessage()
 {
     return Message::obtain(shared_from_this()); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what)
 {
     return Message::obtain(shared_from_this(), what); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, int32_t arg1)
 {
     return Message::obtain(shared_from_this(), what, arg1); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, void* obj)
 {
     return Message::obtain(shared_from_this(), what, obj); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, int32_t arg1, int32_t arg2)
 {
     return Message::obtain(shared_from_this(), what, arg1, arg2); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, int32_t arg1, int32_t arg2, void* obj)
 {
     return Message::obtain(shared_from_this(), what, arg1, arg2, obj); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, int32_t arg1, int32_t arg2, int32_t arg3)
 {
     return Message::obtain(shared_from_this(), what, arg1, arg2, arg3); // ✅ SAFE!
 }
 
 std::shared_ptr<Message> Handler::obtainMessage(int32_t what, std::shared_ptr<RefBase> spRef)
 {
     return Message::obtain(shared_from_this(), what, spRef); 
 }
 
 // ========== MESSAGE SENDING API ==========
 
 bool Handler::sendMessage(const std::shared_ptr<Message>& message)
 {
     return sendMessageAtTime(message, uptimeMicros());
 }
 
 bool Handler::sendMessageDelayed(const std::shared_ptr<Message>& message, int64_t delayMs)
 {
     return sendMessageAtTime(message, (uptimeMicros() + ms2us(delayMs)));
 }
 
 bool Handler::sendMessageAtTime(const std::shared_ptr<Message>& message, int64_t whenUs)
 {
     return mEventQueue->enqueueMessage(message, whenUs);
 }
 
 // ========== MESSAGE QUERY API ==========
 
 bool Handler::hasMessages(int32_t what)
 {
     return mEventQueue->hasMessage(shared_from_this(), what, NULL); // ✅ SAFE!
 }
 
 bool Handler::removeMessages(int32_t what)
 {
     // TODO: Implement message removal
     // return mEventQueue->removeMessages(shared_from_this(), what);
     return false;
 }
 
 bool Handler::removeMessages(int32_t what, void* obj)
 {
     // TODO: Implement selective message removal
     // return mEventQueue->removeMessages(shared_from_this(), what, obj);
     return false;
 }
 
 // ========== MESSAGE PROCESSING ==========
 
 void Handler::dispatchMessage(const std::shared_ptr<Message>& message)
 {
     // Future: Add message preprocessing here
     // logMessage(message);
     // validateMessage(message);
     
     handleMessage(message);
 }
 
 // ========== UTILITY METHODS ==========
 
 int64_t Handler::uptimeMicros()
 {
     auto now = std::chrono::steady_clock::now();
     auto dur = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch());
     return dur.count();
 }
 
} // namespace swt