Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3fcdef18 authored by Lloyd Pique's avatar Lloyd Pique
Browse files

SF: Separate MessageQueue into interface and impl 

Test: Builds
Bug: 74827900
Change-Id: I906892c00b6cb9adca3fbdd72a03001c2d72cbfc
parent ac648ee7

services/surfaceflinger/MessageQueue.cpp

+10 −6
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <utils/Timers.h>

#include <utils/threads.h>



#include <gui/DisplayEventReceiver.h>

#include <gui/IDisplayEventConnection.h>



#include "EventThread.h"
@@ -45,6 +46,12 @@ void MessageBase::handleMessage(const Message&) { 


// ---------------------------------------------------------------------------



MessageQueue::~MessageQueue() = default;



// ---------------------------------------------------------------------------



namespace impl {



void MessageQueue::Handler::dispatchRefresh() {

    if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {

        mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));
@@ -72,17 +79,13 @@ void MessageQueue::Handler::handleMessage(const Message& message) { 


// ---------------------------------------------------------------------------



MessageQueue::MessageQueue() {}



MessageQueue::~MessageQueue() {}



void MessageQueue::init(const sp<SurfaceFlinger>& flinger) {

    mFlinger = flinger;

    mLooper = new Looper(true);

    mHandler = new Handler(*this);

}



void MessageQueue::setEventThread(EventThread* eventThread) {

void MessageQueue::setEventThread(android::EventThread* eventThread) {

    if (mEventThread == eventThread) {

        return;

    }
@@ -159,4 +162,5 @@ int MessageQueue::eventReceiver(int /*fd*/, int /*events*/) { 


// ---------------------------------------------------------------------------



}; // namespace android
 
} // namespace impl

} // namespace android

services/surfaceflinger/MessageQueue.h

+32 −17
Original line number Diff line number Diff line
@@ -25,7 +25,7 @@ 
#include <utils/Timers.h>

#include <utils/threads.h>



#include <gui/DisplayEventReceiver.h>

#include <gui/IDisplayEventConnection.h>

#include <private/gui/BitTube.h>



#include "Barrier.h"
@@ -34,7 +34,6 @@ 


namespace android {



class IDisplayEventConnection;

class EventThread;

class SurfaceFlinger;
@@ -77,6 +76,27 @@ private: 
// ---------------------------------------------------------------------------



class MessageQueue {

public:

    enum {

        INVALIDATE = 0,

        REFRESH = 1,

    };



    virtual ~MessageQueue();



    virtual void init(const sp<SurfaceFlinger>& flinger) = 0;

    virtual void setEventThread(EventThread* events) = 0;

    virtual void waitMessage() = 0;

    virtual status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0) = 0;

    virtual void invalidate() = 0;

    virtual void refresh() = 0;

};



// ---------------------------------------------------------------------------



namespace impl {



class MessageQueue final : public android::MessageQueue {

    class Handler : public MessageHandler {

        enum { eventMaskInvalidate = 0x1, eventMaskRefresh = 0x2, eventMaskTransaction = 0x4 };

        MessageQueue& mQueue;
@@ -93,7 +113,7 @@ class MessageQueue { 


    sp<SurfaceFlinger> mFlinger;

    sp<Looper> mLooper;

    EventThread* mEventThread;

    android::EventThread* mEventThread;

    sp<IDisplayEventConnection> mEvents;

    gui::BitTube mEventTube;

    sp<Handler> mHandler;
@@ -102,27 +122,22 @@ class MessageQueue { 
    int eventReceiver(int fd, int events);



public:

    enum {

        INVALIDATE = 0,

        REFRESH = 1,

    };



    MessageQueue();

    ~MessageQueue();

    void init(const sp<SurfaceFlinger>& flinger);

    void setEventThread(EventThread* events);

    ~MessageQueue() override = default;

    void init(const sp<SurfaceFlinger>& flinger) override;

    void setEventThread(android::EventThread* events) override;



    void waitMessage();

    status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0);

    void waitMessage() override;

    status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0) override;



    // sends INVALIDATE message at next VSYNC

    void invalidate();

    void invalidate() override;

    // sends REFRESH message at next VSYNC

    void refresh();

    void refresh() override;

};



// ---------------------------------------------------------------------------



}; // namespace android

} // namespace impl

} // namespace android



#endif /* ANDROID_MESSAGE_QUEUE_H */

services/surfaceflinger/SurfaceFlinger.cpp

+11 −10
Original line number Diff line number Diff line
@@ -278,7 +278,7 @@ SurfaceFlinger::SurfaceFlinger() : SurfaceFlinger(SkipInitialization) { 


void SurfaceFlinger::onFirstRef()

{

    mEventQueue.init(this);

    mEventQueue->init(this);

}



SurfaceFlinger::~SurfaceFlinger()
@@ -584,9 +584,10 @@ void SurfaceFlinger::init() { 
    mSfEventThreadSource =

            std::make_unique<DispSyncSource>(&mPrimaryDispSync,

                                             SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");



    mSFEventThread = std::make_unique<impl::EventThread>(mSfEventThreadSource.get(), *this, true,

                                                         "sfEventThread");

    mEventQueue.setEventThread(mSFEventThread.get());

    mEventQueue->setEventThread(mSFEventThread.get());



    // Get a RenderEngine for the given display / config (can't fail)

    getBE().mRenderEngine =
@@ -1075,10 +1076,10 @@ status_t SurfaceFlinger::enableVSyncInjections(bool enable) { 
                        std::make_unique<impl::EventThread>(mVSyncInjector.get(), *this, false,

                                                            "injEventThread");

            }

            mEventQueue.setEventThread(mInjectorEventThread.get());

            mEventQueue->setEventThread(mInjectorEventThread.get());

        } else {

            ALOGV("VSync Injections disabled");

            mEventQueue.setEventThread(mSFEventThread.get());

            mEventQueue->setEventThread(mSFEventThread.get());

        }



        mInjectVSyncs = enable;
@@ -1143,30 +1144,30 @@ sp<IDisplayEventConnection> SurfaceFlinger::createDisplayEventConnection( 
// ----------------------------------------------------------------------------



void SurfaceFlinger::waitForEvent() {

    mEventQueue.waitMessage();

    mEventQueue->waitMessage();

}



void SurfaceFlinger::signalTransaction() {

    mEventQueue.invalidate();

    mEventQueue->invalidate();

}



void SurfaceFlinger::signalLayerUpdate() {

    mEventQueue.invalidate();

    mEventQueue->invalidate();

}



void SurfaceFlinger::signalRefresh() {

    mRefreshPending = true;

    mEventQueue.refresh();

    mEventQueue->refresh();

}



status_t SurfaceFlinger::postMessageAsync(const sp<MessageBase>& msg,

        nsecs_t reltime, uint32_t /* flags */) {

    return mEventQueue.postMessage(msg, reltime);

    return mEventQueue->postMessage(msg, reltime);

}



status_t SurfaceFlinger::postMessageSync(const sp<MessageBase>& msg,

        nsecs_t reltime, uint32_t /* flags */) {

    status_t res = mEventQueue.postMessage(msg, reltime);

    status_t res = mEventQueue->postMessage(msg, reltime);

    if (res == NO_ERROR) {

        msg->wait();

    }

services/surfaceflinger/SurfaceFlinger.h

+1 −1
Original line number Diff line number Diff line
@@ -784,7 +784,7 @@ private: 
    bool mLayerTripleBufferingDisabled = false;



    // these are thread safe

    mutable MessageQueue mEventQueue;

    mutable std::unique_ptr<MessageQueue> mEventQueue{std::make_unique<impl::MessageQueue>()};

    FrameTracker mAnimFrameTracker;

    DispSync mPrimaryDispSync;