Merge "Update SOURCE_SENSOR source for input device." into sc-dev
diff --git a/libs/dumputils/dump_utils.cpp b/libs/dumputils/dump_utils.cpp
index 143fa13..8a82c2a 100644
--- a/libs/dumputils/dump_utils.cpp
+++ b/libs/dumputils/dump_utils.cpp
@@ -53,7 +53,6 @@
/* list of hal interface to dump containing process during native dumps */
static const char* hal_interfaces_to_dump[] {
- "android.hardware.audio@2.0::IDevicesFactory",
"android.hardware.audio@4.0::IDevicesFactory",
"android.hardware.audio@5.0::IDevicesFactory",
"android.hardware.audio@6.0::IDevicesFactory",
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index 38ae353..fa5044c 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -49,6 +49,7 @@
srcs: [
":framework_native_aidl",
+ ":inputconstants_aidl",
":libgui_aidl",
":libgui_bufferqueue_sources",
@@ -62,6 +63,7 @@
"DebugEGLImageTracker.cpp",
"DisplayEventDispatcher.cpp",
"DisplayEventReceiver.cpp",
+ "FrameTimelineInfo.cpp",
"GLConsumer.cpp",
"IConsumerListener.cpp",
"IDisplayEventConnection.cpp",
@@ -154,6 +156,7 @@
defaults: ["libgui_bufferqueue-defaults"],
srcs: [
+ ":inputconstants_aidl",
":libgui_aidl",
":libgui_bufferqueue_sources",
],
diff --git a/libs/gui/BLASTBufferQueue.cpp b/libs/gui/BLASTBufferQueue.cpp
index 42d2895..c62d9ad 100644
--- a/libs/gui/BLASTBufferQueue.cpp
+++ b/libs/gui/BLASTBufferQueue.cpp
@@ -370,9 +370,9 @@
}
t->setFrameNumber(mSurfaceControl, bufferItem.mFrameNumber);
- if (!mNextFrameTimelineVsyncIdQueue.empty()) {
- t->setFrameTimelineVsync(mSurfaceControl, mNextFrameTimelineVsyncIdQueue.front());
- mNextFrameTimelineVsyncIdQueue.pop();
+ if (!mNextFrameTimelineInfoQueue.empty()) {
+ t->setFrameTimelineInfo(mSurfaceControl, mNextFrameTimelineInfoQueue.front());
+ mNextFrameTimelineInfoQueue.pop();
}
if (mAutoRefresh != bufferItem.mAutoRefresh) {
@@ -534,8 +534,8 @@
return mBbq->setFrameRate(frameRate, compatibility, shouldBeSeamless);
}
- status_t setFrameTimelineVsync(int64_t frameTimelineVsyncId) override {
- return mBbq->setFrameTimelineVsync(frameTimelineVsyncId);
+ status_t setFrameTimelineInfo(const FrameTimelineInfo& frameTimelineInfo) override {
+ return mBbq->setFrameTimelineInfo(frameTimelineInfo);
}
};
@@ -549,9 +549,9 @@
return t.setFrameRate(mSurfaceControl, frameRate, compatibility, shouldBeSeamless).apply();
}
-status_t BLASTBufferQueue::setFrameTimelineVsync(int64_t frameTimelineVsyncId) {
+status_t BLASTBufferQueue::setFrameTimelineInfo(const FrameTimelineInfo& frameTimelineInfo) {
std::unique_lock _lock{mMutex};
- mNextFrameTimelineVsyncIdQueue.push(frameTimelineVsyncId);
+ mNextFrameTimelineInfoQueue.push(frameTimelineInfo);
return OK;
}
diff --git a/libs/gui/FrameTimelineInfo.cpp b/libs/gui/FrameTimelineInfo.cpp
new file mode 100644
index 0000000..f400774
--- /dev/null
+++ b/libs/gui/FrameTimelineInfo.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "FrameTimelineInfo"
+
+#include <inttypes.h>
+
+#include <android/os/IInputConstants.h>
+#include <gui/FrameTimelineInfo.h>
+#include <gui/LayerState.h>
+#include <utils/Errors.h>
+
+#include <cmath>
+
+using android::os::IInputConstants;
+
+namespace android {
+
+status_t FrameTimelineInfo::write(Parcel& output) const {
+ SAFE_PARCEL(output.writeInt64, vsyncId);
+ SAFE_PARCEL(output.writeInt32, inputEventId);
+ return NO_ERROR;
+}
+
+status_t FrameTimelineInfo::read(const Parcel& input) {
+ SAFE_PARCEL(input.readInt64, &vsyncId);
+ SAFE_PARCEL(input.readInt32, &inputEventId);
+ return NO_ERROR;
+}
+
+void FrameTimelineInfo::merge(const FrameTimelineInfo& other) {
+ // When merging vsync Ids we take the oldest valid one
+ if (vsyncId != INVALID_VSYNC_ID && other.vsyncId != INVALID_VSYNC_ID) {
+ if (other.vsyncId > vsyncId) {
+ vsyncId = other.vsyncId;
+ inputEventId = other.inputEventId;
+ }
+ } else if (vsyncId == INVALID_VSYNC_ID) {
+ vsyncId = other.vsyncId;
+ inputEventId = other.inputEventId;
+ }
+}
+
+void FrameTimelineInfo::clear() {
+ vsyncId = INVALID_VSYNC_ID;
+ inputEventId = IInputConstants::INVALID_INPUT_EVENT_ID;
+}
+
+}; // namespace android
diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp
index a8d6832..f68f3e1 100644
--- a/libs/gui/ISurfaceComposer.cpp
+++ b/libs/gui/ISurfaceComposer.cpp
@@ -68,16 +68,19 @@
return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
}
- virtual status_t setTransactionState(
- int64_t frameTimelineVsyncId, const Vector<ComposerState>& state,
- const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
- const InputWindowCommands& commands, int64_t desiredPresentTime, bool isAutoTimestamp,
- const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
- const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
+ status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo,
+ const Vector<ComposerState>& state,
+ const Vector<DisplayState>& displays, uint32_t flags,
+ const sp<IBinder>& applyToken, const InputWindowCommands& commands,
+ int64_t desiredPresentTime, bool isAutoTimestamp,
+ const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
+ const std::vector<ListenerCallbacks>& listenerCallbacks,
+ uint64_t transactionId) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
- SAFE_PARCEL(data.writeInt64, frameTimelineVsyncId);
+ SAFE_PARCEL(frameTimelineInfo.write, data);
+
SAFE_PARCEL(data.writeUint32, static_cast<uint32_t>(state.size()));
for (const auto& s : state) {
SAFE_PARCEL(s.write, data);
@@ -108,15 +111,14 @@
return remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply);
}
- virtual void bootFinished()
- {
+ void bootFinished() override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);
}
- virtual status_t captureDisplay(const DisplayCaptureArgs& args,
- const sp<IScreenCaptureListener>& captureListener) {
+ status_t captureDisplay(const DisplayCaptureArgs& args,
+ const sp<IScreenCaptureListener>& captureListener) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
SAFE_PARCEL(args.write, data);
@@ -125,8 +127,8 @@
return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY, data, &reply);
}
- virtual status_t captureDisplay(uint64_t displayOrLayerStack,
- const sp<IScreenCaptureListener>& captureListener) {
+ status_t captureDisplay(uint64_t displayOrLayerStack,
+ const sp<IScreenCaptureListener>& captureListener) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
SAFE_PARCEL(data.writeUint64, displayOrLayerStack);
@@ -135,8 +137,8 @@
return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY_BY_ID, data, &reply);
}
- virtual status_t captureLayers(const LayerCaptureArgs& args,
- const sp<IScreenCaptureListener>& captureListener) {
+ status_t captureLayers(const LayerCaptureArgs& args,
+ const sp<IScreenCaptureListener>& captureListener) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
SAFE_PARCEL(args.write, data);
@@ -145,9 +147,8 @@
return remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);
}
- virtual bool authenticateSurfaceTexture(
- const sp<IGraphicBufferProducer>& bufferProducer) const
- {
+ bool authenticateSurfaceTexture(
+ const sp<IGraphicBufferProducer>& bufferProducer) const override {
Parcel data, reply;
int err = NO_ERROR;
err = data.writeInterfaceToken(
@@ -180,8 +181,7 @@
return result != 0;
}
- virtual status_t getSupportedFrameTimestamps(
- std::vector<FrameEvent>* outSupported) const {
+ status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported) const override {
if (!outSupported) {
return UNEXPECTED_NULL;
}
@@ -224,8 +224,8 @@
return NO_ERROR;
}
- virtual sp<IDisplayEventConnection> createDisplayEventConnection(
- VsyncSource vsyncSource, EventRegistrationFlags eventRegistration) {
+ sp<IDisplayEventConnection> createDisplayEventConnection(
+ VsyncSource vsyncSource, EventRegistrationFlags eventRegistration) override {
Parcel data, reply;
sp<IDisplayEventConnection> result;
int err = data.writeInterfaceToken(
@@ -247,8 +247,7 @@
return result;
}
- virtual sp<IBinder> createDisplay(const String8& displayName, bool secure)
- {
+ sp<IBinder> createDisplay(const String8& displayName, bool secure) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t status = data.writeString8(displayName);
@@ -272,15 +271,14 @@
return display;
}
- virtual void destroyDisplay(const sp<IBinder>& display)
- {
+ void destroyDisplay(const sp<IBinder>& display) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply);
}
- virtual std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const {
+ std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (remote()->transact(BnSurfaceComposer::GET_PHYSICAL_DISPLAY_IDS, data, &reply) ==
@@ -297,7 +295,7 @@
return {};
}
- virtual sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const {
+ sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeUint64(displayId.value);
@@ -305,8 +303,7 @@
return reply.readStrongBinder();
}
- virtual void setPowerMode(const sp<IBinder>& display, int mode)
- {
+ void setPowerMode(const sp<IBinder>& display, int mode) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -314,7 +311,7 @@
remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply);
}
- virtual status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) {
+ status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -326,7 +323,7 @@
return result;
}
- virtual status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) {
+ status_t getDisplayInfo(const sp<IBinder>& display, DisplayInfo* info) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -336,7 +333,8 @@
return reply.read(*info);
}
- virtual status_t getDisplayConfigs(const sp<IBinder>& display, Vector<DisplayConfig>* configs) {
+ status_t getDisplayConfigs(const sp<IBinder>& display,
+ Vector<DisplayConfig>* configs) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -354,9 +352,7 @@
return result;
}
- virtual status_t getDisplayStats(const sp<IBinder>& display,
- DisplayStatInfo* stats)
- {
+ status_t getDisplayStats(const sp<IBinder>& display, DisplayStatInfo* stats) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -370,8 +366,7 @@
return result;
}
- virtual int getActiveConfig(const sp<IBinder>& display)
- {
+ int getActiveConfig(const sp<IBinder>& display) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -379,8 +374,8 @@
return reply.readInt32();
}
- virtual status_t getDisplayColorModes(const sp<IBinder>& display,
- Vector<ColorMode>* outColorModes) {
+ status_t getDisplayColorModes(const sp<IBinder>& display,
+ Vector<ColorMode>* outColorModes) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -409,8 +404,8 @@
return result;
}
- virtual status_t getDisplayNativePrimaries(const sp<IBinder>& display,
- ui::DisplayPrimaries& primaries) {
+ status_t getDisplayNativePrimaries(const sp<IBinder>& display,
+ ui::DisplayPrimaries& primaries) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -435,7 +430,7 @@
return result;
}
- virtual ColorMode getActiveColorMode(const sp<IBinder>& display) {
+ ColorMode getActiveColorMode(const sp<IBinder>& display) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -455,8 +450,7 @@
return static_cast<ColorMode>(reply.readInt32());
}
- virtual status_t setActiveColorMode(const sp<IBinder>& display,
- ColorMode colorMode) {
+ status_t setActiveColorMode(const sp<IBinder>& display, ColorMode colorMode) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -481,8 +475,8 @@
return static_cast<status_t>(reply.readInt32());
}
- virtual status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,
- bool* outSupport) const {
+ status_t getAutoLowLatencyModeSupport(const sp<IBinder>& display,
+ bool* outSupport) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t result = data.writeStrongBinder(display);
@@ -499,7 +493,7 @@
return reply.readBool(outSupport);
}
- virtual void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
+ void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -524,7 +518,8 @@
}
}
- virtual status_t getGameContentTypeSupport(const sp<IBinder>& display, bool* outSupport) const {
+ status_t getGameContentTypeSupport(const sp<IBinder>& display,
+ bool* outSupport) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t result = data.writeStrongBinder(display);
@@ -540,7 +535,7 @@
return reply.readBool(outSupport);
}
- virtual void setGameContentType(const sp<IBinder>& display, bool on) {
+ void setGameContentType(const sp<IBinder>& display, bool on) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -563,7 +558,7 @@
}
}
- virtual status_t clearAnimationFrameStats() {
+ status_t clearAnimationFrameStats() override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -578,7 +573,7 @@
return reply.readInt32();
}
- virtual status_t getAnimationFrameStats(FrameStats* outStats) const {
+ status_t getAnimationFrameStats(FrameStats* outStats) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply);
@@ -586,8 +581,8 @@
return reply.readInt32();
}
- virtual status_t getHdrCapabilities(const sp<IBinder>& display,
- HdrCapabilities* outCapabilities) const {
+ status_t getHdrCapabilities(const sp<IBinder>& display,
+ HdrCapabilities* outCapabilities) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t result = data.writeStrongBinder(display);
@@ -608,7 +603,7 @@
return result;
}
- virtual status_t enableVSyncInjections(bool enable) {
+ status_t enableVSyncInjections(bool enable) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -629,7 +624,7 @@
return result;
}
- virtual status_t injectVSync(nsecs_t when) {
+ status_t injectVSync(nsecs_t when) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -650,7 +645,7 @@
return result;
}
- virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) {
+ status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) override {
if (!outLayers) {
return UNEXPECTED_NULL;
}
@@ -680,10 +675,10 @@
return reply.readParcelableVector(outLayers);
}
- virtual status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
- ui::PixelFormat* defaultPixelFormat,
- ui::Dataspace* wideColorGamutDataspace,
- ui::PixelFormat* wideColorGamutPixelFormat) const {
+ status_t getCompositionPreference(ui::Dataspace* defaultDataspace,
+ ui::PixelFormat* defaultPixelFormat,
+ ui::Dataspace* wideColorGamutDataspace,
+ ui::PixelFormat* wideColorGamutPixelFormat) const override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -703,7 +698,7 @@
return error;
}
- virtual status_t getColorManagement(bool* outGetColorManagement) const {
+ status_t getColorManagement(bool* outGetColorManagement) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
remote()->transact(BnSurfaceComposer::GET_COLOR_MANAGEMENT, data, &reply);
@@ -715,10 +710,10 @@
return err;
}
- virtual status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
- ui::PixelFormat* outFormat,
- ui::Dataspace* outDataspace,
- uint8_t* outComponentMask) const {
+ status_t getDisplayedContentSamplingAttributes(const sp<IBinder>& display,
+ ui::PixelFormat* outFormat,
+ ui::Dataspace* outDataspace,
+ uint8_t* outComponentMask) const override {
if (!outFormat || !outDataspace || !outComponentMask) return BAD_VALUE;
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
@@ -752,8 +747,8 @@
return error;
}
- virtual status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
- uint8_t componentMask, uint64_t maxFrames) {
+ status_t setDisplayContentSamplingEnabled(const sp<IBinder>& display, bool enable,
+ uint8_t componentMask, uint64_t maxFrames) override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
data.writeStrongBinder(display);
@@ -766,9 +761,9 @@
return result;
}
- virtual status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
- uint64_t timestamp,
- DisplayedFrameStats* outStats) const {
+ status_t getDisplayedContentSample(const sp<IBinder>& display, uint64_t maxFrames,
+ uint64_t timestamp,
+ DisplayedFrameStats* outStats) const override {
if (!outStats) return BAD_VALUE;
Parcel data, reply;
@@ -805,7 +800,7 @@
return result;
}
- virtual status_t getProtectedContentSupport(bool* outSupported) const {
+ status_t getProtectedContentSupport(bool* outSupported) const override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t error =
@@ -817,8 +812,8 @@
return error;
}
- virtual status_t isWideColorDisplay(const sp<IBinder>& token,
- bool* outIsWideColorDisplay) const {
+ status_t isWideColorDisplay(const sp<IBinder>& token,
+ bool* outIsWideColorDisplay) const override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -837,9 +832,8 @@
return error;
}
- virtual status_t addRegionSamplingListener(const Rect& samplingArea,
- const sp<IBinder>& stopLayerHandle,
- const sp<IRegionSamplingListener>& listener) {
+ status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
+ const sp<IRegionSamplingListener>& listener) override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -868,7 +862,7 @@
return error;
}
- virtual status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) {
+ status_t removeRegionSamplingListener(const sp<IRegionSamplingListener>& listener) override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -888,12 +882,11 @@
return error;
}
- virtual status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
- int32_t defaultConfig, bool allowGroupSwitching,
- float primaryRefreshRateMin,
- float primaryRefreshRateMax,
- float appRequestRefreshRateMin,
- float appRequestRefreshRateMax) {
+ status_t setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken, int32_t defaultConfig,
+ bool allowGroupSwitching, float primaryRefreshRateMin,
+ float primaryRefreshRateMax,
+ float appRequestRefreshRateMin,
+ float appRequestRefreshRateMax) override {
Parcel data, reply;
status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (result != NO_ERROR) {
@@ -947,13 +940,12 @@
return reply.readInt32();
}
- virtual status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
- int32_t* outDefaultConfig,
- bool* outAllowGroupSwitching,
- float* outPrimaryRefreshRateMin,
- float* outPrimaryRefreshRateMax,
- float* outAppRequestRefreshRateMin,
- float* outAppRequestRefreshRateMax) {
+ status_t getDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
+ int32_t* outDefaultConfig, bool* outAllowGroupSwitching,
+ float* outPrimaryRefreshRateMin,
+ float* outPrimaryRefreshRateMax,
+ float* outAppRequestRefreshRateMin,
+ float* outAppRequestRefreshRateMax) override {
if (!outDefaultConfig || !outAllowGroupSwitching || !outPrimaryRefreshRateMin ||
!outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin ||
!outAppRequestRefreshRateMax) {
@@ -1011,8 +1003,8 @@
return reply.readInt32();
}
- virtual status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
- bool* outSupport) const {
+ status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
+ bool* outSupport) const override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -1039,7 +1031,7 @@
return NO_ERROR;
}
- virtual status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) {
+ status_t setDisplayBrightness(const sp<IBinder>& displayToken, float brightness) override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -1064,7 +1056,7 @@
return NO_ERROR;
}
- virtual status_t notifyPowerBoost(int32_t boostId) {
+ status_t notifyPowerBoost(int32_t boostId) override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -1085,8 +1077,8 @@
return NO_ERROR;
}
- virtual status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
- float lightPosY, float lightPosZ, float lightRadius) {
+ status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
+ float lightPosY, float lightPosZ, float lightRadius) override {
Parcel data, reply;
status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (error != NO_ERROR) {
@@ -1114,8 +1106,8 @@
return NO_ERROR;
}
- virtual status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
- int8_t compatibility, bool shouldBeSeamless) {
+ status_t setFrameRate(const sp<IGraphicBufferProducer>& surface, float frameRate,
+ int8_t compatibility, bool shouldBeSeamless) override {
Parcel data, reply;
status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (err != NO_ERROR) {
@@ -1156,7 +1148,7 @@
return reply.readInt32();
}
- virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) {
+ status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override {
if (!outToken) return BAD_VALUE;
Parcel data, reply;
@@ -1191,40 +1183,34 @@
return NO_ERROR;
}
- virtual status_t setFrameTimelineVsync(const sp<IGraphicBufferProducer>& surface,
- int64_t frameTimelineVsyncId) {
+ status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
+ const FrameTimelineInfo& frameTimelineInfo) override {
Parcel data, reply;
status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed writing interface token: %s (%d)", strerror(-err),
- -err);
+ ALOGE("%s: failed writing interface token: %s (%d)", __func__, strerror(-err), -err);
return err;
}
err = data.writeStrongBinder(IInterface::asBinder(surface));
if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed writing strong binder: %s (%d)", strerror(-err),
- -err);
+ ALOGE("%s: failed writing strong binder: %s (%d)", __func__, strerror(-err), -err);
return err;
}
- err = data.writeInt64(frameTimelineVsyncId);
- if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed writing int64_t: %s (%d)", strerror(-err), -err);
- return err;
- }
+ SAFE_PARCEL(frameTimelineInfo.write, data);
- err = remote()->transact(BnSurfaceComposer::SET_FRAME_TIMELINE_VSYNC, data, &reply);
+ err = remote()->transact(BnSurfaceComposer::SET_FRAME_TIMELINE_INFO, data, &reply);
if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed to transact: %s (%d)", strerror(-err), err);
+ ALOGE("%s: failed to transact: %s (%d)", __func__, strerror(-err), err);
return err;
}
return reply.readInt32();
}
- virtual status_t addTransactionTraceListener(
- const sp<gui::ITransactionTraceListener>& listener) {
+ status_t addTransactionTraceListener(
+ const sp<gui::ITransactionTraceListener>& listener) override {
Parcel data, reply;
SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor());
SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener));
@@ -1235,7 +1221,7 @@
/**
* Get priority of the RenderEngine in surface flinger.
*/
- virtual int getGPUContextPriority() {
+ int getGPUContextPriority() override {
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
status_t err =
@@ -1269,8 +1255,9 @@
case SET_TRANSACTION_STATE: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
- int64_t frameTimelineVsyncId;
- SAFE_PARCEL(data.readInt64, &frameTimelineVsyncId);
+ FrameTimelineInfo frameTimelineInfo;
+ SAFE_PARCEL(frameTimelineInfo.read, data);
+
uint32_t count = 0;
SAFE_PARCEL_READ_SIZE(data.readUint32, &count, data.dataSize());
Vector<ComposerState> state;
@@ -1324,10 +1311,10 @@
uint64_t transactionId = -1;
SAFE_PARCEL(data.readUint64, &transactionId);
- return setTransactionState(frameTimelineVsyncId, state, displays, stateFlags,
- applyToken, inputWindowCommands, desiredPresentTime,
- isAutoTimestamp, uncachedBuffer, hasListenerCallbacks,
- listenerCallbacks, transactionId);
+ return setTransactionState(frameTimelineInfo, state, displays, stateFlags, applyToken,
+ inputWindowCommands, desiredPresentTime, isAutoTimestamp,
+ uncachedBuffer, hasListenerCallbacks, listenerCallbacks,
+ transactionId);
}
case BOOT_FINISHED: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
@@ -2078,30 +2065,26 @@
}
return NO_ERROR;
}
- case SET_FRAME_TIMELINE_VSYNC: {
+ case SET_FRAME_TIMELINE_INFO: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
sp<IBinder> binder;
status_t err = data.readStrongBinder(&binder);
if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed to read strong binder: %s (%d)",
- strerror(-err), -err);
+ ALOGE("setFrameTimelineInfo: failed to read strong binder: %s (%d)", strerror(-err),
+ -err);
return err;
}
sp<IGraphicBufferProducer> surface = interface_cast<IGraphicBufferProducer>(binder);
if (!surface) {
- ALOGE("setFrameTimelineVsync: failed to cast to IGraphicBufferProducer: %s (%d)",
+ ALOGE("setFrameTimelineInfo: failed to cast to IGraphicBufferProducer: %s (%d)",
strerror(-err), -err);
return err;
}
- int64_t frameTimelineVsyncId;
- err = data.readInt64(&frameTimelineVsyncId);
- if (err != NO_ERROR) {
- ALOGE("setFrameTimelineVsync: failed to read int64_t: %s (%d)", strerror(-err),
- -err);
- return err;
- }
- status_t result = setFrameTimelineVsync(surface, frameTimelineVsyncId);
+ FrameTimelineInfo frameTimelineInfo;
+ SAFE_PARCEL(frameTimelineInfo.read, data);
+
+ status_t result = setFrameTimelineInfo(surface, frameTimelineInfo);
reply->writeInt32(result);
return NO_ERROR;
}
diff --git a/libs/gui/ITransactionCompletedListener.cpp b/libs/gui/ITransactionCompletedListener.cpp
index 1808571..0ded936 100644
--- a/libs/gui/ITransactionCompletedListener.cpp
+++ b/libs/gui/ITransactionCompletedListener.cpp
@@ -92,10 +92,8 @@
return err;
}
-JankData::JankData() :
- frameVsyncId(ISurfaceComposer::INVALID_VSYNC_ID),
- jankType(JankType::None) {
-}
+JankData::JankData()
+ : frameVsyncId(FrameTimelineInfo::INVALID_VSYNC_ID), jankType(JankType::None) {}
status_t JankData::writeToParcel(Parcel* output) const {
SAFE_PARCEL(output->writeInt64, frameVsyncId);
diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp
index 2946aae..3f314cd 100644
--- a/libs/gui/LayerState.cpp
+++ b/libs/gui/LayerState.cpp
@@ -63,7 +63,7 @@
shouldBeSeamless(true),
fixedTransformHint(ui::Transform::ROT_INVALID),
frameNumber(0),
- frameTimelineVsyncId(ISurfaceComposer::INVALID_VSYNC_ID),
+ frameTimelineInfo(),
autoRefresh(false) {
matrix.dsdx = matrix.dtdy = 1.0f;
matrix.dsdy = matrix.dtdx = 0.0f;
@@ -151,7 +151,7 @@
SAFE_PARCEL(output.writeBool, shouldBeSeamless);
SAFE_PARCEL(output.writeUint32, fixedTransformHint);
SAFE_PARCEL(output.writeUint64, frameNumber);
- SAFE_PARCEL(output.writeInt64, frameTimelineVsyncId);
+ SAFE_PARCEL(frameTimelineInfo.write, output);
SAFE_PARCEL(output.writeBool, autoRefresh);
SAFE_PARCEL(output.writeUint32, blurRegions.size());
@@ -270,7 +270,7 @@
SAFE_PARCEL(input.readUint32, &tmpUint32);
fixedTransformHint = static_cast<ui::Transform::RotationFlags>(tmpUint32);
SAFE_PARCEL(input.readUint64, &frameNumber);
- SAFE_PARCEL(input.readInt64, &frameTimelineVsyncId);
+ SAFE_PARCEL(frameTimelineInfo.read, input);
SAFE_PARCEL(input.readBool, &autoRefresh);
uint32_t numRegions = 0;
@@ -537,15 +537,9 @@
what |= eFrameNumberChanged;
frameNumber = other.frameNumber;
}
- if (other.what & eFrameTimelineVsyncChanged) {
- // When merging vsync Ids we take the oldest valid one
- if (frameTimelineVsyncId != ISurfaceComposer::INVALID_VSYNC_ID &&
- other.frameTimelineVsyncId != ISurfaceComposer::INVALID_VSYNC_ID) {
- frameTimelineVsyncId = std::max(frameTimelineVsyncId, other.frameTimelineVsyncId);
- } else if (frameTimelineVsyncId == ISurfaceComposer::INVALID_VSYNC_ID) {
- frameTimelineVsyncId = other.frameTimelineVsyncId;
- }
- what |= eFrameTimelineVsyncChanged;
+ if (other.what & eFrameTimelineInfoChanged) {
+ what |= eFrameTimelineInfoChanged;
+ frameTimelineInfo.merge(other.frameTimelineInfo);
}
if (other.what & eAutoRefreshChanged) {
what |= eAutoRefreshChanged;
@@ -644,11 +638,13 @@
status_t CaptureArgs::write(Parcel& output) const {
SAFE_PARCEL(output.writeInt32, static_cast<int32_t>(pixelFormat));
SAFE_PARCEL(output.write, sourceCrop);
- SAFE_PARCEL(output.writeFloat, frameScale);
+ SAFE_PARCEL(output.writeFloat, frameScaleX);
+ SAFE_PARCEL(output.writeFloat, frameScaleY);
SAFE_PARCEL(output.writeBool, captureSecureLayers);
SAFE_PARCEL(output.writeInt32, uid);
SAFE_PARCEL(output.writeInt32, static_cast<int32_t>(dataspace));
SAFE_PARCEL(output.writeBool, allowProtected);
+ SAFE_PARCEL(output.writeBool, grayscale);
return NO_ERROR;
}
@@ -657,12 +653,14 @@
SAFE_PARCEL(input.readInt32, &value);
pixelFormat = static_cast<ui::PixelFormat>(value);
SAFE_PARCEL(input.read, sourceCrop);
- SAFE_PARCEL(input.readFloat, &frameScale);
+ SAFE_PARCEL(input.readFloat, &frameScaleX);
+ SAFE_PARCEL(input.readFloat, &frameScaleY);
SAFE_PARCEL(input.readBool, &captureSecureLayers);
SAFE_PARCEL(input.readInt32, &uid);
SAFE_PARCEL(input.readInt32, &value);
dataspace = static_cast<ui::Dataspace>(value);
SAFE_PARCEL(input.readBool, &allowProtected);
+ SAFE_PARCEL(input.readBool, &grayscale);
return NO_ERROR;
}
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index e82f0cc..59ad8d2 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -1496,8 +1496,8 @@
case NATIVE_WINDOW_GET_LAST_QUEUED_BUFFER:
res = dispatchGetLastQueuedBuffer(args);
break;
- case NATIVE_WINDOW_SET_FRAME_TIMELINE_VSYNC:
- res = dispatchSetFrameTimelineVsync(args);
+ case NATIVE_WINDOW_SET_FRAME_TIMELINE_INFO:
+ res = dispatchSetFrameTimelineInfo(args);
break;
default:
res = NAME_NOT_FOUND;
@@ -1806,12 +1806,13 @@
return result;
}
-int Surface::dispatchSetFrameTimelineVsync(va_list args) {
+int Surface::dispatchSetFrameTimelineInfo(va_list args) {
ATRACE_CALL();
auto frameTimelineVsyncId = static_cast<int64_t>(va_arg(args, int64_t));
+ auto inputEventId = static_cast<int32_t>(va_arg(args, int32_t));
- ALOGV("Surface::dispatchSetFrameTimelineVsync");
- return setFrameTimelineVsync(frameTimelineVsyncId);
+ ALOGV("Surface::%s", __func__);
+ return setFrameTimelineInfo({frameTimelineVsyncId, inputEventId});
}
bool Surface::transformToDisplayInverse() {
@@ -2579,9 +2580,8 @@
shouldBeSeamless);
}
-status_t Surface::setFrameTimelineVsync(int64_t frameTimelineVsyncId) {
- return composerService()->setFrameTimelineVsync(mGraphicBufferProducer,
- frameTimelineVsyncId);
+status_t Surface::setFrameTimelineInfo(const FrameTimelineInfo& frameTimelineInfo) {
+ return composerService()->setFrameTimelineInfo(mGraphicBufferProducer, frameTimelineInfo);
}
}; // namespace android
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp
index 96c099b..a1bdc03 100644
--- a/libs/gui/SurfaceComposerClient.cpp
+++ b/libs/gui/SurfaceComposerClient.cpp
@@ -396,7 +396,7 @@
mContainsBuffer(other.mContainsBuffer),
mDesiredPresentTime(other.mDesiredPresentTime),
mIsAutoTimestamp(other.mIsAutoTimestamp),
- mFrameTimelineVsyncId(other.mFrameTimelineVsyncId),
+ mFrameTimelineInfo(other.mFrameTimelineInfo),
mApplyToken(other.mApplyToken) {
mDisplayStates = other.mDisplayStates;
mComposerStates = other.mComposerStates;
@@ -427,7 +427,9 @@
const bool containsBuffer = parcel->readBool();
const int64_t desiredPresentTime = parcel->readInt64();
const bool isAutoTimestamp = parcel->readBool();
- const int64_t frameTimelineVsyncId = parcel->readInt64();
+ FrameTimelineInfo frameTimelineInfo;
+ SAFE_PARCEL(frameTimelineInfo.read, *parcel);
+
sp<IBinder> applyToken;
parcel->readNullableStrongBinder(&applyToken);
size_t count = static_cast<size_t>(parcel->readUint32());
@@ -502,7 +504,7 @@
mContainsBuffer = containsBuffer;
mDesiredPresentTime = desiredPresentTime;
mIsAutoTimestamp = isAutoTimestamp;
- mFrameTimelineVsyncId = frameTimelineVsyncId;
+ mFrameTimelineInfo = frameTimelineInfo;
mDisplayStates = displayStates;
mListenerCallbacks = listenerCallbacks;
mComposerStates = composerStates;
@@ -534,7 +536,7 @@
parcel->writeBool(mContainsBuffer);
parcel->writeInt64(mDesiredPresentTime);
parcel->writeBool(mIsAutoTimestamp);
- parcel->writeInt64(mFrameTimelineVsyncId);
+ SAFE_PARCEL(mFrameTimelineInfo.write, *parcel);
parcel->writeStrongBinder(mApplyToken);
parcel->writeUint32(static_cast<uint32_t>(mDisplayStates.size()));
for (auto const& displayState : mDisplayStates) {
@@ -613,13 +615,7 @@
mExplicitEarlyWakeupEnd = mExplicitEarlyWakeupEnd || other.mExplicitEarlyWakeupEnd;
mApplyToken = other.mApplyToken;
- // When merging vsync Ids we take the oldest one
- if (mFrameTimelineVsyncId != ISurfaceComposer::INVALID_VSYNC_ID &&
- other.mFrameTimelineVsyncId != ISurfaceComposer::INVALID_VSYNC_ID) {
- mFrameTimelineVsyncId = std::max(mFrameTimelineVsyncId, other.mFrameTimelineVsyncId);
- } else if (mFrameTimelineVsyncId == ISurfaceComposer::INVALID_VSYNC_ID) {
- mFrameTimelineVsyncId = other.mFrameTimelineVsyncId;
- }
+ mFrameTimelineInfo.merge(other.mFrameTimelineInfo);
other.clear();
return *this;
@@ -639,7 +635,7 @@
mExplicitEarlyWakeupEnd = false;
mDesiredPresentTime = 0;
mIsAutoTimestamp = true;
- mFrameTimelineVsyncId = ISurfaceComposer::INVALID_VSYNC_ID;
+ mFrameTimelineInfo.clear();
mApplyToken = nullptr;
}
@@ -651,9 +647,8 @@
uncacheBuffer.id = cacheId;
sp<IBinder> applyToken = IInterface::asBinder(TransactionCompletedListener::getIInstance());
- sf->setTransactionState(ISurfaceComposer::INVALID_VSYNC_ID, {}, {}, 0, applyToken, {},
- systemTime(), true, uncacheBuffer, false, {},
- 0 /* Undefined transactionId */);
+ sf->setTransactionState(FrameTimelineInfo{}, {}, {}, 0, applyToken, {}, systemTime(), true,
+ uncacheBuffer, false, {}, 0 /* Undefined transactionId */);
}
void SurfaceComposerClient::Transaction::cacheBuffers() {
@@ -773,7 +768,7 @@
? mApplyToken
: IInterface::asBinder(TransactionCompletedListener::getIInstance());
- sf->setTransactionState(mFrameTimelineVsyncId, composerStates, displayStates, flags, applyToken,
+ sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags, applyToken,
mInputWindowCommands, mDesiredPresentTime, mIsAutoTimestamp,
{} /*uncacheBuffer - only set in doUncacheBufferTransaction*/,
hasListenerCallbacks, listenerCallbacks, mId);
@@ -1549,22 +1544,22 @@
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameTimelineVsync(
- int64_t frameTimelineVsyncId) {
- mFrameTimelineVsyncId = frameTimelineVsyncId;
+SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameTimelineInfo(
+ const FrameTimelineInfo& frameTimelineInfo) {
+ mFrameTimelineInfo = frameTimelineInfo;
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameTimelineVsync(
- const sp<SurfaceControl>& sc, int64_t frameTimelineVsyncId) {
+SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFrameTimelineInfo(
+ const sp<SurfaceControl>& sc, const FrameTimelineInfo& frameTimelineInfo) {
layer_state_t* s = getLayerState(sc);
if (!s) {
mStatus = BAD_INDEX;
return *this;
}
- s->what |= layer_state_t::eFrameTimelineVsyncChanged;
- s->frameTimelineVsyncId = frameTimelineVsyncId;
+ s->what |= layer_state_t::eFrameTimelineInfoChanged;
+ s->frameTimelineInfo = frameTimelineInfo;
return *this;
}
diff --git a/libs/gui/include/gui/BLASTBufferQueue.h b/libs/gui/include/gui/BLASTBufferQueue.h
index 7f69bc4..fa3efe1 100644
--- a/libs/gui/include/gui/BLASTBufferQueue.h
+++ b/libs/gui/include/gui/BLASTBufferQueue.h
@@ -92,7 +92,7 @@
void flushShadowQueue() { mFlushShadowQueue = true; }
status_t setFrameRate(float frameRate, int8_t compatibility, bool shouldBeSeamless);
- status_t setFrameTimelineVsync(int64_t frameTimelineVsyncId);
+ status_t setFrameTimelineInfo(const FrameTimelineInfo& info);
virtual ~BLASTBufferQueue();
@@ -156,7 +156,7 @@
// This is only relevant for shared buffer mode.
bool mAutoRefresh GUARDED_BY(mMutex) = false;
- std::queue<int64_t> mNextFrameTimelineVsyncIdQueue GUARDED_BY(mMutex);
+ std::queue<FrameTimelineInfo> mNextFrameTimelineInfoQueue GUARDED_BY(mMutex);
// Last acquired buffer's scaling mode. This is used to check if we should update the blast
// layer size immediately or wait until we get the next buffer. This will support scenarios
diff --git a/libs/gui/include/gui/DisplayEventDispatcher.h b/libs/gui/include/gui/DisplayEventDispatcher.h
index 5587acf..f446dd8 100644
--- a/libs/gui/include/gui/DisplayEventDispatcher.h
+++ b/libs/gui/include/gui/DisplayEventDispatcher.h
@@ -25,7 +25,7 @@
// The Vsync Id corresponsing to this vsync event. This will be used to
// populate ISurfaceComposer::setFrameTimelineVsync and
// SurfaceComposerClient::setFrameTimelineVsync
- int64_t id = ISurfaceComposer::INVALID_VSYNC_ID;
+ int64_t id = FrameTimelineInfo::INVALID_VSYNC_ID;
// The deadline in CLOCK_MONOTONIC that the app needs to complete its
// frame by (both on the CPU and the GPU)
diff --git a/libs/gui/include/gui/FrameTimelineInfo.h b/libs/gui/include/gui/FrameTimelineInfo.h
new file mode 100644
index 0000000..3b4c009
--- /dev/null
+++ b/libs/gui/include/gui/FrameTimelineInfo.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <stdint.h>
+
+#include <android/os/IInputConstants.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+struct FrameTimelineInfo {
+ // Needs to be in sync with android.graphics.FrameInfo.INVALID_VSYNC_ID in java
+ static constexpr int64_t INVALID_VSYNC_ID = -1;
+
+ // The vsync id that was used to start the transaction
+ int64_t vsyncId = INVALID_VSYNC_ID;
+
+ // The id of the input event that caused this buffer
+ int32_t inputEventId = android::os::IInputConstants::INVALID_INPUT_EVENT_ID;
+
+ status_t write(Parcel& output) const;
+ status_t read(const Parcel& input);
+
+ void merge(const FrameTimelineInfo& other);
+ void clear();
+};
+
+} // namespace android
diff --git a/libs/gui/include/gui/ISurfaceComposer.h b/libs/gui/include/gui/ISurfaceComposer.h
index 86f3c60..81ff6b0 100644
--- a/libs/gui/include/gui/ISurfaceComposer.h
+++ b/libs/gui/include/gui/ISurfaceComposer.h
@@ -24,6 +24,7 @@
#include <android/gui/IScreenCaptureListener.h>
#include <android/gui/ITransactionTraceListener.h>
+#include <gui/FrameTimelineInfo.h>
#include <gui/ITransactionCompletedListener.h>
#include <input/Flags.h>
@@ -117,9 +118,6 @@
using EventRegistrationFlags = Flags<EventRegistration>;
- // Needs to be in sync with android.graphics.FrameInfo.INVALID_VSYNC_ID in java
- static constexpr int64_t INVALID_VSYNC_ID = -1;
-
/*
* Create a connection with SurfaceFlinger.
*/
@@ -164,7 +162,7 @@
/* open/close transactions. requires ACCESS_SURFACE_FLINGER permission */
virtual status_t setTransactionState(
- int64_t frameTimelineVsyncId, const Vector<ComposerState>& state,
+ const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& state,
const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
@@ -494,11 +492,11 @@
virtual status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) = 0;
/*
- * Sets the frame timeline vsync id received from choreographer that corresponds to next
+ * Sets the frame timeline vsync info received from choreographer that corresponds to next
* buffer submitted on that surface.
*/
- virtual status_t setFrameTimelineVsync(const sp<IGraphicBufferProducer>& surface,
- int64_t frameTimelineVsyncId) = 0;
+ virtual status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
+ const FrameTimelineInfo& frameTimelineInfo) = 0;
/*
* Adds a TransactionTraceListener to listen for transaction tracing state updates.
@@ -569,7 +567,7 @@
SET_GAME_CONTENT_TYPE,
SET_FRAME_RATE,
ACQUIRE_FRAME_RATE_FLEXIBILITY_TOKEN,
- SET_FRAME_TIMELINE_VSYNC,
+ SET_FRAME_TIMELINE_INFO,
ADD_TRANSACTION_TRACE_LISTENER,
GET_GPU_CONTEXT_PRIORITY,
// Always append new enum to the end.
diff --git a/libs/gui/include/gui/LayerState.h b/libs/gui/include/gui/LayerState.h
index b1305c6..2668108 100644
--- a/libs/gui/include/gui/LayerState.h
+++ b/libs/gui/include/gui/LayerState.h
@@ -132,7 +132,7 @@
eProducerDisconnect = 0x100'00000000,
eFixedTransformHintChanged = 0x200'00000000,
eFrameNumberChanged = 0x400'00000000,
- eFrameTimelineVsyncChanged = 0x800'00000000,
+ eFrameTimelineInfoChanged = 0x800'00000000,
eBlurRegionsChanged = 0x1000'00000000,
eAutoRefreshChanged = 0x2000'00000000,
};
@@ -238,7 +238,7 @@
// graphics producer.
uint64_t frameNumber;
- int64_t frameTimelineVsyncId;
+ FrameTimelineInfo frameTimelineInfo;
// Indicates that the consumer should acquire the next frame as soon as it
// can and not wait for a frame to become available. This is only relevant
@@ -328,7 +328,8 @@
ui::PixelFormat pixelFormat{ui::PixelFormat::RGBA_8888};
Rect sourceCrop;
- float frameScale{1};
+ float frameScaleX{1};
+ float frameScaleY{1};
bool captureSecureLayers{false};
int32_t uid{UNSET_UID};
// Force capture to be in a color space. If the value is ui::Dataspace::UNKNOWN, the captured
@@ -346,6 +347,8 @@
// the contents being accessed/captured by screenshot or unsecure display.
bool allowProtected = false;
+ bool grayscale = false;
+
virtual status_t write(Parcel& output) const;
virtual status_t read(const Parcel& input);
};
diff --git a/libs/gui/include/gui/Surface.h b/libs/gui/include/gui/Surface.h
index 43b5dcd..b6b5c7c 100644
--- a/libs/gui/include/gui/Surface.h
+++ b/libs/gui/include/gui/Surface.h
@@ -18,6 +18,7 @@
#define ANDROID_GUI_SURFACE_H
#include <gui/BufferQueueDefs.h>
+#include <gui/FrameTimelineInfo.h>
#include <gui/HdrMetadata.h>
#include <gui/IGraphicBufferProducer.h>
#include <gui/IProducerListener.h>
@@ -187,7 +188,7 @@
status_t getConsumerUsage(uint64_t* outUsage) const;
virtual status_t setFrameRate(float frameRate, int8_t compatibility, bool shouldBeSeamless);
- virtual status_t setFrameTimelineVsync(int64_t frameTimelineVsyncId);
+ virtual status_t setFrameTimelineInfo(const FrameTimelineInfo& info);
protected:
virtual ~Surface();
@@ -273,7 +274,7 @@
int dispatchAddQueueInterceptor(va_list args);
int dispatchAddQueryInterceptor(va_list args);
int dispatchGetLastQueuedBuffer(va_list args);
- int dispatchSetFrameTimelineVsync(va_list args);
+ int dispatchSetFrameTimelineInfo(va_list args);
bool transformToDisplayInverse();
protected:
diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h
index 11db658..bed5c44 100644
--- a/libs/gui/include/gui/SurfaceComposerClient.h
+++ b/libs/gui/include/gui/SurfaceComposerClient.h
@@ -385,8 +385,8 @@
int64_t mDesiredPresentTime = 0;
bool mIsAutoTimestamp = true;
- // The vsync Id provided by Choreographer.getVsyncId
- int64_t mFrameTimelineVsyncId = ISurfaceComposer::INVALID_VSYNC_ID;
+ // The vsync id provided by Choreographer.getVsyncId and the input event id
+ FrameTimelineInfo mFrameTimelineInfo;
// If not null, transactions will be queued up using this token otherwise a common token
// per process will be used.
@@ -546,11 +546,12 @@
Transaction& setFixedTransformHint(const sp<SurfaceControl>& sc, int32_t transformHint);
// Sets the frame timeline vsync id received from choreographer that corresponds
- // to the transaction.
- Transaction& setFrameTimelineVsync(int64_t frameTimelineVsyncId);
+ // to the transaction, and the input event id that identifies the input event that caused
+ // the current frame.
+ Transaction& setFrameTimelineInfo(const FrameTimelineInfo& frameTimelineInfo);
// Variant that only applies to a specific SurfaceControl.
- Transaction& setFrameTimelineVsync(const sp<SurfaceControl>& sc,
- int64_t frameTimelineVsyncId);
+ Transaction& setFrameTimelineInfo(const sp<SurfaceControl>& sc,
+ const FrameTimelineInfo& frameTimelineInfo);
// Indicates that the consumer should acquire the next frame as soon as it
// can and not wait for a frame to become available. This is only relevant
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 63db9a7..3f7a5b1 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -695,7 +695,7 @@
void destroyDisplay(const sp<IBinder>& /*display */) override {}
std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override { return {}; }
sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId) const override { return nullptr; }
- status_t setTransactionState(int64_t /*frameTimelineVsyncId*/,
+ status_t setTransactionState(const FrameTimelineInfo& /*frameTimelineInfo*/,
const Vector<ComposerState>& /*state*/,
const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/,
const sp<IBinder>& /*applyToken*/,
@@ -877,8 +877,8 @@
return NO_ERROR;
}
- status_t setFrameTimelineVsync(const sp<IGraphicBufferProducer>& /*surface*/,
- int64_t /*frameTimelineVsyncId*/) override {
+ status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& /*surface*/,
+ const FrameTimelineInfo& /*frameTimelineInfo*/) override {
return NO_ERROR;
}
diff --git a/libs/input/android/os/IInputConstants.aidl b/libs/input/android/os/IInputConstants.aidl
index 6316b59..bce0ec8 100644
--- a/libs/input/android/os/IInputConstants.aidl
+++ b/libs/input/android/os/IInputConstants.aidl
@@ -28,4 +28,13 @@
* to identify apps that are using this flag.
*/
const long BLOCK_FLAG_SLIPPERY = 157929241;
+
+ // Indicate invalid battery capacity
+ const int INVALID_BATTERY_CAPACITY = -1;
+
+ /**
+ * Every input event has an id. This constant value is used when a valid input event id is not
+ * available.
+ */
+ const int INVALID_INPUT_EVENT_ID = 0;
}
diff --git a/libs/nativewindow/include/system/window.h b/libs/nativewindow/include/system/window.h
index 82d2e66..ffe4412 100644
--- a/libs/nativewindow/include/system/window.h
+++ b/libs/nativewindow/include/system/window.h
@@ -255,7 +255,7 @@
NATIVE_WINDOW_ALLOCATE_BUFFERS = 45, /* private */
NATIVE_WINDOW_GET_LAST_QUEUED_BUFFER = 46, /* private */
NATIVE_WINDOW_SET_QUERY_INTERCEPTOR = 47, /* private */
- NATIVE_WINDOW_SET_FRAME_TIMELINE_VSYNC = 48, /* private */
+ NATIVE_WINDOW_SET_FRAME_TIMELINE_INFO = 48, /* private */
// clang-format on
};
@@ -1023,10 +1023,11 @@
(int)compatibility, (int)shouldBeSeamless);
}
-static inline int native_window_set_frame_timeline_vsync(struct ANativeWindow* window,
- int64_t frameTimelineVsyncId) {
- return window->perform(window, NATIVE_WINDOW_SET_FRAME_TIMELINE_VSYNC,
- frameTimelineVsyncId);
+static inline int native_window_set_frame_timeline_info(struct ANativeWindow* window,
+ int64_t frameTimelineVsyncId,
+ int32_t inputEventId) {
+ return window->perform(window, NATIVE_WINDOW_SET_FRAME_TIMELINE_INFO,
+ frameTimelineVsyncId, inputEventId);
}
// ------------------------------------------------------------------------------------------------
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index 32e6b10..5219787 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -384,8 +384,8 @@
return NO_ERROR;
}
-void BufferQueueLayer::setFrameTimelineVsyncForBuffer(int64_t frameTimelineVsyncId) {
- mFrameTimelineVsyncId = frameTimelineVsyncId;
+void BufferQueueLayer::setFrameTimelineInfoForBuffer(const FrameTimelineInfo& frameTimelineInfo) {
+ mFrameTimelineInfo = frameTimelineInfo;
}
// -----------------------------------------------------------------------
@@ -445,9 +445,8 @@
}
auto surfaceFrame =
- mFlinger->mFrameTimeline->createSurfaceFrameForToken(mFrameTimelineVsyncId,
- mOwnerPid, mOwnerUid, mName,
- mName);
+ mFlinger->mFrameTimeline->createSurfaceFrameForToken(mFrameTimelineInfo, mOwnerPid,
+ mOwnerUid, mName, mName);
surfaceFrame->setActualQueueTime(systemTime());
mQueueItems.push_back({item, surfaceFrame});
@@ -485,9 +484,8 @@
}
auto surfaceFrame =
- mFlinger->mFrameTimeline->createSurfaceFrameForToken(mFrameTimelineVsyncId,
- mOwnerPid, mOwnerUid, mName,
- mName);
+ mFlinger->mFrameTimeline->createSurfaceFrameForToken(mFrameTimelineInfo, mOwnerPid,
+ mOwnerUid, mName, mName);
surfaceFrame->setActualQueueTime(systemTime());
mQueueItems[mQueueItems.size() - 1].item = item;
mQueueItems[mQueueItems.size() - 1].surfaceFrame = std::move(surfaceFrame);
diff --git a/services/surfaceflinger/BufferQueueLayer.h b/services/surfaceflinger/BufferQueueLayer.h
index 0e8fdbe..41ff012 100644
--- a/services/surfaceflinger/BufferQueueLayer.h
+++ b/services/surfaceflinger/BufferQueueLayer.h
@@ -101,7 +101,7 @@
status_t updateActiveBuffer() override;
status_t updateFrameNumber(nsecs_t latchTime) override;
- void setFrameTimelineVsyncForBuffer(int64_t frameTimelineVsyncId) override;
+ void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& frameTimelineInfo) override;
sp<Layer> createClone() override;
@@ -145,10 +145,10 @@
sp<ContentsChangedListener> mContentsChangedListener;
- // The last vsync id received on this layer. This will be used when we get
+ // The last vsync info received on this layer. This will be used when we get
// a buffer to correlate the buffer with the vsync id. Can only be accessed
// with the SF state lock held.
- std::optional<int64_t> mFrameTimelineVsyncId;
+ FrameTimelineInfo mFrameTimelineInfo;
// Keeps track of the time SF latched the last buffer from this layer.
// Used in buffer stuffing analysis in FrameTimeline.
diff --git a/services/surfaceflinger/FrameTimeline/FrameTimeline.cpp b/services/surfaceflinger/FrameTimeline/FrameTimeline.cpp
index 17d1f3b..3743716 100644
--- a/services/surfaceflinger/FrameTimeline/FrameTimeline.cpp
+++ b/services/surfaceflinger/FrameTimeline/FrameTimeline.cpp
@@ -275,13 +275,15 @@
return ++mTraceCookie;
}
-SurfaceFrame::SurfaceFrame(int64_t token, pid_t ownerPid, uid_t ownerUid, std::string layerName,
- std::string debugName, PredictionState predictionState,
+SurfaceFrame::SurfaceFrame(const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid,
+ uid_t ownerUid, std::string layerName, std::string debugName,
+ PredictionState predictionState,
frametimeline::TimelineItem&& predictions,
std::shared_ptr<TimeStats> timeStats,
JankClassificationThresholds thresholds,
TraceCookieCounter* traceCookieCounter)
- : mToken(token),
+ : mToken(frameTimelineInfo.vsyncId),
+ mInputEventId(frameTimelineInfo.inputEventId),
mOwnerPid(ownerPid),
mOwnerUid(ownerUid),
mLayerName(std::move(layerName)),
@@ -295,27 +297,27 @@
mTraceCookieCounter(*traceCookieCounter) {}
void SurfaceFrame::setActualStartTime(nsecs_t actualStartTime) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mActuals.startTime = actualStartTime;
}
void SurfaceFrame::setActualQueueTime(nsecs_t actualQueueTime) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mActualQueueTime = actualQueueTime;
}
void SurfaceFrame::setAcquireFenceTime(nsecs_t acquireFenceTime) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mActuals.endTime = std::max(acquireFenceTime, mActualQueueTime);
}
void SurfaceFrame::setPresentState(PresentState presentState, nsecs_t lastLatchTime) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mPresentState = presentState;
mLastLatchTime = lastLatchTime;
}
std::optional<int32_t> SurfaceFrame::getJankType() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
if (mActuals.presentTime == 0) {
return std::nullopt;
}
@@ -323,32 +325,32 @@
}
nsecs_t SurfaceFrame::getBaseTime() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
return getMinTime(mPredictionState, mPredictions, mActuals);
}
TimelineItem SurfaceFrame::getActuals() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
return mActuals;
}
SurfaceFrame::PresentState SurfaceFrame::getPresentState() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
return mPresentState;
}
FramePresentMetadata SurfaceFrame::getFramePresentMetadata() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
return mFramePresentMetadata;
}
FrameReadyMetadata SurfaceFrame::getFrameReadyMetadata() const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
return mFrameReadyMetadata;
}
void SurfaceFrame::dump(std::string& result, const std::string& indent, nsecs_t baseTime) const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
StringAppendF(&result, "%s", indent.c_str());
StringAppendF(&result, "Layer - %s", mDebugName.c_str());
if (mJankType != JankType::None) {
@@ -387,7 +389,7 @@
void SurfaceFrame::onPresent(nsecs_t presentTime, int32_t displayFrameJankType,
nsecs_t vsyncPeriod) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
if (mPresentState != PresentState::Presented) {
// No need to update dropped buffers
return;
@@ -479,6 +481,9 @@
mTimeStats->incrementJankyFrames(mOwnerUid, mLayerName, mJankType);
}
+/**
+ * TODO(b/178637512): add inputEventId to the perfetto trace.
+ */
void SurfaceFrame::trace(int64_t displayFrameToken) {
using FrameTimelineDataSource = impl::FrameTimeline::FrameTimelineDataSource;
@@ -486,12 +491,12 @@
bool missingToken = false;
// Expected timeline start
FrameTimelineDataSource::Trace([&](FrameTimelineDataSource::TraceContext ctx) {
- std::lock_guard<std::mutex> lock(mMutex);
- if (mToken == ISurfaceComposer::INVALID_VSYNC_ID) {
+ std::scoped_lock lock(mMutex);
+ if (mToken == FrameTimelineInfo::INVALID_VSYNC_ID) {
ALOGD("Cannot trace SurfaceFrame - %s with invalid token", mLayerName.c_str());
missingToken = true;
return;
- } else if (displayFrameToken == ISurfaceComposer::INVALID_VSYNC_ID) {
+ } else if (displayFrameToken == FrameTimelineInfo::INVALID_VSYNC_ID) {
ALOGD("Cannot trace SurfaceFrame - %s with invalid displayFrameToken",
mLayerName.c_str());
missingToken = true;
@@ -521,7 +526,7 @@
// Expected timeline end
FrameTimelineDataSource::Trace([&](FrameTimelineDataSource::TraceContext ctx) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
auto packet = ctx.NewTracePacket();
packet->set_timestamp_clock_id(perfetto::protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
packet->set_timestamp(static_cast<uint64_t>(mPredictions.endTime));
@@ -535,7 +540,7 @@
int64_t actualTimelineCookie = mTraceCookieCounter.getCookieForTracing();
// Actual timeline start
FrameTimelineDataSource::Trace([&](FrameTimelineDataSource::TraceContext ctx) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
auto packet = ctx.NewTracePacket();
packet->set_timestamp_clock_id(perfetto::protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
// Actual start time is not yet available, so use expected start instead
@@ -566,7 +571,7 @@
});
// Actual timeline end
FrameTimelineDataSource::Trace([&](FrameTimelineDataSource::TraceContext ctx) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
auto packet = ctx.NewTracePacket();
packet->set_timestamp_clock_id(perfetto::protos::pbzero::BUILTIN_CLOCK_MONOTONIC);
packet->set_timestamp(static_cast<uint64_t>(mActuals.endTime));
@@ -582,7 +587,7 @@
int64_t TokenManager::generateTokenForPredictions(TimelineItem&& predictions) {
ATRACE_CALL();
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
const int64_t assignedToken = mCurrentToken++;
mPredictions[assignedToken] = {systemTime(), predictions};
flushTokens(systemTime());
@@ -590,7 +595,7 @@
}
std::optional<TimelineItem> TokenManager::getPredictionsForToken(int64_t token) const {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
auto predictionsIterator = mPredictions.find(token);
if (predictionsIterator != mPredictions.end()) {
return predictionsIterator->second.predictions;
@@ -634,26 +639,28 @@
}
std::shared_ptr<SurfaceFrame> FrameTimeline::createSurfaceFrameForToken(
- std::optional<int64_t> token, pid_t ownerPid, uid_t ownerUid, std::string layerName,
- std::string debugName) {
+ const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
+ std::string layerName, std::string debugName) {
ATRACE_CALL();
- if (!token) {
- return std::make_shared<SurfaceFrame>(ISurfaceComposer::INVALID_VSYNC_ID, ownerPid,
- ownerUid, std::move(layerName), std::move(debugName),
+ if (frameTimelineInfo.vsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {
+ return std::make_shared<SurfaceFrame>(frameTimelineInfo, ownerPid, ownerUid,
+ std::move(layerName), std::move(debugName),
PredictionState::None, TimelineItem(), mTimeStats,
mJankClassificationThresholds, &mTraceCookieCounter);
}
- std::optional<TimelineItem> predictions = mTokenManager.getPredictionsForToken(*token);
+ std::optional<TimelineItem> predictions =
+ mTokenManager.getPredictionsForToken(frameTimelineInfo.vsyncId);
if (predictions) {
- return std::make_shared<SurfaceFrame>(*token, ownerPid, ownerUid, std::move(layerName),
- std::move(debugName), PredictionState::Valid,
- std::move(*predictions), mTimeStats,
- mJankClassificationThresholds, &mTraceCookieCounter);
+ return std::make_shared<SurfaceFrame>(frameTimelineInfo, ownerPid, ownerUid,
+ std::move(layerName), std::move(debugName),
+ PredictionState::Valid, std::move(*predictions),
+ mTimeStats, mJankClassificationThresholds,
+ &mTraceCookieCounter);
}
- return std::make_shared<SurfaceFrame>(*token, ownerPid, ownerUid, std::move(layerName),
- std::move(debugName), PredictionState::Expired,
- TimelineItem(), mTimeStats, mJankClassificationThresholds,
- &mTraceCookieCounter);
+ return std::make_shared<SurfaceFrame>(frameTimelineInfo, ownerPid, ownerUid,
+ std::move(layerName), std::move(debugName),
+ PredictionState::Expired, TimelineItem(), mTimeStats,
+ mJankClassificationThresholds, &mTraceCookieCounter);
}
FrameTimeline::DisplayFrame::DisplayFrame(std::shared_ptr<TimeStats> timeStats,
@@ -669,13 +676,13 @@
void FrameTimeline::addSurfaceFrame(std::shared_ptr<SurfaceFrame> surfaceFrame) {
ATRACE_CALL();
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mCurrentDisplayFrame->addSurfaceFrame(surfaceFrame);
}
void FrameTimeline::setSfWakeUp(int64_t token, nsecs_t wakeUpTime, nsecs_t vsyncPeriod) {
ATRACE_CALL();
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mCurrentDisplayFrame->onSfWakeUp(token, vsyncPeriod,
mTokenManager.getPredictionsForToken(token), wakeUpTime);
}
@@ -683,7 +690,7 @@
void FrameTimeline::setSfPresent(nsecs_t sfPresentTime,
const std::shared_ptr<FenceTime>& presentFence) {
ATRACE_CALL();
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
mCurrentDisplayFrame->setActualEndTime(sfPresentTime);
mPendingPresentFences.emplace_back(std::make_pair(presentFence, mCurrentDisplayFrame));
flushPendingPresentFences();
@@ -826,7 +833,7 @@
// Expected timeline start
FrameTimelineDataSource::Trace([&](FrameTimelineDataSource::TraceContext ctx) {
auto packet = ctx.NewTracePacket();
- if (mToken == ISurfaceComposer::INVALID_VSYNC_ID) {
+ if (mToken == FrameTimelineInfo::INVALID_VSYNC_ID) {
ALOGD("Cannot trace DisplayFrame with invalid token");
missingToken = true;
return;
@@ -999,7 +1006,7 @@
}
void FrameTimeline::dumpAll(std::string& result) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
StringAppendF(&result, "Number of display frames : %d\n", (int)mDisplayFrames.size());
nsecs_t baseTime = (mDisplayFrames.empty()) ? 0 : mDisplayFrames[0]->getBaseTime();
for (size_t i = 0; i < mDisplayFrames.size(); i++) {
@@ -1009,7 +1016,7 @@
}
void FrameTimeline::dumpJank(std::string& result) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
nsecs_t baseTime = (mDisplayFrames.empty()) ? 0 : mDisplayFrames[0]->getBaseTime();
for (size_t i = 0; i < mDisplayFrames.size(); i++) {
mDisplayFrames[i]->dumpJank(result, baseTime, static_cast<int>(i));
@@ -1031,7 +1038,7 @@
}
void FrameTimeline::setMaxDisplayFrames(uint32_t size) {
- std::lock_guard<std::mutex> lock(mMutex);
+ std::scoped_lock lock(mMutex);
// The size can either increase or decrease, clear everything, to be consistent
mDisplayFrames.clear();
diff --git a/services/surfaceflinger/FrameTimeline/FrameTimeline.h b/services/surfaceflinger/FrameTimeline/FrameTimeline.h
index ed38cc6..54e8efb 100644
--- a/services/surfaceflinger/FrameTimeline/FrameTimeline.h
+++ b/services/surfaceflinger/FrameTimeline/FrameTimeline.h
@@ -154,10 +154,10 @@
// Only FrameTimeline can construct a SurfaceFrame as it provides Predictions(through
// TokenManager), Thresholds and TimeStats pointer.
- SurfaceFrame(int64_t token, pid_t ownerPid, uid_t ownerUid, std::string layerName,
- std::string debugName, PredictionState predictionState, TimelineItem&& predictions,
- std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,
- TraceCookieCounter* traceCookieCounter);
+ SurfaceFrame(const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
+ std::string layerName, std::string debugName, PredictionState predictionState,
+ TimelineItem&& predictions, std::shared_ptr<TimeStats> timeStats,
+ JankClassificationThresholds thresholds, TraceCookieCounter* traceCookieCounter);
~SurfaceFrame() = default;
// Returns std::nullopt if the frame hasn't been classified yet.
@@ -166,6 +166,7 @@
// Functions called by SF
int64_t getToken() const { return mToken; };
+ int32_t getInputEventId() const { return mInputEventId; };
TimelineItem getPredictions() const { return mPredictions; };
// Actual timestamps of the app are set individually at different functions.
// Start time (if the app provides) and Queue time are accessible after queueing the frame,
@@ -198,6 +199,7 @@
private:
const int64_t mToken;
+ const int32_t mInputEventId;
const pid_t mOwnerPid;
const uid_t mOwnerUid;
const std::string mLayerName;
@@ -243,10 +245,9 @@
// Create a new surface frame, set the predictions based on a token and return it to the caller.
// Debug name is the human-readable debugging string for dumpsys.
- virtual std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(std::optional<int64_t> token,
- pid_t ownerPid, uid_t ownerUid,
- std::string layerName,
- std::string debugName) = 0;
+ virtual std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(
+ const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
+ std::string layerName, std::string debugName) = 0;
// Adds a new SurfaceFrame to the current DisplayFrame. Frames from multiple layers can be
// composited into one display frame.
@@ -279,7 +280,7 @@
class TokenManager : public android::frametimeline::TokenManager {
public:
- TokenManager() : mCurrentToken(ISurfaceComposer::INVALID_VSYNC_ID + 1) {}
+ TokenManager() : mCurrentToken(FrameTimelineInfo::INVALID_VSYNC_ID + 1) {}
~TokenManager() = default;
int64_t generateTokenForPredictions(TimelineItem&& predictions) override;
@@ -353,7 +354,7 @@
private:
void dump(std::string& result, nsecs_t baseTime) const;
- int64_t mToken = ISurfaceComposer::INVALID_VSYNC_ID;
+ int64_t mToken = FrameTimelineInfo::INVALID_VSYNC_ID;
/* Usage of TimelineItem w.r.t SurfaceFlinger
* startTime Time when SurfaceFlinger wakes up to handle transactions and buffer updates
@@ -393,10 +394,9 @@
~FrameTimeline() = default;
frametimeline::TokenManager* getTokenManager() override { return &mTokenManager; }
- std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(std::optional<int64_t> token,
- pid_t ownerPid, uid_t ownerUid,
- std::string layerName,
- std::string debugName) override;
+ std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(
+ const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
+ std::string layerName, std::string debugName) override;
void addSurfaceFrame(std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame) override;
void setSfWakeUp(int64_t token, nsecs_t wakeupTime, nsecs_t vsyncPeriod) override;
void setSfPresent(nsecs_t sfPresentTime,
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 177a81a..f6440d3 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -129,7 +129,7 @@
mCurrentState.shadowRadius = 0.f;
mCurrentState.treeHasFrameRateVote = false;
mCurrentState.fixedTransformHint = ui::Transform::ROT_INVALID;
- mCurrentState.frameTimelineVsyncId = ISurfaceComposer::INVALID_VSYNC_ID;
+ mCurrentState.frameTimelineInfo = {};
mCurrentState.postTime = -1;
if (args.flags & ISurfaceComposerClient::eNoColorFill) {
@@ -907,14 +907,10 @@
}
if (stateUpdateAvailable) {
- const auto vsyncId =
- stateToCommit->frameTimelineVsyncId == ISurfaceComposer::INVALID_VSYNC_ID
- ? std::nullopt
- : std::make_optional(stateToCommit->frameTimelineVsyncId);
-
mSurfaceFrame =
- mFlinger->mFrameTimeline->createSurfaceFrameForToken(vsyncId, mOwnerPid, mOwnerUid,
- mName, mTransactionName);
+ mFlinger->mFrameTimeline
+ ->createSurfaceFrameForToken(stateToCommit->frameTimelineInfo, mOwnerPid,
+ mOwnerUid, mName, mTransactionName);
mSurfaceFrame->setActualQueueTime(stateToCommit->postTime);
// For transactions we set the acquire fence time to the post time as we
// don't have a buffer. For BufferStateLayer it is overridden in
@@ -1491,8 +1487,8 @@
return true;
}
-void Layer::setFrameTimelineVsyncForTransaction(int64_t frameTimelineVsyncId, nsecs_t postTime) {
- mCurrentState.frameTimelineVsyncId = frameTimelineVsyncId;
+void Layer::setFrameTimelineInfoForTransaction(const FrameTimelineInfo& info, nsecs_t postTime) {
+ mCurrentState.frameTimelineInfo = info;
mCurrentState.postTime = postTime;
mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 357c4a4..0660a4a 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -304,8 +304,8 @@
// a fixed transform hint is not set.
ui::Transform::RotationFlags fixedTransformHint;
- // The vsync id that was used to start the transaction
- int64_t frameTimelineVsyncId;
+ // The vsync info that was used to start the transaction
+ FrameTimelineInfo frameTimelineInfo;
// When the transaction was posted
nsecs_t postTime;
@@ -869,8 +869,9 @@
bool setFrameRate(FrameRate);
- virtual void setFrameTimelineVsyncForBuffer(int64_t /*frameTimelineVsyncId*/) {}
- void setFrameTimelineVsyncForTransaction(int64_t frameTimelineVsyncId, nsecs_t postTime);
+ virtual void setFrameTimelineInfoForBuffer(const FrameTimelineInfo& /*info*/) {}
+ void setFrameTimelineInfoForTransaction(const FrameTimelineInfo& frameTimelineInfo,
+ nsecs_t postTime);
// Creates a new handle each time, so we only expect
// this to be called once.
diff --git a/services/surfaceflinger/RegionSamplingThread.cpp b/services/surfaceflinger/RegionSamplingThread.cpp
index 19b3d6e..9186538 100644
--- a/services/surfaceflinger/RegionSamplingThread.cpp
+++ b/services/surfaceflinger/RegionSamplingThread.cpp
@@ -451,7 +451,7 @@
const sp<SyncScreenCaptureListener> captureListener = new SyncScreenCaptureListener();
mFlinger.captureScreenCommon(std::move(renderAreaFuture), traverseLayers, buffer,
- true /* regionSampling */, captureListener);
+ true /* regionSampling */, false /* grayscale */, captureListener);
ScreenCaptureResults captureResults = captureListener->waitForResults();
std::vector<Descriptor> activeDescriptors;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index a6b05d0..a63a3d7 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -3294,7 +3294,7 @@
break;
}
transactions.push_back(transaction);
- applyTransactionState(transaction.frameTimelineVsyncId, transaction.states,
+ applyTransactionState(transaction.frameTimelineInfo, transaction.states,
transaction.displays, transaction.flags,
mPendingInputWindowCommands, transaction.desiredPresentTime,
transaction.isAutoTimestamp, transaction.buffer,
@@ -3374,7 +3374,7 @@
}
status_t SurfaceFlinger::setTransactionState(
- int64_t frameTimelineVsyncId, const Vector<ComposerState>& states,
+ const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
@@ -3427,7 +3427,7 @@
// if the transaction contains a buffer.
if (!transactionIsReadyToBeApplied(isAutoTimestamp, desiredPresentTime, states, true) ||
pendingTransactions) {
- mTransactionQueues[applyToken].emplace(frameTimelineVsyncId, states, displays, flags,
+ mTransactionQueues[applyToken].emplace(frameTimelineInfo, states, displays, flags,
desiredPresentTime, isAutoTimestamp, uncacheBuffer,
postTime, privileged, hasListenerCallbacks,
listenerCallbacks, originPid, originUid,
@@ -3436,7 +3436,7 @@
return NO_ERROR;
}
- applyTransactionState(frameTimelineVsyncId, states, displays, flags, inputWindowCommands,
+ applyTransactionState(frameTimelineInfo, states, displays, flags, inputWindowCommands,
desiredPresentTime, isAutoTimestamp, uncacheBuffer, postTime, privileged,
hasListenerCallbacks, listenerCallbacks, originPid, originUid,
transactionId, /*isMainThread*/ false);
@@ -3444,7 +3444,7 @@
}
void SurfaceFlinger::applyTransactionState(
- int64_t frameTimelineVsyncId, const Vector<ComposerState>& states,
+ const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
const Vector<DisplayState>& displays, uint32_t flags,
const InputWindowCommands& inputWindowCommands, const int64_t desiredPresentTime,
bool isAutoTimestamp, const client_cache_t& uncacheBuffer, const int64_t postTime,
@@ -3485,9 +3485,9 @@
uint32_t clientStateFlags = 0;
for (const ComposerState& state : states) {
clientStateFlags |=
- setClientStateLocked(frameTimelineVsyncId, state, desiredPresentTime,
- isAutoTimestamp, postTime, privileged,
- listenerCallbacksWithSurfaces, originPid, originUid);
+ setClientStateLocked(frameTimelineInfo, state, desiredPresentTime, isAutoTimestamp,
+ postTime, privileged, listenerCallbacksWithSurfaces, originPid,
+ originUid);
if ((flags & eAnimation) && state.state.surface) {
if (const auto layer = fromHandleLocked(state.state.surface).promote(); layer) {
mScheduler->recordLayerHistory(layer.get(),
@@ -3665,7 +3665,7 @@
}
uint32_t SurfaceFlinger::setClientStateLocked(
- int64_t frameTimelineVsyncId, const ComposerState& composerState,
+ const FrameTimelineInfo& frameTimelineInfo, const ComposerState& composerState,
int64_t desiredPresentTime, bool isAutoTimestamp, int64_t postTime, bool privileged,
std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks,
int originPid, int originUid) {
@@ -3925,10 +3925,10 @@
flags |= eTraversalNeeded;
}
}
- if (what & layer_state_t::eFrameTimelineVsyncChanged) {
- layer->setFrameTimelineVsyncForTransaction(s.frameTimelineVsyncId, postTime);
- } else if (frameTimelineVsyncId != ISurfaceComposer::INVALID_VSYNC_ID) {
- layer->setFrameTimelineVsyncForTransaction(frameTimelineVsyncId, postTime);
+ if (what & layer_state_t::eFrameTimelineInfoChanged) {
+ layer->setFrameTimelineInfoForTransaction(s.frameTimelineInfo, postTime);
+ } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
+ layer->setFrameTimelineInfoForTransaction(frameTimelineInfo, postTime);
}
if (what & layer_state_t::eFixedTransformHintChanged) {
if (layer->setFixedTransformHint(s.fixedTransformHint)) {
@@ -4264,7 +4264,7 @@
d.width = 0;
d.height = 0;
displays.add(d);
- setTransactionState(ISurfaceComposer::INVALID_VSYNC_ID, state, displays, 0, nullptr,
+ setTransactionState(FrameTimelineInfo{}, state, displays, 0, nullptr,
mPendingInputWindowCommands, systemTime(), true, {}, false, {},
0 /* Undefined transactionId */);
@@ -4909,23 +4909,24 @@
result.append("\n");
}
-void SurfaceFlinger::updateColorMatrixLocked() {
- mat4 colorMatrix;
- if (mGlobalSaturationFactor != 1.0f) {
- // Rec.709 luma coefficients
- float3 luminance{0.213f, 0.715f, 0.072f};
- luminance *= 1.0f - mGlobalSaturationFactor;
- mat4 saturationMatrix = mat4(
- vec4{luminance.r + mGlobalSaturationFactor, luminance.r, luminance.r, 0.0f},
- vec4{luminance.g, luminance.g + mGlobalSaturationFactor, luminance.g, 0.0f},
- vec4{luminance.b, luminance.b, luminance.b + mGlobalSaturationFactor, 0.0f},
- vec4{0.0f, 0.0f, 0.0f, 1.0f}
- );
- colorMatrix = mClientColorMatrix * saturationMatrix * mDaltonizer();
- } else {
- colorMatrix = mClientColorMatrix * mDaltonizer();
+mat4 SurfaceFlinger::calculateColorMatrix(float saturation) {
+ if (saturation == 1) {
+ return mat4();
}
+ float3 luminance{0.213f, 0.715f, 0.072f};
+ luminance *= 1.0f - saturation;
+ mat4 saturationMatrix = mat4(vec4{luminance.r + saturation, luminance.r, luminance.r, 0.0f},
+ vec4{luminance.g, luminance.g + saturation, luminance.g, 0.0f},
+ vec4{luminance.b, luminance.b, luminance.b + saturation, 0.0f},
+ vec4{0.0f, 0.0f, 0.0f, 1.0f});
+ return saturationMatrix;
+}
+
+void SurfaceFlinger::updateColorMatrixLocked() {
+ mat4 colorMatrix =
+ mClientColorMatrix * calculateColorMatrix(mGlobalSaturationFactor) * mDaltonizer();
+
if (mCurrentState.colorMatrix != colorMatrix) {
mCurrentState.colorMatrix = colorMatrix;
mCurrentState.colorMatrixChanged = true;
@@ -5015,7 +5016,7 @@
case CAPTURE_LAYERS:
case CAPTURE_DISPLAY:
case SET_DISPLAY_BRIGHTNESS:
- case SET_FRAME_TIMELINE_VSYNC:
+ case SET_FRAME_TIMELINE_INFO:
// This is not sensitive information, so should not require permission control.
case GET_GPU_CONTEXT_PRIORITY: {
return OK;
@@ -5637,7 +5638,8 @@
};
return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
- args.pixelFormat, args.allowProtected, captureListener);
+ args.pixelFormat, args.allowProtected, args.grayscale,
+ captureListener);
}
status_t SurfaceFlinger::captureDisplay(uint64_t displayOrLayerStack,
@@ -5673,7 +5675,7 @@
return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, size,
ui::PixelFormat::RGBA_8888, false /* allowProtected */,
- captureListener);
+ false /* grayscale */, captureListener);
}
status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
@@ -5719,12 +5721,12 @@
crop.bottom = parentSourceBounds.getHeight();
}
- if (crop.isEmpty() || args.frameScale <= 0.0f) {
+ if (crop.isEmpty() || args.frameScaleX <= 0.0f || args.frameScaleY <= 0.0f) {
// Error out if the layer has no source bounds (i.e. they are boundless) and a source
// crop was not specified, or an invalid frame scale was provided.
return BAD_VALUE;
}
- reqSize = ui::Size(crop.width() * args.frameScale, crop.height() * args.frameScale);
+ reqSize = ui::Size(crop.width() * args.frameScaleX, crop.height() * args.frameScaleY);
for (const auto& handle : args.excludeHandles) {
sp<Layer> excludeLayer = fromHandleLocked(handle).promote();
@@ -5794,13 +5796,14 @@
};
return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, reqSize,
- args.pixelFormat, args.allowProtected, captureListener);
+ args.pixelFormat, args.allowProtected, args.grayscale,
+ captureListener);
}
status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,
TraverseLayersFunction traverseLayers,
ui::Size bufferSize, ui::PixelFormat reqPixelFormat,
- const bool allowProtected,
+ bool allowProtected, bool grayscale,
const sp<IScreenCaptureListener>& captureListener) {
ATRACE_CALL();
@@ -5831,12 +5834,13 @@
static_cast<android_pixel_format>(reqPixelFormat),
1 /* layerCount */, usage, "screenshot");
return captureScreenCommon(std::move(renderAreaFuture), traverseLayers, buffer,
- false /* regionSampling */, captureListener);
+ false /* regionSampling */, grayscale, captureListener);
}
status_t SurfaceFlinger::captureScreenCommon(RenderAreaFuture renderAreaFuture,
TraverseLayersFunction traverseLayers,
- sp<GraphicBuffer>& buffer, const bool regionSampling,
+ sp<GraphicBuffer>& buffer, bool regionSampling,
+ bool grayscale,
const sp<IScreenCaptureListener>& captureListener) {
ATRACE_CALL();
@@ -5852,7 +5856,7 @@
if (mRefreshPending) {
ALOGW("Skipping screenshot for now");
captureScreenCommon(std::move(renderAreaFuture), traverseLayers, buffer, regionSampling,
- captureListener);
+ grayscale, captureListener);
return;
}
ScreenCaptureResults captureResults;
@@ -5867,7 +5871,7 @@
status_t result = NO_ERROR;
renderArea->render([&] {
result = renderScreenImplLocked(*renderArea, traverseLayers, buffer, forSystem,
- regionSampling, captureResults);
+ regionSampling, grayscale, captureResults);
});
captureResults.result = result;
@@ -5880,7 +5884,7 @@
status_t SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,
TraverseLayersFunction traverseLayers,
const sp<GraphicBuffer>& buffer, bool forSystem,
- bool regionSampling,
+ bool regionSampling, bool grayscale,
ScreenCaptureResults& captureResults) {
ATRACE_CALL();
@@ -5921,6 +5925,9 @@
clientCompositionDisplay.outputDataspace = renderArea.getReqDataSpace();
clientCompositionDisplay.maxLuminance = DisplayDevice::sDefaultMaxLumiance;
+ const float colorSaturation = grayscale ? 0 : 1;
+ clientCompositionDisplay.colorTransform = calculateColorMatrix(colorSaturation);
+
const float alpha = RenderArea::getCaptureFillValue(renderArea.getCaptureFill());
compositionengine::LayerFE::LayerSettings fillLayer;
@@ -6383,21 +6390,21 @@
}));
}
-status_t SurfaceFlinger::setFrameTimelineVsync(const sp<IGraphicBufferProducer>& surface,
- int64_t frameTimelineVsyncId) {
+status_t SurfaceFlinger::setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
+ const FrameTimelineInfo& frameTimelineInfo) {
Mutex::Autolock lock(mStateLock);
if (!authenticateSurfaceTextureLocked(surface)) {
- ALOGE("Attempt to set frame timeline vsync on an unrecognized IGraphicBufferProducer");
+ ALOGE("Attempt to set frame timeline info on an unrecognized IGraphicBufferProducer");
return BAD_VALUE;
}
sp<Layer> layer = (static_cast<MonitoredProducer*>(surface.get()))->getLayer();
if (layer == nullptr) {
- ALOGE("Attempt to set frame timeline vsync on a layer that no longer exists");
+ ALOGE("Attempt to set frame timeline info on a layer that no longer exists");
return BAD_VALUE;
}
- layer->setFrameTimelineVsyncForBuffer(frameTimelineVsyncId);
+ layer->setFrameTimelineInfoForBuffer(frameTimelineInfo);
return NO_ERROR;
}
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index e82095b..ec73b09 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -343,7 +343,7 @@
virtual ~SurfaceFlinger();
virtual uint32_t setClientStateLocked(
- int64_t frameTimelineVsyncId, const ComposerState& composerState,
+ const FrameTimelineInfo& info, const ComposerState& composerState,
int64_t desiredPresentTime, bool isAutoTimestamp, int64_t postTime, bool privileged,
std::unordered_set<ListenerCallbacks, ListenerCallbacksHash>& listenerCallbacks,
int originPid, int originUid) REQUIRES(mStateLock);
@@ -435,14 +435,15 @@
};
struct TransactionState {
- TransactionState(int64_t frameTimelineVsyncId, const Vector<ComposerState>& composerStates,
+ TransactionState(const FrameTimelineInfo& frameTimelineInfo,
+ const Vector<ComposerState>& composerStates,
const Vector<DisplayState>& displayStates, uint32_t transactionFlags,
int64_t desiredPresentTime, bool isAutoTimestamp,
const client_cache_t& uncacheBuffer, int64_t postTime, bool privileged,
bool hasListenerCallbacks,
std::vector<ListenerCallbacks> listenerCallbacks, int originPid,
int originUid, uint64_t transactionId)
- : frameTimelineVsyncId(frameTimelineVsyncId),
+ : frameTimelineInfo(frameTimelineInfo),
states(composerStates),
displays(displayStates),
flags(transactionFlags),
@@ -457,7 +458,7 @@
originUid(originUid),
id(transactionId) {}
- int64_t frameTimelineVsyncId;
+ FrameTimelineInfo frameTimelineInfo;
Vector<ComposerState> states;
Vector<DisplayState> displays;
uint32_t flags;
@@ -522,7 +523,8 @@
void destroyDisplay(const sp<IBinder>& displayToken) override;
std::vector<PhysicalDisplayId> getPhysicalDisplayIds() const override;
sp<IBinder> getPhysicalDisplayToken(PhysicalDisplayId displayId) const override;
- status_t setTransactionState(int64_t frameTimelineVsyncId, const Vector<ComposerState>& state,
+ status_t setTransactionState(const FrameTimelineInfo& frameTimelineInfo,
+ const Vector<ComposerState>& state,
const Vector<DisplayState>& displays, uint32_t flags,
const sp<IBinder>& applyToken,
const InputWindowCommands& inputWindowCommands,
@@ -608,8 +610,8 @@
int8_t compatibility, bool shouldBeSeamless) override;
status_t acquireFrameRateFlexibilityToken(sp<IBinder>* outToken) override;
- status_t setFrameTimelineVsync(const sp<IGraphicBufferProducer>& surface,
- int64_t frameTimelineVsyncId) override;
+ status_t setFrameTimelineInfo(const sp<IGraphicBufferProducer>& surface,
+ const FrameTimelineInfo& frameTimelineInfo) override;
status_t addTransactionTraceListener(
const sp<gui::ITransactionTraceListener>& listener) override;
@@ -727,7 +729,7 @@
/*
* Transactions
*/
- void applyTransactionState(int64_t frameTimelineVsyncId, const Vector<ComposerState>& state,
+ void applyTransactionState(const FrameTimelineInfo& info, const Vector<ComposerState>& state,
const Vector<DisplayState>& displays, uint32_t flags,
const InputWindowCommands& inputWindowCommands,
const int64_t desiredPresentTime, bool isAutoTimestamp,
@@ -810,13 +812,14 @@
void startBootAnim();
status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, ui::Size bufferSize,
- ui::PixelFormat, const bool allowProtected,
+ ui::PixelFormat, bool allowProtected, bool grayscale,
const sp<IScreenCaptureListener>&);
status_t captureScreenCommon(RenderAreaFuture, TraverseLayersFunction, sp<GraphicBuffer>&,
- bool regionSampling, const sp<IScreenCaptureListener>&);
+ bool regionSampling, bool grayscale,
+ const sp<IScreenCaptureListener>&);
status_t renderScreenImplLocked(const RenderArea&, TraverseLayersFunction,
const sp<GraphicBuffer>&, bool forSystem, bool regionSampling,
- ScreenCaptureResults&);
+ bool grayscale, ScreenCaptureResults&);
sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack) REQUIRES(mStateLock);
sp<DisplayDevice> getDisplayByLayerStack(uint64_t layerStack) REQUIRES(mStateLock);
@@ -1019,6 +1022,8 @@
void onFrameRateFlexibilityTokenReleased();
+ static mat4 calculateColorMatrix(float saturation);
+
void updateColorMatrixLocked();
// Verify that transaction is being called by an approved process:
diff --git a/services/surfaceflinger/tests/LayerState_test.cpp b/services/surfaceflinger/tests/LayerState_test.cpp
index 93d5f2f..f010786 100644
--- a/services/surfaceflinger/tests/LayerState_test.cpp
+++ b/services/surfaceflinger/tests/LayerState_test.cpp
@@ -30,12 +30,14 @@
DisplayCaptureArgs args;
args.pixelFormat = ui::PixelFormat::RGB_565;
args.sourceCrop = Rect(0, 0, 500, 200);
- args.frameScale = 2;
+ args.frameScaleX = 2;
+ args.frameScaleY = 4;
args.captureSecureLayers = true;
args.displayToken = new BBinder();
args.width = 10;
args.height = 20;
args.useIdentityTransform = true;
+ args.grayscale = true;
Parcel p;
args.write(p);
@@ -46,23 +48,27 @@
ASSERT_EQ(args.pixelFormat, args2.pixelFormat);
ASSERT_EQ(args.sourceCrop, args2.sourceCrop);
- ASSERT_EQ(args.frameScale, args2.frameScale);
+ ASSERT_EQ(args.frameScaleX, args2.frameScaleX);
+ ASSERT_EQ(args.frameScaleY, args2.frameScaleY);
ASSERT_EQ(args.captureSecureLayers, args2.captureSecureLayers);
ASSERT_EQ(args.displayToken, args2.displayToken);
ASSERT_EQ(args.width, args2.width);
ASSERT_EQ(args.height, args2.height);
ASSERT_EQ(args.useIdentityTransform, args2.useIdentityTransform);
+ ASSERT_EQ(args.grayscale, args2.grayscale);
}
TEST(LayerStateTest, ParcellingLayerCaptureArgs) {
LayerCaptureArgs args;
args.pixelFormat = ui::PixelFormat::RGB_565;
args.sourceCrop = Rect(0, 0, 500, 200);
- args.frameScale = 2;
+ args.frameScaleX = 2;
+ args.frameScaleY = 4;
args.captureSecureLayers = true;
args.layerHandle = new BBinder();
args.excludeHandles = {new BBinder(), new BBinder()};
args.childrenOnly = false;
+ args.grayscale = true;
Parcel p;
args.write(p);
@@ -73,11 +79,13 @@
ASSERT_EQ(args.pixelFormat, args2.pixelFormat);
ASSERT_EQ(args.sourceCrop, args2.sourceCrop);
- ASSERT_EQ(args.frameScale, args2.frameScale);
+ ASSERT_EQ(args.frameScaleX, args2.frameScaleX);
+ ASSERT_EQ(args.frameScaleY, args2.frameScaleY);
ASSERT_EQ(args.captureSecureLayers, args2.captureSecureLayers);
ASSERT_EQ(args.layerHandle, args2.layerHandle);
ASSERT_EQ(args.excludeHandles, args2.excludeHandles);
ASSERT_EQ(args.childrenOnly, args2.childrenOnly);
+ ASSERT_EQ(args.grayscale, args2.grayscale);
}
TEST(LayerStateTest, ParcellingScreenCaptureResults) {
@@ -106,5 +114,34 @@
ASSERT_EQ(results.result, results2.result);
}
+/**
+ * Parcel a layer_state_t struct, and then unparcel. Ensure that the object that was parceled
+ * matches the object that's unparceled.
+ */
+TEST(LayerStateTest, ParcelUnparcelLayerStateT) {
+ layer_state_t input;
+ input.frameTimelineInfo.vsyncId = 1;
+ input.frameTimelineInfo.inputEventId = 2;
+ Parcel p;
+ input.write(p);
+ layer_state_t output;
+ p.setDataPosition(0);
+ output.read(p);
+ ASSERT_EQ(input.frameTimelineInfo.vsyncId, output.frameTimelineInfo.vsyncId);
+ ASSERT_EQ(input.frameTimelineInfo.inputEventId, output.frameTimelineInfo.inputEventId);
+}
+
+TEST(LayerStateTest, LayerStateMerge_SelectsValidInputEvent) {
+ layer_state_t layer1;
+ layer1.frameTimelineInfo.inputEventId = android::os::IInputConstants::INVALID_INPUT_EVENT_ID;
+ layer_state_t layer2;
+ layer2.frameTimelineInfo.inputEventId = 1;
+ layer2.what |= layer_state_t::eFrameTimelineInfoChanged;
+
+ layer1.merge(layer2);
+
+ ASSERT_EQ(1, layer1.frameTimelineInfo.inputEventId);
+}
+
} // namespace test
} // namespace android
diff --git a/services/surfaceflinger/tests/ScreenCapture_test.cpp b/services/surfaceflinger/tests/ScreenCapture_test.cpp
index 214a0cd..51ce1d3 100644
--- a/services/surfaceflinger/tests/ScreenCapture_test.cpp
+++ b/services/surfaceflinger/tests/ScreenCapture_test.cpp
@@ -487,7 +487,9 @@
// red area to the right of the blue area
mCapture->expectColor(Rect(30, 0, 59, 59), Color::RED);
- captureArgs.frameScale = 0.5f;
+ captureArgs.frameScaleX = 0.5f;
+ captureArgs.frameScaleY = 0.5f;
+
ScreenCapture::captureLayers(&mCapture, captureArgs);
// Capturing the downsized area (30x30) should leave both red and blue but in a smaller area.
mCapture->expectColor(Rect(0, 0, 14, 14), Color::BLUE);
@@ -768,6 +770,41 @@
mCapture->expectBorder(Rect(128, 128, 160, 160), {63, 63, 195, 255});
}
+TEST_F(ScreenCaptureTest, CaptureWithGrayscale) {
+ sp<SurfaceControl> layer;
+ ASSERT_NO_FATAL_FAILURE(layer = createLayer("test layer", 32, 32,
+ ISurfaceComposerClient::eFXSurfaceBufferState,
+ mBGSurfaceControl.get()));
+ ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
+ Transaction().show(layer).setLayer(layer, INT32_MAX).apply();
+
+ LayerCaptureArgs captureArgs;
+ captureArgs.layerHandle = layer->getHandle();
+
+ ScreenCapture::captureLayers(&mCapture, captureArgs);
+ mCapture->expectColor(Rect(0, 0, 32, 32), Color::RED);
+
+ captureArgs.grayscale = true;
+
+ const uint8_t tolerance = 1;
+
+ // Values based on SurfaceFlinger::calculateColorMatrix
+ float3 luminance{0.213f, 0.715f, 0.072f};
+
+ ScreenCapture::captureLayers(&mCapture, captureArgs);
+
+ uint8_t expectedColor = luminance.r * 255;
+ mCapture->expectColor(Rect(0, 0, 32, 32),
+ Color{expectedColor, expectedColor, expectedColor, 255}, tolerance);
+
+ ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::BLUE, 32, 32));
+ ScreenCapture::captureLayers(&mCapture, captureArgs);
+
+ expectedColor = luminance.b * 255;
+ mCapture->expectColor(Rect(0, 0, 32, 32),
+ Color{expectedColor, expectedColor, expectedColor, 255}, tolerance);
+}
+
// In the following tests we verify successful skipping of a parent layer,
// so we use the same verification logic and only change how we mutate
// the parent layer to verify that various properties are ignored.
diff --git a/services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp b/services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp
index e2584e2..6e9f09b 100644
--- a/services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp
+++ b/services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp
@@ -14,9 +14,6 @@
* limitations under the License.
*/
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wextra"
#include "gmock/gmock-spec-builders.h"
#include "mock/MockTimeStats.h"
@@ -177,16 +174,17 @@
static constexpr const uid_t sUidOne = 0;
static constexpr pid_t sPidOne = 10;
static constexpr pid_t sPidTwo = 20;
+static constexpr int32_t sInputEventId = 5;
TEST_F(FrameTimelineTest, tokenManagerRemovesStalePredictions) {
int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
- EXPECT_EQ(getPredictions().size(), 1);
+ EXPECT_EQ(getPredictions().size(), 1u);
flushTokens(systemTime() + maxTokenRetentionTime);
int64_t token2 = mTokenManager->generateTokenForPredictions({10, 20, 30});
std::optional<TimelineItem> predictions = mTokenManager->getPredictionsForToken(token1);
// token1 should have expired
- EXPECT_EQ(getPredictions().size(), 1);
+ EXPECT_EQ(getPredictions().size(), 1u);
EXPECT_EQ(predictions.has_value(), false);
predictions = mTokenManager->getPredictionsForToken(token2);
@@ -194,16 +192,16 @@
}
TEST_F(FrameTimelineTest, createSurfaceFrameForToken_getOwnerPidReturnsCorrectPid) {
- auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
+ auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne,
sLayerNameOne, sLayerNameOne);
- auto surfaceFrame2 = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidTwo, sUidOne,
+ auto surfaceFrame2 = mFrameTimeline->createSurfaceFrameForToken({}, sPidTwo, sUidOne,
sLayerNameOne, sLayerNameOne);
EXPECT_EQ(surfaceFrame1->getOwnerPid(), sPidOne);
EXPECT_EQ(surfaceFrame2->getOwnerPid(), sPidTwo);
}
TEST_F(FrameTimelineTest, createSurfaceFrameForToken_noToken) {
- auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
+ auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne,
sLayerNameOne, sLayerNameOne);
EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::None);
}
@@ -211,21 +209,33 @@
TEST_F(FrameTimelineTest, createSurfaceFrameForToken_expiredToken) {
int64_t token1 = mTokenManager->generateTokenForPredictions({0, 0, 0});
flushTokens(systemTime() + maxTokenRetentionTime);
- auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(token1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ auto surfaceFrame =
+ mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Expired);
}
TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validToken) {
int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
- auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(token1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ auto surfaceFrame =
+ mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
EXPECT_EQ(surfaceFrame->getPredictionState(), PredictionState::Valid);
EXPECT_EQ(compareTimelineItems(surfaceFrame->getPredictions(), TimelineItem(10, 20, 30)), true);
}
+TEST_F(FrameTimelineTest, createSurfaceFrameForToken_validInputEventId) {
+ int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
+ constexpr int32_t inputEventId = 1;
+ auto surfaceFrame =
+ mFrameTimeline->createSurfaceFrameForToken({token1, inputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
+
+ EXPECT_EQ(inputEventId, surfaceFrame->getInputEventId());
+}
+
TEST_F(FrameTimelineTest, presentFenceSignaled_droppedFramesNotUpdated) {
// Global increment
EXPECT_CALL(*mTimeStats, incrementJankyFrames(testing::_));
@@ -234,8 +244,9 @@
int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
- auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(token1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ auto surfaceFrame1 =
+ mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
// Set up the display frame
mFrameTimeline->setSfWakeUp(token1, 20, 11);
@@ -264,11 +275,11 @@
int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
int64_t sfToken2 = mTokenManager->generateTokenForPredictions({52, 56, 60});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
auto surfaceFrame2 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameTwo, sLayerNameTwo);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameTwo, sLayerNameTwo);
mFrameTimeline->setSfWakeUp(sfToken1, 22, 11);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
mFrameTimeline->addSurfaceFrame(surfaceFrame1);
@@ -288,8 +299,8 @@
// Trigger a flush by finalizing the next DisplayFrame
auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
auto surfaceFrame3 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken2, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken2, 52, 11);
surfaceFrame3->setPresentState(SurfaceFrame::PresentState::Dropped);
mFrameTimeline->addSurfaceFrame(surfaceFrame3);
@@ -320,8 +331,9 @@
int64_t sfToken = mTokenManager->generateTokenForPredictions(
{22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId},
+ sPidOne, sUidOne, sLayerNameOne,
+ sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
mFrameTimeline->addSurfaceFrame(surfaceFrame);
@@ -341,8 +353,8 @@
int64_t sfToken = mTokenManager->generateTokenForPredictions(
{22 + frameTimeFactor, 26 + frameTimeFactor, 30 + frameTimeFactor});
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken, 22 + frameTimeFactor, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
mFrameTimeline->addSurfaceFrame(surfaceFrame);
@@ -356,18 +368,18 @@
}
TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceAfterQueue) {
- auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, 0,
- "acquireFenceAfterQueue",
- "acquireFenceAfterQueue");
+ auto surfaceFrame =
+ mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, "acquireFenceAfterQueue",
+ "acquireFenceAfterQueue");
surfaceFrame->setActualQueueTime(123);
surfaceFrame->setAcquireFenceTime(456);
EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
}
TEST_F(FrameTimelineTest, surfaceFrameEndTimeAcquireFenceBeforeQueue) {
- auto surfaceFrame = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, 0,
- "acquireFenceAfterQueue",
- "acquireFenceAfterQueue");
+ auto surfaceFrame =
+ mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, 0, "acquireFenceAfterQueue",
+ "acquireFenceAfterQueue");
surfaceFrame->setActualQueueTime(456);
surfaceFrame->setAcquireFenceTime(123);
EXPECT_EQ(surfaceFrame->getActuals().endTime, 456);
@@ -383,8 +395,8 @@
// Size shouldn't exceed maxDisplayFrames - 64
for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerNameOne,
+ sLayerNameOne);
int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
mFrameTimeline->setSfWakeUp(sfToken, 22, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -395,15 +407,15 @@
// Increase the size to 256
mFrameTimeline->setMaxDisplayFrames(256);
- EXPECT_EQ(*maxDisplayFrames, 256);
+ EXPECT_EQ(*maxDisplayFrames, 256u);
// Global increment
EXPECT_CALL(*mTimeStats, incrementJankyFrames(testing::_))
.Times(static_cast<int32_t>(*maxDisplayFrames + 10));
for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerNameOne,
+ sLayerNameOne);
int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
mFrameTimeline->setSfWakeUp(sfToken, 22, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -414,15 +426,15 @@
// Shrink the size to 128
mFrameTimeline->setMaxDisplayFrames(128);
- EXPECT_EQ(*maxDisplayFrames, 128);
+ EXPECT_EQ(*maxDisplayFrames, 128u);
// Global increment
EXPECT_CALL(*mTimeStats, incrementJankyFrames(testing::_))
.Times(static_cast<int32_t>(*maxDisplayFrames + 10));
for (size_t i = 0; i < *maxDisplayFrames + 10; i++) {
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne, sLayerNameOne,
+ sLayerNameOne);
int64_t sfToken = mTokenManager->generateTokenForPredictions({22, 26, 30});
mFrameTimeline->setSfWakeUp(sfToken, 22, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -449,8 +461,8 @@
std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken1,
std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count(),
11);
@@ -478,8 +490,8 @@
std::chrono::duration_cast<std::chrono::nanoseconds>(56ms).count(),
std::chrono::duration_cast<std::chrono::nanoseconds>(60ms).count()});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken1,
std::chrono::duration_cast<std::chrono::nanoseconds>(52ms).count(),
30);
@@ -507,8 +519,8 @@
std::chrono::duration_cast<std::chrono::nanoseconds>(86ms).count(),
std::chrono::duration_cast<std::chrono::nanoseconds>(90ms).count()});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(
std::chrono::duration_cast<std::chrono::nanoseconds>(45ms).count());
mFrameTimeline->setSfWakeUp(sfToken1,
@@ -542,8 +554,9 @@
int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
- auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(token1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ auto surfaceFrame1 =
+ mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
// Set up the display frame
mFrameTimeline->setSfWakeUp(token1, 20, 11);
@@ -558,7 +571,7 @@
mFrameTimeline->setSfPresent(55, presentFence2);
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
- EXPECT_EQ(packets.size(), 0);
+ EXPECT_EQ(packets.size(), 0u);
}
TEST_F(FrameTimelineTest, tracing_sanityTest) {
@@ -573,8 +586,9 @@
tracingSession->StartBlocking();
int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
- auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(token1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ auto surfaceFrame1 =
+ mFrameTimeline->createSurfaceFrameForToken({token1, sInputEventId}, sPidOne, sUidOne,
+ sLayerNameOne, sLayerNameOne);
// Set up the display frame
mFrameTimeline->setSfWakeUp(token2, 20, 11);
@@ -594,7 +608,7 @@
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
// Display Frame 1 has 8 packets - 4 from DisplayFrame and 4 from SurfaceFrame.
- EXPECT_EQ(packets.size(), 8);
+ EXPECT_EQ(packets.size(), 8u);
}
TEST_F(FrameTimelineTest, traceDisplayFrame_invalidTokenDoesNotEmitTracePacket) {
@@ -622,7 +636,7 @@
tracingSession->StopBlocking();
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
- EXPECT_EQ(packets.size(), 0);
+ EXPECT_EQ(packets.size(), 0u);
}
TEST_F(FrameTimelineTest, traceSurfaceFrame_invalidTokenDoesNotEmitTracePacket) {
@@ -635,7 +649,7 @@
tracingSession->StartBlocking();
int64_t token1 = mTokenManager->generateTokenForPredictions({10, 20, 30});
int64_t token2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
- auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken(std::nullopt, sPidOne, sUidOne,
+ auto surfaceFrame1 = mFrameTimeline->createSurfaceFrameForToken({}, sPidOne, sUidOne,
sLayerNameOne, sLayerNameOne);
// Set up the display frame
@@ -657,7 +671,7 @@
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
// Display Frame 1 has 4 packets (SurfaceFrame shouldn't be traced since it has an invalid
// token).
- EXPECT_EQ(packets.size(), 4);
+ EXPECT_EQ(packets.size(), 4u);
}
void validateTraceEvent(const ProtoExpectedDisplayFrameStart& received,
@@ -791,12 +805,12 @@
tracingSession->StopBlocking();
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
- EXPECT_EQ(packets.size(), 4);
+ EXPECT_EQ(packets.size(), 4u);
// Packet - 0 : ExpectedDisplayFrameStart
const auto& packet0 = packets[0];
ASSERT_TRUE(packet0.has_timestamp());
- EXPECT_EQ(packet0.timestamp(), 10);
+ EXPECT_EQ(packet0.timestamp(), 10u);
ASSERT_TRUE(packet0.has_frame_timeline_event());
const auto& event0 = packet0.frame_timeline_event();
@@ -807,7 +821,7 @@
// Packet - 1 : FrameEnd (ExpectedDisplayFrame)
const auto& packet1 = packets[1];
ASSERT_TRUE(packet1.has_timestamp());
- EXPECT_EQ(packet1.timestamp(), 25);
+ EXPECT_EQ(packet1.timestamp(), 25u);
ASSERT_TRUE(packet1.has_frame_timeline_event());
const auto& event1 = packet1.frame_timeline_event();
@@ -818,7 +832,7 @@
// Packet - 2 : ActualDisplayFrameStart
const auto& packet2 = packets[2];
ASSERT_TRUE(packet2.has_timestamp());
- EXPECT_EQ(packet2.timestamp(), 20);
+ EXPECT_EQ(packet2.timestamp(), 20u);
ASSERT_TRUE(packet2.has_frame_timeline_event());
const auto& event2 = packet2.frame_timeline_event();
@@ -829,7 +843,7 @@
// Packet - 3 : FrameEnd (ActualDisplayFrame)
const auto& packet3 = packets[3];
ASSERT_TRUE(packet3.has_timestamp());
- EXPECT_EQ(packet3.timestamp(), 26);
+ EXPECT_EQ(packet3.timestamp(), 26u);
ASSERT_TRUE(packet3.has_frame_timeline_event());
const auto& event3 = packet3.frame_timeline_event();
@@ -853,8 +867,8 @@
int64_t displayFrameToken2 = mTokenManager->generateTokenForPredictions({40, 50, 60});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setActualStartTime(0);
surfaceFrame1->setActualQueueTime(15);
surfaceFrame1->setAcquireFenceTime(20);
@@ -904,12 +918,12 @@
tracingSession->StopBlocking();
auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());
- EXPECT_EQ(packets.size(), 8);
+ EXPECT_EQ(packets.size(), 8u);
// Packet - 4 : ExpectedSurfaceFrameStart
const auto& packet4 = packets[4];
ASSERT_TRUE(packet4.has_timestamp());
- EXPECT_EQ(packet4.timestamp(), 10);
+ EXPECT_EQ(packet4.timestamp(), 10u);
ASSERT_TRUE(packet4.has_frame_timeline_event());
const auto& event4 = packet4.frame_timeline_event();
@@ -920,7 +934,7 @@
// Packet - 5 : FrameEnd (ExpectedSurfaceFrame)
const auto& packet5 = packets[5];
ASSERT_TRUE(packet5.has_timestamp());
- EXPECT_EQ(packet5.timestamp(), 25);
+ EXPECT_EQ(packet5.timestamp(), 25u);
ASSERT_TRUE(packet5.has_frame_timeline_event());
const auto& event5 = packet5.frame_timeline_event();
@@ -931,7 +945,7 @@
// Packet - 6 : ActualSurfaceFrameStart
const auto& packet6 = packets[6];
ASSERT_TRUE(packet6.has_timestamp());
- EXPECT_EQ(packet6.timestamp(), 10);
+ EXPECT_EQ(packet6.timestamp(), 10u);
ASSERT_TRUE(packet6.has_frame_timeline_event());
const auto& event6 = packet6.frame_timeline_event();
@@ -942,7 +956,7 @@
// Packet - 7 : FrameEnd (ActualSurfaceFrame)
const auto& packet7 = packets[7];
ASSERT_TRUE(packet7.has_timestamp());
- EXPECT_EQ(packet7.timestamp(), 20);
+ EXPECT_EQ(packet7.timestamp(), 20u);
ASSERT_TRUE(packet7.has_frame_timeline_event());
const auto& event7 = packet7.frame_timeline_event();
@@ -961,8 +975,8 @@
int64_t surfaceFrameToken = mTokenManager->generateTokenForPredictions({10, 20, 30});
int64_t sfToken1 = mTokenManager->generateTokenForPredictions({22, 26, 30});
auto surfaceFrame =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
mFrameTimeline->setSfWakeUp(sfToken1, 22, 11);
surfaceFrame->setPresentState(SurfaceFrame::PresentState::Presented);
mFrameTimeline->addSurfaceFrame(surfaceFrame);
@@ -1126,8 +1140,8 @@
int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(16);
mFrameTimeline->setSfWakeUp(sfToken1, 22, 11);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1145,8 +1159,8 @@
// Trigger a flush by finalizing the next DisplayFrame
auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
auto surfaceFrame2 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken2, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame2->setAcquireFenceTime(36);
mFrameTimeline->setSfWakeUp(sfToken2, 52, 11);
surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1199,8 +1213,8 @@
int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 40});
int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 70});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(16);
mFrameTimeline->setSfWakeUp(sfToken1, 22, 11);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1218,8 +1232,8 @@
// Trigger a flush by finalizing the next DisplayFrame
auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
auto surfaceFrame2 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken2, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame2->setAcquireFenceTime(36);
mFrameTimeline->setSfWakeUp(sfToken2, 52, 11);
surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1270,8 +1284,8 @@
int64_t sfToken1 = mTokenManager->generateTokenForPredictions({42, 46, 50});
int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 26, 60});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(40);
mFrameTimeline->setSfWakeUp(sfToken1, 42, 11);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1316,8 +1330,8 @@
int64_t surfaceFrameToken1 = mTokenManager->generateTokenForPredictions({5, 16, 30});
int64_t surfaceFrameToken2 = mTokenManager->generateTokenForPredictions({25, 36, 50});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(26);
mFrameTimeline->setSfWakeUp(sfToken1, 32, 11);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1335,8 +1349,8 @@
// Trigger a flush by finalizing the next DisplayFrame
auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
auto surfaceFrame2 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken2, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame2->setAcquireFenceTime(40);
mFrameTimeline->setSfWakeUp(sfToken2, 43, 11);
surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1390,8 +1404,8 @@
int64_t sfToken1 = mTokenManager->generateTokenForPredictions({52, 56, 60});
int64_t sfToken2 = mTokenManager->generateTokenForPredictions({112, 116, 120});
auto surfaceFrame1 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken1, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken1, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame1->setAcquireFenceTime(50);
mFrameTimeline->setSfWakeUp(sfToken1, 52, 30);
surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Presented);
@@ -1409,8 +1423,8 @@
// Trigger a flush by finalizing the next DisplayFrame
auto presentFence2 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);
auto surfaceFrame2 =
- mFrameTimeline->createSurfaceFrameForToken(surfaceFrameToken2, sPidOne, sUidOne,
- sLayerNameOne, sLayerNameOne);
+ mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken2, sInputEventId}, sPidOne,
+ sUidOne, sLayerNameOne, sLayerNameOne);
surfaceFrame2->setAcquireFenceTime(84);
mFrameTimeline->setSfWakeUp(sfToken2, 112, 30);
surfaceFrame2->setPresentState(SurfaceFrame::PresentState::Presented, 54);
@@ -1456,6 +1470,3 @@
JankType::AppDeadlineMissed | JankType::BufferStuffing);
}
} // namespace android::frametimeline
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wextra"
\ No newline at end of file
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 2701f47..3be45e2 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -353,7 +353,8 @@
bool regionSampling) {
ScreenCaptureResults captureResults;
return mFlinger->renderScreenImplLocked(renderArea, traverseLayers, buffer, forSystem,
- regionSampling, captureResults);
+ regionSampling, false /* grayscale */,
+ captureResults);
}
auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
@@ -368,16 +369,14 @@
auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }
- auto setTransactionState(int64_t frameTimelineVsyncId, const Vector<ComposerState>& states,
- const Vector<DisplayState>& displays, uint32_t flags,
- const sp<IBinder>& applyToken,
- const InputWindowCommands& inputWindowCommands,
- int64_t desiredPresentTime, bool isAutoTimestamp,
- const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
- std::vector<ListenerCallbacks>& listenerCallbacks,
- uint64_t transactionId) {
- return mFlinger->setTransactionState(frameTimelineVsyncId, states, displays, flags,
- applyToken, inputWindowCommands, desiredPresentTime,
+ auto setTransactionState(
+ const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
+ const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
+ const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
+ bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
+ std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
+ return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
+ inputWindowCommands, desiredPresentTime,
isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
listenerCallbacks, transactionId);
}
diff --git a/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp b/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp
index 06275c6..6d2f672 100644
--- a/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp
+++ b/services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp
@@ -14,10 +14,6 @@
* limitations under the License.
*/
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wconversion"
-#pragma clang diagnostic ignored "-Wextra"
#undef LOG_TAG
#define LOG_TAG "CompositionTest"
@@ -100,43 +96,44 @@
InputWindowCommands inputWindowCommands;
int64_t desiredPresentTime = 0;
bool isAutoTimestamp = true;
- int64_t frameTimelineVsyncId = ISurfaceComposer::INVALID_VSYNC_ID;
+ FrameTimelineInfo frameTimelineInfo;
client_cache_t uncacheBuffer;
- int64_t id = -1;
+ uint64_t id = static_cast<uint64_t>(-1);
+ static_assert(0xffffffffffffffff == static_cast<uint64_t>(-1));
};
void checkEqual(TransactionInfo info, SurfaceFlinger::TransactionState state) {
- EXPECT_EQ(0, info.states.size());
- EXPECT_EQ(0, state.states.size());
+ EXPECT_EQ(0u, info.states.size());
+ EXPECT_EQ(0u, state.states.size());
- EXPECT_EQ(0, info.displays.size());
- EXPECT_EQ(0, state.displays.size());
+ EXPECT_EQ(0u, info.displays.size());
+ EXPECT_EQ(0u, state.displays.size());
EXPECT_EQ(info.flags, state.flags);
EXPECT_EQ(info.desiredPresentTime, state.desiredPresentTime);
}
void setupSingle(TransactionInfo& transaction, uint32_t flags, bool syncInputWindows,
int64_t desiredPresentTime, bool isAutoTimestamp,
- int64_t frameTimelineVsyncId) {
+ const FrameTimelineInfo& frameTimelineInfo) {
mTransactionNumber++;
transaction.flags |= flags; // ISurfaceComposer::eSynchronous;
transaction.inputWindowCommands.syncInputWindows = syncInputWindows;
transaction.desiredPresentTime = desiredPresentTime;
transaction.isAutoTimestamp = isAutoTimestamp;
- transaction.frameTimelineVsyncId = frameTimelineVsyncId;
+ transaction.frameTimelineInfo = frameTimelineInfo;
}
void NotPlacedOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
- ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
// called in SurfaceFlinger::signalTransaction
EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
EXPECT_CALL(*mVSyncTracker, nextAnticipatedVSyncTimeFrom(_)).WillOnce(Return(systemTime()));
TransactionInfo transaction;
setupSingle(transaction, flags, syncInputWindows,
/*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true,
- ISurfaceComposer::INVALID_VSYNC_ID);
+ FrameTimelineInfo{});
nsecs_t applicationTime = systemTime();
- mFlinger.setTransactionState(transaction.frameTimelineVsyncId, transaction.states,
+ mFlinger.setTransactionState(transaction.frameTimelineInfo, transaction.states,
transaction.displays, transaction.flags,
transaction.applyToken, transaction.inputWindowCommands,
transaction.desiredPresentTime, transaction.isAutoTimestamp,
@@ -155,11 +152,11 @@
EXPECT_LE(returnedTime, applicationTime + s2ns(5));
}
auto transactionQueue = mFlinger.getTransactionQueue();
- EXPECT_EQ(0, transactionQueue.size());
+ EXPECT_EQ(0u, transactionQueue.size());
}
void PlaceOnTransactionQueue(uint32_t flags, bool syncInputWindows) {
- ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
// called in SurfaceFlinger::signalTransaction
EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -170,10 +167,9 @@
.WillOnce(Return(time + nsecs_t(5 * 1e8)));
TransactionInfo transaction;
setupSingle(transaction, flags, syncInputWindows,
- /*desiredPresentTime*/ time + s2ns(1), false,
- ISurfaceComposer::INVALID_VSYNC_ID);
+ /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{});
nsecs_t applicationSentTime = systemTime();
- mFlinger.setTransactionState(transaction.frameTimelineVsyncId, transaction.states,
+ mFlinger.setTransactionState(transaction.frameTimelineInfo, transaction.states,
transaction.displays, transaction.flags,
transaction.applyToken, transaction.inputWindowCommands,
transaction.desiredPresentTime, transaction.isAutoTimestamp,
@@ -184,11 +180,11 @@
EXPECT_LE(returnedTime, applicationSentTime + s2ns(5));
// This transaction should have been placed on the transaction queue
auto transactionQueue = mFlinger.getTransactionQueue();
- EXPECT_EQ(1, transactionQueue.size());
+ EXPECT_EQ(1u, transactionQueue.size());
}
void BlockedByPriorTransaction(uint32_t flags, bool syncInputWindows) {
- ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
// called in SurfaceFlinger::signalTransaction
nsecs_t time = systemTime();
EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -197,18 +193,17 @@
// transaction that should go on the pending thread
TransactionInfo transactionA;
setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
- /*desiredPresentTime*/ time + s2ns(1), false,
- ISurfaceComposer::INVALID_VSYNC_ID);
+ /*desiredPresentTime*/ time + s2ns(1), false, FrameTimelineInfo{});
// transaction that would not have gone on the pending thread if not
// blocked
TransactionInfo transactionB;
setupSingle(transactionB, flags, syncInputWindows,
/*desiredPresentTime*/ systemTime(), /*isAutoTimestamp*/ true,
- ISurfaceComposer::INVALID_VSYNC_ID);
+ FrameTimelineInfo{});
nsecs_t applicationSentTime = systemTime();
- mFlinger.setTransactionState(transactionA.frameTimelineVsyncId, transactionA.states,
+ mFlinger.setTransactionState(transactionA.frameTimelineInfo, transactionA.states,
transactionA.displays, transactionA.flags,
transactionA.applyToken, transactionA.inputWindowCommands,
transactionA.desiredPresentTime, transactionA.isAutoTimestamp,
@@ -221,7 +216,7 @@
EXPECT_LE(systemTime(), applicationSentTime + s2ns(5));
applicationSentTime = systemTime();
- mFlinger.setTransactionState(transactionB.frameTimelineVsyncId, transactionB.states,
+ mFlinger.setTransactionState(transactionB.frameTimelineInfo, transactionB.states,
transactionB.displays, transactionB.flags,
transactionB.applyToken, transactionB.inputWindowCommands,
transactionB.desiredPresentTime, transactionB.isAutoTimestamp,
@@ -240,10 +235,10 @@
// check that there is one binder on the pending queue.
auto transactionQueue = mFlinger.getTransactionQueue();
- EXPECT_EQ(1, transactionQueue.size());
+ EXPECT_EQ(1u, transactionQueue.size());
auto& [applyToken, transactionStates] = *(transactionQueue.begin());
- EXPECT_EQ(2, transactionStates.size());
+ EXPECT_EQ(2u, transactionStates.size());
auto& transactionStateA = transactionStates.front();
transactionStates.pop();
@@ -258,7 +253,7 @@
};
TEST_F(TransactionApplicationTest, Flush_RemovesFromQueue) {
- ASSERT_EQ(0, mFlinger.getTransactionQueue().size());
+ ASSERT_EQ(0u, mFlinger.getTransactionQueue().size());
// called in SurfaceFlinger::signalTransaction
EXPECT_CALL(*mMessageQueue, invalidate()).Times(1);
@@ -268,18 +263,18 @@
.WillOnce(Return(s2ns(2)));
TransactionInfo transactionA; // transaction to go on pending queue
setupSingle(transactionA, /*flags*/ 0, /*syncInputWindows*/ false,
- /*desiredPresentTime*/ s2ns(1), false, ISurfaceComposer::INVALID_VSYNC_ID);
- mFlinger.setTransactionState(transactionA.frameTimelineVsyncId, transactionA.states,
+ /*desiredPresentTime*/ s2ns(1), false, FrameTimelineInfo{});
+ mFlinger.setTransactionState(transactionA.frameTimelineInfo, transactionA.states,
transactionA.displays, transactionA.flags, transactionA.applyToken,
transactionA.inputWindowCommands, transactionA.desiredPresentTime,
transactionA.isAutoTimestamp, transactionA.uncacheBuffer,
mHasListenerCallbacks, mCallbacks, transactionA.id);
auto& transactionQueue = mFlinger.getTransactionQueue();
- ASSERT_EQ(1, transactionQueue.size());
+ ASSERT_EQ(1u, transactionQueue.size());
auto& [applyToken, transactionStates] = *(transactionQueue.begin());
- ASSERT_EQ(1, transactionStates.size());
+ ASSERT_EQ(1u, transactionStates.size());
auto& transactionState = transactionStates.front();
checkEqual(transactionA, transactionState);
@@ -289,8 +284,8 @@
// different process) to re-query and reset the cached expected present time
TransactionInfo empty;
empty.applyToken = sp<IBinder>();
- mFlinger.setTransactionState(empty.frameTimelineVsyncId, empty.states, empty.displays,
- empty.flags, empty.applyToken, empty.inputWindowCommands,
+ mFlinger.setTransactionState(empty.frameTimelineInfo, empty.states, empty.displays, empty.flags,
+ empty.applyToken, empty.inputWindowCommands,
empty.desiredPresentTime, empty.isAutoTimestamp,
empty.uncacheBuffer, mHasListenerCallbacks, mCallbacks, empty.id);
@@ -298,7 +293,7 @@
// passed
mFlinger.flushTransactionQueues();
- EXPECT_EQ(0, transactionQueue.size());
+ EXPECT_EQ(0u, transactionQueue.size());
}
TEST_F(TransactionApplicationTest, NotPlacedOnTransactionQueue_Synchronous) {
@@ -343,6 +338,3 @@
EXPECT_EQ(nullptr, ret.promote().get());
}
} // namespace android
-
-// TODO(b/129481165): remove the #pragma below and fix conversion issues
-#pragma clang diagnostic pop // ignored "-Wconversion -Wextra"