blob: 46eca69c6a6939335fb8ec0c8c65b2230b8bc57f [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"
Vishnu Naircb8be502022-10-12 19:03:23 +000036#include "FrontEnd/LayerCreationArgs.h"
Vishnu Nair07e2a482022-10-18 19:18:16 +000037#include "FrontEnd/LayerHandle.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"
Dominik Laskowskid82e0f02022-10-26 15:23:04 -040041#include "Scheduler/RefreshRateSelector.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"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070045#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010046#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080047#include "mock/DisplayHardware/MockDisplayMode.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070048#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080049#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080050#include "mock/MockSchedulerCallback.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080051
Lloyd Piquef58625d2017-12-19 13:22:33 -080052namespace android {
53
Lloyd Piquee39cad22017-12-20 17:01:29 -080054class EventThread;
55
Peiyong Lin833074a2018-08-28 11:53:54 -070056namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070057
Lloyd Piquee39cad22017-12-20 17:01:29 -080058class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070059
60} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080061
62namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070063
Lloyd Piquee39cad22017-12-20 17:01:29 -080064class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070065
66} // namespace Hwc2
67
Peiyong Line9d809e2020-04-14 13:10:48 -070068namespace hal = android::hardware::graphics::composer::hal;
69
Lloyd Pique90c115d2018-09-18 21:39:42 -070070namespace surfaceflinger::test {
71
72class Factory final : public surfaceflinger::Factory {
73public:
74 ~Factory() = default;
75
Lloyd Pique90c115d2018-09-18 21:39:42 -070076 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070077 return nullptr;
78 }
79
Ady Abraham8287e852020-08-12 14:44:58 -070080 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010081 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080082 return std::make_unique<scheduler::FakePhaseOffsets>();
83 }
84
Lloyd Pique90c115d2018-09-18 21:39:42 -070085 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070086 return sp<StartPropertySetThread>::make(timestampPropertyValue);
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 }
88
Lloyd Pique9370a482019-10-03 17:58:30 -070089 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070090 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 }
92
93 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
94 uint32_t layerCount, uint64_t usage,
95 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070096 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -070097 }
98
99 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
100 sp<IGraphicBufferConsumer>* outConsumer,
101 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700102 if (!mCreateBufferQueue) {
103 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
104 return;
105 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700106 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
107 }
108
109 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
110 const sp<IGraphicBufferProducer>& producer) override {
111 if (!mCreateNativeWindowSurface) return nullptr;
112 return mCreateNativeWindowSurface(producer);
113 }
114
Lloyd Pique70d91362018-10-18 16:02:55 -0700115 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
116 return compositionengine::impl::createCompositionEngine();
117 }
118
Patrick Williams83f36b22022-09-14 17:57:35 +0000119 sp<Layer> createBufferStateLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700120
Patrick Williams46b61b92022-09-01 17:25:49 +0000121 sp<Layer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700122
Vishnu Naire14c6b32022-08-06 04:20:15 +0000123 sp<LayerFE> createLayerFE(const std::string& layerName) override {
124 return sp<LayerFE>::make(layerName);
125 }
126
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800127 std::unique_ptr<FrameTracer> createFrameTracer() override {
128 return std::make_unique<mock::FrameTracer>();
129 }
130
Adithya Srinivasan01189672020-10-20 14:23:05 -0700131 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800132 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
133 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700134 }
135
Lloyd Pique90c115d2018-09-18 21:39:42 -0700136 using CreateBufferQueueFunction =
137 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
138 sp<IGraphicBufferConsumer>* /* outConsumer */,
139 bool /* consumerIsSurfaceFlinger */)>;
140 CreateBufferQueueFunction mCreateBufferQueue;
141
142 using CreateNativeWindowSurfaceFunction =
143 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
144 const sp<IGraphicBufferProducer>&)>;
145 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700146
147 using CreateCompositionEngineFunction =
148 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
149 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700150};
151
152} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800153
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800154class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800155public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700156 using HotplugEvent = SurfaceFlinger::HotplugEvent;
157
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800158 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
159 if (!mFlinger) {
160 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
161 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800162 }
163
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700164 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700165 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700166
Lloyd Piquef58625d2017-12-19 13:22:33 -0800167 // Extend this as needed for accessing SurfaceFlinger private (and public)
168 // functions.
169
Peiyong Lin833074a2018-08-28 11:53:54 -0700170 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Patrick Williams0a525a42022-10-26 20:20:50 +0000171 mFlinger->mRenderEngine = std::move(renderEngine);
172 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800173 }
174
175 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700176 mFlinger->mCompositionEngine->setHwComposer(
177 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800178 }
179
Xiang Wang839fe5b2022-04-04 17:39:38 +0000180 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
181 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
182 }
183
Alec Mourie4034bb2019-11-19 12:45:54 -0800184 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
185 mFlinger->mCompositionEngine->setTimeStats(timeStats);
186 }
187
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800188 enum class SchedulerCallbackImpl { kNoOp, kMock };
189
190 static constexpr struct OneDisplayMode {
191 } kOneDisplayMode;
192
193 static constexpr struct TwoDisplayModes {
194 } kTwoDisplayModes;
195
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400196 using RefreshRateSelectorPtr = std::shared_ptr<scheduler::RefreshRateSelector>;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800197
198 using DisplayModesVariant =
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400199 std::variant<OneDisplayMode, TwoDisplayModes, RefreshRateSelectorPtr>;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800200
Ady Abraham8cb21882020-08-26 18:22:05 -0700201 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
202 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700203 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800204 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800205 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800206 DisplayModesVariant modesVariant = kOneDisplayMode,
207 bool useNiceMock = false) {
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400208 RefreshRateSelectorPtr selectorPtr;
209 if (std::holds_alternative<RefreshRateSelectorPtr>(modesVariant)) {
210 selectorPtr = std::move(std::get<RefreshRateSelectorPtr>(modesVariant));
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800211 } else {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800212 constexpr DisplayModeId kModeId60{0};
213 DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
Ady Abrahamabc27602020-04-08 17:20:29 -0700214
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800215 if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800216 constexpr DisplayModeId kModeId90{1};
217 modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800218 }
219
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400220 selectorPtr = std::make_shared<scheduler::RefreshRateSelector>(modes, kModeId60);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700221 }
222
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400223 const auto fps = FTL_FAKE_GUARD(kMainThreadContext, selectorPtr->getActiveMode().getFps());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800224 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
Ady Abraham23ea9da2021-07-14 16:32:56 -0700225 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
226 mFlinger->mVsyncConfiguration->getCurrentConfigs());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800227
Marin Shalamanov68a94092020-11-24 17:48:00 +0100228 mFlinger->mRefreshRateStats =
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800229 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800230 hal::PowerMode::OFF);
231
232 using Callback = scheduler::ISchedulerCallback;
233 Callback& callback = callbackImpl == SchedulerCallbackImpl::kNoOp
234 ? static_cast<Callback&>(mNoOpSchedulerCallback)
235 : static_cast<Callback&>(mSchedulerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700236
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800237 if (useNiceMock) {
238 mScheduler =
239 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
240 std::move(vsyncTracker),
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400241 std::move(selectorPtr),
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800242 callback);
243 } else {
244 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
245 std::move(vsyncTracker),
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400246 std::move(selectorPtr), callback);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800247 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700248
Dominik Laskowski98041832019-08-01 18:35:59 -0700249 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
250 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700251 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700252 }
253
Dominik Laskowski068173d2021-08-11 17:22:59 -0700254 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700255
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800256 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
257 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800258
Ady Abraham2739e832022-02-14 17:42:00 -0800259 auto& mutableVsyncModulator() { return mFlinger->mVsyncModulator; }
260
Lloyd Pique90c115d2018-09-18 21:39:42 -0700261 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800262 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700263 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800264 }
265
Lloyd Pique90c115d2018-09-18 21:39:42 -0700266 using CreateNativeWindowSurfaceFunction =
267 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800268 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700269 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800270 }
271
Daniel Solomon42d04562019-01-20 21:03:19 -0800272 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
273 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
274 }
275
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700276 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700277
Valerie Haud251afb2019-03-29 14:19:02 -0700278 auto& mutableStateLock() { return mFlinger->mStateLock; }
279
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700280 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
281 const sp<const DisplayDevice>& display) {
282 return layer->findOutputLayerForDisplay(display.get());
283 }
284
285 static void setLayerSidebandStream(const sp<Layer>& layer,
286 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800287 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800288 layer->mSidebandStream = sidebandStream;
Vishnu Nairbedb44b2022-08-02 21:47:40 +0000289 layer->editLayerSnapshot()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700290 }
291
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500292 void setLayerCompositionType(const sp<Layer>& layer,
293 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700294 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800295 LOG_ALWAYS_FATAL_IF(!outputLayer);
296 auto& state = outputLayer->editState();
297 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700298 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700299 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800300
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700301 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700302 layer->mPotentialCursor = potentialCursor;
303 }
304
Garfield Tande619fa2020-10-02 17:13:53 -0700305 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000306 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700307 }
308
Matt Buckley50c44062022-01-17 20:48:10 +0000309 void setPowerHintSessionMode(bool early, bool late) {
310 mFlinger->mPowerHintSessionMode = {.late = late, .early = early};
311 }
312
Lloyd Piquef58625d2017-12-19 13:22:33 -0800313 /* ------------------------------------------------------------------------
314 * Forwarding for functions being tested
315 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000316
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700317 void configure() { mFlinger->configure(); }
318
319 void configureAndCommit() {
320 configure();
321 commitTransactionsLocked(eDisplayTransactionNeeded);
322 }
323
324 TimePoint commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
325 mFlinger->commit(frameTime, vsyncId, expectedVsyncTime);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000326 return frameTime;
327 }
328
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700329 TimePoint commit(TimePoint frameTime, VsyncId vsyncId) {
330 return commit(frameTime, vsyncId, frameTime + Period(10ms));
Xiang Wang839fe5b2022-04-04 17:39:38 +0000331 }
332
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700333 TimePoint commit() {
334 const TimePoint frameTime = scheduler::SchedulerClock::now();
335 return commit(frameTime, kVsyncId);
Xiang Wang839fe5b2022-04-04 17:39:38 +0000336 }
337
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700338 void commitAndComposite(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime) {
339 mFlinger->composite(commit(frameTime, vsyncId, expectedVsyncTime), vsyncId);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700340 }
341
Ady Abraham302ebed2022-03-07 16:03:41 -0800342 void commitAndComposite() { mFlinger->composite(commit(), kVsyncId); }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700343
Lloyd Piquea482f992018-01-22 19:00:34 -0800344 auto createDisplay(const String8& displayName, bool secure) {
345 return mFlinger->createDisplay(displayName, secure);
346 }
347
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700348 auto destroyDisplay(const sp<IBinder>& displayToken) {
349 return mFlinger->destroyDisplay(displayToken);
350 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800351
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100352 auto getDisplay(const sp<IBinder>& displayToken) {
353 Mutex::Autolock lock(mFlinger->mStateLock);
354 return mFlinger->getDisplayDeviceLocked(displayToken);
355 }
356
Dominik Laskowski13948602021-03-08 20:48:28 -0800357 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
358
Lloyd Pique9370a482019-10-03 17:58:30 -0700359 auto setupNewDisplayDeviceInternal(
360 const wp<IBinder>& displayToken,
361 std::shared_ptr<compositionengine::Display> compositionDisplay,
362 const DisplayDeviceState& state,
363 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700364 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700365 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
366 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800367 }
368
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700369 void commitTransactionsLocked(uint32_t transactionFlags) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700370 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700371 ftl::FakeGuard guard(kMainThreadContext);
Dominik Laskowskif11728a2022-07-28 13:07:42 -0700372 mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800373 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800374
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700375 void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
376 mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800377 }
378
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800379 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700380 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800381 return mFlinger->setDisplayStateLocked(s);
382 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800383
Dominik Laskowski83b88212018-12-11 13:34:06 -0800384 // Allow reading display state without locking, as if called on the SF main thread.
385 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
386 return mFlinger->onInitializeDisplays();
387 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800388
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100389 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
390
Alec Mouricdf16792021-12-10 13:16:06 -0800391 auto setDisplayBrightness(const sp<IBinder>& display,
392 const gui::DisplayBrightness& brightness) {
393 return mFlinger->setDisplayBrightness(display, brightness);
394 }
395
Dominik Laskowski83b88212018-12-11 13:34:06 -0800396 // Allow reading display state without locking, as if called on the SF main thread.
397 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700398 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800399 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800400 }
401
Robert Carr12a3b9b2022-03-10 09:55:29 -0800402 auto renderScreenImpl(const RenderArea& renderArea,
chaviw426b5c02020-07-27 11:20:15 -0700403 SurfaceFlinger::TraverseLayersFunction traverseLayers,
Alec Mouria90a5702021-04-16 16:36:21 +0000404 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
405 bool forSystem, bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700406 ScreenCaptureResults captureResults;
Patrick Williams377c0142022-10-13 17:33:38 +0000407 return FTL_FAKE_GUARD(kMainThreadContext,
408 mFlinger->renderScreenImpl(renderArea, traverseLayers, buffer,
409 forSystem, regionSampling,
410 false /* grayscale */, captureResults));
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700411 }
412
chaviw4b9d5e12020-08-04 18:30:35 -0700413 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200414 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700415 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700416 }
417
Daniel Solomon42d04562019-01-20 21:03:19 -0800418 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
419 ui::DisplayPrimaries &primaries) {
420 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
421 }
422
Vishnu Nair59f6d2d2022-10-05 16:59:56 -0700423 auto& getTransactionQueue() { return mFlinger->mTransactionHandler.mLocklessTransactionQueue; }
424 auto& getPendingTransactionQueue() {
425 return mFlinger->mTransactionHandler.mPendingTransactionQueues;
426 }
427 size_t getPendingTransactionCount() {
428 return mFlinger->mTransactionHandler.mPendingTransactionCount.load();
429 }
Valerie Haud251afb2019-03-29 14:19:02 -0700430
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000431 auto setTransactionState(
432 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
433 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
434 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
435 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
436 std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
437 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
438 inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800439 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
440 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700441 }
442
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700443 auto flushTransactionQueues() {
444 return FTL_FAKE_GUARD(kMainThreadContext, mFlinger->flushTransactionQueues(kVsyncId));
445 }
Valerie Haud251afb2019-03-29 14:19:02 -0700446
Eduardo Rochaac867192020-09-14 20:12:17 +0000447 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
448 return mFlinger->onTransact(code, data, reply, flags);
449 }
450
Huihong Luo02186fb2022-02-23 14:21:54 -0800451 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800452
Ady Abraham899dcdb2021-06-15 16:56:21 -0700453 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
454 std::chrono::nanoseconds presentLatency) const {
455 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800456 }
457
Ady Abraham285f8c12022-10-11 17:12:14 -0700458 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
459 const gui::DisplayModeSpecs& specs) {
460 return mFlinger->setDesiredDisplayModeSpecs(displayToken, specs);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100461 }
462
463 void onActiveDisplayChanged(const sp<DisplayDevice>& activeDisplay) {
464 Mutex::Autolock lock(mFlinger->mStateLock);
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700465 ftl::FakeGuard guard(kMainThreadContext);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100466 mFlinger->onActiveDisplayChangedLocked(activeDisplay);
467 }
468
Patrick Williamsa361de62022-10-06 20:34:10 +0000469 auto createLayer(LayerCreationArgs& args, const sp<IBinder>& parentHandle,
470 gui::CreateSurfaceResult& outResult) {
Vishnu Naircb8be502022-10-12 19:03:23 +0000471 args.parentHandle = parentHandle;
472 return mFlinger->createLayer(args, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800473 }
474
475 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
Patrick Williamsa361de62022-10-06 20:34:10 +0000476 gui::CreateSurfaceResult& outResult) {
477 return mFlinger->mirrorLayer(args, mirrorFromHandle, outResult);
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800478 }
479
Vishnu Nair0a4fb002022-08-08 02:40:42 +0000480 void updateLayerMetadataSnapshot() { mFlinger->updateLayerMetadataSnapshot(); }
481
Lloyd Pique86016da2018-03-01 16:09:38 -0800482 /* ------------------------------------------------------------------------
483 * Read-only access to private data to assert post-conditions.
484 */
485
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
Lloyd Piquef58625d2017-12-19 13:22:33 -0800496 /* ------------------------------------------------------------------------
497 * Read-write access to private data to set up preconditions and assert
498 * post-conditions.
499 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800500
Dominik Laskowskieb627312022-04-07 09:13:16 -0700501 const auto& displays() const { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700502 const auto& physicalDisplays() const { return mFlinger->mPhysicalDisplays; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700503 const auto& currentState() const { return mFlinger->mCurrentState; }
504 const auto& drawingState() const { return mFlinger->mDrawingState; }
505 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700506
Dominik Laskowskieb627312022-04-07 09:13:16 -0700507 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskibab51282022-08-12 09:28:55 -0700508 const auto& hwcDisplayData() const { return getHwComposer().mDisplayData; }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700509
Dominik Laskowski788945b2022-08-30 12:10:56 -0700510 auto& mutableSupportsWideColor() { return mFlinger->mSupportsWideColor; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800511
Lloyd Piquee39cad22017-12-20 17:01:29 -0800512 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800513 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700514 auto& mutableDisplays() { return mFlinger->mDisplays; }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700515 auto& mutablePhysicalDisplays() { return mFlinger->mPhysicalDisplays; }
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 Pique6cf11032018-01-22 18:57:44 -0800518 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800519 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700520 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800521 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700522 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700523 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800524
Lloyd Pique441d5042018-10-18 16:49:51 -0700525 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
526 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700527 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Dominik Laskowskie591b552022-09-09 10:44:56 -0700528 auto& mutableActiveDisplayId() { return mFlinger->mActiveDisplayId; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800529
Vishnu Nair07e2a482022-10-18 19:18:16 +0000530 auto fromHandle(const sp<IBinder>& handle) { return LayerHandle::getLayer(handle); }
Valerie Hau09e60052019-12-15 14:51:15 -0800531
Lloyd Piquee39cad22017-12-20 17:01:29 -0800532 ~TestableSurfaceFlinger() {
533 // All these pointer and container clears help ensure that GMock does
534 // not report a leaked object, since the SurfaceFlinger instance may
535 // still be referenced by something despite our best efforts to destroy
536 // it after each test is done.
537 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800538 mutableCurrentState().displays.clear();
539 mutableDrawingState().displays.clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700540 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700541 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Patrick Williams0a525a42022-10-26 20:20:50 +0000542 mFlinger->mRenderEngine = std::unique_ptr<renderengine::RenderEngine>();
543 mFlinger->mCompositionEngine->setRenderEngine(mFlinger->mRenderEngine.get());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800544 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800545
Lloyd Piquea618d852018-01-17 11:52:30 -0800546 /* ------------------------------------------------------------------------
547 * Wrapper classes for Read-write access to private data to set up
548 * preconditions and assert post-conditions.
549 */
Ana Krulec4593b692019-01-11 22:07:25 -0800550 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800551 HWC2Display(
552 Hwc2::Composer& composer,
553 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
554 capabilities,
555 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800556 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800557 ~HWC2Display() {
558 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700559 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800560 }
561
562 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700563 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800564 };
565
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800566 class FakeHwcDisplayInjector {
567 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700568 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800569 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100570 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800571 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800572 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700573 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700574 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800575
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200576 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
577 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700578 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800579
Peiyong Line9d809e2020-04-14 13:10:48 -0700580 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800581 mHwcDisplayId = displayId;
582 return *this;
583 }
584
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800585 auto& setResolution(ui::Size resolution) {
586 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800587 return *this;
588 }
589
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800590 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100591 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800592 return *this;
593 }
594
595 auto& setDpiX(int32_t dpi) {
596 mDpiX = dpi;
597 return *this;
598 }
599
600 auto& setDpiY(int32_t dpi) {
601 mDpiY = dpi;
602 return *this;
603 }
604
Peiyong Line9d809e2020-04-14 13:10:48 -0700605 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800606 mActiveConfig = config;
607 return *this;
608 }
609
Ady Abrahamde549d42022-01-26 19:19:17 -0800610 auto& setCapabilities(
611 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
612 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700613 mCapabilities = capabilities;
614 return *this;
615 }
616
Peiyong Lin65248e02020-04-18 21:15:07 -0700617 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700618 mPowerMode = mode;
619 return *this;
620 }
621
Marin Shalamanov045b7002021-01-07 16:56:24 +0100622 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
623 using ::testing::_;
624 using ::testing::DoAll;
625 using ::testing::Return;
626 using ::testing::SetArgPointee;
627
Ady Abrahamde549d42022-01-26 19:19:17 -0800628 static const std::unordered_set<
629 aidl::android::hardware::graphics::composer3::Capability>
630 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700631 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
632
633 // Caution - Make sure that any values passed by reference here do
634 // not refer to an instance owned by FakeHwcDisplayInjector. This
635 // class has temporary lifetime, while the constructed HWC2::Display
636 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800637 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
638 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800639
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800640 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700641 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800642 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700643
Marin Shalamanov045b7002021-01-07 16:56:24 +0100644 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
645 .WillRepeatedly(
646 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
647 Return(hal::Error::NONE)));
648
649 EXPECT_CALL(*composer,
650 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800651 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
652 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100653
654 EXPECT_CALL(*composer,
655 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
656 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800657 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
658 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100659
660 EXPECT_CALL(*composer,
661 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
662 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800663 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
664 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100665
666 EXPECT_CALL(*composer,
667 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
668 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
669
670 EXPECT_CALL(*composer,
671 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
672 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
673
674 EXPECT_CALL(*composer,
675 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
676 hal::Attribute::CONFIG_GROUP, _))
677 .WillRepeatedly(
678 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100679
Peiyong Line9d809e2020-04-14 13:10:48 -0700680 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200681 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
682 LOG_ALWAYS_FATAL_IF(!physicalId);
683 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100684 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700685 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100686 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700687 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100688 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700689 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
690 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100691 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700692 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800693 }
694
695 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200696 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700697 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700698 const bool mIsPrimary;
699
Peiyong Line9d809e2020-04-14 13:10:48 -0700700 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800701 ui::Size mResolution = DEFAULT_RESOLUTION;
702 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800703 int32_t mDpiX = DEFAULT_DPI;
704 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100705 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700706 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700707 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800708 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
709 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800710 };
711
712 class FakeDisplayDeviceInjector {
713 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700714 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800715 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100716 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700717 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700718 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700719 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
720 display),
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700721 mConnectionType(connectionType),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100722 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski075d3172018-05-24 15:50:06 -0700723 mCreationArgs.isPrimary = isPrimary;
linpeter1c69cd32022-07-13 19:20:48 +0800724 mCreationArgs.initialPowerMode = hal::PowerMode::ON;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700725 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800726
727 sp<IBinder> token() const { return mDisplayToken; }
728
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700729 auto physicalDisplay() const {
730 return ftl::Optional(mCreationArgs.compositionDisplay->getDisplayId())
731 .and_then(&PhysicalDisplayId::tryCast)
732 .and_then(display::getPhysicalDisplay(mFlinger.physicalDisplays()));
733 }
734
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800735 DisplayDeviceState& mutableDrawingDisplayState() {
736 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
737 }
738
739 DisplayDeviceState& mutableCurrentDisplayState() {
740 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
741 }
742
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800743 const auto& getDrawingDisplayState() {
744 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
745 }
746
747 const auto& getCurrentDisplayState() {
748 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
749 }
750
Dominik Laskowskieb627312022-04-07 09:13:16 -0700751 const sp<DisplayDevice>& mutableDisplayDevice() {
752 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
753 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800754
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400755 // If `selectorPtr` is nullptr, the injector creates RefreshRateSelector from the `modes`.
756 // Otherwise, it uses `selectorPtr`, which the caller must create using the same `modes`.
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800757 //
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400758 // TODO(b/182939859): Once `modes` can be retrieved from RefreshRateSelector, remove
759 // the `selectorPtr` parameter in favor of an alternative setRefreshRateSelector API.
760 auto& setDisplayModes(
761 DisplayModes modes, DisplayModeId activeModeId,
762 std::shared_ptr<scheduler::RefreshRateSelector> selectorPtr = nullptr) {
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700763 mDisplayModes = std::move(modes);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800764 mCreationArgs.activeModeId = activeModeId;
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400765 mCreationArgs.refreshRateSelector = std::move(selectorPtr);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100766 return *this;
767 }
768
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800769 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700770 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800771 return *this;
772 }
773
Lloyd Pique542307f2018-10-19 13:24:08 -0700774 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700775 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800776 return *this;
777 }
778
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800779 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700780 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800781 return *this;
782 }
783
Peiyong Lin65248e02020-04-18 21:15:07 -0700784 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700785 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700786 return *this;
787 }
788
Valerie Hau9758ae02018-10-09 16:05:09 -0700789 auto& setHwcColorModes(
790 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
791 hwcColorModes) {
792 mCreationArgs.hwcColorModes = hwcColorModes;
793 return *this;
794 }
795
796 auto& setHasWideColorGamut(bool hasWideColorGamut) {
797 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
798 return *this;
799 }
800
Lloyd Pique33050472019-12-19 17:12:44 -0800801 auto& setPhysicalOrientation(ui::Rotation orientation) {
802 mCreationArgs.physicalOrientation = orientation;
803 return *this;
804 }
805
Ady Abraham690f4612021-07-01 23:24:03 -0700806 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800807 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
808
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700809 auto& modes = mDisplayModes;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800810 auto& activeModeId = mCreationArgs.activeModeId;
811
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400812 if (displayId && !mCreationArgs.refreshRateSelector) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800813 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
814 if (modes.empty()) {
815 constexpr DisplayModeId kModeId{0};
816 DisplayModePtr mode =
817 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
818 .setId(kModeId)
819 .setPhysicalDisplayId(*physicalId)
820 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
821 .setVsyncPeriod(
822 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
823 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
824 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
825 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
826 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800827
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800828 modes = ftl::init::map(kModeId, std::move(mode));
829 activeModeId = kModeId;
830 }
831
Dominik Laskowskid82e0f02022-10-26 15:23:04 -0400832 mCreationArgs.refreshRateSelector =
833 std::make_shared<scheduler::RefreshRateSelector>(modes, activeModeId);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800834 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800835 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700836
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700837 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
838 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
ramindani69b58e82022-09-26 16:48:36 -0700839 if (mFlinger.scheduler()) {
Dominik Laskowskib5a094b2022-10-27 12:00:12 -0400840 mFlinger.scheduler()->registerDisplay(display->getPhysicalId(),
841 display->holdRefreshRateSelector());
ramindani69b58e82022-09-26 16:48:36 -0700842 }
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700843
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800844 DisplayDeviceState state;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700845 state.isSecure = mCreationArgs.isSecure;
846
847 if (mConnectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700848 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200849 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
850 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100851 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100852
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800853 const auto activeMode = modes.get(activeModeId);
854 LOG_ALWAYS_FATAL_IF(!activeMode);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800855
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100856 state.physical = {.id = *physicalId,
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100857 .hwcDisplayId = *mHwcDisplayId,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800858 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800859
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700860 const auto it = mFlinger.mutablePhysicalDisplays()
861 .emplace_or_replace(*physicalId, mDisplayToken, *physicalId,
862 *mConnectionType, std::move(modes),
Dominik Laskowski788945b2022-08-30 12:10:56 -0700863 ui::ColorModes(), std::nullopt)
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700864 .first;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700865
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700866 display->setActiveMode(activeModeId, it->second.snapshot());
Marin Shalamanov045b7002021-01-07 16:56:24 +0100867 }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700868
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800869 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
870 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
871
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800872 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800873 }
874
875 private:
876 TestableSurfaceFlinger& mFlinger;
Ady Abrahamd11bade2022-08-01 16:18:03 -0700877 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700878 DisplayDeviceCreationArgs mCreationArgs;
Dominik Laskowskib363c4c2022-08-02 14:03:41 -0700879 DisplayModes mDisplayModes;
880 const std::optional<ui::DisplayConnectionType> mConnectionType;
Peiyong Line9d809e2020-04-14 13:10:48 -0700881 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800882 };
883
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700884private:
Dominik Laskowski08fbd852022-07-14 08:53:42 -0700885 static constexpr VsyncId kVsyncId{123};
Ady Abraham302ebed2022-03-07 16:03:41 -0800886
Lloyd Pique90c115d2018-09-18 21:39:42 -0700887 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800888 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800889 scheduler::mock::SchedulerCallback mSchedulerCallback;
890 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Dominik Laskowski068173d2021-08-11 17:22:59 -0700891 scheduler::TestableScheduler* mScheduler = nullptr;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800892};
893
894} // namespace android