HWUI: use public choreographer api

Bug: 198192636
Test: atest hwui_unit_tests
Change-Id: Ic8b833d87d2ba381496cfcf7e21bb9557e9ba85f

2 files changed, 46 insertions, 27 deletions

diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index f83c0a4926f9..6755b7c081f4 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -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:
diff --git a/libs/hwui/renderthread/RenderThread.h b/libs/hwui/renderthread/RenderThread.h
index 0b81fc04edf5..c1f6790b25b2 100644
--- a/libs/hwui/renderthread/RenderThread.h
+++ b/libs/hwui/renderthread/RenderThread.h
@@ -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();