blob: 28549a692d7140b24677b3de74b8add130e61539 [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 Pique90c115d2018-09-18 21:39:42 -070046#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080047#include "SurfaceFlinger.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070048#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010049#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080050#include "mock/DisplayHardware/MockDisplayMode.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000051#include "mock/DisplayHardware/MockPowerAdvisor.h"
Dominik Laskowskiaee9a622023-02-11 14:24:19 -050052#include "mock/MockEventThread.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070053#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080054#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080055#include "mock/MockSchedulerCallback.h"
ramindanid4354a92023-10-02 15:11:09 -070056#include "mock/MockVsyncTrackerCallback.h"
Huihong Luo59a60b72023-03-08 21:44:59 +000057#include "mock/system/window/MockNativeWindow.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080058
Brian Johnson9ea03122023-06-30 14:46:34 -070059#include "Scheduler/VSyncTracker.h"
60#include "Scheduler/VsyncController.h"
61#include "mock/MockVSyncDispatch.h"
62#include "mock/MockVSyncTracker.h"
63#include "mock/MockVsyncController.h"
64
Lloyd Piquef58625d2017-12-19 13:22:33 -080065namespace android {
Leon Scroggins III4235ea02023-04-17 15:14:20 -040066
67struct DisplayStatInfo;
68
Peiyong Lin833074a2018-08-28 11:53:54 -070069namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070070
Lloyd Piquee39cad22017-12-20 17:01:29 -080071class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070072
73} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080074
75namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070076
Lloyd Piquee39cad22017-12-20 17:01:29 -080077class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070078
79} // namespace Hwc2
80
Peiyong Line9d809e2020-04-14 13:10:48 -070081namespace hal = android::hardware::graphics::composer::hal;
82
Lloyd Pique90c115d2018-09-18 21:39:42 -070083namespace surfaceflinger::test {
84
85class Factory final : public surfaceflinger::Factory {
86public:
87 ~Factory() = default;
88
Lloyd Pique90c115d2018-09-18 21:39:42 -070089 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070090 return nullptr;
91 }
92
Ady Abraham8287e852020-08-12 14:44:58 -070093 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010094 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080095 return std::make_unique<scheduler::FakePhaseOffsets>();
96 }
97
Lloyd Pique90c115d2018-09-18 21:39:42 -070098 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070099 return sp<StartPropertySetThread>::make(timestampPropertyValue);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700100 }
101
Lloyd Pique9370a482019-10-03 17:58:30 -0700102 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700103 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700104 }
105
106 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
107 uint32_t layerCount, uint64_t usage,
108 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700109 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700110 }
111
112 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
113 sp<IGraphicBufferConsumer>* outConsumer,
114 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700115 if (!mCreateBufferQueue) {
116 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
117 return;
118 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700119 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
120 }
121
122 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
123 const sp<IGraphicBufferProducer>& producer) override {
124 if (!mCreateNativeWindowSurface) return nullptr;
125 return mCreateNativeWindowSurface(producer);
126 }
127
Lloyd Pique70d91362018-10-18 16:02:55 -0700128 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
129 return compositionengine::impl::createCompositionEngine();
130 }
131
Patrick Williams83f36b22022-09-14 17:57:35 +0000132 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700133
Patrick Williams46b61b92022-09-01 17:25:49 +0000134 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700135
Vishnu Naire14c6b32022-08-06 04:20:15 +0000136 sp<LayerFE> createLayerFE(const std::string& layerName) override {
137 return sp<LayerFE>::make(layerName);
138 }
139
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800140 std::unique_ptr<FrameTracer> createFrameTracer() override {
141 return std::make_unique<mock::FrameTracer>();
142 }
143
Adithya Srinivasan01189672020-10-20 14:23:05 -0700144 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800145 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
146 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700147 }
148
Lloyd Pique90c115d2018-09-18 21:39:42 -0700149 using CreateBufferQueueFunction =
150 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
151 sp<IGraphicBufferConsumer>* /* outConsumer */,
152 bool /* consumerIsSurfaceFlinger */)>;
153 CreateBufferQueueFunction mCreateBufferQueue;
154
155 using CreateNativeWindowSurfaceFunction =
156 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
157 const sp<IGraphicBufferProducer>&)>;
158 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700159
160 using CreateCompositionEngineFunction =
161 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
162 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700163};
164
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500165struct MockSchedulerOptions {
166 PhysicalDisplayId displayId = PhysicalDisplayId::fromPort(0);
167 bool useNiceMock = false;
168};
169
Lloyd Pique90c115d2018-09-18 21:39:42 -0700170} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800171
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800172class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800173public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700174 using HotplugEvent = SurfaceFlinger::HotplugEvent;
175
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800176 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
177 if (!mFlinger) {
Lloyd Pique30db6402023-06-26 18:56:51 +0000178 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800179 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800180 }
181
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700182 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700183 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700184
Lloyd Piquef58625d2017-12-19 13:22:33 -0800185 // Extend this as needed for accessing SurfaceFlinger private (and public)
186 // functions.
187
Peiyong Lin833074a2018-08-28 11:53:54 -0700188 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Patrick Williams0a525a42022-10-26 20:20:50 +0000189 mFlinger->mRenderEngine = std::move(renderEngine);
190 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800191 }
192
193 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700194 mFlinger->mCompositionEngine->setHwComposer(
195 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800196 }
197
Xiang Wang839fe5b2022-04-04 17:39:38 +0000198 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
199 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
200 }
201
Alec Mourie4034bb2019-11-19 12:45:54 -0800202 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
203 mFlinger->mCompositionEngine->setTimeStats(timeStats);
204 }
205
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800206 enum class SchedulerCallbackImpl { kNoOp, kMock };
207
ramindanid4354a92023-10-02 15:11:09 -0700208 enum class VsyncTrackerCallbackImpl { kNoOp, kMock };
209
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500210 struct DefaultDisplayMode {
211 // The ID of the injected RefreshRateSelector and its default display mode.
212 PhysicalDisplayId displayId;
213 };
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800214
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500215 using RefreshRateSelectorPtr = scheduler::Scheduler::RefreshRateSelectorPtr;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800216
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500217 using DisplayModesVariant = std::variant<DefaultDisplayMode, RefreshRateSelectorPtr>;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800218
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500219 surfaceflinger::Factory& getFactory() { return mFactory; }
220
221 TimeStats& getTimeStats() { return *mFlinger->mTimeStats; }
222
ramindanid4354a92023-10-02 15:11:09 -0700223 void setupScheduler(
224 std::unique_ptr<scheduler::VsyncController> vsyncController,
225 std::shared_ptr<scheduler::VSyncTracker> vsyncTracker,
226 std::unique_ptr<EventThread> appEventThread, std::unique_ptr<EventThread> sfEventThread,
227 DisplayModesVariant modesVariant,
228 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
229 VsyncTrackerCallbackImpl vsyncTrackerCallbackImpl = VsyncTrackerCallbackImpl::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
248 using VsyncTrackerCallback = scheduler::IVsyncTrackerCallback;
249 VsyncTrackerCallback& vsyncTrackerCallback =
250 vsyncTrackerCallbackImpl == VsyncTrackerCallbackImpl::kNoOp
251 ? static_cast<VsyncTrackerCallback&>(mNoOpVsyncTrackerCallback)
252 : static_cast<VsyncTrackerCallback&>(mVsyncTrackerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700253
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800254 if (useNiceMock) {
255 mScheduler =
256 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
257 std::move(vsyncTracker),
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400258 std::move(selectorPtr),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500259 mFactory,
260 *mFlinger->mTimeStats,
ramindanid4354a92023-10-02 15:11:09 -0700261 schedulerCallback,
262 vsyncTrackerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800263 } else {
264 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
265 std::move(vsyncTracker),
Leon Scroggins III823d4ca2023-12-12 16:57:34 -0500266 std::move(selectorPtr), mFactory,
267 *mFlinger->mTimeStats, schedulerCallback,
268 vsyncTrackerCallback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800269 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700270
Leon Scroggins III67388622023-02-06 20:36:20 -0500271 mScheduler->initVsync(mScheduler->getVsyncSchedule()->getDispatch(), *mTokenManager, 0ms);
Ady Abraham011f8ba2022-11-22 15:09:07 -0800272
Dominik Laskowskie99b98c2023-02-02 12:37:23 -0500273 mScheduler->mutableAppConnectionHandle() =
274 mScheduler->createConnection(std::move(appEventThread));
275
276 mFlinger->mAppConnectionHandle = mScheduler->mutableAppConnectionHandle();
Dominik Laskowski98041832019-08-01 18:35:59 -0700277 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700278 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700279 }
280
Rachel Lee414f4082023-10-23 14:48:44 -0700281 void setupMockScheduler(surfaceflinger::test::MockSchedulerOptions options = {}) {
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500282 using testing::_;
283 using testing::Return;
284
285 auto eventThread = makeMock<mock::EventThread>(options.useNiceMock);
286 auto sfEventThread = makeMock<mock::EventThread>(options.useNiceMock);
287
288 EXPECT_CALL(*eventThread, registerDisplayEventConnection(_));
289 EXPECT_CALL(*eventThread, createEventConnection(_, _))
290 .WillOnce(Return(sp<EventThreadConnection>::make(eventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700291 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500292
293 EXPECT_CALL(*sfEventThread, registerDisplayEventConnection(_));
294 EXPECT_CALL(*sfEventThread, createEventConnection(_, _))
295 .WillOnce(Return(sp<EventThreadConnection>::make(sfEventThread.get(),
Ady Abrahamf2851612023-09-25 17:19:00 -0700296 mock::EventThread::kCallingUid)));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500297
298 auto vsyncController = makeMock<mock::VsyncController>(options.useNiceMock);
Leon Scroggins III67388622023-02-06 20:36:20 -0500299 auto vsyncTracker = makeSharedMock<mock::VSyncTracker>(options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500300
Ady Abraham4335afd2023-12-18 19:10:47 -0800301 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500302 EXPECT_CALL(*vsyncTracker, currentPeriod())
303 .WillRepeatedly(Return(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD));
Ady Abrahamc94bffc2023-11-22 11:10:09 -0800304 EXPECT_CALL(*vsyncTracker, minFramePeriod())
305 .WillRepeatedly(
306 Return(Period::fromNs(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)));
Ady Abraham4335afd2023-12-18 19:10:47 -0800307 EXPECT_CALL(*vsyncTracker, nextAnticipatedVSyncTimeFrom(_, _)).WillRepeatedly(Return(0));
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500308 setupScheduler(std::move(vsyncController), std::move(vsyncTracker), std::move(eventThread),
309 std::move(sfEventThread), DefaultDisplayMode{options.displayId},
ramindanid4354a92023-10-02 15:11:09 -0700310 SchedulerCallbackImpl::kNoOp, VsyncTrackerCallbackImpl::kNoOp,
311 options.useNiceMock);
Dominik Laskowskiaee9a622023-02-11 14:24:19 -0500312 }
313
Dominik Laskowski068173d2021-08-11 17:22:59 -0700314 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700315
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800316 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
317 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800318
Lloyd Pique90c115d2018-09-18 21:39:42 -0700319 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800320 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700321 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800322 }
323
Lloyd Pique90c115d2018-09-18 21:39:42 -0700324 using CreateNativeWindowSurfaceFunction =
325 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800326 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700327 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800328 }
329
Lloyd Pique30db6402023-06-26 18:56:51 +0000330 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
331 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
332 }
333
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700334 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700335
Valerie Haud251afb2019-03-29 14:19:02 -0700336 auto& mutableStateLock() { return mFlinger->mStateLock; }
337
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700338 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
339 const sp<const DisplayDevice>& display) {
340 return layer->findOutputLayerForDisplay(display.get());
341 }
342
343 static void setLayerSidebandStream(const sp<Layer>& layer,
344 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800345 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800346 layer->mSidebandStream = sidebandStream;
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000347 layer->editLayerSnapshot()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700348 }
349
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500350 void setLayerCompositionType(const sp<Layer>& layer,
351 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700352 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800353 LOG_ALWAYS_FATAL_IF(!outputLayer);
354 auto& state = outputLayer->editState();
355 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700356 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700357 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800358
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700359 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700360 layer->mPotentialCursor = potentialCursor;
361 }
362
Garfield Tande619fa2020-10-02 17:13:53 -0700363 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000364 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700365 }
366
Lloyd Piquef58625d2017-12-19 13:22:33 -0800367 /* ------------------------------------------------------------------------
368 * Forwarding for functions being tested
369 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000370
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500371 void configure() {
372 ftl::FakeGuard guard(kMainThreadContext);
373 mFlinger->configure();
374 }
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700375
376 void configureAndCommit() {
377 configure();
378 commitTransactionsLocked(eDisplayTransactionNeeded);
379 }
380
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400381 void commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime,
382 bool composite = false) {
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500383 ftl::FakeGuard guard(kMainThreadContext);
384
385 const auto displayIdOpt = mScheduler->pacesetterDisplayId();
386 LOG_ALWAYS_FATAL_IF(!displayIdOpt);
387 const auto displayId = *displayIdOpt;
388
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400389 constexpr bool kBackpressureGpuComposition = true;
Dominik Laskowskiec0eac22023-01-28 16:16:19 -0500390 scheduler::FrameTargeter frameTargeter(displayId, kBackpressureGpuComposition);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400391
392 frameTargeter.beginFrame({.frameBeginTime = frameTime,
393 .vsyncId = vsyncId,
394 .expectedVsyncTime = expectedVsyncTime,
395 .sfWorkDuration = 10ms},
396 *mScheduler->getVsyncSchedule());
397
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400398 scheduler::FrameTargets targets;
399 scheduler::FrameTargeters targeters;
400
401 for (const auto& [id, display] :
402 FTL_FAKE_GUARD(mFlinger->mStateLock, mFlinger->mPhysicalDisplays)) {
403 targets.try_emplace(id, &frameTargeter.target());
404 targeters.try_emplace(id, &frameTargeter);
405 }
406
407 mFlinger->commit(displayId, targets);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400408
409 if (composite) {
Dominik Laskowskifdac5652023-06-29 12:01:13 -0400410 mFlinger->composite(displayId, targeters);
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400411 }
Xiang Wang839fe5b2022-04-04 17:39:38 +0000412 }
413
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400414 void commit(TimePoint frameTime, VsyncId vsyncId, bool composite = false) {
415 return commit(frameTime, vsyncId, frameTime + Period(10ms), composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000416 }
417
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400418 void commit(bool composite = false) {
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700419 const TimePoint frameTime = scheduler::SchedulerClock::now();
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400420 commit(frameTime, kVsyncId, composite);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000421 }
422
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700423 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400424 constexpr bool kComposite = true;
425 commit(frameTime, vsyncId, expectedVsyncTime, kComposite);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700426 }
427
Dominik Laskowskib418dd72023-06-13 17:31:04 -0400428 void commitAndComposite() {
429 constexpr bool kComposite = true;
430 commit(kComposite);
431 }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700432
Huihong Luo59a60b72023-03-08 21:44:59 +0000433 auto createDisplay(const String8& displayName, bool secure, float requestedRefreshRate = 0.0f) {
434 return mFlinger->createDisplay(displayName, secure, requestedRefreshRate);
Lloyd Piquea482f992018-01-22 19:00:34 -0800435 }
436
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700437 auto destroyDisplay(const sp<IBinder>& displayToken) {
438 return mFlinger->destroyDisplay(displayToken);
439 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800440
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100441 auto getDisplay(const sp<IBinder>& displayToken) {
442 Mutex::Autolock lock(mFlinger->mStateLock);
443 return mFlinger->getDisplayDeviceLocked(displayToken);
444 }
445
Dominik Laskowski13948602021-03-08 20:48:28 -0800446 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
447
Lloyd Pique9370a482019-10-03 17:58:30 -0700448 auto setupNewDisplayDeviceInternal(
449 const wp<IBinder>& displayToken,
450 std::shared_ptr<compositionengine::Display> compositionDisplay,
451 const DisplayDeviceState& state,
452 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700453 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700454 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
455 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800456 }
457
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700458 void commitTransactionsLocked(uint32_t transactionFlags) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700459 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700460 ftl::FakeGuard guard(kMainThreadContext);
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
Patrick Williams31908132023-01-09 13:38:48 -0600488 auto renderScreenImpl(std::shared_ptr<const RenderArea> renderArea,
Vishnu Nair7aa0eb72023-01-24 03:59:27 +0000489 SurfaceFlinger::GetLayerSnapshotsFunction traverseLayers,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000490 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000491 bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700492 ScreenCaptureResults captureResults;
Patrick Williams377c0142022-10-13 17:33:38 +0000493 return FTL_FAKE_GUARD(kMainThreadContext,
Patrick Williams7584c6a2022-10-29 02:10:58 +0000494 mFlinger->renderScreenImpl(std::move(renderArea), traverseLayers,
Chavi Weingartenf5fb5b02023-11-30 17:27:52 +0000495 buffer, regionSampling,
Chavi Weingarten18fa7c62023-11-28 21:16:03 +0000496 false /* grayscale */,
497 false /* isProtected */, captureResults));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700498 }
499
chaviw4b9d5e12020-08-04 18:30:35 -0700500 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Ajinkya Chalke02844632023-03-01 12:10:14 +0000501 std::unordered_set<uint32_t> excludeLayerIds,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200502 const LayerVector::Visitor& visitor) {
Ajinkya Chalke02844632023-03-01 12:10:14 +0000503 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid,
504 excludeLayerIds, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700505 }
506
Daniel Solomon42d04562019-01-20 21:03:19 -0800507 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
508 ui::DisplayPrimaries &primaries) {
509 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
510 }
511
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700512 auto& getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
513 auto& getPendingTransactionQueue() {
514 return mFlinger->mTransactionHandler.mPendingTransactionQueues;
515 }
516 size_t getPendingTransactionCount() {
517 return mFlinger->mTransactionHandler.mPendingTransactionCount.load();
518 }
Valerie Haud251afb2019-03-29 14:19:02 -0700519
Pablo Gamito23780be2023-04-18 08:30:00 +0000520 auto setTransactionState(
521 const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
522 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
523 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
524 bool isAutoTimestamp, const std::vector<client_cache_t>& uncacheBuffers,
525 bool hasListenerCallbacks, std::vector<ListenerCallbacks>& listenerCallbacks,
526 uint64_t transactionId, const std::vector<uint64_t>& mergedTransactionIds) {
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000527 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
528 inputWindowCommands, desiredPresentTime,
Patrick Williams6c6dd3b2023-02-13 22:53:06 +0000529 isAutoTimestamp, uncacheBuffers, hasListenerCallbacks,
Pablo Gamito23780be2023-04-18 08:30:00 +0000530 listenerCallbacks, transactionId,
531 mergedTransactionIds);
Valerie Haud251afb2019-03-29 14:19:02 -0700532 }
533
Vishnu Nair40fff5c2022-11-04 02:46:28 +0000534 auto setTransactionStateInternal(TransactionState& transaction) {
535 return mFlinger->mTransactionHandler.queueTransaction(std::move(transaction));
536 }
537
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700538 auto flushTransactionQueues() {
539 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues(kVsyncId));
540 }
Valerie Haud251afb2019-03-29 14:19:02 -0700541
Eduardo Rochaac867192020-09-14 20:12:17 +0000542 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
543 return mFlinger->onTransact(code, data, reply, flags);
544 }
545
Huihong Luo02186fb2022-02-23 14:21:54 -0800546 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800547
Ady Abraham899dcdb2021-06-15 16:56:21 -0700548 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
549 std::chrono::nanoseconds presentLatency) const {
Lloyd Pique30db6402023-06-26 18:56:51 +0000550 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800551 }
552
Ady Abraham285f8c12022-10-11 17:12:14 -0700553 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
554 const gui::DisplayModeSpecs& specs) {
555 return mFlinger->setDesiredDisplayModeSpecs(displayToken, specs);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100556 }
557
Dominik Laskowski360ae782023-02-22 13:30:37 -0500558 void onActiveDisplayChanged(const DisplayDevice* inactiveDisplayPtr,
559 const DisplayDevice& activeDisplay) {
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100560 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700561 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowski360ae782023-02-22 13:30:37 -0500562 mFlinger->onActiveDisplayChangedLocked(inactiveDisplayPtr, activeDisplay);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100563 }
564
Patrick Williamsa361de62022-10-06 20:34:10 +0000565 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle,
566 gui::CreateSurfaceResult& outResult) {
Vishnu Naircb8be502022-10-12 19:03:23 +0000567 args.parentHandle = parentHandle;
568 return mFlinger->createLayer(args, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800569 }
570
571 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000572 gui::CreateSurfaceResult& outResult) {
573 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800574 }
575
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000576 void updateLayerMetadataSnapshot() { mFlinger->updateLayerMetadataSnapshot(); }
577
Sally Qi6bb12822022-10-05 11:42:30 -0700578 void getDynamicDisplayInfoFromToken(const sp<IBinder>& displayToken,
579 ui::DynamicDisplayInfo* dynamicDisplayInfo) {
580 mFlinger->getDynamicDisplayInfoFromToken(displayToken, dynamicDisplayInfo);
Marc Kassisbdf7e4b2022-11-04 17:26:48 +0100581 }
582
Huihong Luo59a60b72023-03-08 21:44:59 +0000583 sp<DisplayDevice> createVirtualDisplayDevice(const sp<IBinder> displayToken,
584 VirtualDisplayId displayId,
585 float requestedRefreshRate) {
586 constexpr ui::Size kResolution = {1080, 1920};
587 auto compositionDisplay = compositionengine::impl::
588 createDisplay(mFlinger->getCompositionEngine(),
589 compositionengine::DisplayCreationArgsBuilder()
590 .setId(displayId)
591 .setPixels(kResolution)
592 .setPowerAdvisor(&mPowerAdvisor)
593 .build());
594 DisplayDeviceCreationArgs creationArgs(mFlinger, mFlinger->getHwComposer(), displayToken,
595 compositionDisplay);
596 creationArgs.requestedRefreshRate = Fps::fromValue(requestedRefreshRate);
597 creationArgs.nativeWindow = sp<mock::NativeWindow>::make();
598 return sp<DisplayDevice>::make(creationArgs);
599 }
600
Leon Scroggins III4235ea02023-04-17 15:14:20 -0400601 status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* outInfo) {
602 return mFlinger->getDisplayStats(displayToken, outInfo);
603 }
604
Lloyd Pique86016da2018-03-01 16:09:38 -0800605 /* ------------------------------------------------------------------------
606 * Read-only access to private data to assert post-conditions.
607 */
608
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800609 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700610 auto& getHwComposer() const {
611 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
612 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700613 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800614
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000615 mock::FrameTracer* getFrameTracer() const {
616 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
617 }
618
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700619 void injectLegacyLayer(sp<Layer> layer) {
620 mFlinger->mLegacyLayers[static_cast<uint32_t>(layer->sequence)] = layer;
621 };
622
623 void releaseLegacyLayer(uint32_t sequence) { mFlinger->mLegacyLayers.erase(sequence); };
624
Vishnu Nair41376b62023-11-08 05:08:58 -0800625 auto setLayerHistoryDisplayArea(uint32_t displayArea) {
626 return mFlinger->mScheduler->onActiveDisplayAreaChanged(displayArea);
627 };
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700628 auto updateLayerHistory(nsecs_t now) { return mFlinger->updateLayerHistory(now); };
Vishnu Nair8134c1a2023-10-17 22:55:49 -0700629 auto setDaltonizerType(ColorBlindnessType type) {
630 mFlinger->mDaltonizer.setType(type);
631 return mFlinger->updateColorMatrixLocked();
632 }
633 auto updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs, bool transactionsFlushed,
634 bool& out) {
635 ftl::FakeGuard guard(kMainThreadContext);
636 return mFlinger->updateLayerSnapshots(vsyncId, frameTimeNs, transactionsFlushed, out);
637 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800638 /* ------------------------------------------------------------------------
639 * Read-write access to private data to set up preconditions and assert
640 * post-conditions.
641 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800642
Dominik Laskowskieb627312022-04-07 09:13:16 -0700643 const auto& displays() const { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700644 const auto& physicalDisplays() const { return mFlinger->mPhysicalDisplays; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700645 const auto& currentState() const { return mFlinger->mCurrentState; }
646 const auto& drawingState() const { return mFlinger->mDrawingState; }
647 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700648
Dominik Laskowskieb627312022-04-07 09:13:16 -0700649 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700650 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700651
Lloyd Pique30db6402023-06-26 18:56:51 +0000652 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
653
Lloyd Piquee39cad22017-12-20 17:01:29 -0800654 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800655 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700656 auto& mutableDisplays() { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700657 auto& mutablePhysicalDisplays() { return mFlinger->mPhysicalDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800658 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700659 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700660 auto& mutableVisibleRegionsDirty() { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800661 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800662 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
663 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700664 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700665 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800666
Lloyd Pique441d5042018-10-18 16:49:51 -0700667 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
668 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700669 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Dominik Laskowskie591b552022-09-09 10:44:56 -0700670 auto& mutableActiveDisplayId() { return mFlinger->mActiveDisplayId; }
Vishnu Nair802ac4f2023-05-10 13:55:22 -0700671 auto& mutablePreviouslyComposedLayers() { return mFlinger->mPreviouslyComposedLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800672
Leon Scroggins III85d4b222023-05-09 13:58:18 -0400673 auto& mutableActiveDisplayRotationFlags() {
674 return SurfaceFlinger::sActiveDisplayRotationFlags;
675 }
676
Lloyd Pique30db6402023-06-26 18:56:51 +0000677 auto& mutableMinAcquiredBuffers() { return SurfaceFlinger::minAcquiredBuffers; }
Ady Abraham822ecbd2023-07-07 16:16:09 -0700678 auto& mutableLayersPendingRemoval() { return mFlinger->mLayersPendingRemoval; }
Vishnu Nair47b7bb42023-09-29 16:27:33 -0700679 auto& mutableLayerSnapshotBuilder() { return mFlinger->mLayerSnapshotBuilder; };
Ady Abraham822ecbd2023-07-07 16:16:09 -0700680
Vishnu Nair07e2a482022-10-18 19:18:16 +0000681 auto fromHandle(const sp<IBinder>& handle) { return LayerHandle::getLayer(handle); }
Valerie Hau09e60052019-12-15 14:51:15 -0800682
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700683 auto initTransactionTraceWriter() {
684 mFlinger->mTransactionTracing.emplace();
685 return mFlinger->initTransactionTraceWriter();
686 }
687
Arthur Hung69f95222023-10-04 07:39:02 +0000688 void enableNewFrontEnd() {
689 mFlinger->mLayerLifecycleManagerEnabled = true;
690 mFlinger->mLegacyFrontEndEnabled = false;
691 }
692
ramindanic67d22c2023-11-28 14:58:47 -0800693 void notifyExpectedPresentIfRequired(PhysicalDisplayId displayId, Period vsyncPeriod,
694 TimePoint expectedPresentTime, Fps frameInterval,
695 std::optional<Period> timeoutOpt) {
696 mFlinger->notifyExpectedPresentIfRequired(displayId, vsyncPeriod, expectedPresentTime,
697 frameInterval, timeoutOpt);
698 }
699
700 void setNotifyExpectedPresentData(PhysicalDisplayId displayId,
701 TimePoint lastExpectedPresentTimestamp,
702 Fps lastFrameInterval) {
703 auto& displayData = mFlinger->mNotifyExpectedPresentMap[displayId];
704 displayData.lastExpectedPresentTimestamp = lastExpectedPresentTimestamp;
705 displayData.lastFrameInterval = lastFrameInterval;
706 }
707
Lloyd Piquee39cad22017-12-20 17:01:29 -0800708 ~TestableSurfaceFlinger() {
709 // All these pointer and container clears help ensure that GMock does
710 // not report a leaked object, since the SurfaceFlinger instance may
711 // still be referenced by something despite our best efforts to destroy
712 // it after each test is done.
713 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800714 mutableCurrentState().displays.clear();
715 mutableDrawingState().displays.clear();
Ady Abraham822ecbd2023-07-07 16:16:09 -0700716 mFlinger->mLayersPendingRemoval.clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700717 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700718 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Patrick Williams0a525a42022-10-26 20:20:50 +0000719 mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>();
720 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Vishnu Nair8c5b7002023-08-17 21:03:57 -0700721 mFlinger->mTransactionTracing.reset();
Lloyd Piquee39cad22017-12-20 17:01:29 -0800722 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800723
Lloyd Piquea618d852018-01-17 11:52:30 -0800724 /* ------------------------------------------------------------------------
725 * Wrapper classes for Read-write access to private data to set up
726 * preconditions and assert post-conditions.
727 */
Ana Krulec4593b692019-01-11 22:07:25 -0800728 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800729 HWC2Display(
730 Hwc2::Composer& composer,
731 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
732 capabilities,
733 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800734 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800735 ~HWC2Display() {
736 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700737 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800738 }
739
740 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700741 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800742 };
743
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800744 class FakeHwcDisplayInjector {
745 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700746 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800747 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100748 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800749 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800750 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700751 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700752 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800753
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200754 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
755 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700756 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800757
Peiyong Line9d809e2020-04-14 13:10:48 -0700758 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800759 mHwcDisplayId = displayId;
760 return *this;
761 }
762
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800763 auto& setResolution(ui::Size resolution) {
764 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800765 return *this;
766 }
767
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800768 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100769 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800770 return *this;
771 }
772
773 auto& setDpiX(int32_t dpi) {
774 mDpiX = dpi;
775 return *this;
776 }
777
778 auto& setDpiY(int32_t dpi) {
779 mDpiY = dpi;
780 return *this;
781 }
782
Peiyong Line9d809e2020-04-14 13:10:48 -0700783 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800784 mActiveConfig = config;
785 return *this;
786 }
787
Ady Abrahamde549d42022-01-26 19:19:17 -0800788 auto& setCapabilities(
789 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
790 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700791 mCapabilities = capabilities;
792 return *this;
793 }
794
Dominik Laskowskic132a152022-11-30 15:44:52 -0500795 auto& setPowerMode(std::optional<hal::PowerMode> mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700796 mPowerMode = mode;
797 return *this;
798 }
799
Marin Shalamanov045b7002021-01-07 16:56:24 +0100800 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
801 using ::testing::_;
802 using ::testing::DoAll;
803 using ::testing::Return;
804 using ::testing::SetArgPointee;
805
Ady Abrahamde549d42022-01-26 19:19:17 -0800806 static const std::unordered_set<
807 aidl::android::hardware::graphics::composer3::Capability>
808 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700809 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
810
811 // Caution - Make sure that any values passed by reference here do
812 // not refer to an instance owned by FakeHwcDisplayInjector. This
813 // class has temporary lifetime, while the constructed HWC2::Display
814 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800815 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
816 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800817 display->mutableIsConnected() = true;
Dominik Laskowskic132a152022-11-30 15:44:52 -0500818
819 if (mPowerMode) {
820 display->setPowerMode(*mPowerMode);
821 }
822
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800823 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700824
Marin Shalamanov045b7002021-01-07 16:56:24 +0100825 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
826 .WillRepeatedly(
827 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
828 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100829 EXPECT_CALL(*composer,
830 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800831 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
832 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100833
834 EXPECT_CALL(*composer,
835 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
836 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800837 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
838 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100839
840 EXPECT_CALL(*composer,
841 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
842 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800843 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
844 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100845
846 EXPECT_CALL(*composer,
847 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
848 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
849
850 EXPECT_CALL(*composer,
851 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
852 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
853
854 EXPECT_CALL(*composer,
855 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
856 hal::Attribute::CONFIG_GROUP, _))
857 .WillRepeatedly(
858 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100859
Peiyong Line9d809e2020-04-14 13:10:48 -0700860 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200861 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
862 LOG_ALWAYS_FATAL_IF(!physicalId);
863 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100864 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700865 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100866 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700867 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100868 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700869 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
870 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100871 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700872 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800873 }
874
875 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200876 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700877 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700878 const bool mIsPrimary;
879
Peiyong Line9d809e2020-04-14 13:10:48 -0700880 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800881 ui::Size mResolution = DEFAULT_RESOLUTION;
882 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800883 int32_t mDpiX = DEFAULT_DPI;
884 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100885 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700886 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Dominik Laskowskic132a152022-11-30 15:44:52 -0500887 std::optional<hal::PowerMode> mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800888 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
889 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800890 };
891
892 class FakeDisplayDeviceInjector {
893 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700894 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800895 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100896 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700897 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700898 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700899 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
900 display),
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700901 mConnectionType(connectionType),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100902 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700903 mCreationArgs.isPrimary = isPrimary;
linpeter1c69cd32022-07-13 19:20:48 +0800904 mCreationArgs.initialPowerMode = hal::PowerMode::ON;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700905 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800906
907 sp<IBinder> token() const { return mDisplayToken; }
908
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700909 auto physicalDisplay() const {
910 return ftl::Optional(mCreationArgs.compositionDisplay->getDisplayId())
911 .and_then(&PhysicalDisplayId::tryCast)
912 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays()));
913 }
914
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800915 DisplayDeviceState& mutableDrawingDisplayState() {
916 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
917 }
918
919 DisplayDeviceState& mutableCurrentDisplayState() {
920 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
921 }
922
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800923 const auto& getDrawingDisplayState() {
924 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
925 }
926
927 const auto& getCurrentDisplayState() {
928 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
929 }
930
Dominik Laskowskieb627312022-04-07 09:13:16 -0700931 const sp<DisplayDevice>& mutableDisplayDevice() {
932 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
933 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800934
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500935 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700936 mDisplayModes = std::move(modes);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800937 mCreationArgs.activeModeId = activeModeId;
Dominik Laskowski2b1037b2023-02-11 16:45:36 -0500938 mCreationArgs.refreshRateSelector = nullptr;
939 return *this;
940 }
941
942 auto& setRefreshRateSelector(RefreshRateSelectorPtr selectorPtr) {
943 mDisplayModes = selectorPtr->displayModes();
944 mCreationArgs.activeModeId = selectorPtr->getActiveMode().modePtr->getId();
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400945 mCreationArgs.refreshRateSelector = std::move(selectorPtr);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100946 return *this;
947 }
948
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800949 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700950 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800951 return *this;
952 }
953
Lloyd Pique542307f2018-10-19 13:24:08 -0700954 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700955 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800956 return *this;
957 }
958
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800959 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700960 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800961 return *this;
962 }
963
Dominik Laskowskic132a152022-11-30 15:44:52 -0500964 auto& setPowerMode(std::optional<hal::PowerMode> mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700965 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700966 return *this;
967 }
968
Valerie Hau9758ae02018-10-09 16:05:09 -0700969 auto& setHwcColorModes(
970 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
971 hwcColorModes) {
972 mCreationArgs.hwcColorModes = hwcColorModes;
973 return *this;
974 }
975
976 auto& setHasWideColorGamut(bool hasWideColorGamut) {
977 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
978 return *this;
979 }
980
Lloyd Pique33050472019-12-19 17:12:44 -0800981 auto& setPhysicalOrientation(ui::Rotation orientation) {
982 mCreationArgs.physicalOrientation = orientation;
983 return *this;
984 }
985
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -0500986 auto& skipRegisterDisplay() {
987 mRegisterDisplay = false;
988 return *this;
989 }
990
Ady Abraham690f4612021-07-01 23:24:03 -0700991 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Brian Johnson9ea03122023-06-30 14:46:34 -0700992 return inject(std::make_unique<mock::VsyncController>(),
993 std::make_shared<mock::VSyncTracker>());
994 }
995
996 sp<DisplayDevice> inject(std::unique_ptr<android::scheduler::VsyncController> controller,
997 std::shared_ptr<android::scheduler::VSyncTracker> tracker)
998 NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800999 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
1000
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001001 auto& modes = mDisplayModes;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001002 auto& activeModeId = mCreationArgs.activeModeId;
1003
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001004 if (displayId && !mCreationArgs.refreshRateSelector) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001005 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
1006 if (modes.empty()) {
1007 constexpr DisplayModeId kModeId{0};
1008 DisplayModePtr mode =
1009 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
1010 .setId(kModeId)
1011 .setPhysicalDisplayId(*physicalId)
1012 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
1013 .setVsyncPeriod(
1014 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
1015 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
1016 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
1017 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
1018 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001019
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001020 modes = ftl::init::map(kModeId, std::move(mode));
1021 activeModeId = kModeId;
1022 }
1023
Dominik Laskowskid82e0f02022-10-26 15:23:04 -04001024 mCreationArgs.refreshRateSelector =
1025 std::make_shared<scheduler::RefreshRateSelector>(modes, activeModeId);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001026 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001027 }
Lloyd Pique9370a482019-10-03 17:58:30 -07001028
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001029 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
1030 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
1031
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001032 DisplayDeviceState state;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001033 state.isSecure = mCreationArgs.isSecure;
1034
1035 if (mConnectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -07001036 LOG_ALWAYS_FATAL_IF(!displayId);
Dominik Laskowski596a2562022-10-28 11:26:12 -04001037 const auto physicalIdOpt = PhysicalDisplayId::tryCast(*displayId);
1038 LOG_ALWAYS_FATAL_IF(!physicalIdOpt);
1039 const auto physicalId = *physicalIdOpt;
1040
Dominik Laskowskic132a152022-11-30 15:44:52 -05001041 if (mCreationArgs.isPrimary) {
1042 mFlinger.mutableActiveDisplayId() = physicalId;
1043 }
1044
Marin Shalamanov700e6392020-02-12 20:22:26 +01001045 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +01001046
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001047 const auto activeMode = modes.get(activeModeId);
1048 LOG_ALWAYS_FATAL_IF(!activeMode);
ramindania04b8a52023-08-07 18:49:47 -07001049 const auto fps = activeMode->get()->getPeakFps();
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001050
Dominik Laskowski596a2562022-10-28 11:26:12 -04001051 state.physical = {.id = physicalId,
Marin Shalamanovc7e9f822021-11-16 20:07:55 +01001052 .hwcDisplayId = *mHwcDisplayId,
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001053 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -08001054
Ady Abrahamace3d052022-11-17 16:25:05 -08001055 mFlinger.mutablePhysicalDisplays().emplace_or_replace(physicalId, mDisplayToken,
1056 physicalId, *mConnectionType,
1057 std::move(modes),
1058 ui::ColorModes(),
1059 std::nullopt);
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001060
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001061 if (mFlinger.scheduler() && mRegisterDisplay) {
Dominik Laskowski596a2562022-10-28 11:26:12 -04001062 mFlinger.scheduler()->registerDisplay(physicalId,
Brian Johnson9ea03122023-06-30 14:46:34 -07001063 display->holdRefreshRateSelector(),
1064 std::move(controller),
1065 std::move(tracker));
Dominik Laskowski596a2562022-10-28 11:26:12 -04001066 }
1067
Ady Abrahamace3d052022-11-17 16:25:05 -08001068 display->setActiveMode(activeModeId, fps, fps);
Marin Shalamanov045b7002021-01-07 16:56:24 +01001069 }
Dominik Laskowskieb627312022-04-07 09:13:16 -07001070
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001071 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
1072 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
1073
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001074 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001075 }
1076
1077 private:
1078 TestableSurfaceFlinger& mFlinger;
Ady Abrahamd11bade2022-08-01 16:18:03 -07001079 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -07001080 DisplayDeviceCreationArgs mCreationArgs;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001081 DisplayModes mDisplayModes;
Leon Scroggins IIIba9323a2023-02-22 10:40:20 -05001082 bool mRegisterDisplay = true;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -07001083 const std::optional<ui::DisplayConnectionType> mConnectionType;
Peiyong Line9d809e2020-04-14 13:10:48 -07001084 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -08001085 };
1086
Dominik Laskowski8b01cc02020-07-14 19:02:41 -07001087private:
Dominik Laskowskiaee9a622023-02-11 14:24:19 -05001088 template <typename T>
1089 static std::unique_ptr<T> makeMock(bool useNiceMock) {
1090 return useNiceMock ? std::make_unique<testing::NiceMock<T>>() : std::make_unique<T>();
1091 }
1092
Leon Scroggins III67388622023-02-06 20:36:20 -05001093 template <typename T>
1094 static std::shared_ptr<T> makeSharedMock(bool useNiceMock) {
1095 return useNiceMock ? std::make_shared<testing::NiceMock<T>>() : std::make_shared<T>();
1096 }
1097
Dominik Laskowski08fbd852022-07-14 08:53:42 -07001098 static constexpr VsyncId kVsyncId{123};
Ady Abraham302ebed2022-03-07 16:03:41 -08001099
Lloyd Pique90c115d2018-09-18 21:39:42 -07001100 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -08001101 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -08001102 scheduler::mock::SchedulerCallback mSchedulerCallback;
1103 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
ramindanid4354a92023-10-02 15:11:09 -07001104 scheduler::mock::VsyncTrackerCallback mVsyncTrackerCallback;
1105 scheduler::mock::NoOpVsyncTrackerCallback mNoOpVsyncTrackerCallback;
Ady Abraham011f8ba2022-11-22 15:09:07 -08001106 std::unique_ptr<frametimeline::impl::TokenManager> mTokenManager;
Dominik Laskowski068173d2021-08-11 17:22:59 -07001107 scheduler::TestableScheduler* mScheduler = nullptr;
Huihong Luo59a60b72023-03-08 21:44:59 +00001108 Hwc2::mock::PowerAdvisor mPowerAdvisor;
Lloyd Piquef58625d2017-12-19 13:22:33 -08001109};
1110
1111} // namespace android