blob: 7889096fe2d912da22e598cde3ecf61a32354561 [file] [log] [blame]
Lloyd Piquef58625d2017-12-19 13:22:33 -08001/*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
Dominik Laskowski83bd7712022-01-07 14:30:53 -080019#include <algorithm>
Xiang Wang839fe5b2022-04-04 17:39:38 +000020#include <chrono>
Melody Hsu63e3dcc2024-04-03 23:22:20 +000021#include <memory>
Dominik Laskowski83bd7712022-01-07 14:30:53 -080022#include <variant>
23
Dominik Laskowskib418dd72023-06-13 17:31:04 -040024#include <ftl/fake_guard.h>
25#include <ftl/match.h>
Melody Hsu63e3dcc2024-04-03 23:22:20 +000026#include <gui/LayerMetadata.h>
Dominik Laskowskib418dd72023-06-13 17:31:04 -040027#include <gui/ScreenCaptureResults.h>
28#include <ui/DynamicDisplayInfo.h>
29
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080030#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070031#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080032#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070033#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070034#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080035#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070036#include <compositionengine/mock/DisplaySurface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070037
Lloyd Piquef58625d2017-12-19 13:22:33 -080038#include "DisplayDevice.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070039#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080040#include "FrameTracer/FrameTracer.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000041#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair07e2a482022-10-18 19:18:16 +000042#include "FrontEnd/LayerHandle.h"
Melody Hsu63e3dcc2024-04-03 23:22:20 +000043#include "FrontEnd/RequestedLayerState.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070044#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070045#include "NativeWindowSurface.h"
Patrick Williams7584c6a2022-10-29 02:10:58 +000046#include "RenderArea.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070047#include "Scheduler/MessageQueue.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040048#include "Scheduler/RefreshRateSelector.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080049#include "SurfaceFlinger.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070050#include "TestableScheduler.h"
Melody Hsu63e3dcc2024-04-03 23:22:20 +000051#include "android/gui/ISurfaceComposerClient.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010052#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080053#include "mock/DisplayHardware/MockDisplayMode.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000054#include "mock/DisplayHardware/MockPowerAdvisor.h"
Dominik Laskowskiaee9a622023-02-11 14:24:19 -050055#include "mock/MockEventThread.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070056#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080057#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080058#include "mock/MockSchedulerCallback.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000059#include "mock/system/window/MockNativeWindow.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080060
Brian Johnson9ea03122023-06-30 14:46:34 -070061#include "Scheduler/VSyncTracker.h"
62#include "Scheduler/VsyncController.h"
63#include "mock/MockVSyncDispatch.h"
64#include "mock/MockVSyncTracker.h"
65#include "mock/MockVsyncController.h"
66
Lloyd Piquef58625d2017-12-19 13:22:33 -080067namespace android {
Leon Scroggins III4235ea02023-04-17 15:14:20 -040068
69struct DisplayStatInfo;
70
Peiyong Lin833074a2018-08-28 11:53:54 -070071namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070072
Lloyd Piquee39cad22017-12-20 17:01:29 -080073class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070074
75} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080076
77namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070078
Lloyd Piquee39cad22017-12-20 17:01:29 -080079class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070080
81} // namespace Hwc2
82
Peiyong Line9d809e2020-04-14 13:10:48 -070083namespace hal = android::hardware::graphics::composer::hal;
84
Lloyd Pique90c115d2018-09-18 21:39:42 -070085namespace surfaceflinger::test {
86
87class Factory final : public surfaceflinger::Factory {
88public:
89 ~Factory() = default;
90
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070092 return nullptr;
93 }
94
Ady Abraham8287e852020-08-12 14:44:58 -070095 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010096 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080097 return std::make_unique<scheduler::FakePhaseOffsets>();
98 }
99
Lloyd Pique9370a482019-10-03 17:58:30 -0700100 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700101 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700102 }
103
104 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
105 uint32_t layerCount, uint64_t usage,
106 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700107 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700108 }
109
110 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
111 sp<IGraphicBufferConsumer>* outConsumer,
112 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700113 if (!mCreateBufferQueue) {
114 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
115 return;
116 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700117 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
118 }
119
120 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
121 const sp<IGraphicBufferProducer>& producer) override {
122 if (!mCreateNativeWindowSurface) return nullptr;
123 return mCreateNativeWindowSurface(producer);
124 }
125
Lloyd Pique70d91362018-10-18 16:02:55 -0700126 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
127 return compositionengine::impl::createCompositionEngine();
128 }
129
Patrick Williams83f36b22022-09-14 17:57:35 +0000130 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700131
Patrick Williams46b61b92022-09-01 17:25:49 +0000132 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700133
Lloyd Pique70ddc672024-04-30 18:20:40 -0700134 sp<LayerFE> createLayerFE(const std::string& layerName, const Layer* /* owner */) override {
Vishnu Naire14c6b32022-08-06 04:20:15 +0000135 return sp<LayerFE>::make(layerName);
136 }
137
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800138 std::unique_ptr<FrameTracer> createFrameTracer() override {
139 return std::make_unique<mock::FrameTracer>();
140 }
141
Adithya Srinivasan01189672020-10-20 14:23:05 -0700142 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800143 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
144 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700145 }
146
Lloyd Pique90c115d2018-09-18 21:39:42 -0700147 using CreateBufferQueueFunction =
148 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
149 sp<IGraphicBufferConsumer>* /* outConsumer */,
150 bool /* consumerIsSurfaceFlinger */)>;
151 CreateBufferQueueFunction mCreateBufferQueue;
152
153 using CreateNativeWindowSurfaceFunction =
154 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
155 const sp<IGraphicBufferProducer>&)>;
156 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700157
158 using CreateCompositionEngineFunction =
159 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
160 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700161};
162
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500163struct MockSchedulerOptions {
164 PhysicalDisplayId displayId = PhysicalDisplayId::fromPort(0);
165 bool useNiceMock = false;
166};
167
Lloyd Pique90c115d2018-09-18 21:39:42 -0700168} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800169
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800170class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800171public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700172 using HotplugEvent = SurfaceFlinger::HotplugEvent;
173
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800174 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
175 if (!mFlinger) {
Lloyd Pique30db6402023-06-26 18:56:51 +0000176 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800177 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800178 }
179
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700180 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700181 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700182
Lloyd Piquef58625d2017-12-19 13:22:33 -0800183 // Extend this as needed for accessing SurfaceFlinger private (and public)
184 // functions.
185
Peiyong Lin833074a2018-08-28 11:53:54 -0700186 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Patrick Williams0a525a42022-10-26 20:20:50 +0000187 mFlinger->mRenderEngine = std::move(renderEngine);
188 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800189 }
190
191 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700192 mFlinger->mCompositionEngine->setHwComposer(
193 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800194 }
195
Xiang Wang839fe5b2022-04-04 17:39:38 +0000196 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
197 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
198 }
199
Alec Mourie4034bb2019-11-19 12:45:54 -0800200 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
201 mFlinger->mCompositionEngine->setTimeStats(timeStats);
202 }
203
Melody Hsu63e3dcc2024-04-03 23:22:20 +0000204 void setupCompositionEngine(
205 std::unique_ptr<compositionengine::CompositionEngine> compositionEngine) {
206 mFlinger->mCompositionEngine = std::move(compositionEngine);
207 }
208
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800209 enum class SchedulerCallbackImpl { kNoOp, kMock };
210
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500211 struct DefaultDisplayMode {
212 // The ID of the injected RefreshRateSelector and its default display mode.
213 PhysicalDisplayId displayId;
214 };
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800215
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500216 using RefreshRateSelectorPtr = scheduler::Scheduler::RefreshRateSelectorPtr;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800217
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500218 using DisplayModesVariant = std::variant<DefaultDisplayMode, RefreshRateSelectorPtr>;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800219
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500220 surfaceflinger::Factory& getFactory() { return mFactory; }
221
222 TimeStats& getTimeStats() { return *mFlinger->mTimeStats; }
223
ramindaniae645822024-01-11 10:57:29 -0800224 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
225 std::shared_ptr<scheduler::VSyncTracker> vsyncTracker,
226 std::unique_ptr<EventThread> appEventThread,
227 std::unique_ptr<EventThread> sfEventThread,
228 DisplayModesVariant modesVariant,
229 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
230 bool useNiceMock = false) {
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500231 RefreshRateSelectorPtr selectorPtr = ftl::match(
232 modesVariant,
233 [](DefaultDisplayMode arg) {
234 constexpr DisplayModeId kModeId60{0};
235 return std::make_shared<scheduler::RefreshRateSelector>(
236 makeModes(mock::createDisplayMode(arg.displayId, kModeId60, 60_Hz)),
237 kModeId60);
238 },
239 [](RefreshRateSelectorPtr selectorPtr) { return selectorPtr; });
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700240
Ady Abraham011f8ba2022-11-22 15:09:07 -0800241 mTokenManager = std::make_unique<frametimeline::impl::TokenManager>();
242
ramindanid4354a92023-10-02 15:11:09 -0700243 using ISchedulerCallback = scheduler::ISchedulerCallback;
244 ISchedulerCallback& schedulerCallback = callbackImpl == SchedulerCallbackImpl::kNoOp
245 ? static_cast<ISchedulerCallback&>(mNoOpSchedulerCallback)
246 : static_cast<ISchedulerCallback&>(mSchedulerCallback);
247
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800248 if (useNiceMock) {
249 mScheduler =
250 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
251 std::move(vsyncTracker),
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400252 std::move(selectorPtr),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500253 mFactory,
254 *mFlinger->mTimeStats,
ramindaniae645822024-01-11 10:57:29 -0800255 schedulerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800256 } else {
257 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
258 std::move(vsyncTracker),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500259 std::move(selectorPtr), mFactory,
ramindaniae645822024-01-11 10:57:29 -0800260 *mFlinger->mTimeStats, schedulerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800261 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700262
Leon Scroggins IIIa7be94e2024-01-23 12:24:30 -0500263 mScheduler->initVsync(*mTokenManager, 0ms);
Ady Abraham011f8ba2022-11-22 15:09:07 -0800264
Dominik Laskowski4babfc42024-02-16 12:28:40 -0500265 mScheduler->setEventThread(scheduler::Cycle::Render, std::move(appEventThread));
266 mScheduler->setEventThread(scheduler::Cycle::LastComposite, std::move(sfEventThread));
Dominik Laskowskie99b98c2023-02-02 12:37:23 -0500267
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700268 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700269 }
270
Rachel Lee414f4082023-10-23 14:48:44 -0700271 void setupMockScheduler(surfaceflinger::test::MockSchedulerOptions options = {}) {
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500272 using testing::_;
273 using testing::Return;
274
275 auto eventThread = makeMock<mock::EventThread>(options.useNiceMock);
276 auto sfEventThread = makeMock<mock::EventThread>(options.useNiceMock);
277
278 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
279 EXPECT_CALL(*eventThread, createEventConnection(_, _))
280 .WillOnce(Return(sp<EventThreadConnection>::make(eventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700281 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500282
283 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
284 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
285 .WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700286 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500287
288 auto vsyncController = makeMock<mock::VsyncController>(options.useNiceMock);
Leon Scroggins III67388622023-02-06 20:36:20 -0500289 auto vsyncTracker = makeSharedMock<mock::VSyncTracker>(options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500290
Ady Abraham4335afd2023-12-18 19:10:47 -0800291 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500292 EXPECT_CALL(*vsyncTracker, currentPeriod())
293 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abrahamc94bffc2023-11-22 11:10:09 -0800294 EXPECT_CALL(*vsyncTracker, minFramePeriod())
295 .WillRepeatedly(
296 Return(Period::fromNs(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)));
Ady Abraham4335afd2023-12-18 19:10:47 -0800297 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500298 setupScheduler(std::move(vsyncController), std::move(vsyncTracker), std::move(eventThread),
299 std::move(sfEventThread), DefaultDisplayMode{options.displayId},
ramindaniae645822024-01-11 10:57:29 -0800300 SchedulerCallbackImpl::kNoOp, options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500301 }
302
Dominik Laskowski068173d2021-08-11 17:22:59 -0700303 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700304
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800305 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
306 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800307
Lloyd Pique90c115d2018-09-18 21:39:42 -0700308 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800309 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700310 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800311 }
312
Lloyd Pique90c115d2018-09-18 21:39:42 -0700313 using CreateNativeWindowSurfaceFunction =
314 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800315 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700316 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800317 }
318
Lloyd Pique30db6402023-06-26 18:56:51 +0000319 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
320 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
321 }
322
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700323 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700324
Valerie Haud251afb2019-03-29 14:19:02 -0700325 auto& mutableStateLock() { return mFlinger->mStateLock; }
326
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700327 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
328 const sp<const DisplayDevice>& display) {
329 return layer->findOutputLayerForDisplay(display.get());
330 }
331
332 static void setLayerSidebandStream(const sp<Layer>& layer,
333 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800334 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800335 layer->mSidebandStream = sidebandStream;
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000336 layer->editLayerSnapshot()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700337 }
338
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500339 void setLayerCompositionType(const sp<Layer>& layer,
340 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700341 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800342 LOG_ALWAYS_FATAL_IF(!outputLayer);
343 auto& state = outputLayer->editState();
344 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700345 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700346 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800347
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700348 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700349 layer->mPotentialCursor = potentialCursor;
350 }
351
Garfield Tande619fa2020-10-02 17:13:53 -0700352 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000353 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700354 }
355
Lloyd Piquef58625d2017-12-19 13:22:33 -0800356 /* ------------------------------------------------------------------------
357 * Forwarding for functions being tested
358 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000359
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500360 void configure() {
361 ftl::FakeGuard guard(kMainThreadContext);
362 mFlinger->configure();
363 }
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700364
365 void configureAndCommit() {
366 configure();
367 commitTransactionsLocked(eDisplayTransactionNeeded);
368 }
369
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400370 void commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime,
371 bool composite = false) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500372 ftl::FakeGuard guard(kMainThreadContext);
373
374 const auto displayIdOpt = mScheduler->pacesetterDisplayId();
375 LOG_ALWAYS_FATAL_IF(!displayIdOpt);
376 const auto displayId = *displayIdOpt;
377
Leon Scroggins III0bd0d4c2022-12-08 13:20:45 -0500378 scheduler::FrameTargeter frameTargeter(displayId,
379 scheduler::Feature::kBackpressureGpuComposition);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400380
381 frameTargeter.beginFrame({.frameBeginTime = frameTime,
382 .vsyncId = vsyncId,
383 .expectedVsyncTime = expectedVsyncTime,
Leon Scroggins III0bd0d4c2022-12-08 13:20:45 -0500384 .sfWorkDuration = 10ms,
385 .hwcMinWorkDuration = 10ms},
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400386 *mScheduler->getVsyncSchedule());
387
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400388 scheduler::FrameTargets targets;
389 scheduler::FrameTargeters targeters;
390
391 for (const auto& [id, display] :
392 FTL_FAKE_GUARD(mFlinger->mStateLock, mFlinger->mPhysicalDisplays)) {
393 targets.try_emplace(id, &frameTargeter.target());
394 targeters.try_emplace(id, &frameTargeter);
395 }
396
397 mFlinger->commit(displayId, targets);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400398
399 if (composite) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400400 mFlinger->composite(displayId, targeters);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400401 }
Xiang Wang839fe5b2022-04-04 17:39:38 +0000402 }
403
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400404 void commit(TimePoint frameTime, VsyncId vsyncId, bool composite = false) {
405 return commit(frameTime, vsyncId, frameTime + Period(10ms), composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000406 }
407
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400408 void commit(bool composite = false) {
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700409 const TimePoint frameTime = scheduler::SchedulerClock::now();
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400410 commit(frameTime, kVsyncId, composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000411 }
412
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700413 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400414 constexpr bool kComposite = true;
415 commit(frameTime, vsyncId, expectedVsyncTime, kComposite);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700416 }
417
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400418 void commitAndComposite() {
419 constexpr bool kComposite = true;
420 commit(kComposite);
421 }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700422
Alan Dingd53801c2024-05-08 16:45:29 -0700423 auto createVirtualDisplay(const std::string& displayName, bool isSecure,
424 float requestedRefreshRate = 0.0f) {
425 static const std::string kTestId =
426 "virtual:libsurfaceflinger_unittest:TestableSurfaceFlinger";
427 return mFlinger->createVirtualDisplay(displayName, isSecure, kTestId, requestedRefreshRate);
Alan Dingfc6eab52024-05-02 18:28:45 -0700428 }
429
Alan Dingd53801c2024-05-08 16:45:29 -0700430 auto createVirtualDisplay(const std::string& displayName, bool isSecure,
431 const std::string& uniqueId, float requestedRefreshRate = 0.0f) {
432 return mFlinger->createVirtualDisplay(displayName, isSecure, uniqueId,
433 requestedRefreshRate);
Lloyd Piquea482f992018-01-22 19:00:34 -0800434 }
435
Alan Dingd53801c2024-05-08 16:45:29 -0700436 auto destroyVirtualDisplay(const sp<IBinder>& displayToken) {
437 return mFlinger->destroyVirtualDisplay(displayToken);
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700438 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800439
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100440 auto getDisplay(const sp<IBinder>& displayToken) {
441 Mutex::Autolock lock(mFlinger->mStateLock);
442 return mFlinger->getDisplayDeviceLocked(displayToken);
443 }
444
Dominik Laskowski13948602021-03-08 20:48:28 -0800445 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
446
Lloyd Pique9370a482019-10-03 17:58:30 -0700447 auto setupNewDisplayDeviceInternal(
448 const wp<IBinder>& displayToken,
449 std::shared_ptr<compositionengine::Display> compositionDisplay,
450 const DisplayDeviceState& state,
451 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700452 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700453 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
454 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800455 }
456
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700457 void commitTransactionsLocked(uint32_t transactionFlags) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700458 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700459 ftl::FakeGuard guard(kMainThreadContext);
Melody Hsube95e022024-05-07 07:04:55 +0000460 mFlinger->processDisplayChangesLocked();
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700461 mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800462 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800463
Huihong Luo791bef92023-09-19 21:18:45 -0700464 void onComposerHalHotplugEvent(hal::HWDisplayId hwcDisplayId, DisplayHotplugEvent event) {
465 mFlinger->onComposerHalHotplugEvent(hwcDisplayId, event);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800466 }
467
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800468 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700469 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800470 return mFlinger->setDisplayStateLocked(s);
471 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800472
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400473 void initializeDisplays() FTL_FAKE_GUARD(kMainThreadContext) { mFlinger->initializeDisplays(); }
Lloyd Pique86016da2018-03-01 16:09:38 -0800474
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100475 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
476
Alec Mouricdf16792021-12-10 13:16:06 -0800477 auto setDisplayBrightness(const sp<IBinder>& display,
478 const gui::DisplayBrightness& brightness) {
479 return mFlinger->setDisplayBrightness(display, brightness);
480 }
481
Dominik Laskowski83b88212018-12-11 13:34:06 -0800482 // Allow reading display state without locking, as if called on the SF main thread.
483 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700484 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800485 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800486 }
487
Melody Hsu335ef3e2024-05-31 22:58:40 +0000488 auto renderScreenImpl(const sp<DisplayDevice> display,
489 std::unique_ptr<const RenderArea> renderArea,
Melody Hsueddfe932024-06-04 18:10:41 +0000490 SurfaceFlinger::GetLayerSnapshotsFunction getLayerSnapshotsFn,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000491 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000492 bool regionSampling) {
Melody Hsu335ef3e2024-05-31 22:58:40 +0000493 Mutex::Autolock lock(mFlinger->mStateLock);
494 ftl::FakeGuard guard(kMainThreadContext);
495
chaviw426b5c02020-07-27 11:20:15 -0700496 ScreenCaptureResults captureResults;
Melody Hsu335ef3e2024-05-31 22:58:40 +0000497 SurfaceFlinger::OutputCompositionState state = display->getCompositionDisplay()->getState();
Melody Hsueddfe932024-06-04 18:10:41 +0000498 auto layers = mFlinger->getLayerSnapshotsFromMainThread(getLayerSnapshotsFn);
Melody Hsu335ef3e2024-05-31 22:58:40 +0000499
500 return mFlinger->renderScreenImpl(std::move(renderArea), buffer, regionSampling,
501 false /* grayscale */, false /* isProtected */,
502 captureResults, display, state, layers);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700503 }
504
chaviw4b9d5e12020-08-04 18:30:35 -0700505 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Ajinkya Chalke02844632023-03-01 12:10:14 +0000506 std::unordered_set<uint32_t> excludeLayerIds,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200507 const LayerVector::Visitor& visitor) {
Melody Hsueddfe932024-06-04 18:10:41 +0000508 return mFlinger->traverseLayersInLayerStack(layerStack, uid, excludeLayerIds, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700509 }
510
Daniel Solomon42d04562019-01-20 21:03:19 -0800511 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
512 ui::DisplayPrimaries &primaries) {
513 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
514 }
515
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700516 auto& getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
517 auto& getPendingTransactionQueue() {
Vishnu Nair7be27602024-03-28 20:27:09 -0700518 ftl::FakeGuard guard(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700519 return mFlinger->mTransactionHandler.mPendingTransactionQueues;
520 }
521 size_t getPendingTransactionCount() {
Vishnu Nair7be27602024-03-28 20:27:09 -0700522 ftl::FakeGuard guard(kMainThreadContext);
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700523 return mFlinger->mTransactionHandler.mPendingTransactionCount.load();
524 }
Valerie Haud251afb2019-03-29 14:19:02 -0700525
Pablo Gamito23780be2023-04-18 08:30:00 +0000526 auto setTransactionState(
527 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
528 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
529 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
530 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
531 bool hasListenerCallbacks, std::vector<ListenerCallbacks>& listenerCallbacks,
532 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000533 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
534 inputWindowCommands, desiredPresentTime,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000535 isAutoTimestamp, uncacheBuffers, hasListenerCallbacks,
Pablo Gamito23780be2023-04-18 08:30:00 +0000536 listenerCallbacks, transactionId,
537 mergedTransactionIds);
Valerie Haud251afb2019-03-29 14:19:02 -0700538 }
539
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000540 auto setTransactionStateInternal(TransactionState& transaction) {
Vishnu Nair7be27602024-03-28 20:27:09 -0700541 return FTL_FAKE_GUARD(kMainThreadContext,
542 mFlinger->mTransactionHandler.queueTransaction(
543 std::move(transaction)));
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000544 }
545
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700546 auto flushTransactionQueues() {
547 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues(kVsyncId));
548 }
Valerie Haud251afb2019-03-29 14:19:02 -0700549
Eduardo Rochaac867192020-09-14 20:12:17 +0000550 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
551 return mFlinger->onTransact(code, data, reply, flags);
552 }
553
Huihong Luo02186fb2022-02-23 14:21:54 -0800554 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800555
Ady Abraham899dcdb2021-06-15 16:56:21 -0700556 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
557 std::chrono::nanoseconds presentLatency) const {
Lloyd Pique30db6402023-06-26 18:56:51 +0000558 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800559 }
560
Ady Abraham285f8c12022-10-11 17:12:14 -0700561 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
562 const gui::DisplayModeSpecs& specs) {
563 return mFlinger->setDesiredDisplayModeSpecs(displayToken, specs);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100564 }
565
Dominik Laskowski360ae782023-02-22 13:30:37 -0500566 void onActiveDisplayChanged(const DisplayDevice* inactiveDisplayPtr,
567 const DisplayDevice& activeDisplay) {
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100568 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700569 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowski360ae782023-02-22 13:30:37 -0500570 mFlinger->onActiveDisplayChangedLocked(inactiveDisplayPtr, activeDisplay);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100571 }
572
Patrick Williamsa361de62022-10-06 20:34:10 +0000573 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle,
574 gui::CreateSurfaceResult& outResult) {
Vishnu Naircb8be502022-10-12 19:03:23 +0000575 args.parentHandle = parentHandle;
576 return mFlinger->createLayer(args, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800577 }
578
579 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000580 gui::CreateSurfaceResult& outResult) {
581 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800582 }
583
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000584 void updateLayerMetadataSnapshot() { mFlinger->updateLayerMetadataSnapshot(); }
585
Sally Qi6bb12822022-10-05 11:42:30 -0700586 void getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
587 ui::DynamicDisplayInfo* dynamicDisplayInfo) {
588 mFlinger->getDynamicDisplayInfoFromToken(displayToken, dynamicDisplayInfo);
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100589 }
590
Huihong Luo59a60b72023-03-08 21:44:59 +0000591 sp<DisplayDevice> createVirtualDisplayDevice(const sp<IBinder> displayToken,
592 VirtualDisplayId displayId,
593 float requestedRefreshRate) {
594 constexpr ui::Size kResolution = {1080, 1920};
595 auto compositionDisplay = compositionengine::impl::
596 createDisplay(mFlinger->getCompositionEngine(),
597 compositionengine::DisplayCreationArgsBuilder()
598 .setId(displayId)
599 .setPixels(kResolution)
600 .setPowerAdvisor(&mPowerAdvisor)
601 .build());
602 DisplayDeviceCreationArgs creationArgs(mFlinger, mFlinger->getHwComposer(), displayToken,
603 compositionDisplay);
604 creationArgs.requestedRefreshRate = Fps::fromValue(requestedRefreshRate);
605 creationArgs.nativeWindow = sp<mock::NativeWindow>::make();
606 return sp<DisplayDevice>::make(creationArgs);
607 }
608
Leon Scroggins III4235ea02023-04-17 15:14:20 -0400609 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* outInfo) {
610 return mFlinger->getDisplayStats(displayToken, outInfo);
611 }
612
Melody Hsu63e3dcc2024-04-03 23:22:20 +0000613 // Used to add a layer before updateLayerSnapshots is called.
614 // Must have transactionsFlushed enabled for the new layer to be updated.
615 void addLayer(std::unique_ptr<frontend::RequestedLayerState>& layer) {
616 std::scoped_lock<std::mutex> lock(mFlinger->mCreatedLayersLock);
617 mFlinger->mNewLayers.emplace_back(std::move(layer));
618 }
619
Lloyd Pique86016da2018-03-01 16:09:38 -0800620 /* ------------------------------------------------------------------------
621 * Read-only access to private data to assert post-conditions.
622 */
623
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800624 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700625 auto& getHwComposer() const {
626 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
627 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700628 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800629
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000630 mock::FrameTracer* getFrameTracer() const {
631 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
632 }
633
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700634 void injectLegacyLayer(sp<Layer> layer) {
Vishnu Nair7be27602024-03-28 20:27:09 -0700635 FTL_FAKE_GUARD(kMainThreadContext,
636 mFlinger->mLegacyLayers[static_cast<uint32_t>(layer->sequence)] = layer);
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700637 };
638
Vishnu Nair7be27602024-03-28 20:27:09 -0700639 void releaseLegacyLayer(uint32_t sequence) {
640 FTL_FAKE_GUARD(kMainThreadContext, mFlinger->mLegacyLayers.erase(sequence));
641 };
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700642
Vishnu Nair41376b62023-11-08 05:08:58 -0800643 auto setLayerHistoryDisplayArea(uint32_t displayArea) {
644 return mFlinger->mScheduler->onActiveDisplayAreaChanged(displayArea);
645 };
Vishnu Nair7be27602024-03-28 20:27:09 -0700646 auto updateLayerHistory(nsecs_t now) {
647 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->updateLayerHistory(now));
648 };
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700649 auto setDaltonizerType(ColorBlindnessType type) {
650 mFlinger->mDaltonizer.setType(type);
651 return mFlinger->updateColorMatrixLocked();
652 }
653 auto updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
654 bool& out) {
655 ftl::FakeGuard guard(kMainThreadContext);
656 return mFlinger->updateLayerSnapshots(vsyncId, frameTimeNs, transactionsFlushed, out);
657 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800658 /* ------------------------------------------------------------------------
659 * Read-write access to private data to set up preconditions and assert
660 * post-conditions.
661 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800662
Dominik Laskowskieb627312022-04-07 09:13:16 -0700663 const auto& displays() const { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700664 const auto& physicalDisplays() const { return mFlinger->mPhysicalDisplays; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700665 const auto& currentState() const { return mFlinger->mCurrentState; }
666 const auto& drawingState() const { return mFlinger->mDrawingState; }
667 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700668
Dominik Laskowskieb627312022-04-07 09:13:16 -0700669 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700670 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700671
Lloyd Pique30db6402023-06-26 18:56:51 +0000672 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
673
Dominik Laskowski6e465152022-09-28 11:00:25 -0400674 auto& mutableDisplayModeController() { return mFlinger->mDisplayModeController; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800675 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800676 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700677 auto& mutableDisplays() { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700678 auto& mutablePhysicalDisplays() { return mFlinger->mPhysicalDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800679 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700680 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700681 auto& mutableVisibleRegionsDirty() { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800682 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800683 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
684 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700685 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700686 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800687
Lloyd Pique441d5042018-10-18 16:49:51 -0700688 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
689 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700690 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Dominik Laskowskie591b552022-09-09 10:44:56 -0700691 auto& mutableActiveDisplayId() { return mFlinger->mActiveDisplayId; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700692 auto& mutablePreviouslyComposedLayers() { return mFlinger->mPreviouslyComposedLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800693
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400694 auto& mutableActiveDisplayRotationFlags() {
695 return SurfaceFlinger::sActiveDisplayRotationFlags;
696 }
697
Lloyd Pique30db6402023-06-26 18:56:51 +0000698 auto& mutableMinAcquiredBuffers() { return SurfaceFlinger::minAcquiredBuffers; }
Ady Abraham822ecbd2023-07-07 16:16:09 -0700699 auto& mutableLayersPendingRemoval() { return mFlinger->mLayersPendingRemoval; }
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700700 auto& mutableLayerSnapshotBuilder() { return mFlinger->mLayerSnapshotBuilder; };
Ady Abraham822ecbd2023-07-07 16:16:09 -0700701
Vishnu Nair07e2a482022-10-18 19:18:16 +0000702 auto fromHandle(const sp<IBinder>& handle) { return LayerHandle::getLayer(handle); }
Valerie Hau09e60052019-12-15 14:51:15 -0800703
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700704 auto initTransactionTraceWriter() {
705 mFlinger->mTransactionTracing.emplace();
706 return mFlinger->initTransactionTraceWriter();
707 }
708
Melody Hsuce0fe522024-05-03 01:54:56 +0000709 // Needed since mLayerLifecycleManagerEnabled is false by default and must
710 // be enabled for tests to go through the new front end path.
711 void enableLayerLifecycleManager() { mFlinger->mLayerLifecycleManagerEnabled = true; }
712
ramindanic67d22c2023-11-28 14:58:47 -0800713 void notifyExpectedPresentIfRequired(PhysicalDisplayId displayId, Period vsyncPeriod,
714 TimePoint expectedPresentTime, Fps frameInterval,
715 std::optional<Period> timeoutOpt) {
716 mFlinger->notifyExpectedPresentIfRequired(displayId, vsyncPeriod, expectedPresentTime,
717 frameInterval, timeoutOpt);
718 }
719
ramindaniae645822024-01-11 10:57:29 -0800720 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) {
721 ftl::FakeGuard guard(kMainThreadContext);
722 mFlinger->sendNotifyExpectedPresentHint(displayId);
723 }
724
725 bool verifyHintIsScheduledOnPresent(PhysicalDisplayId displayId) {
726 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
727 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnPresent;
728 }
729
730 bool verifyHintIsSent(PhysicalDisplayId displayId) {
731 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
732 SurfaceFlinger::NotifyExpectedPresentHintStatus::Sent;
733 }
734
735 bool verifyHintStatusIsStart(PhysicalDisplayId displayId) {
736 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
737 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start;
738 }
739
740 bool verifyHintStatusIsScheduledOnTx(PhysicalDisplayId displayId) {
741 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
742 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnTx;
743 }
744
745 bool verifyLastExpectedPresentTime(PhysicalDisplayId displayId, nsecs_t expectedPresentTime) {
746 return mFlinger->mNotifyExpectedPresentMap.at(displayId)
747 .lastExpectedPresentTimestamp.ns() == expectedPresentTime;
748 }
749
ramindanic67d22c2023-11-28 14:58:47 -0800750 void setNotifyExpectedPresentData(PhysicalDisplayId displayId,
751 TimePoint lastExpectedPresentTimestamp,
752 Fps lastFrameInterval) {
753 auto& displayData = mFlinger->mNotifyExpectedPresentMap[displayId];
754 displayData.lastExpectedPresentTimestamp = lastExpectedPresentTimestamp;
755 displayData.lastFrameInterval = lastFrameInterval;
756 }
757
ramindaniae645822024-01-11 10:57:29 -0800758 void resetNotifyExpectedPresentHintState(PhysicalDisplayId displayId) {
759 mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus =
760 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start;
761 }
762
Lloyd Piquee39cad22017-12-20 17:01:29 -0800763 ~TestableSurfaceFlinger() {
764 // All these pointer and container clears help ensure that GMock does
765 // not report a leaked object, since the SurfaceFlinger instance may
766 // still be referenced by something despite our best efforts to destroy
767 // it after each test is done.
768 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800769 mutableCurrentState().displays.clear();
770 mutableDrawingState().displays.clear();
Ady Abraham822ecbd2023-07-07 16:16:09 -0700771 mFlinger->mLayersPendingRemoval.clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700772 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700773 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Patrick Williams0a525a42022-10-26 20:20:50 +0000774 mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>();
775 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700776 mFlinger->mTransactionTracing.reset();
Lloyd Piquee39cad22017-12-20 17:01:29 -0800777 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800778
Lloyd Piquea618d852018-01-17 11:52:30 -0800779 /* ------------------------------------------------------------------------
780 * Wrapper classes for Read-write access to private data to set up
781 * preconditions and assert post-conditions.
782 */
Ana Krulec4593b692019-01-11 22:07:25 -0800783 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800784 HWC2Display(
785 Hwc2::Composer& composer,
786 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
787 capabilities,
788 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800789 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800790 ~HWC2Display() {
791 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700792 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800793 }
794
795 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700796 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800797 };
798
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800799 class FakeHwcDisplayInjector {
800 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700801 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800802 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100803 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800804 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800805 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700806 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800807
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200808 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
809 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700810 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800811
Peiyong Line9d809e2020-04-14 13:10:48 -0700812 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800813 mHwcDisplayId = displayId;
814 return *this;
815 }
816
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800817 auto& setResolution(ui::Size resolution) {
818 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800819 return *this;
820 }
821
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800822 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100823 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800824 return *this;
825 }
826
827 auto& setDpiX(int32_t dpi) {
828 mDpiX = dpi;
829 return *this;
830 }
831
832 auto& setDpiY(int32_t dpi) {
833 mDpiY = dpi;
834 return *this;
835 }
836
Peiyong Line9d809e2020-04-14 13:10:48 -0700837 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800838 mActiveConfig = config;
839 return *this;
840 }
841
Ady Abrahamde549d42022-01-26 19:19:17 -0800842 auto& setCapabilities(
843 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
844 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700845 mCapabilities = capabilities;
846 return *this;
847 }
848
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400849 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700850 mPowerMode = mode;
851 return *this;
852 }
853
Marin Shalamanov045b7002021-01-07 16:56:24 +0100854 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
855 using ::testing::_;
856 using ::testing::DoAll;
857 using ::testing::Return;
858 using ::testing::SetArgPointee;
859
Ady Abrahamde549d42022-01-26 19:19:17 -0800860 static const std::unordered_set<
861 aidl::android::hardware::graphics::composer3::Capability>
862 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700863 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
864
865 // Caution - Make sure that any values passed by reference here do
866 // not refer to an instance owned by FakeHwcDisplayInjector. This
867 // class has temporary lifetime, while the constructed HWC2::Display
868 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800869 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
870 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800871 display->mutableIsConnected() = true;
Dominik Laskowskic132a152022-11-30 15:44:52 -0500872
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400873 display->setPowerMode(mPowerMode);
Dominik Laskowskic132a152022-11-30 15:44:52 -0500874
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800875 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700876
Marin Shalamanov045b7002021-01-07 16:56:24 +0100877 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
878 .WillRepeatedly(
879 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
880 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100881 EXPECT_CALL(*composer,
882 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800883 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
884 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100885
886 EXPECT_CALL(*composer,
887 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
888 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800889 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
890 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100891
892 EXPECT_CALL(*composer,
893 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
894 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800895 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
896 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100897
898 EXPECT_CALL(*composer,
899 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
900 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
901
902 EXPECT_CALL(*composer,
903 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
904 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
905
906 EXPECT_CALL(*composer,
907 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
908 hal::Attribute::CONFIG_GROUP, _))
909 .WillRepeatedly(
910 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100911
Peiyong Line9d809e2020-04-14 13:10:48 -0700912 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200913 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
914 LOG_ALWAYS_FATAL_IF(!physicalId);
915 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100916 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700917 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100918 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700919 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100920 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700921 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
922 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100923 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700924 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800925 }
926
927 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200928 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700929 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700930 const bool mIsPrimary;
931
Peiyong Line9d809e2020-04-14 13:10:48 -0700932 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800933 ui::Size mResolution = DEFAULT_RESOLUTION;
934 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800935 int32_t mDpiX = DEFAULT_DPI;
936 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100937 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700938 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400939 hal::PowerMode mPowerMode = hal::PowerMode::ON;
Ady Abrahamde549d42022-01-26 19:19:17 -0800940 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
941 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800942 };
943
944 class FakeDisplayDeviceInjector {
945 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700946 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800947 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100948 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700949 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700950 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700951 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
952 display),
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700953 mConnectionType(connectionType),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100954 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700955 mCreationArgs.isPrimary = isPrimary;
linpeter1c69cd32022-07-13 19:20:48 +0800956 mCreationArgs.initialPowerMode = hal::PowerMode::ON;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700957 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800958
959 sp<IBinder> token() const { return mDisplayToken; }
960
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700961 auto physicalDisplay() const {
962 return ftl::Optional(mCreationArgs.compositionDisplay->getDisplayId())
963 .and_then(&PhysicalDisplayId::tryCast)
964 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays()));
965 }
966
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800967 DisplayDeviceState& mutableDrawingDisplayState() {
968 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
969 }
970
971 DisplayDeviceState& mutableCurrentDisplayState() {
972 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
973 }
974
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800975 const auto& getDrawingDisplayState() {
976 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
977 }
978
979 const auto& getCurrentDisplayState() {
980 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
981 }
982
Dominik Laskowskieb627312022-04-07 09:13:16 -0700983 const sp<DisplayDevice>& mutableDisplayDevice() {
984 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
985 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800986
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500987 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700988 mDisplayModes = std::move(modes);
Dominik Laskowski6e465152022-09-28 11:00:25 -0400989 mActiveModeId = activeModeId;
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500990 mCreationArgs.refreshRateSelector = nullptr;
991 return *this;
992 }
993
994 auto& setRefreshRateSelector(RefreshRateSelectorPtr selectorPtr) {
995 mDisplayModes = selectorPtr->displayModes();
Dominik Laskowski6e465152022-09-28 11:00:25 -0400996 mActiveModeId = selectorPtr->getActiveMode().modePtr->getId();
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400997 mCreationArgs.refreshRateSelector = std::move(selectorPtr);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100998 return *this;
999 }
1000
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001001 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001002 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001003 return *this;
1004 }
1005
Lloyd Pique542307f2018-10-19 13:24:08 -07001006 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001007 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001008 return *this;
1009 }
1010
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001011 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001012 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001013 return *this;
1014 }
1015
Dominik Laskowskia42d5392022-09-29 14:26:53 -04001016 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001017 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -07001018 return *this;
1019 }
1020
Valerie Hau9758ae02018-10-09 16:05:09 -07001021 auto& setHwcColorModes(
1022 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
1023 hwcColorModes) {
1024 mCreationArgs.hwcColorModes = hwcColorModes;
1025 return *this;
1026 }
1027
1028 auto& setHasWideColorGamut(bool hasWideColorGamut) {
1029 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
1030 return *this;
1031 }
1032
Lloyd Pique33050472019-12-19 17:12:44 -08001033 auto& setPhysicalOrientation(ui::Rotation orientation) {
1034 mCreationArgs.physicalOrientation = orientation;
1035 return *this;
1036 }
1037
Dominik Laskowski6e465152022-09-28 11:00:25 -04001038 // Used to avoid overwriting mocks injected by TestableSurfaceFlinger::setupMockScheduler.
1039 auto& skipSchedulerRegistration() {
1040 mSchedulerRegistration = false;
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001041 return *this;
1042 }
1043
Ady Abraham690f4612021-07-01 23:24:03 -07001044 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Brian Johnson9ea03122023-06-30 14:46:34 -07001045 return inject(std::make_unique<mock::VsyncController>(),
1046 std::make_shared<mock::VSyncTracker>());
1047 }
1048
1049 sp<DisplayDevice> inject(std::unique_ptr<android::scheduler::VsyncController> controller,
1050 std::shared_ptr<android::scheduler::VSyncTracker> tracker)
1051 NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001052 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
Dominik Laskowski6e465152022-09-28 11:00:25 -04001053 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001054
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001055 auto& modes = mDisplayModes;
Dominik Laskowski6e465152022-09-28 11:00:25 -04001056 auto& activeModeId = mActiveModeId;
1057 std::optional<Fps> refreshRateOpt;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001058
Dominik Laskowski6e465152022-09-28 11:00:25 -04001059 DisplayDeviceState state;
1060 state.isSecure = mCreationArgs.isSecure;
1061
1062 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
1063 LOG_ALWAYS_FATAL_IF(!mConnectionType);
1064 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
1065
1066 if (mCreationArgs.isPrimary) {
1067 mFlinger.mutableActiveDisplayId() = *physicalId;
1068 }
1069
1070 if (!mCreationArgs.refreshRateSelector) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001071 if (modes.empty()) {
1072 constexpr DisplayModeId kModeId{0};
1073 DisplayModePtr mode =
1074 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
1075 .setId(kModeId)
1076 .setPhysicalDisplayId(*physicalId)
1077 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
1078 .setVsyncPeriod(
1079 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
1080 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
1081 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
1082 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
1083 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001084
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001085 modes = ftl::init::map(kModeId, std::move(mode));
1086 activeModeId = kModeId;
1087 }
1088
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001089 mCreationArgs.refreshRateSelector =
1090 std::make_shared<scheduler::RefreshRateSelector>(modes, activeModeId);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001091 }
Dominik Laskowski6e465152022-09-28 11:00:25 -04001092
1093 const auto activeModeOpt = modes.get(activeModeId);
1094 LOG_ALWAYS_FATAL_IF(!activeModeOpt);
1095 refreshRateOpt = activeModeOpt->get()->getPeakFps();
1096
1097 state.physical = {.id = *physicalId,
1098 .hwcDisplayId = *mHwcDisplayId,
1099 .activeMode = activeModeOpt->get()};
1100
1101 const auto it = mFlinger.mutablePhysicalDisplays()
1102 .emplace_or_replace(*physicalId, mDisplayToken, *physicalId,
1103 *mConnectionType, std::move(modes),
1104 ui::ColorModes(), std::nullopt)
1105 .first;
1106
1107 mFlinger.mutableDisplayModeController()
1108 .registerDisplay(*physicalId, it->second.snapshot(),
1109 mCreationArgs.refreshRateSelector);
1110
1111 if (mFlinger.scheduler() && mSchedulerRegistration) {
1112 mFlinger.scheduler()->registerDisplay(*physicalId,
1113 mCreationArgs.refreshRateSelector,
1114 std::move(controller),
1115 std::move(tracker));
1116 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001117 }
Lloyd Pique9370a482019-10-03 17:58:30 -07001118
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001119 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
1120 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
1121
Dominik Laskowski6e465152022-09-28 11:00:25 -04001122 if (refreshRateOpt) {
1123 display->setActiveMode(activeModeId, *refreshRateOpt, *refreshRateOpt);
Marin Shalamanov045b7002021-01-07 16:56:24 +01001124 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07001125
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001126 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
1127 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
1128
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001129 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001130 }
1131
1132 private:
1133 TestableSurfaceFlinger& mFlinger;
Ady Abrahamd11bade2022-08-01 16:18:03 -07001134 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001135 DisplayDeviceCreationArgs mCreationArgs;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001136 DisplayModes mDisplayModes;
Dominik Laskowski6e465152022-09-28 11:00:25 -04001137 DisplayModeId mActiveModeId;
1138 bool mSchedulerRegistration = true;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001139 const std::optional<ui::DisplayConnectionType> mConnectionType;
Peiyong Line9d809e2020-04-14 13:10:48 -07001140 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001141 };
1142
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001143private:
Dominik Laskowskiaee9a622023-02-11 14:24:19 -05001144 template <typename T>
1145 static std::unique_ptr<T> makeMock(bool useNiceMock) {
1146 return useNiceMock ? std::make_unique<testing::NiceMock<T>>() : std::make_unique<T>();
1147 }
1148
Leon Scroggins III67388622023-02-06 20:36:20 -05001149 template <typename T>
1150 static std::shared_ptr<T> makeSharedMock(bool useNiceMock) {
1151 return useNiceMock ? std::make_shared<testing::NiceMock<T>>() : std::make_shared<T>();
1152 }
1153
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001154 static constexpr VsyncId kVsyncId{123};
Ady Abraham302ebed2022-03-07 16:03:41 -08001155
Lloyd Pique90c115d2018-09-18 21:39:42 -07001156 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -08001157 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001158 scheduler::mock::SchedulerCallback mSchedulerCallback;
1159 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Ady Abraham011f8ba2022-11-22 15:09:07 -08001160 std::unique_ptr<frametimeline::impl::TokenManager> mTokenManager;
Dominik Laskowski068173d2021-08-11 17:22:59 -07001161 scheduler::TestableScheduler* mScheduler = nullptr;
Huihong Luo59a60b72023-03-08 21:44:59 +00001162 Hwc2::mock::PowerAdvisor mPowerAdvisor;
Lloyd Piquef58625d2017-12-19 13:22:33 -08001163};
1164
1165} // namespace android