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

Commit 432b6911 authored by Rachel Lee's avatar Rachel Lee
Browse files

HWUI: use public choreographer api 

Bug: 198192636
Test: atest hwui_unit_tests
Change-Id: Ic8b833d87d2ba381496cfcf7e21bb9557e9ba85f
parent 6350ff0b

libs/hwui/renderthread/RenderThread.cpp

+43 −26
Original line number Diff line number Diff line
@@ -16,8 +16,21 @@ 


#include "RenderThread.h"



#include <GrContextOptions.h>

#include <android-base/properties.h>

#include <dlfcn.h>

#include <gl/GrGLInterface.h>

#include <gui/TraceUtils.h>

#include <sys/resource.h>

#include <ui/FatVector.h>

#include <utils/Condition.h>

#include <utils/Log.h>

#include <utils/Mutex.h>



#include <thread>



#include "../HardwareBitmapUploader.h"

#include "CacheManager.h"

#include "CanvasContext.h"

#include "DeviceInfo.h"

#include "EglManager.h"
@@ -31,19 +44,6 @@ 
#include "renderstate/RenderState.h"

#include "utils/TimeUtils.h"



#include <GrContextOptions.h>

#include <gl/GrGLInterface.h>



#include <dlfcn.h>

#include <sys/resource.h>

#include <utils/Condition.h>

#include <utils/Log.h>

#include <utils/Mutex.h>

#include <thread>



#include <android-base/properties.h>

#include <ui/FatVector.h>



namespace android {

namespace uirenderer {

namespace renderthread {
@@ -112,18 +112,31 @@ ASurfaceControlFunctions::ASurfaceControlFunctions() { 
                        "Failed to find required symbol ASurfaceTransaction_setZOrder!");

}



void RenderThread::frameCallback(int64_t frameTimeNanos, void* data) {

void RenderThread::extendedFrameCallback(const AChoreographerFrameCallbackData* cbData,

                                         void* data) {

    RenderThread* rt = reinterpret_cast<RenderThread*>(data);

    int64_t vsyncId = AChoreographer_getVsyncId(rt->mChoreographer);

    int64_t frameDeadline = AChoreographer_getFrameDeadline(rt->mChoreographer);

    size_t preferredFrameTimelineIndex =

            AChoreographerFrameCallbackData_getPreferredFrameTimelineIndex(cbData);

    int64_t vsyncId = AChoreographerFrameCallbackData_getFrameTimelineVsyncId(

            cbData, preferredFrameTimelineIndex);

    int64_t frameDeadline = AChoreographerFrameCallbackData_getFrameTimelineDeadline(

            cbData, preferredFrameTimelineIndex);

    int64_t frameTimeNanos = AChoreographerFrameCallbackData_getFrameTimeNanos(cbData);

    // TODO(b/193273294): Remove when shared memory in use w/ expected present time always current.

    int64_t frameInterval = AChoreographer_getFrameInterval(rt->mChoreographer);

    rt->mVsyncRequested = false;

    if (rt->timeLord().vsyncReceived(frameTimeNanos, frameTimeNanos, vsyncId, frameDeadline,

            frameInterval) && !rt->mFrameCallbackTaskPending) {

    rt->frameCallback(vsyncId, frameDeadline, frameTimeNanos, frameInterval);

}



void RenderThread::frameCallback(int64_t vsyncId, int64_t frameDeadline, int64_t frameTimeNanos,

                                 int64_t frameInterval) {

    mVsyncRequested = false;

    if (timeLord().vsyncReceived(frameTimeNanos, frameTimeNanos, vsyncId, frameDeadline,

                                 frameInterval) &&

        !mFrameCallbackTaskPending) {

        ATRACE_NAME("queue mFrameCallbackTask");

        rt->mFrameCallbackTaskPending = true;

        nsecs_t runAt = (frameTimeNanos + rt->mDispatchFrameDelay);

        rt->queue().postAt(runAt, [=]() { rt->dispatchFrameCallbacks(); });

        mFrameCallbackTaskPending = true;

        nsecs_t runAt = (frameTimeNanos + mDispatchFrameDelay);

        queue().postAt(runAt, [=]() { dispatchFrameCallbacks(); });

    }

}
@@ -139,8 +152,8 @@ public: 
    ChoreographerSource(RenderThread* renderThread) : mRenderThread(renderThread) {}



    virtual void requestNextVsync() override {

        AChoreographer_postFrameCallback64(mRenderThread->mChoreographer,

                                           RenderThread::frameCallback, mRenderThread);

        AChoreographer_postExtendedFrameCallback(

                mRenderThread->mChoreographer, RenderThread::extendedFrameCallback, mRenderThread);

    }



    virtual void drainPendingEvents() override {
@@ -157,12 +170,16 @@ public: 


    virtual void requestNextVsync() override {

        mRenderThread->queue().postDelayed(16_ms, [this]() {

            RenderThread::frameCallback(systemTime(SYSTEM_TIME_MONOTONIC), mRenderThread);

            mRenderThread->frameCallback(UiFrameInfoBuilder::INVALID_VSYNC_ID,

                                         std::numeric_limits<int64_t>::max(),

                                         systemTime(SYSTEM_TIME_MONOTONIC), 16_ms);

        });

    }



    virtual void drainPendingEvents() override {

        RenderThread::frameCallback(systemTime(SYSTEM_TIME_MONOTONIC), mRenderThread);

        mRenderThread->frameCallback(UiFrameInfoBuilder::INVALID_VSYNC_ID,

                                     std::numeric_limits<int64_t>::max(),

                                     systemTime(SYSTEM_TIME_MONOTONIC), 16_ms);

    }



private:

libs/hwui/renderthread/RenderThread.h

+3 −1
Original line number Diff line number Diff line
@@ -211,7 +211,9 @@ private: 
    // corresponding callbacks for each display event type

    static int choreographerCallback(int fd, int events, void* data);

    // Callback that will be run on vsync ticks.

    static void frameCallback(int64_t frameTimeNanos, void* data);

    static void extendedFrameCallback(const AChoreographerFrameCallbackData* cbData, void* data);

    void frameCallback(int64_t vsyncId, int64_t frameDeadline, int64_t frameTimeNanos,

                       int64_t frameInterval);

    // Callback that will be run whenver there is a refresh rate change.

    static void refreshRateCallback(int64_t vsyncPeriod, void* data);

    void drainDisplayEventQueue();