blob: 29ff5ee183fa4de784e59e43f333345eb6639cf8 [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>
Dominik Laskowski08fbd852022-07-14 08:53:42 -070030#include <ftl/fake_guard.h>
chaviw0ef7caa2021-01-05 11:04:50 -080031#include <gui/ScreenCaptureResults.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070032
Lloyd Piquef58625d2017-12-19 13:22:33 -080033#include "DisplayDevice.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070034#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080035#include "FrameTracer/FrameTracer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070036#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070037#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070038#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070039#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070040#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080041#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070042#include "SurfaceFlingerDefaultFactory.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070043#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010044#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080045#include "mock/DisplayHardware/MockDisplayMode.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070046#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080047#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080048#include "mock/MockSchedulerCallback.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080049
Lloyd Piquef58625d2017-12-19 13:22:33 -080050namespace android {
51
Lloyd Piquee39cad22017-12-20 17:01:29 -080052class EventThread;
53
Peiyong Lin833074a2018-08-28 11:53:54 -070054namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070055
Lloyd Piquee39cad22017-12-20 17:01:29 -080056class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070057
58} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080059
60namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070061
Lloyd Piquee39cad22017-12-20 17:01:29 -080062class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070063
64} // namespace Hwc2
65
Peiyong Line9d809e2020-04-14 13:10:48 -070066namespace hal = android::hardware::graphics::composer::hal;
67
Lloyd Pique90c115d2018-09-18 21:39:42 -070068namespace surfaceflinger::test {
69
70class Factory final : public surfaceflinger::Factory {
71public:
72 ~Factory() = default;
73
Lloyd Pique90c115d2018-09-18 21:39:42 -070074 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070075 return nullptr;
76 }
77
Ady Abraham8287e852020-08-12 14:44:58 -070078 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010079 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080080 return std::make_unique<scheduler::FakePhaseOffsets>();
81 }
82
Lloyd Pique90c115d2018-09-18 21:39:42 -070083 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070084 return sp<StartPropertySetThread>::make(timestampPropertyValue);
Lloyd Pique90c115d2018-09-18 21:39:42 -070085 }
86
Lloyd Pique9370a482019-10-03 17:58:30 -070087 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070088 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070089 }
90
91 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
92 uint32_t layerCount, uint64_t usage,
93 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070094 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -070095 }
96
97 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
98 sp<IGraphicBufferConsumer>* outConsumer,
99 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700100 if (!mCreateBufferQueue) {
101 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
102 return;
103 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700104 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
105 }
106
107 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
108 const sp<IGraphicBufferProducer>& producer) override {
109 if (!mCreateNativeWindowSurface) return nullptr;
110 return mCreateNativeWindowSurface(producer);
111 }
112
Lloyd Pique70d91362018-10-18 16:02:55 -0700113 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
114 return compositionengine::impl::createCompositionEngine();
115 }
116
Patrick Williams83f36b22022-09-14 17:57:35 +0000117 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700118
Patrick Williams46b61b92022-09-01 17:25:49 +0000119 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700120
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800121 std::unique_ptr<FrameTracer> createFrameTracer() override {
122 return std::make_unique<mock::FrameTracer>();
123 }
124
Adithya Srinivasan01189672020-10-20 14:23:05 -0700125 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800126 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
127 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700128 }
129
Lloyd Pique90c115d2018-09-18 21:39:42 -0700130 using CreateBufferQueueFunction =
131 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
132 sp<IGraphicBufferConsumer>* /* outConsumer */,
133 bool /* consumerIsSurfaceFlinger */)>;
134 CreateBufferQueueFunction mCreateBufferQueue;
135
136 using CreateNativeWindowSurfaceFunction =
137 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
138 const sp<IGraphicBufferProducer>&)>;
139 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700140
141 using CreateCompositionEngineFunction =
142 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
143 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700144};
145
146} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800147
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800148class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800149public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700150 using HotplugEvent = SurfaceFlinger::HotplugEvent;
151
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800152 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
153 if (!mFlinger) {
154 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
155 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800156 }
157
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700158 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700159 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700160
Lloyd Piquef58625d2017-12-19 13:22:33 -0800161 // Extend this as needed for accessing SurfaceFlinger private (and public)
162 // functions.
163
Peiyong Lin833074a2018-08-28 11:53:54 -0700164 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700165 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800166 }
167
168 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700169 mFlinger->mCompositionEngine->setHwComposer(
170 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800171 }
172
Xiang Wang839fe5b2022-04-04 17:39:38 +0000173 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
174 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
175 }
176
Alec Mourie4034bb2019-11-19 12:45:54 -0800177 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
178 mFlinger->mCompositionEngine->setTimeStats(timeStats);
179 }
180
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800181 enum class SchedulerCallbackImpl { kNoOp, kMock };
182
183 static constexpr struct OneDisplayMode {
184 } kOneDisplayMode;
185
186 static constexpr struct TwoDisplayModes {
187 } kTwoDisplayModes;
188
189 using RefreshRateConfigsPtr = std::shared_ptr<scheduler::RefreshRateConfigs>;
190
191 using DisplayModesVariant =
192 std::variant<OneDisplayMode, TwoDisplayModes, RefreshRateConfigsPtr>;
193
Ady Abraham8cb21882020-08-26 18:22:05 -0700194 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
195 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700196 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800197 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800198 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800199 DisplayModesVariant modesVariant = kOneDisplayMode,
200 bool useNiceMock = false) {
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800201 RefreshRateConfigsPtr configs;
202 if (std::holds_alternative<RefreshRateConfigsPtr>(modesVariant)) {
203 configs = std::move(std::get<RefreshRateConfigsPtr>(modesVariant));
204 } else {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800205 constexpr DisplayModeId kModeId60{0};
206 DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
Ady Abrahamabc27602020-04-08 17:20:29 -0700207
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800208 if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800209 constexpr DisplayModeId kModeId90{1};
210 modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800211 }
212
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800213 configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700214 }
215
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700216 const auto fps = FTL_FAKE_GUARD(kMainThreadContext, configs->getActiveMode().getFps());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800217 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
Ady Abraham23ea9da2021-07-14 16:32:56 -0700218 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
219 mFlinger->mVsyncConfiguration->getCurrentConfigs());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800220
Marin Shalamanov68a94092020-11-24 17:48:00 +0100221 mFlinger->mRefreshRateStats =
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800222 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800223 hal::PowerMode::OFF);
224
225 using Callback = scheduler::ISchedulerCallback;
226 Callback& callback = callbackImpl == SchedulerCallbackImpl::kNoOp
227 ? static_cast<Callback&>(mNoOpSchedulerCallback)
228 : static_cast<Callback&>(mSchedulerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700229
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800230 if (useNiceMock) {
231 mScheduler =
232 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
233 std::move(vsyncTracker),
234 std::move(configs),
235 callback);
236 } else {
237 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
238 std::move(vsyncTracker),
239 std::move(configs), callback);
240 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700241
Dominik Laskowski98041832019-08-01 18:35:59 -0700242 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
243 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700244 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700245 }
246
Dominik Laskowski068173d2021-08-11 17:22:59 -0700247 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700248
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800249 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
250 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800251
Ady Abraham2739e832022-02-14 17:42:00 -0800252 auto& mutableVsyncModulator() { return mFlinger->mVsyncModulator; }
253
Lloyd Pique90c115d2018-09-18 21:39:42 -0700254 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800255 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700256 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800257 }
258
Lloyd Pique90c115d2018-09-18 21:39:42 -0700259 using CreateNativeWindowSurfaceFunction =
260 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800261 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700262 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800263 }
264
Daniel Solomon42d04562019-01-20 21:03:19 -0800265 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
266 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
267 }
268
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700269 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700270
Valerie Haud251afb2019-03-29 14:19:02 -0700271 auto& mutableStateLock() { return mFlinger->mStateLock; }
272
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700273 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
274 const sp<const DisplayDevice>& display) {
275 return layer->findOutputLayerForDisplay(display.get());
276 }
277
278 static void setLayerSidebandStream(const sp<Layer>& layer,
279 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800280 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800281 layer->mSidebandStream = sidebandStream;
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000282 layer->editLayerSnapshot()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700283 }
284
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500285 void setLayerCompositionType(const sp<Layer>& layer,
286 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700287 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800288 LOG_ALWAYS_FATAL_IF(!outputLayer);
289 auto& state = outputLayer->editState();
290 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700291 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700292 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800293
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700294 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700295 layer->mPotentialCursor = potentialCursor;
296 }
297
Garfield Tande619fa2020-10-02 17:13:53 -0700298 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000299 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700300 }
301
Matt Buckley50c44062022-01-17 20:48:10 +0000302 void setPowerHintSessionMode(bool early, bool late) {
303 mFlinger->mPowerHintSessionMode = {.late = late, .early = early};
304 }
305
Lloyd Piquef58625d2017-12-19 13:22:33 -0800306 /* ------------------------------------------------------------------------
307 * Forwarding for functions being tested
308 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000309
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700310 void configure() { mFlinger->configure(); }
311
312 void configureAndCommit() {
313 configure();
314 commitTransactionsLocked(eDisplayTransactionNeeded);
315 }
316
317 TimePoint commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
318 mFlinger->commit(frameTime, vsyncId, expectedVsyncTime);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000319 return frameTime;
320 }
321
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700322 TimePoint commit(TimePoint frameTime, VsyncId vsyncId) {
323 return commit(frameTime, vsyncId, frameTime + Period(10ms));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000324 }
325
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700326 TimePoint commit() {
327 const TimePoint frameTime = scheduler::SchedulerClock::now();
328 return commit(frameTime, kVsyncId);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000329 }
330
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700331 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
332 mFlinger->composite(commit(frameTime, vsyncId, expectedVsyncTime), vsyncId);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700333 }
334
Ady Abraham302ebed2022-03-07 16:03:41 -0800335 void commitAndComposite() { mFlinger->composite(commit(), kVsyncId); }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700336
Lloyd Piquea482f992018-01-22 19:00:34 -0800337 auto createDisplay(const String8& displayName, bool secure) {
338 return mFlinger->createDisplay(displayName, secure);
339 }
340
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700341 auto destroyDisplay(const sp<IBinder>& displayToken) {
342 return mFlinger->destroyDisplay(displayToken);
343 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800344
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100345 auto getDisplay(const sp<IBinder>& displayToken) {
346 Mutex::Autolock lock(mFlinger->mStateLock);
347 return mFlinger->getDisplayDeviceLocked(displayToken);
348 }
349
Dominik Laskowski13948602021-03-08 20:48:28 -0800350 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
351
Lloyd Pique9370a482019-10-03 17:58:30 -0700352 auto setupNewDisplayDeviceInternal(
353 const wp<IBinder>& displayToken,
354 std::shared_ptr<compositionengine::Display> compositionDisplay,
355 const DisplayDeviceState& state,
356 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700357 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700358 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
359 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800360 }
361
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700362 void commitTransactionsLocked(uint32_t transactionFlags) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700363 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700364 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700365 mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800366 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800367
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700368 void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
369 mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800370 }
371
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800372 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700373 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800374 return mFlinger->setDisplayStateLocked(s);
375 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800376
Dominik Laskowski83b88212018-12-11 13:34:06 -0800377 // Allow reading display state without locking, as if called on the SF main thread.
378 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
379 return mFlinger->onInitializeDisplays();
380 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800381
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100382 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
383
Alec Mouricdf16792021-12-10 13:16:06 -0800384 auto setDisplayBrightness(const sp<IBinder>& display,
385 const gui::DisplayBrightness& brightness) {
386 return mFlinger->setDisplayBrightness(display, brightness);
387 }
388
Dominik Laskowski83b88212018-12-11 13:34:06 -0800389 // Allow reading display state without locking, as if called on the SF main thread.
390 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700391 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800392 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800393 }
394
Robert Carr12a3b9b2022-03-10 09:55:29 -0800395 auto renderScreenImpl(const RenderArea& renderArea,
chaviw426b5c02020-07-27 11:20:15 -0700396 SurfaceFlinger::TraverseLayersFunction traverseLayers,
Alec Mouria90a5702021-04-16 16:36:21 +0000397 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
398 bool forSystem, bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700399 ScreenCaptureResults captureResults;
Robert Carr12a3b9b2022-03-10 09:55:29 -0800400 return mFlinger->renderScreenImpl(renderArea, traverseLayers, buffer, forSystem,
chaviw17ac24b2021-01-28 18:50:05 -0800401 regionSampling, false /* grayscale */,
402 captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700403 }
404
chaviw4b9d5e12020-08-04 18:30:35 -0700405 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200406 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700407 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700408 }
409
Daniel Solomon42d04562019-01-20 21:03:19 -0800410 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
411 ui::DisplayPrimaries &primaries) {
412 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
413 }
414
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700415 auto& getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
416 auto& getPendingTransactionQueue() {
417 return mFlinger->mTransactionHandler.mPendingTransactionQueues;
418 }
419 size_t getPendingTransactionCount() {
420 return mFlinger->mTransactionHandler.mPendingTransactionCount.load();
421 }
Valerie Haud251afb2019-03-29 14:19:02 -0700422
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000423 auto setTransactionState(
424 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
425 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
426 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
427 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
428 std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
429 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
430 inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800431 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
432 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700433 }
434
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700435 auto flushTransactionQueues() {
436 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues(kVsyncId));
437 }
Valerie Haud251afb2019-03-29 14:19:02 -0700438
Eduardo Rochaac867192020-09-14 20:12:17 +0000439 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
440 return mFlinger->onTransact(code, data, reply, flags);
441 }
442
Huihong Luo02186fb2022-02-23 14:21:54 -0800443 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800444
Ady Abraham899dcdb2021-06-15 16:56:21 -0700445 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
446 std::chrono::nanoseconds presentLatency) const {
447 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800448 }
449
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100450 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode,
451 bool allowGroupSwitching, float primaryRefreshRateMin,
452 float primaryRefreshRateMax, float appRequestRefreshRateMin,
453 float appRequestRefreshRateMax) {
454 return mFlinger->setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,
455 primaryRefreshRateMin, primaryRefreshRateMax,
456 appRequestRefreshRateMin,
457 appRequestRefreshRateMax);
458 }
459
460 void onActiveDisplayChanged(const sp<DisplayDevice>& activeDisplay) {
461 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700462 ftl::FakeGuard guard(kMainThreadContext);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100463 mFlinger->onActiveDisplayChangedLocked(activeDisplay);
464 }
465
Patrick Williamsa361de62022-10-06 20:34:10 +0000466 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle,
467 gui::CreateSurfaceResult& outResult) {
468 return mFlinger->createLayer(args, parentHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800469 }
470
471 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000472 gui::CreateSurfaceResult& outResult) {
473 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800474 }
475
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000476 void updateLayerMetadataSnapshot() { mFlinger->updateLayerMetadataSnapshot(); }
477
Lloyd Pique86016da2018-03-01 16:09:38 -0800478 /* ------------------------------------------------------------------------
479 * Read-only access to private data to assert post-conditions.
480 */
481
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800482 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700483 auto& getHwComposer() const {
484 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
485 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700486 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800487
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000488 mock::FrameTracer* getFrameTracer() const {
489 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
490 }
491
Lloyd Piquef58625d2017-12-19 13:22:33 -0800492 /* ------------------------------------------------------------------------
493 * Read-write access to private data to set up preconditions and assert
494 * post-conditions.
495 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800496
Dominik Laskowskieb627312022-04-07 09:13:16 -0700497 const auto& displays() const { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700498 const auto& physicalDisplays() const { return mFlinger->mPhysicalDisplays; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700499 const auto& currentState() const { return mFlinger->mCurrentState; }
500 const auto& drawingState() const { return mFlinger->mDrawingState; }
501 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700502
Dominik Laskowskieb627312022-04-07 09:13:16 -0700503 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700504 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700505
Dominik Laskowski788945b2022-08-30 12:10:56 -0700506 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800507
Lloyd Piquee39cad22017-12-20 17:01:29 -0800508 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800509 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700510 auto& mutableDisplays() { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700511 auto& mutablePhysicalDisplays() { return mFlinger->mPhysicalDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800512 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700513 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800514 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800515 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700516 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800517 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700518 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700519 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800520
Lloyd Pique441d5042018-10-18 16:49:51 -0700521 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
522 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700523 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Dominik Laskowskie591b552022-09-09 10:44:56 -0700524 auto& mutableActiveDisplayId() { return mFlinger->mActiveDisplayId; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800525
Valerie Hau09e60052019-12-15 14:51:15 -0800526 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800527 return mFlinger->fromHandle(handle);
528 }
529
Lloyd Piquee39cad22017-12-20 17:01:29 -0800530 ~TestableSurfaceFlinger() {
531 // All these pointer and container clears help ensure that GMock does
532 // not report a leaked object, since the SurfaceFlinger instance may
533 // still be referenced by something despite our best efforts to destroy
534 // it after each test is done.
535 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800536 mutableCurrentState().displays.clear();
537 mutableDrawingState().displays.clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700538 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700539 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700540 mFlinger->mCompositionEngine->setRenderEngine(
541 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800542 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800543
Lloyd Piquea618d852018-01-17 11:52:30 -0800544 /* ------------------------------------------------------------------------
545 * Wrapper classes for Read-write access to private data to set up
546 * preconditions and assert post-conditions.
547 */
Ana Krulec4593b692019-01-11 22:07:25 -0800548 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800549 HWC2Display(
550 Hwc2::Composer& composer,
551 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
552 capabilities,
553 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800554 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800555 ~HWC2Display() {
556 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700557 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800558 }
559
560 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700561 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800562 };
563
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800564 class FakeHwcDisplayInjector {
565 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700566 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800567 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100568 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800569 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800570 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700571 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700572 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800573
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200574 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
575 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700576 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800577
Peiyong Line9d809e2020-04-14 13:10:48 -0700578 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800579 mHwcDisplayId = displayId;
580 return *this;
581 }
582
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800583 auto& setResolution(ui::Size resolution) {
584 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800585 return *this;
586 }
587
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800588 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100589 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800590 return *this;
591 }
592
593 auto& setDpiX(int32_t dpi) {
594 mDpiX = dpi;
595 return *this;
596 }
597
598 auto& setDpiY(int32_t dpi) {
599 mDpiY = dpi;
600 return *this;
601 }
602
Peiyong Line9d809e2020-04-14 13:10:48 -0700603 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800604 mActiveConfig = config;
605 return *this;
606 }
607
Ady Abrahamde549d42022-01-26 19:19:17 -0800608 auto& setCapabilities(
609 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
610 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700611 mCapabilities = capabilities;
612 return *this;
613 }
614
Peiyong Lin65248e02020-04-18 21:15:07 -0700615 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700616 mPowerMode = mode;
617 return *this;
618 }
619
Marin Shalamanov045b7002021-01-07 16:56:24 +0100620 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
621 using ::testing::_;
622 using ::testing::DoAll;
623 using ::testing::Return;
624 using ::testing::SetArgPointee;
625
Ady Abrahamde549d42022-01-26 19:19:17 -0800626 static const std::unordered_set<
627 aidl::android::hardware::graphics::composer3::Capability>
628 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700629 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
630
631 // Caution - Make sure that any values passed by reference here do
632 // not refer to an instance owned by FakeHwcDisplayInjector. This
633 // class has temporary lifetime, while the constructed HWC2::Display
634 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800635 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
636 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800637
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800638 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700639 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800640 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700641
Marin Shalamanov045b7002021-01-07 16:56:24 +0100642 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
643 .WillRepeatedly(
644 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
645 Return(hal::Error::NONE)));
646
647 EXPECT_CALL(*composer,
648 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800649 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
650 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100651
652 EXPECT_CALL(*composer,
653 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
654 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800655 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
656 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100657
658 EXPECT_CALL(*composer,
659 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
660 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800661 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
662 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100663
664 EXPECT_CALL(*composer,
665 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
666 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
667
668 EXPECT_CALL(*composer,
669 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
670 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
671
672 EXPECT_CALL(*composer,
673 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
674 hal::Attribute::CONFIG_GROUP, _))
675 .WillRepeatedly(
676 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100677
Peiyong Line9d809e2020-04-14 13:10:48 -0700678 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200679 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
680 LOG_ALWAYS_FATAL_IF(!physicalId);
681 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100682 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700683 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100684 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700685 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100686 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700687 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
688 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100689 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700690 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800691 }
692
693 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200694 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700695 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700696 const bool mIsPrimary;
697
Peiyong Line9d809e2020-04-14 13:10:48 -0700698 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800699 ui::Size mResolution = DEFAULT_RESOLUTION;
700 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800701 int32_t mDpiX = DEFAULT_DPI;
702 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100703 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700704 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700705 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800706 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
707 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800708 };
709
710 class FakeDisplayDeviceInjector {
711 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700712 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800713 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100714 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700715 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700716 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700717 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
718 display),
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700719 mConnectionType(connectionType),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100720 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700721 mCreationArgs.isPrimary = isPrimary;
linpeter1c69cd32022-07-13 19:20:48 +0800722 mCreationArgs.initialPowerMode = hal::PowerMode::ON;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700723 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800724
725 sp<IBinder> token() const { return mDisplayToken; }
726
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700727 auto physicalDisplay() const {
728 return ftl::Optional(mCreationArgs.compositionDisplay->getDisplayId())
729 .and_then(&PhysicalDisplayId::tryCast)
730 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays()));
731 }
732
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800733 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) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700760 mDisplayModes = std::move(modes);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800761 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 Laskowskib363c4c2022-08-02 14:03:41 -0700806 auto& modes = mDisplayModes;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800807 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
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700834 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
835 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
ramindani69b58e82022-09-26 16:48:36 -0700836 if (mFlinger.scheduler()) {
837 mFlinger.scheduler()->registerDisplay(display);
838 }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700839
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800840 DisplayDeviceState state;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700841 state.isSecure = mCreationArgs.isSecure;
842
843 if (mConnectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700844 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200845 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
846 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100847 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100848
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800849 const auto activeMode = modes.get(activeModeId);
850 LOG_ALWAYS_FATAL_IF(!activeMode);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800851
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100852 state.physical = {.id = *physicalId,
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100853 .hwcDisplayId = *mHwcDisplayId,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800854 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800855
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700856 const auto it = mFlinger.mutablePhysicalDisplays()
857 .emplace_or_replace(*physicalId, mDisplayToken, *physicalId,
858 *mConnectionType, std::move(modes),
Dominik Laskowski788945b2022-08-30 12:10:56 -0700859 ui::ColorModes(), std::nullopt)
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700860 .first;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700861
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700862 display->setActiveMode(activeModeId, it->second.snapshot());
Marin Shalamanov045b7002021-01-07 16:56:24 +0100863 }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700864
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800865 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
866 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
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;
Ady Abrahamd11bade2022-08-01 16:18:03 -0700873 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700874 DisplayDeviceCreationArgs mCreationArgs;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700875 DisplayModes mDisplayModes;
876 const std::optional<ui::DisplayConnectionType> mConnectionType;
Peiyong Line9d809e2020-04-14 13:10:48 -0700877 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800878 };
879
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700880private:
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700881 static constexpr VsyncId kVsyncId{123};
Ady Abraham302ebed2022-03-07 16:03:41 -0800882
Lloyd Pique90c115d2018-09-18 21:39:42 -0700883 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800884 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800885 scheduler::mock::SchedulerCallback mSchedulerCallback;
886 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Dominik Laskowski068173d2021-08-11 17:22:59 -0700887 scheduler::TestableScheduler* mScheduler = nullptr;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800888};
889
890} // namespace android