blob: 60285f98f4c9862d425a934b8ec497e0dc85cadb [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
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080023#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070024#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080025#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070026#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070027#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080028#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070029#include <compositionengine/mock/DisplaySurface.h>
chaviw0ef7caa2021-01-05 11:04:50 -080030#include <gui/ScreenCaptureResults.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070031
Lloyd Pique90c115d2018-09-18 21:39:42 -070032#include "BufferStateLayer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070033#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080034#include "DisplayDevice.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080035#include "EffectLayer.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070036#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080037#include "FrameTracer/FrameTracer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070038#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070039#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070040#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070041#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070042#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080043#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070044#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070045#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070046#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010047#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080048#include "mock/DisplayHardware/MockDisplayMode.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070049#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080050#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080051#include "mock/MockSchedulerCallback.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080052
Lloyd Piquef58625d2017-12-19 13:22:33 -080053namespace android {
54
Lloyd Piquee39cad22017-12-20 17:01:29 -080055class EventThread;
56
Peiyong Lin833074a2018-08-28 11:53:54 -070057namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070058
Lloyd Piquee39cad22017-12-20 17:01:29 -080059class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070060
61} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080062
63namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070064
Lloyd Piquee39cad22017-12-20 17:01:29 -080065class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070066
67} // namespace Hwc2
68
Peiyong Line9d809e2020-04-14 13:10:48 -070069namespace hal = android::hardware::graphics::composer::hal;
70
Lloyd Pique90c115d2018-09-18 21:39:42 -070071namespace surfaceflinger::test {
72
73class Factory final : public surfaceflinger::Factory {
74public:
75 ~Factory() = default;
76
Lloyd Pique90c115d2018-09-18 21:39:42 -070077 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070078 return nullptr;
79 }
80
Ady Abraham8287e852020-08-12 14:44:58 -070081 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010082 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080083 return std::make_unique<scheduler::FakePhaseOffsets>();
84 }
85
Pablo Gamitoc351d6f2020-09-17 15:34:26 +000086 sp<SurfaceInterceptor> createSurfaceInterceptor() override {
87 return new android::impl::SurfaceInterceptor();
Lloyd Pique90c115d2018-09-18 21:39:42 -070088 }
89
90 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 return new StartPropertySetThread(timestampPropertyValue);
92 }
93
Lloyd Pique9370a482019-10-03 17:58:30 -070094 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
95 return new DisplayDevice(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070096 }
97
98 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
99 uint32_t layerCount, uint64_t usage,
100 std::string requestorName) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700101 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
102 }
103
104 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
105 sp<IGraphicBufferConsumer>* outConsumer,
106 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700107 if (!mCreateBufferQueue) {
108 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
109 return;
110 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700111 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
112 }
113
114 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
115 const sp<IGraphicBufferProducer>& producer) override {
116 if (!mCreateNativeWindowSurface) return nullptr;
117 return mCreateNativeWindowSurface(producer);
118 }
119
Lloyd Pique70d91362018-10-18 16:02:55 -0700120 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
121 return compositionengine::impl::createCompositionEngine();
122 }
123
Lloyd Pique90c115d2018-09-18 21:39:42 -0700124 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700125 return nullptr;
126 }
127
Vishnu Nairfa247b12020-02-11 08:58:26 -0800128 sp<EffectLayer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700129
130 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700131 return nullptr;
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
159} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800160
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800161class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800162public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700163 using HotplugEvent = SurfaceFlinger::HotplugEvent;
164
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800165 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
166 if (!mFlinger) {
167 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
168 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800169 mFlinger->mAnimationTransactionTimeout = ms2ns(10);
170 }
171
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700172 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700173 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700174
Lloyd Piquef58625d2017-12-19 13:22:33 -0800175 // Extend this as needed for accessing SurfaceFlinger private (and public)
176 // functions.
177
Peiyong Lin833074a2018-08-28 11:53:54 -0700178 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700179 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800180 }
181
182 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700183 mFlinger->mCompositionEngine->setHwComposer(
184 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800185 }
186
Xiang Wang839fe5b2022-04-04 17:39:38 +0000187 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
188 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
189 }
190
Alec Mourie4034bb2019-11-19 12:45:54 -0800191 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
192 mFlinger->mCompositionEngine->setTimeStats(timeStats);
193 }
194
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800195 enum class SchedulerCallbackImpl { kNoOp, kMock };
196
197 static constexpr struct OneDisplayMode {
198 } kOneDisplayMode;
199
200 static constexpr struct TwoDisplayModes {
201 } kTwoDisplayModes;
202
203 using RefreshRateConfigsPtr = std::shared_ptr<scheduler::RefreshRateConfigs>;
204
205 using DisplayModesVariant =
206 std::variant<OneDisplayMode, TwoDisplayModes, RefreshRateConfigsPtr>;
207
Ady Abraham8cb21882020-08-26 18:22:05 -0700208 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
209 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700210 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800211 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800212 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800213 DisplayModesVariant modesVariant = kOneDisplayMode,
214 bool useNiceMock = false) {
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800215 RefreshRateConfigsPtr configs;
216 if (std::holds_alternative<RefreshRateConfigsPtr>(modesVariant)) {
217 configs = std::move(std::get<RefreshRateConfigsPtr>(modesVariant));
218 } else {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800219 constexpr DisplayModeId kModeId60{0};
220 DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
Ady Abrahamabc27602020-04-08 17:20:29 -0700221
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800222 if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800223 constexpr DisplayModeId kModeId90{1};
224 modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800225 }
226
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800227 configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700228 }
229
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800230 const auto fps = configs->getActiveMode()->getFps();
231 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
Ady Abraham23ea9da2021-07-14 16:32:56 -0700232 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
233 mFlinger->mVsyncConfiguration->getCurrentConfigs());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800234
Marin Shalamanov68a94092020-11-24 17:48:00 +0100235 mFlinger->mRefreshRateStats =
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800236 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800237 hal::PowerMode::OFF);
238
239 using Callback = scheduler::ISchedulerCallback;
240 Callback& callback = callbackImpl == SchedulerCallbackImpl::kNoOp
241 ? static_cast<Callback&>(mNoOpSchedulerCallback)
242 : static_cast<Callback&>(mSchedulerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700243
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800244 if (useNiceMock) {
245 mScheduler =
246 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
247 std::move(vsyncTracker),
248 std::move(configs),
249 callback);
250 } else {
251 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
252 std::move(vsyncTracker),
253 std::move(configs), callback);
254 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700255
Dominik Laskowski98041832019-08-01 18:35:59 -0700256 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
257 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700258 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700259 }
260
Dominik Laskowski068173d2021-08-11 17:22:59 -0700261 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700262
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800263 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
264 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800265
Ady Abraham2739e832022-02-14 17:42:00 -0800266 auto& mutableVsyncModulator() { return mFlinger->mVsyncModulator; }
267
Lloyd Pique90c115d2018-09-18 21:39:42 -0700268 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800269 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700270 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800271 }
272
Lloyd Pique90c115d2018-09-18 21:39:42 -0700273 using CreateNativeWindowSurfaceFunction =
274 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800275 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700276 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800277 }
278
Daniel Solomon42d04562019-01-20 21:03:19 -0800279 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
280 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
281 }
282
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700283 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700284
Valerie Haud251afb2019-03-29 14:19:02 -0700285 auto& mutableStateLock() { return mFlinger->mStateLock; }
286
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700287 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
288 const sp<const DisplayDevice>& display) {
289 return layer->findOutputLayerForDisplay(display.get());
290 }
291
292 static void setLayerSidebandStream(const sp<Layer>& layer,
293 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800294 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800295 layer->mSidebandStream = sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800296 layer->editCompositionState()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700297 }
298
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500299 void setLayerCompositionType(const sp<Layer>& layer,
300 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700301 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800302 LOG_ALWAYS_FATAL_IF(!outputLayer);
303 auto& state = outputLayer->editState();
304 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700305 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700306 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800307
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700308 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700309 layer->mPotentialCursor = potentialCursor;
310 }
311
Garfield Tande619fa2020-10-02 17:13:53 -0700312 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000313 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700314 }
315
Matt Buckley50c44062022-01-17 20:48:10 +0000316 void setPowerHintSessionMode(bool early, bool late) {
317 mFlinger->mPowerHintSessionMode = {.late = late, .early = early};
318 }
319
Lloyd Piquef58625d2017-12-19 13:22:33 -0800320 /* ------------------------------------------------------------------------
321 * Forwarding for functions being tested
322 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000323
324 nsecs_t commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expectedVSyncTime) {
325 mFlinger->commit(frameTime, vsyncId, expectedVSyncTime);
326 return frameTime;
327 }
328
329 nsecs_t commit(nsecs_t frameTime, int64_t vsyncId) {
330 std::chrono::nanoseconds period = 10ms;
331 return commit(frameTime, vsyncId, frameTime + period.count());
332 }
333
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700334 nsecs_t commit() {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700335 const nsecs_t now = systemTime();
336 const nsecs_t expectedVsyncTime = now + 10'000'000;
Xiang Wang839fe5b2022-04-04 17:39:38 +0000337 return commit(now, kVsyncId, expectedVsyncTime);
338 }
339
340 void commitAndComposite(const nsecs_t frameTime, const int64_t vsyncId,
341 const nsecs_t expectedVsyncTime) {
342 mFlinger->composite(commit(frameTime, vsyncId, expectedVsyncTime), kVsyncId);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700343 }
344
Ady Abraham302ebed2022-03-07 16:03:41 -0800345 void commitAndComposite() { mFlinger->composite(commit(), kVsyncId); }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700346
Lloyd Piquea482f992018-01-22 19:00:34 -0800347 auto createDisplay(const String8& displayName, bool secure) {
348 return mFlinger->createDisplay(displayName, secure);
349 }
350
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700351 auto destroyDisplay(const sp<IBinder>& displayToken) {
352 return mFlinger->destroyDisplay(displayToken);
353 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800354
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100355 auto getDisplay(const sp<IBinder>& displayToken) {
356 Mutex::Autolock lock(mFlinger->mStateLock);
357 return mFlinger->getDisplayDeviceLocked(displayToken);
358 }
359
Dominik Laskowski13948602021-03-08 20:48:28 -0800360 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
361
Lloyd Pique9370a482019-10-03 17:58:30 -0700362 auto setupNewDisplayDeviceInternal(
363 const wp<IBinder>& displayToken,
364 std::shared_ptr<compositionengine::Display> compositionDisplay,
365 const DisplayDeviceState& state,
366 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700367 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700368 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
369 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800370 }
371
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700372 auto commitTransactionsLocked(uint32_t transactionFlags) {
373 Mutex::Autolock lock(mFlinger->mStateLock);
374 return mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800375 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800376
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700377 void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
378 mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800379 }
380
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800381 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700382 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800383 return mFlinger->setDisplayStateLocked(s);
384 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800385
Dominik Laskowski83b88212018-12-11 13:34:06 -0800386 // Allow reading display state without locking, as if called on the SF main thread.
387 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
388 return mFlinger->onInitializeDisplays();
389 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800390
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100391 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
392
Alec Mouricdf16792021-12-10 13:16:06 -0800393 auto setDisplayBrightness(const sp<IBinder>& display,
394 const gui::DisplayBrightness& brightness) {
395 return mFlinger->setDisplayBrightness(display, brightness);
396 }
397
Dominik Laskowski83b88212018-12-11 13:34:06 -0800398 // Allow reading display state without locking, as if called on the SF main thread.
399 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700400 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800401 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800402 }
403
Robert Carr12a3b9b2022-03-10 09:55:29 -0800404 auto renderScreenImpl(const RenderArea& renderArea,
chaviw426b5c02020-07-27 11:20:15 -0700405 SurfaceFlinger::TraverseLayersFunction traverseLayers,
Alec Mouria90a5702021-04-16 16:36:21 +0000406 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
407 bool forSystem, bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700408 ScreenCaptureResults captureResults;
Robert Carr12a3b9b2022-03-10 09:55:29 -0800409 return mFlinger->renderScreenImpl(renderArea, traverseLayers, buffer, forSystem,
chaviw17ac24b2021-01-28 18:50:05 -0800410 regionSampling, false /* grayscale */,
411 captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700412 }
413
chaviw4b9d5e12020-08-04 18:30:35 -0700414 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200415 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700416 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700417 }
418
Daniel Solomon42d04562019-01-20 21:03:19 -0800419 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
420 ui::DisplayPrimaries &primaries) {
421 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
422 }
423
Arthur Hung58144272021-01-16 03:43:53 +0000424 auto& getTransactionQueue() { return mFlinger->mTransactionQueue; }
425 auto& getPendingTransactionQueue() { return mFlinger->mPendingTransactionQueues; }
ramindani4d48f902021-09-20 21:07:45 +0000426 auto& getTransactionCommittedSignals() { return mFlinger->mTransactionCommittedSignals; }
Valerie Haud251afb2019-03-29 14:19:02 -0700427
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000428 auto setTransactionState(
429 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
430 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
431 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
432 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
433 std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
434 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
435 inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800436 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
437 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700438 }
439
Vishnu Nair7891e962021-11-11 12:07:21 -0800440 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(0); };
Valerie Haud251afb2019-03-29 14:19:02 -0700441
Eduardo Rochaac867192020-09-14 20:12:17 +0000442 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
443 return mFlinger->onTransact(code, data, reply, flags);
444 }
445
Huihong Luo02186fb2022-02-23 14:21:54 -0800446 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800447
Ady Abraham899dcdb2021-06-15 16:56:21 -0700448 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
449 std::chrono::nanoseconds presentLatency) const {
450 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800451 }
452
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100453 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode,
454 bool allowGroupSwitching, float primaryRefreshRateMin,
455 float primaryRefreshRateMax, float appRequestRefreshRateMin,
456 float appRequestRefreshRateMax) {
457 return mFlinger->setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,
458 primaryRefreshRateMin, primaryRefreshRateMax,
459 appRequestRefreshRateMin,
460 appRequestRefreshRateMax);
461 }
462
463 void onActiveDisplayChanged(const sp<DisplayDevice>& activeDisplay) {
464 Mutex::Autolock lock(mFlinger->mStateLock);
465 mFlinger->onActiveDisplayChangedLocked(activeDisplay);
466 }
467
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800468 auto createLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
469 const sp<IBinder>& parentHandle, int32_t* outLayerId,
470 const sp<Layer>& parentLayer, uint32_t* outTransformHint) {
471 return mFlinger->createLayer(args, outHandle, parentHandle, outLayerId, parentLayer,
472 outTransformHint);
473 }
474
475 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
476 sp<IBinder>* outHandle, int32_t* outLayerId) {
477 return mFlinger->mirrorLayer(args, mirrorFromHandle, outHandle, outLayerId);
478 }
479
Lloyd Pique86016da2018-03-01 16:09:38 -0800480 /* ------------------------------------------------------------------------
481 * Read-only access to private data to assert post-conditions.
482 */
483
484 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800485 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800486 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700487 auto& getHwComposer() const {
488 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
489 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700490 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800491
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000492 mock::FrameTracer* getFrameTracer() const {
493 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
494 }
495
Ady Abrahame9ebce02022-02-03 12:05:06 -0800496 nsecs_t getAnimationTransactionTimeout() const {
497 return mFlinger->mAnimationTransactionTimeout;
498 }
499
Lloyd Piquef58625d2017-12-19 13:22:33 -0800500 /* ------------------------------------------------------------------------
501 * Read-write access to private data to set up preconditions and assert
502 * post-conditions.
503 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800504
Dominik Laskowskieb627312022-04-07 09:13:16 -0700505 const auto& displays() const { return mFlinger->mDisplays; }
506 const auto& currentState() const { return mFlinger->mCurrentState; }
507 const auto& drawingState() const { return mFlinger->mDrawingState; }
508 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
509 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
510
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800511 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
512
Lloyd Piquee39cad22017-12-20 17:01:29 -0800513 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800514 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700515 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800516 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700517 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800518 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800519 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800520 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700521 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700522 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800523 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700524 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700525 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800526
Lloyd Pique441d5042018-10-18 16:49:51 -0700527 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
528 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700529 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Ady Abrahamadc914c2021-10-13 17:04:27 -0700530 auto& mutableActiveDisplayToken() { return mFlinger->mActiveDisplayToken; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800531
Valerie Hau09e60052019-12-15 14:51:15 -0800532 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800533 return mFlinger->fromHandle(handle);
534 }
535
Lloyd Piquee39cad22017-12-20 17:01:29 -0800536 ~TestableSurfaceFlinger() {
537 // All these pointer and container clears help ensure that GMock does
538 // not report a leaked object, since the SurfaceFlinger instance may
539 // still be referenced by something despite our best efforts to destroy
540 // it after each test is done.
541 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800542 mutableCurrentState().displays.clear();
543 mutableDrawingState().displays.clear();
Pablo Gamito5cfc6e52020-09-10 11:18:03 +0000544 mutableInterceptor().clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700545 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700546 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700547 mFlinger->mCompositionEngine->setRenderEngine(
548 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800549 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800550
Lloyd Piquea618d852018-01-17 11:52:30 -0800551 /* ------------------------------------------------------------------------
552 * Wrapper classes for Read-write access to private data to set up
553 * preconditions and assert post-conditions.
554 */
Ana Krulec4593b692019-01-11 22:07:25 -0800555 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800556 HWC2Display(
557 Hwc2::Composer& composer,
558 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
559 capabilities,
560 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800561 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800562 ~HWC2Display() {
563 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700564 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800565 }
566
567 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700568 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800569 };
570
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800571 class FakeHwcDisplayInjector {
572 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700573 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800574 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100575 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800576 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800577 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700578 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700579 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800580
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200581 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
582 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700583 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800584
Peiyong Line9d809e2020-04-14 13:10:48 -0700585 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800586 mHwcDisplayId = displayId;
587 return *this;
588 }
589
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800590 auto& setResolution(ui::Size resolution) {
591 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800592 return *this;
593 }
594
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800595 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100596 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800597 return *this;
598 }
599
600 auto& setDpiX(int32_t dpi) {
601 mDpiX = dpi;
602 return *this;
603 }
604
605 auto& setDpiY(int32_t dpi) {
606 mDpiY = dpi;
607 return *this;
608 }
609
Peiyong Line9d809e2020-04-14 13:10:48 -0700610 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800611 mActiveConfig = config;
612 return *this;
613 }
614
Ady Abrahamde549d42022-01-26 19:19:17 -0800615 auto& setCapabilities(
616 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
617 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700618 mCapabilities = capabilities;
619 return *this;
620 }
621
Peiyong Lin65248e02020-04-18 21:15:07 -0700622 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700623 mPowerMode = mode;
624 return *this;
625 }
626
Marin Shalamanov045b7002021-01-07 16:56:24 +0100627 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
628 using ::testing::_;
629 using ::testing::DoAll;
630 using ::testing::Return;
631 using ::testing::SetArgPointee;
632
Ady Abrahamde549d42022-01-26 19:19:17 -0800633 static const std::unordered_set<
634 aidl::android::hardware::graphics::composer3::Capability>
635 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700636 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
637
638 // Caution - Make sure that any values passed by reference here do
639 // not refer to an instance owned by FakeHwcDisplayInjector. This
640 // class has temporary lifetime, while the constructed HWC2::Display
641 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800642 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
643 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800644
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800645 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700646 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800647 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700648
Marin Shalamanov045b7002021-01-07 16:56:24 +0100649 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
650 .WillRepeatedly(
651 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
652 Return(hal::Error::NONE)));
653
654 EXPECT_CALL(*composer,
655 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800656 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
657 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100658
659 EXPECT_CALL(*composer,
660 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
661 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800662 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
663 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100664
665 EXPECT_CALL(*composer,
666 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
667 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800668 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
669 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100670
671 EXPECT_CALL(*composer,
672 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
673 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
674
675 EXPECT_CALL(*composer,
676 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
677 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
678
679 EXPECT_CALL(*composer,
680 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
681 hal::Attribute::CONFIG_GROUP, _))
682 .WillRepeatedly(
683 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100684
Peiyong Line9d809e2020-04-14 13:10:48 -0700685 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200686 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
687 LOG_ALWAYS_FATAL_IF(!physicalId);
688 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100689 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700690 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100691 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700692 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100693 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700694 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
695 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100696 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700697 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800698 }
699
700 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200701 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700702 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700703 const bool mIsPrimary;
704
Peiyong Line9d809e2020-04-14 13:10:48 -0700705 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800706 ui::Size mResolution = DEFAULT_RESOLUTION;
707 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800708 int32_t mDpiX = DEFAULT_DPI;
709 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100710 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700711 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700712 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800713 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
714 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800715 };
716
717 class FakeDisplayDeviceInjector {
718 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700719 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800720 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100721 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700722 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700723 : mFlinger(flinger),
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100724 mCreationArgs(flinger.mFlinger.get(), flinger.mFlinger->getHwComposer(),
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800725 mDisplayToken, display),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100726 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800727 mCreationArgs.connectionType = connectionType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700728 mCreationArgs.isPrimary = isPrimary;
729 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800730
731 sp<IBinder> token() const { return mDisplayToken; }
732
733 DisplayDeviceState& mutableDrawingDisplayState() {
734 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
735 }
736
737 DisplayDeviceState& mutableCurrentDisplayState() {
738 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
739 }
740
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800741 const auto& getDrawingDisplayState() {
742 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
743 }
744
745 const auto& getCurrentDisplayState() {
746 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
747 }
748
Dominik Laskowskieb627312022-04-07 09:13:16 -0700749 const sp<DisplayDevice>& mutableDisplayDevice() {
750 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
751 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800752
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800753 // If `configs` is nullptr, the injector creates RefreshRateConfigs from the `modes`.
754 // Otherwise, it uses `configs`, which the caller must create using the same `modes`.
755 //
756 // TODO(b/182939859): Once `modes` can be retrieved from RefreshRateConfigs, remove
757 // the `configs` parameter in favor of an alternative setRefreshRateConfigs API.
758 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId,
759 std::shared_ptr<scheduler::RefreshRateConfigs> configs = nullptr) {
760 mCreationArgs.supportedModes = std::move(modes);
761 mCreationArgs.activeModeId = activeModeId;
762 mCreationArgs.refreshRateConfigs = std::move(configs);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100763 return *this;
764 }
765
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800766 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700767 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800768 return *this;
769 }
770
Lloyd Pique542307f2018-10-19 13:24:08 -0700771 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700772 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800773 return *this;
774 }
775
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800776 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700777 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800778 return *this;
779 }
780
Peiyong Lin65248e02020-04-18 21:15:07 -0700781 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700782 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700783 return *this;
784 }
785
Valerie Hau9758ae02018-10-09 16:05:09 -0700786 auto& setHwcColorModes(
787 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
788 hwcColorModes) {
789 mCreationArgs.hwcColorModes = hwcColorModes;
790 return *this;
791 }
792
793 auto& setHasWideColorGamut(bool hasWideColorGamut) {
794 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
795 return *this;
796 }
797
Lloyd Pique33050472019-12-19 17:12:44 -0800798 auto& setPhysicalOrientation(ui::Rotation orientation) {
799 mCreationArgs.physicalOrientation = orientation;
800 return *this;
801 }
802
Ady Abraham690f4612021-07-01 23:24:03 -0700803 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800804 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
805
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800806 auto& modes = mCreationArgs.supportedModes;
807 auto& activeModeId = mCreationArgs.activeModeId;
808
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800809 if (displayId && !mCreationArgs.refreshRateConfigs) {
810 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
811 if (modes.empty()) {
812 constexpr DisplayModeId kModeId{0};
813 DisplayModePtr mode =
814 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
815 .setId(kModeId)
816 .setPhysicalDisplayId(*physicalId)
817 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
818 .setVsyncPeriod(
819 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
820 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
821 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
822 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
823 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800824
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800825 modes = ftl::init::map(kModeId, std::move(mode));
826 activeModeId = kModeId;
827 }
828
829 mCreationArgs.refreshRateConfigs =
830 std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
831 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800832 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700833
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800834 DisplayDeviceState state;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800835 if (const auto type = mCreationArgs.connectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700836 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200837 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
838 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100839 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100840
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800841 const auto activeMode = modes.get(activeModeId);
842 LOG_ALWAYS_FATAL_IF(!activeMode);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800843
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100844 state.physical = {.id = *physicalId,
845 .type = *type,
846 .hwcDisplayId = *mHwcDisplayId,
847 .deviceProductInfo = {},
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800848 .supportedModes = modes,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800849 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800850 }
851
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700852 state.isSecure = mCreationArgs.isSecure;
853
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800854 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
855 if (!display->isVirtual()) {
856 display->setActiveMode(activeModeId);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100857 }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700858 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
859
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800860 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
861 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
862
Dominik Laskowski55c85402020-01-21 16:25:47 -0800863 if (const auto& physical = state.physical) {
Dominik Laskowskieb627312022-04-07 09:13:16 -0700864 mFlinger.mutablePhysicalDisplayTokens().emplace_or_replace(physical->id,
865 mDisplayToken);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800866 }
867
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800868 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800869 }
870
871 private:
872 TestableSurfaceFlinger& mFlinger;
873 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700874 DisplayDeviceCreationArgs mCreationArgs;
Peiyong Line9d809e2020-04-14 13:10:48 -0700875 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800876 };
877
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700878private:
Ady Abraham302ebed2022-03-07 16:03:41 -0800879 constexpr static int64_t kVsyncId = 123;
880
Lloyd Pique90c115d2018-09-18 21:39:42 -0700881 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800882 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800883 scheduler::mock::SchedulerCallback mSchedulerCallback;
884 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Dominik Laskowski068173d2021-08-11 17:22:59 -0700885 scheduler::TestableScheduler* mScheduler = nullptr;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800886};
887
888} // namespace android