commit e55aa630dee82e63476101f9313e5b6dbf17b952
author Alec Mouri <alecmouri@google.com> Wed Apr 15 19:46:05 2020 -0700
committer Alec Mouri <alecmouri@google.com> Thu Apr 23 16:21:40 2020 -0700
tree abe71a829d9be1c9c9629139b7a544488b15848c
parent d5fa1dcff518772b0f72d5a8141bc8a58ff01a0c

Grab display information for render thread through java

With HWUI becoming an APEX module, we need to use public apis wherever
possible - since there aren't plans to expose a stable api for physical
display information through native, instead grab the system context
from ActivityThread so that we can use DisplayManager's public apis.

The api for retrieving the system context is left as a hidden api - a
future change should stabilize the API or switch to a new api that does
not yet exist. But, this is the right shape for plumbing through the
display information, as the old code retrieved it through SurfaceFlinger
which should not be stabilized as the source of truth for display
information is DisplayManagerService.

Bug: 146387012
Bug: 150880248
Test: builds, boots, verified that the correct display info is plumbed
down

Change-Id: I1a99a72244969bdece2903993e3beb27a6e534b1

libs/hwui/DeviceInfo.h

diff --git a/libs/hwui/DeviceInfo.h b/libs/hwui/DeviceInfo.h
index bcc9301..191dcd8 100644
--- a/libs/hwui/DeviceInfo.h
+++ b/libs/hwui/DeviceInfo.h
@@ -16,8 +16,10 @@
 #ifndef DEVICEINFO_H
 #define DEVICEINFO_H
 
-#include <apex/display.h>
 #include <SkImageInfo.h>
+#include <android/data_space.h>
+
+#include <mutex>
 
 #include "utils/Macros.h"
 
@@ -39,16 +41,34 @@
     // Gets the density in density-independent pixels
     static float getDensity() { return sDensity.load(); }
     static int64_t getVsyncPeriod() { return get()->mVsyncPeriod; }
-    static int64_t getCompositorOffset() { return get()->mCompositorOffset; }
-    static int64_t getAppOffset() { return get()->mAppOffset; }
+    static int64_t getCompositorOffset() { return get()->getCompositorOffsetInternal(); }
+    static int64_t getAppOffset() { return get()->mAppVsyncOffsetNanos; }
     // Sets the density in density-independent pixels
     static void setDensity(float density) { sDensity.store(density); }
+    static void setMaxRefreshRate(float refreshRate) { get()->mMaxRefreshRate = refreshRate; }
+    static void setWidth(int32_t width) { get()->mWidth = width; }
+    static void setHeight(int32_t height) { get()->mHeight = height; }
+    static void setRefreshRate(float refreshRate) {
+        get()->mVsyncPeriod = static_cast<int64_t>(1000000000 / refreshRate);
+    }
+    static void setPresentationDeadlineNanos(int64_t deadlineNanos) {
+        get()->mPresentationDeadlineNanos = deadlineNanos;
+    }
+    static void setAppVsyncOffsetNanos(int64_t offsetNanos) {
+        get()->mAppVsyncOffsetNanos = offsetNanos;
+    }
+    static void setWideColorDataspace(ADataSpace dataspace);
 
     // this value is only valid after the GPU has been initialized and there is a valid graphics
     // context or if you are using the HWUI_NULL_GPU
     int maxTextureSize() const;
     sk_sp<SkColorSpace> getWideColorSpace() const { return mWideColorSpace; }
-    SkColorType getWideColorType() const { return mWideColorType; }
+    SkColorType getWideColorType() {
+        static std::once_flag kFlag;
+        // lazily update display info from SF here, so that the call is performed by RenderThread.
+        std::call_once(kFlag, [&, this]() { updateDisplayInfo(); });
+        return mWideColorType;
+    }
 
     // This method should be called whenever the display refresh rate changes.
     void onRefreshRateChanged(int64_t vsyncPeriod);
@@ -57,23 +77,26 @@
     friend class renderthread::RenderThread;
     static void setMaxTextureSize(int maxTextureSize);
     void updateDisplayInfo();
+    int64_t getCompositorOffsetInternal() const {
+        // Assume that SF takes around a millisecond to latch buffers after
+        // waking up
+        return mVsyncPeriod - (mPresentationDeadlineNanos - 1000000);
+    }
 
     DeviceInfo();
-    ~DeviceInfo();
+    ~DeviceInfo() = default;
 
     int mMaxTextureSize;
     sk_sp<SkColorSpace> mWideColorSpace = SkColorSpace::MakeSRGB();
     SkColorType mWideColorType = SkColorType::kN32_SkColorType;
-    ADisplayConfig* mCurrentConfig = nullptr;
-    ADisplay** mDisplays = nullptr;
     int mDisplaysSize = 0;
     int mPhysicalDisplayIndex = -1;
     float mMaxRefreshRate = 60.0;
     int32_t mWidth = 1080;
     int32_t mHeight = 1920;
     int64_t mVsyncPeriod = 16666666;
-    int64_t mCompositorOffset = 0;
-    int64_t mAppOffset = 0;
+    int64_t mPresentationDeadlineNanos = 0;
+    int64_t mAppVsyncOffsetNanos = 0;
 
     // Density is not retrieved from the ADisplay apis, so this may potentially
     // be called on multiple threads.