blob: 3b03f920900110080333df47ce129abb31c77055 [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>
Dominik Laskowski83bd7712022-01-07 14:30:53 -080021#include <variant>
22
Dominik Laskowskib418dd72023-06-13 17:31:04 -040023#include <ftl/fake_guard.h>
24#include <ftl/match.h>
25#include <gui/ScreenCaptureResults.h>
26#include <ui/DynamicDisplayInfo.h>
27
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080028#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070029#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080030#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070031#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070032#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080033#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070034#include <compositionengine/mock/DisplaySurface.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070035
Lloyd Piquef58625d2017-12-19 13:22:33 -080036#include "DisplayDevice.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070037#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080038#include "FrameTracer/FrameTracer.h"
Vishnu Naircb8be502022-10-12 19:03:23 +000039#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair07e2a482022-10-18 19:18:16 +000040#include "FrontEnd/LayerHandle.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070041#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070042#include "NativeWindowSurface.h"
Patrick Williams7584c6a2022-10-29 02:10:58 +000043#include "RenderArea.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070044#include "Scheduler/MessageQueue.h"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040045#include "Scheduler/RefreshRateSelector.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080046#include "SurfaceFlinger.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070047#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010048#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080049#include "mock/DisplayHardware/MockDisplayMode.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000050#include "mock/DisplayHardware/MockPowerAdvisor.h"
Dominik Laskowskiaee9a622023-02-11 14:24:19 -050051#include "mock/MockEventThread.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070052#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080053#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080054#include "mock/MockSchedulerCallback.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000055#include "mock/system/window/MockNativeWindow.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080056
Brian Johnson9ea03122023-06-30 14:46:34 -070057#include "Scheduler/VSyncTracker.h"
58#include "Scheduler/VsyncController.h"
59#include "mock/MockVSyncDispatch.h"
60#include "mock/MockVSyncTracker.h"
61#include "mock/MockVsyncController.h"
62
Lloyd Piquef58625d2017-12-19 13:22:33 -080063namespace android {
Leon Scroggins III4235ea02023-04-17 15:14:20 -040064
65struct DisplayStatInfo;
66
Peiyong Lin833074a2018-08-28 11:53:54 -070067namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070068
Lloyd Piquee39cad22017-12-20 17:01:29 -080069class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070070
71} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080072
73namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070074
Lloyd Piquee39cad22017-12-20 17:01:29 -080075class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070076
77} // namespace Hwc2
78
Peiyong Line9d809e2020-04-14 13:10:48 -070079namespace hal = android::hardware::graphics::composer::hal;
80
Lloyd Pique90c115d2018-09-18 21:39:42 -070081namespace surfaceflinger::test {
82
83class Factory final : public surfaceflinger::Factory {
84public:
85 ~Factory() = default;
86
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070088 return nullptr;
89 }
90
Ady Abraham8287e852020-08-12 14:44:58 -070091 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010092 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080093 return std::make_unique<scheduler::FakePhaseOffsets>();
94 }
95
Lloyd Pique9370a482019-10-03 17:58:30 -070096 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070097 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070098 }
99
100 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
101 uint32_t layerCount, uint64_t usage,
102 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700103 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700104 }
105
106 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
107 sp<IGraphicBufferConsumer>* outConsumer,
108 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700109 if (!mCreateBufferQueue) {
110 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
111 return;
112 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700113 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
114 }
115
116 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
117 const sp<IGraphicBufferProducer>& producer) override {
118 if (!mCreateNativeWindowSurface) return nullptr;
119 return mCreateNativeWindowSurface(producer);
120 }
121
Lloyd Pique70d91362018-10-18 16:02:55 -0700122 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
123 return compositionengine::impl::createCompositionEngine();
124 }
125
Patrick Williams83f36b22022-09-14 17:57:35 +0000126 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700127
Patrick Williams46b61b92022-09-01 17:25:49 +0000128 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700129
Vishnu Naire14c6b32022-08-06 04:20:15 +0000130 sp<LayerFE> createLayerFE(const std::string& layerName) override {
131 return sp<LayerFE>::make(layerName);
132 }
133
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800134 std::unique_ptr<FrameTracer> createFrameTracer() override {
135 return std::make_unique<mock::FrameTracer>();
136 }
137
Adithya Srinivasan01189672020-10-20 14:23:05 -0700138 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800139 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
140 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700141 }
142
Lloyd Pique90c115d2018-09-18 21:39:42 -0700143 using CreateBufferQueueFunction =
144 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
145 sp<IGraphicBufferConsumer>* /* outConsumer */,
146 bool /* consumerIsSurfaceFlinger */)>;
147 CreateBufferQueueFunction mCreateBufferQueue;
148
149 using CreateNativeWindowSurfaceFunction =
150 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
151 const sp<IGraphicBufferProducer>&)>;
152 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700153
154 using CreateCompositionEngineFunction =
155 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
156 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700157};
158
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500159struct MockSchedulerOptions {
160 PhysicalDisplayId displayId = PhysicalDisplayId::fromPort(0);
161 bool useNiceMock = false;
162};
163
Lloyd Pique90c115d2018-09-18 21:39:42 -0700164} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800165
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800166class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800167public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700168 using HotplugEvent = SurfaceFlinger::HotplugEvent;
169
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800170 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
171 if (!mFlinger) {
Lloyd Pique30db6402023-06-26 18:56:51 +0000172 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800173 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800174 }
175
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700176 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700177 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700178
Lloyd Piquef58625d2017-12-19 13:22:33 -0800179 // Extend this as needed for accessing SurfaceFlinger private (and public)
180 // functions.
181
Peiyong Lin833074a2018-08-28 11:53:54 -0700182 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Patrick Williams0a525a42022-10-26 20:20:50 +0000183 mFlinger->mRenderEngine = std::move(renderEngine);
184 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800185 }
186
187 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700188 mFlinger->mCompositionEngine->setHwComposer(
189 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800190 }
191
Xiang Wang839fe5b2022-04-04 17:39:38 +0000192 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
193 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
194 }
195
Alec Mourie4034bb2019-11-19 12:45:54 -0800196 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
197 mFlinger->mCompositionEngine->setTimeStats(timeStats);
198 }
199
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800200 enum class SchedulerCallbackImpl { kNoOp, kMock };
201
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500202 struct DefaultDisplayMode {
203 // The ID of the injected RefreshRateSelector and its default display mode.
204 PhysicalDisplayId displayId;
205 };
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800206
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500207 using RefreshRateSelectorPtr = scheduler::Scheduler::RefreshRateSelectorPtr;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800208
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500209 using DisplayModesVariant = std::variant<DefaultDisplayMode, RefreshRateSelectorPtr>;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800210
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500211 surfaceflinger::Factory& getFactory() { return mFactory; }
212
213 TimeStats& getTimeStats() { return *mFlinger->mTimeStats; }
214
ramindaniae645822024-01-11 10:57:29 -0800215 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
216 std::shared_ptr<scheduler::VSyncTracker> vsyncTracker,
217 std::unique_ptr<EventThread> appEventThread,
218 std::unique_ptr<EventThread> sfEventThread,
219 DisplayModesVariant modesVariant,
220 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
221 bool useNiceMock = false) {
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500222 RefreshRateSelectorPtr selectorPtr = ftl::match(
223 modesVariant,
224 [](DefaultDisplayMode arg) {
225 constexpr DisplayModeId kModeId60{0};
226 return std::make_shared<scheduler::RefreshRateSelector>(
227 makeModes(mock::createDisplayMode(arg.displayId, kModeId60, 60_Hz)),
228 kModeId60);
229 },
230 [](RefreshRateSelectorPtr selectorPtr) { return selectorPtr; });
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700231
Ady Abraham011f8ba2022-11-22 15:09:07 -0800232 mTokenManager = std::make_unique<frametimeline::impl::TokenManager>();
233
ramindanid4354a92023-10-02 15:11:09 -0700234 using ISchedulerCallback = scheduler::ISchedulerCallback;
235 ISchedulerCallback& schedulerCallback = callbackImpl == SchedulerCallbackImpl::kNoOp
236 ? static_cast<ISchedulerCallback&>(mNoOpSchedulerCallback)
237 : static_cast<ISchedulerCallback&>(mSchedulerCallback);
238
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800239 if (useNiceMock) {
240 mScheduler =
241 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
242 std::move(vsyncTracker),
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400243 std::move(selectorPtr),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500244 mFactory,
245 *mFlinger->mTimeStats,
ramindaniae645822024-01-11 10:57:29 -0800246 schedulerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800247 } else {
248 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
249 std::move(vsyncTracker),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500250 std::move(selectorPtr), mFactory,
ramindaniae645822024-01-11 10:57:29 -0800251 *mFlinger->mTimeStats, schedulerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800252 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700253
Leon Scroggins IIIa7be94e2024-01-23 12:24:30 -0500254 mScheduler->initVsync(*mTokenManager, 0ms);
Ady Abraham011f8ba2022-11-22 15:09:07 -0800255
Dominik Laskowski4babfc42024-02-16 12:28:40 -0500256 mScheduler->setEventThread(scheduler::Cycle::Render, std::move(appEventThread));
257 mScheduler->setEventThread(scheduler::Cycle::LastComposite, std::move(sfEventThread));
Dominik Laskowskie99b98c2023-02-02 12:37:23 -0500258
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700259 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700260 }
261
Rachel Lee414f4082023-10-23 14:48:44 -0700262 void setupMockScheduler(surfaceflinger::test::MockSchedulerOptions options = {}) {
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500263 using testing::_;
264 using testing::Return;
265
266 auto eventThread = makeMock<mock::EventThread>(options.useNiceMock);
267 auto sfEventThread = makeMock<mock::EventThread>(options.useNiceMock);
268
269 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
270 EXPECT_CALL(*eventThread, createEventConnection(_, _))
271 .WillOnce(Return(sp<EventThreadConnection>::make(eventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700272 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500273
274 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
275 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
276 .WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700277 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500278
279 auto vsyncController = makeMock<mock::VsyncController>(options.useNiceMock);
Leon Scroggins III67388622023-02-06 20:36:20 -0500280 auto vsyncTracker = makeSharedMock<mock::VSyncTracker>(options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500281
Ady Abraham4335afd2023-12-18 19:10:47 -0800282 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500283 EXPECT_CALL(*vsyncTracker, currentPeriod())
284 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abrahamc94bffc2023-11-22 11:10:09 -0800285 EXPECT_CALL(*vsyncTracker, minFramePeriod())
286 .WillRepeatedly(
287 Return(Period::fromNs(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)));
Ady Abraham4335afd2023-12-18 19:10:47 -0800288 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500289 setupScheduler(std::move(vsyncController), std::move(vsyncTracker), std::move(eventThread),
290 std::move(sfEventThread), DefaultDisplayMode{options.displayId},
ramindaniae645822024-01-11 10:57:29 -0800291 SchedulerCallbackImpl::kNoOp, options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500292 }
293
Dominik Laskowski068173d2021-08-11 17:22:59 -0700294 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700295
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800296 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
297 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800298
Lloyd Pique90c115d2018-09-18 21:39:42 -0700299 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800300 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700301 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800302 }
303
Lloyd Pique90c115d2018-09-18 21:39:42 -0700304 using CreateNativeWindowSurfaceFunction =
305 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800306 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700307 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800308 }
309
Lloyd Pique30db6402023-06-26 18:56:51 +0000310 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
311 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
312 }
313
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700314 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700315
Valerie Haud251afb2019-03-29 14:19:02 -0700316 auto& mutableStateLock() { return mFlinger->mStateLock; }
317
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700318 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
319 const sp<const DisplayDevice>& display) {
320 return layer->findOutputLayerForDisplay(display.get());
321 }
322
323 static void setLayerSidebandStream(const sp<Layer>& layer,
324 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800325 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800326 layer->mSidebandStream = sidebandStream;
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000327 layer->editLayerSnapshot()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700328 }
329
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500330 void setLayerCompositionType(const sp<Layer>& layer,
331 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700332 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800333 LOG_ALWAYS_FATAL_IF(!outputLayer);
334 auto& state = outputLayer->editState();
335 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700336 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700337 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800338
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700339 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700340 layer->mPotentialCursor = potentialCursor;
341 }
342
Garfield Tande619fa2020-10-02 17:13:53 -0700343 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000344 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700345 }
346
Lloyd Piquef58625d2017-12-19 13:22:33 -0800347 /* ------------------------------------------------------------------------
348 * Forwarding for functions being tested
349 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000350
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500351 void configure() {
352 ftl::FakeGuard guard(kMainThreadContext);
353 mFlinger->configure();
354 }
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700355
356 void configureAndCommit() {
357 configure();
358 commitTransactionsLocked(eDisplayTransactionNeeded);
359 }
360
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400361 void commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime,
362 bool composite = false) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500363 ftl::FakeGuard guard(kMainThreadContext);
364
365 const auto displayIdOpt = mScheduler->pacesetterDisplayId();
366 LOG_ALWAYS_FATAL_IF(!displayIdOpt);
367 const auto displayId = *displayIdOpt;
368
Leon Scroggins III0bd0d4c2022-12-08 13:20:45 -0500369 scheduler::FrameTargeter frameTargeter(displayId,
370 scheduler::Feature::kBackpressureGpuComposition);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400371
372 frameTargeter.beginFrame({.frameBeginTime = frameTime,
373 .vsyncId = vsyncId,
374 .expectedVsyncTime = expectedVsyncTime,
Leon Scroggins III0bd0d4c2022-12-08 13:20:45 -0500375 .sfWorkDuration = 10ms,
376 .hwcMinWorkDuration = 10ms},
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400377 *mScheduler->getVsyncSchedule());
378
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400379 scheduler::FrameTargets targets;
380 scheduler::FrameTargeters targeters;
381
382 for (const auto& [id, display] :
383 FTL_FAKE_GUARD(mFlinger->mStateLock, mFlinger->mPhysicalDisplays)) {
384 targets.try_emplace(id, &frameTargeter.target());
385 targeters.try_emplace(id, &frameTargeter);
386 }
387
388 mFlinger->commit(displayId, targets);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400389
390 if (composite) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400391 mFlinger->composite(displayId, targeters);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400392 }
Xiang Wang839fe5b2022-04-04 17:39:38 +0000393 }
394
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400395 void commit(TimePoint frameTime, VsyncId vsyncId, bool composite = false) {
396 return commit(frameTime, vsyncId, frameTime + Period(10ms), composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000397 }
398
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400399 void commit(bool composite = false) {
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700400 const TimePoint frameTime = scheduler::SchedulerClock::now();
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400401 commit(frameTime, kVsyncId, composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000402 }
403
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700404 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400405 constexpr bool kComposite = true;
406 commit(frameTime, vsyncId, expectedVsyncTime, kComposite);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700407 }
408
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400409 void commitAndComposite() {
410 constexpr bool kComposite = true;
411 commit(kComposite);
412 }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700413
Alan Dingfc6eab52024-05-02 18:28:45 -0700414 auto createDisplay(const String8& displayName, bool isSecure,
415 float requestedRefreshRate = 0.0f) {
416 const std::string testId = "virtual:libsurfaceflinger_unittest:TestableSurfaceFlinger";
417 return mFlinger->createDisplay(displayName, isSecure, testId, requestedRefreshRate);
418 }
419
420 auto createDisplay(const String8& displayName, bool isSecure, const std::string& uniqueId,
421 float requestedRefreshRate = 0.0f) {
422 return mFlinger->createDisplay(displayName, isSecure, uniqueId, requestedRefreshRate);
Lloyd Piquea482f992018-01-22 19:00:34 -0800423 }
424
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700425 auto destroyDisplay(const sp<IBinder>& displayToken) {
426 return mFlinger->destroyDisplay(displayToken);
427 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800428
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100429 auto getDisplay(const sp<IBinder>& displayToken) {
430 Mutex::Autolock lock(mFlinger->mStateLock);
431 return mFlinger->getDisplayDeviceLocked(displayToken);
432 }
433
Dominik Laskowski13948602021-03-08 20:48:28 -0800434 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
435
Lloyd Pique9370a482019-10-03 17:58:30 -0700436 auto setupNewDisplayDeviceInternal(
437 const wp<IBinder>& displayToken,
438 std::shared_ptr<compositionengine::Display> compositionDisplay,
439 const DisplayDeviceState& state,
440 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700441 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700442 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
443 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800444 }
445
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700446 void commitTransactionsLocked(uint32_t transactionFlags) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700447 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700448 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700449 mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800450 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800451
Huihong Luo791bef92023-09-19 21:18:45 -0700452 void onComposerHalHotplugEvent(hal::HWDisplayId hwcDisplayId, DisplayHotplugEvent event) {
453 mFlinger->onComposerHalHotplugEvent(hwcDisplayId, event);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800454 }
455
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800456 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700457 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800458 return mFlinger->setDisplayStateLocked(s);
459 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800460
Dominik Laskowskib5f40e52022-09-29 13:25:05 -0400461 void initializeDisplays() FTL_FAKE_GUARD(kMainThreadContext) { mFlinger->initializeDisplays(); }
Lloyd Pique86016da2018-03-01 16:09:38 -0800462
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100463 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
464
Alec Mouricdf16792021-12-10 13:16:06 -0800465 auto setDisplayBrightness(const sp<IBinder>& display,
466 const gui::DisplayBrightness& brightness) {
467 return mFlinger->setDisplayBrightness(display, brightness);
468 }
469
Dominik Laskowski83b88212018-12-11 13:34:06 -0800470 // Allow reading display state without locking, as if called on the SF main thread.
471 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700472 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800473 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800474 }
475
Patrick Williams31908132023-01-09 13:38:48 -0600476 auto renderScreenImpl(std::shared_ptr<const RenderArea> renderArea,
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000477 SurfaceFlinger::GetLayerSnapshotsFunction traverseLayers,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000478 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000479 bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700480 ScreenCaptureResults captureResults;
Patrick Williams377c0142022-10-13 17:33:38 +0000481 return FTL_FAKE_GUARD(kMainThreadContext,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000482 mFlinger->renderScreenImpl(std::move(renderArea), traverseLayers,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000483 buffer, regionSampling,
Chavi Weingarten18fa7c62023-11-28 21:16:03 +0000484 false /* grayscale */,
485 false /* isProtected */, captureResults));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700486 }
487
chaviw4b9d5e12020-08-04 18:30:35 -0700488 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Ajinkya Chalke02844632023-03-01 12:10:14 +0000489 std::unordered_set<uint32_t> excludeLayerIds,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200490 const LayerVector::Visitor& visitor) {
Ajinkya Chalke02844632023-03-01 12:10:14 +0000491 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid,
492 excludeLayerIds, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700493 }
494
Daniel Solomon42d04562019-01-20 21:03:19 -0800495 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
496 ui::DisplayPrimaries &primaries) {
497 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
498 }
499
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700500 auto& getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
501 auto& getPendingTransactionQueue() {
502 return mFlinger->mTransactionHandler.mPendingTransactionQueues;
503 }
504 size_t getPendingTransactionCount() {
505 return mFlinger->mTransactionHandler.mPendingTransactionCount.load();
506 }
Valerie Haud251afb2019-03-29 14:19:02 -0700507
Pablo Gamito23780be2023-04-18 08:30:00 +0000508 auto setTransactionState(
509 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
510 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
511 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
512 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
513 bool hasListenerCallbacks, std::vector<ListenerCallbacks>& listenerCallbacks,
514 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000515 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
516 inputWindowCommands, desiredPresentTime,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000517 isAutoTimestamp, uncacheBuffers, hasListenerCallbacks,
Pablo Gamito23780be2023-04-18 08:30:00 +0000518 listenerCallbacks, transactionId,
519 mergedTransactionIds);
Valerie Haud251afb2019-03-29 14:19:02 -0700520 }
521
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000522 auto setTransactionStateInternal(TransactionState& transaction) {
523 return mFlinger->mTransactionHandler.queueTransaction(std::move(transaction));
524 }
525
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700526 auto flushTransactionQueues() {
527 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues(kVsyncId));
528 }
Valerie Haud251afb2019-03-29 14:19:02 -0700529
Eduardo Rochaac867192020-09-14 20:12:17 +0000530 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
531 return mFlinger->onTransact(code, data, reply, flags);
532 }
533
Huihong Luo02186fb2022-02-23 14:21:54 -0800534 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800535
Ady Abraham899dcdb2021-06-15 16:56:21 -0700536 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
537 std::chrono::nanoseconds presentLatency) const {
Lloyd Pique30db6402023-06-26 18:56:51 +0000538 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800539 }
540
Ady Abraham285f8c12022-10-11 17:12:14 -0700541 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
542 const gui::DisplayModeSpecs& specs) {
543 return mFlinger->setDesiredDisplayModeSpecs(displayToken, specs);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100544 }
545
Dominik Laskowski360ae782023-02-22 13:30:37 -0500546 void onActiveDisplayChanged(const DisplayDevice* inactiveDisplayPtr,
547 const DisplayDevice& activeDisplay) {
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100548 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700549 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowski360ae782023-02-22 13:30:37 -0500550 mFlinger->onActiveDisplayChangedLocked(inactiveDisplayPtr, activeDisplay);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100551 }
552
Patrick Williamsa361de62022-10-06 20:34:10 +0000553 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle,
554 gui::CreateSurfaceResult& outResult) {
Vishnu Naircb8be502022-10-12 19:03:23 +0000555 args.parentHandle = parentHandle;
556 return mFlinger->createLayer(args, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800557 }
558
559 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000560 gui::CreateSurfaceResult& outResult) {
561 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800562 }
563
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000564 void updateLayerMetadataSnapshot() { mFlinger->updateLayerMetadataSnapshot(); }
565
Sally Qi6bb12822022-10-05 11:42:30 -0700566 void getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
567 ui::DynamicDisplayInfo* dynamicDisplayInfo) {
568 mFlinger->getDynamicDisplayInfoFromToken(displayToken, dynamicDisplayInfo);
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100569 }
570
Huihong Luo59a60b72023-03-08 21:44:59 +0000571 sp<DisplayDevice> createVirtualDisplayDevice(const sp<IBinder> displayToken,
572 VirtualDisplayId displayId,
573 float requestedRefreshRate) {
574 constexpr ui::Size kResolution = {1080, 1920};
575 auto compositionDisplay = compositionengine::impl::
576 createDisplay(mFlinger->getCompositionEngine(),
577 compositionengine::DisplayCreationArgsBuilder()
578 .setId(displayId)
579 .setPixels(kResolution)
580 .setPowerAdvisor(&mPowerAdvisor)
581 .build());
582 DisplayDeviceCreationArgs creationArgs(mFlinger, mFlinger->getHwComposer(), displayToken,
583 compositionDisplay);
584 creationArgs.requestedRefreshRate = Fps::fromValue(requestedRefreshRate);
585 creationArgs.nativeWindow = sp<mock::NativeWindow>::make();
586 return sp<DisplayDevice>::make(creationArgs);
587 }
588
Leon Scroggins III4235ea02023-04-17 15:14:20 -0400589 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* outInfo) {
590 return mFlinger->getDisplayStats(displayToken, outInfo);
591 }
592
Lloyd Pique86016da2018-03-01 16:09:38 -0800593 /* ------------------------------------------------------------------------
594 * Read-only access to private data to assert post-conditions.
595 */
596
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800597 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700598 auto& getHwComposer() const {
599 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
600 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700601 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800602
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000603 mock::FrameTracer* getFrameTracer() const {
604 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
605 }
606
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700607 void injectLegacyLayer(sp<Layer> layer) {
608 mFlinger->mLegacyLayers[static_cast<uint32_t>(layer->sequence)] = layer;
609 };
610
611 void releaseLegacyLayer(uint32_t sequence) { mFlinger->mLegacyLayers.erase(sequence); };
612
Vishnu Nair41376b62023-11-08 05:08:58 -0800613 auto setLayerHistoryDisplayArea(uint32_t displayArea) {
614 return mFlinger->mScheduler->onActiveDisplayAreaChanged(displayArea);
615 };
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700616 auto updateLayerHistory(nsecs_t now) { return mFlinger->updateLayerHistory(now); };
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700617 auto setDaltonizerType(ColorBlindnessType type) {
618 mFlinger->mDaltonizer.setType(type);
619 return mFlinger->updateColorMatrixLocked();
620 }
621 auto updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
622 bool& out) {
623 ftl::FakeGuard guard(kMainThreadContext);
624 return mFlinger->updateLayerSnapshots(vsyncId, frameTimeNs, transactionsFlushed, out);
625 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800626 /* ------------------------------------------------------------------------
627 * Read-write access to private data to set up preconditions and assert
628 * post-conditions.
629 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800630
Dominik Laskowskieb627312022-04-07 09:13:16 -0700631 const auto& displays() const { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700632 const auto& physicalDisplays() const { return mFlinger->mPhysicalDisplays; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700633 const auto& currentState() const { return mFlinger->mCurrentState; }
634 const auto& drawingState() const { return mFlinger->mDrawingState; }
635 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700636
Dominik Laskowskieb627312022-04-07 09:13:16 -0700637 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700638 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700639
Lloyd Pique30db6402023-06-26 18:56:51 +0000640 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
641
Lloyd Piquee39cad22017-12-20 17:01:29 -0800642 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800643 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700644 auto& mutableDisplays() { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700645 auto& mutablePhysicalDisplays() { return mFlinger->mPhysicalDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800646 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700647 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700648 auto& mutableVisibleRegionsDirty() { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800649 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800650 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
651 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700652 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700653 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800654
Lloyd Pique441d5042018-10-18 16:49:51 -0700655 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
656 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700657 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Dominik Laskowskie591b552022-09-09 10:44:56 -0700658 auto& mutableActiveDisplayId() { return mFlinger->mActiveDisplayId; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700659 auto& mutablePreviouslyComposedLayers() { return mFlinger->mPreviouslyComposedLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800660
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400661 auto& mutableActiveDisplayRotationFlags() {
662 return SurfaceFlinger::sActiveDisplayRotationFlags;
663 }
664
Lloyd Pique30db6402023-06-26 18:56:51 +0000665 auto& mutableMinAcquiredBuffers() { return SurfaceFlinger::minAcquiredBuffers; }
Ady Abraham822ecbd2023-07-07 16:16:09 -0700666 auto& mutableLayersPendingRemoval() { return mFlinger->mLayersPendingRemoval; }
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700667 auto& mutableLayerSnapshotBuilder() { return mFlinger->mLayerSnapshotBuilder; };
Ady Abraham822ecbd2023-07-07 16:16:09 -0700668
Vishnu Nair07e2a482022-10-18 19:18:16 +0000669 auto fromHandle(const sp<IBinder>& handle) { return LayerHandle::getLayer(handle); }
Valerie Hau09e60052019-12-15 14:51:15 -0800670
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700671 auto initTransactionTraceWriter() {
672 mFlinger->mTransactionTracing.emplace();
673 return mFlinger->initTransactionTraceWriter();
674 }
675
Arthur Hung69f95222023-10-04 07:39:02 +0000676 void enableNewFrontEnd() {
677 mFlinger->mLayerLifecycleManagerEnabled = true;
678 mFlinger->mLegacyFrontEndEnabled = false;
679 }
680
ramindanic67d22c2023-11-28 14:58:47 -0800681 void notifyExpectedPresentIfRequired(PhysicalDisplayId displayId, Period vsyncPeriod,
682 TimePoint expectedPresentTime, Fps frameInterval,
683 std::optional<Period> timeoutOpt) {
684 mFlinger->notifyExpectedPresentIfRequired(displayId, vsyncPeriod, expectedPresentTime,
685 frameInterval, timeoutOpt);
686 }
687
ramindaniae645822024-01-11 10:57:29 -0800688 void sendNotifyExpectedPresentHint(PhysicalDisplayId displayId) {
689 ftl::FakeGuard guard(kMainThreadContext);
690 mFlinger->sendNotifyExpectedPresentHint(displayId);
691 }
692
693 bool verifyHintIsScheduledOnPresent(PhysicalDisplayId displayId) {
694 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
695 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnPresent;
696 }
697
698 bool verifyHintIsSent(PhysicalDisplayId displayId) {
699 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
700 SurfaceFlinger::NotifyExpectedPresentHintStatus::Sent;
701 }
702
703 bool verifyHintStatusIsStart(PhysicalDisplayId displayId) {
704 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
705 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start;
706 }
707
708 bool verifyHintStatusIsScheduledOnTx(PhysicalDisplayId displayId) {
709 return mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus ==
710 SurfaceFlinger::NotifyExpectedPresentHintStatus::ScheduleOnTx;
711 }
712
713 bool verifyLastExpectedPresentTime(PhysicalDisplayId displayId, nsecs_t expectedPresentTime) {
714 return mFlinger->mNotifyExpectedPresentMap.at(displayId)
715 .lastExpectedPresentTimestamp.ns() == expectedPresentTime;
716 }
717
ramindanic67d22c2023-11-28 14:58:47 -0800718 void setNotifyExpectedPresentData(PhysicalDisplayId displayId,
719 TimePoint lastExpectedPresentTimestamp,
720 Fps lastFrameInterval) {
721 auto& displayData = mFlinger->mNotifyExpectedPresentMap[displayId];
722 displayData.lastExpectedPresentTimestamp = lastExpectedPresentTimestamp;
723 displayData.lastFrameInterval = lastFrameInterval;
724 }
725
ramindaniae645822024-01-11 10:57:29 -0800726 void resetNotifyExpectedPresentHintState(PhysicalDisplayId displayId) {
727 mFlinger->mNotifyExpectedPresentMap.at(displayId).hintStatus =
728 SurfaceFlinger::NotifyExpectedPresentHintStatus::Start;
729 }
730
Lloyd Piquee39cad22017-12-20 17:01:29 -0800731 ~TestableSurfaceFlinger() {
732 // All these pointer and container clears help ensure that GMock does
733 // not report a leaked object, since the SurfaceFlinger instance may
734 // still be referenced by something despite our best efforts to destroy
735 // it after each test is done.
736 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800737 mutableCurrentState().displays.clear();
738 mutableDrawingState().displays.clear();
Ady Abraham822ecbd2023-07-07 16:16:09 -0700739 mFlinger->mLayersPendingRemoval.clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700740 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700741 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Patrick Williams0a525a42022-10-26 20:20:50 +0000742 mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>();
743 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700744 mFlinger->mTransactionTracing.reset();
Lloyd Piquee39cad22017-12-20 17:01:29 -0800745 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800746
Lloyd Piquea618d852018-01-17 11:52:30 -0800747 /* ------------------------------------------------------------------------
748 * Wrapper classes for Read-write access to private data to set up
749 * preconditions and assert post-conditions.
750 */
Ana Krulec4593b692019-01-11 22:07:25 -0800751 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800752 HWC2Display(
753 Hwc2::Composer& composer,
754 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
755 capabilities,
756 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800757 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800758 ~HWC2Display() {
759 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700760 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800761 }
762
763 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700764 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800765 };
766
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800767 class FakeHwcDisplayInjector {
768 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700769 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800770 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100771 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800772 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800773 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700774 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800775
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200776 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
777 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700778 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800779
Peiyong Line9d809e2020-04-14 13:10:48 -0700780 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800781 mHwcDisplayId = displayId;
782 return *this;
783 }
784
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800785 auto& setResolution(ui::Size resolution) {
786 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800787 return *this;
788 }
789
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800790 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100791 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800792 return *this;
793 }
794
795 auto& setDpiX(int32_t dpi) {
796 mDpiX = dpi;
797 return *this;
798 }
799
800 auto& setDpiY(int32_t dpi) {
801 mDpiY = dpi;
802 return *this;
803 }
804
Peiyong Line9d809e2020-04-14 13:10:48 -0700805 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800806 mActiveConfig = config;
807 return *this;
808 }
809
Ady Abrahamde549d42022-01-26 19:19:17 -0800810 auto& setCapabilities(
811 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
812 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700813 mCapabilities = capabilities;
814 return *this;
815 }
816
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400817 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700818 mPowerMode = mode;
819 return *this;
820 }
821
Marin Shalamanov045b7002021-01-07 16:56:24 +0100822 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
823 using ::testing::_;
824 using ::testing::DoAll;
825 using ::testing::Return;
826 using ::testing::SetArgPointee;
827
Ady Abrahamde549d42022-01-26 19:19:17 -0800828 static const std::unordered_set<
829 aidl::android::hardware::graphics::composer3::Capability>
830 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700831 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
832
833 // Caution - Make sure that any values passed by reference here do
834 // not refer to an instance owned by FakeHwcDisplayInjector. This
835 // class has temporary lifetime, while the constructed HWC2::Display
836 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800837 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
838 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800839 display->mutableIsConnected() = true;
Dominik Laskowskic132a152022-11-30 15:44:52 -0500840
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400841 display->setPowerMode(mPowerMode);
Dominik Laskowskic132a152022-11-30 15:44:52 -0500842
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800843 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700844
Marin Shalamanov045b7002021-01-07 16:56:24 +0100845 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
846 .WillRepeatedly(
847 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
848 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100849 EXPECT_CALL(*composer,
850 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800851 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
852 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100853
854 EXPECT_CALL(*composer,
855 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
856 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800857 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
858 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100859
860 EXPECT_CALL(*composer,
861 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
862 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800863 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
864 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100865
866 EXPECT_CALL(*composer,
867 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
868 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
869
870 EXPECT_CALL(*composer,
871 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
872 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
873
874 EXPECT_CALL(*composer,
875 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
876 hal::Attribute::CONFIG_GROUP, _))
877 .WillRepeatedly(
878 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100879
Peiyong Line9d809e2020-04-14 13:10:48 -0700880 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200881 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
882 LOG_ALWAYS_FATAL_IF(!physicalId);
883 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100884 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700885 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100886 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700887 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100888 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700889 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
890 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100891 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700892 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800893 }
894
895 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200896 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700897 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700898 const bool mIsPrimary;
899
Peiyong Line9d809e2020-04-14 13:10:48 -0700900 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800901 ui::Size mResolution = DEFAULT_RESOLUTION;
902 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800903 int32_t mDpiX = DEFAULT_DPI;
904 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100905 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700906 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400907 hal::PowerMode mPowerMode = hal::PowerMode::ON;
Ady Abrahamde549d42022-01-26 19:19:17 -0800908 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
909 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800910 };
911
912 class FakeDisplayDeviceInjector {
913 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700914 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800915 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100916 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700917 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700918 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700919 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
920 display),
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700921 mConnectionType(connectionType),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100922 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700923 mCreationArgs.isPrimary = isPrimary;
linpeter1c69cd32022-07-13 19:20:48 +0800924 mCreationArgs.initialPowerMode = hal::PowerMode::ON;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700925 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800926
927 sp<IBinder> token() const { return mDisplayToken; }
928
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700929 auto physicalDisplay() const {
930 return ftl::Optional(mCreationArgs.compositionDisplay->getDisplayId())
931 .and_then(&PhysicalDisplayId::tryCast)
932 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays()));
933 }
934
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800935 DisplayDeviceState& mutableDrawingDisplayState() {
936 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
937 }
938
939 DisplayDeviceState& mutableCurrentDisplayState() {
940 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
941 }
942
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800943 const auto& getDrawingDisplayState() {
944 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
945 }
946
947 const auto& getCurrentDisplayState() {
948 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
949 }
950
Dominik Laskowskieb627312022-04-07 09:13:16 -0700951 const sp<DisplayDevice>& mutableDisplayDevice() {
952 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
953 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800954
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500955 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700956 mDisplayModes = std::move(modes);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800957 mCreationArgs.activeModeId = activeModeId;
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500958 mCreationArgs.refreshRateSelector = nullptr;
959 return *this;
960 }
961
962 auto& setRefreshRateSelector(RefreshRateSelectorPtr selectorPtr) {
963 mDisplayModes = selectorPtr->displayModes();
964 mCreationArgs.activeModeId = selectorPtr->getActiveMode().modePtr->getId();
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400965 mCreationArgs.refreshRateSelector = std::move(selectorPtr);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100966 return *this;
967 }
968
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800969 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700970 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800971 return *this;
972 }
973
Lloyd Pique542307f2018-10-19 13:24:08 -0700974 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700975 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800976 return *this;
977 }
978
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800979 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700980 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800981 return *this;
982 }
983
Dominik Laskowskia42d5392022-09-29 14:26:53 -0400984 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700985 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700986 return *this;
987 }
988
Valerie Hau9758ae02018-10-09 16:05:09 -0700989 auto& setHwcColorModes(
990 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
991 hwcColorModes) {
992 mCreationArgs.hwcColorModes = hwcColorModes;
993 return *this;
994 }
995
996 auto& setHasWideColorGamut(bool hasWideColorGamut) {
997 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
998 return *this;
999 }
1000
Lloyd Pique33050472019-12-19 17:12:44 -08001001 auto& setPhysicalOrientation(ui::Rotation orientation) {
1002 mCreationArgs.physicalOrientation = orientation;
1003 return *this;
1004 }
1005
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001006 auto& skipRegisterDisplay() {
1007 mRegisterDisplay = false;
1008 return *this;
1009 }
1010
Ady Abraham690f4612021-07-01 23:24:03 -07001011 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Brian Johnson9ea03122023-06-30 14:46:34 -07001012 return inject(std::make_unique<mock::VsyncController>(),
1013 std::make_shared<mock::VSyncTracker>());
1014 }
1015
1016 sp<DisplayDevice> inject(std::unique_ptr<android::scheduler::VsyncController> controller,
1017 std::shared_ptr<android::scheduler::VSyncTracker> tracker)
1018 NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001019 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
1020
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001021 auto& modes = mDisplayModes;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001022 auto& activeModeId = mCreationArgs.activeModeId;
1023
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001024 if (displayId && !mCreationArgs.refreshRateSelector) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001025 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
1026 if (modes.empty()) {
1027 constexpr DisplayModeId kModeId{0};
1028 DisplayModePtr mode =
1029 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
1030 .setId(kModeId)
1031 .setPhysicalDisplayId(*physicalId)
1032 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
1033 .setVsyncPeriod(
1034 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
1035 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
1036 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
1037 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
1038 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001039
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001040 modes = ftl::init::map(kModeId, std::move(mode));
1041 activeModeId = kModeId;
1042 }
1043
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001044 mCreationArgs.refreshRateSelector =
1045 std::make_shared<scheduler::RefreshRateSelector>(modes, activeModeId);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001046 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001047 }
Lloyd Pique9370a482019-10-03 17:58:30 -07001048
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001049 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
1050 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
1051
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001052 DisplayDeviceState state;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001053 state.isSecure = mCreationArgs.isSecure;
1054
1055 if (mConnectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -07001056 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001057 const auto physicalIdOpt = PhysicalDisplayId::tryCast(*displayId);
1058 LOG_ALWAYS_FATAL_IF(!physicalIdOpt);
1059 const auto physicalId = *physicalIdOpt;
1060
Dominik Laskowskic132a152022-11-30 15:44:52 -05001061 if (mCreationArgs.isPrimary) {
1062 mFlinger.mutableActiveDisplayId() = physicalId;
1063 }
1064
Marin Shalamanov700e6392020-02-12 20:22:26 +01001065 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +01001066
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001067 const auto activeMode = modes.get(activeModeId);
1068 LOG_ALWAYS_FATAL_IF(!activeMode);
ramindania04b8a52023-08-07 18:49:47 -07001069 const auto fps = activeMode->get()->getPeakFps();
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001070
Dominik Laskowski596a2562022-10-28 11:26:12 -04001071 state.physical = {.id = physicalId,
Marin Shalamanovc7e9f822021-11-16 20:07:55 +01001072 .hwcDisplayId = *mHwcDisplayId,
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001073 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -08001074
Ady Abrahamace3d052022-11-17 16:25:05 -08001075 mFlinger.mutablePhysicalDisplays().emplace_or_replace(physicalId, mDisplayToken,
1076 physicalId, *mConnectionType,
1077 std::move(modes),
1078 ui::ColorModes(),
1079 std::nullopt);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001080
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001081 if (mFlinger.scheduler() && mRegisterDisplay) {
Dominik Laskowski596a2562022-10-28 11:26:12 -04001082 mFlinger.scheduler()->registerDisplay(physicalId,
Brian Johnson9ea03122023-06-30 14:46:34 -07001083 display->holdRefreshRateSelector(),
1084 std::move(controller),
1085 std::move(tracker));
Dominik Laskowski596a2562022-10-28 11:26:12 -04001086 }
1087
Ady Abrahamace3d052022-11-17 16:25:05 -08001088 display->setActiveMode(activeModeId, fps, fps);
Marin Shalamanov045b7002021-01-07 16:56:24 +01001089 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07001090
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001091 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
1092 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
1093
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001094 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001095 }
1096
1097 private:
1098 TestableSurfaceFlinger& mFlinger;
Ady Abrahamd11bade2022-08-01 16:18:03 -07001099 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001100 DisplayDeviceCreationArgs mCreationArgs;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001101 DisplayModes mDisplayModes;
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001102 bool mRegisterDisplay = true;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001103 const std::optional<ui::DisplayConnectionType> mConnectionType;
Peiyong Line9d809e2020-04-14 13:10:48 -07001104 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001105 };
1106
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001107private:
Dominik Laskowskiaee9a622023-02-11 14:24:19 -05001108 template <typename T>
1109 static std::unique_ptr<T> makeMock(bool useNiceMock) {
1110 return useNiceMock ? std::make_unique<testing::NiceMock<T>>() : std::make_unique<T>();
1111 }
1112
Leon Scroggins III67388622023-02-06 20:36:20 -05001113 template <typename T>
1114 static std::shared_ptr<T> makeSharedMock(bool useNiceMock) {
1115 return useNiceMock ? std::make_shared<testing::NiceMock<T>>() : std::make_shared<T>();
1116 }
1117
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001118 static constexpr VsyncId kVsyncId{123};
Ady Abraham302ebed2022-03-07 16:03:41 -08001119
Lloyd Pique90c115d2018-09-18 21:39:42 -07001120 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -08001121 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001122 scheduler::mock::SchedulerCallback mSchedulerCallback;
1123 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Ady Abraham011f8ba2022-11-22 15:09:07 -08001124 std::unique_ptr<frametimeline::impl::TokenManager> mTokenManager;
Dominik Laskowski068173d2021-08-11 17:22:59 -07001125 scheduler::TestableScheduler* mScheduler = nullptr;
Huihong Luo59a60b72023-03-08 21:44:59 +00001126 Hwc2::mock::PowerAdvisor mPowerAdvisor;
Lloyd Piquef58625d2017-12-19 13:22:33 -08001127};
1128
1129} // namespace android